#include <HLTTauDQML1Plotter.h>

Inheritance diagram for HLTTauDQML1Plotter:

Classes
struct	ComparePt
Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &, const std::map< int, LVColl > &)
	HLTTauDQML1Plotter (const edm::ParameterSet &, int, int, int, double, bool, double, std::string)
const std::string	name ()
	~HLTTauDQML1Plotter ()
Private Member Functions
void	endJob ()
Private Attributes
int	binsEt_
int	binsEta_
int	binsPhi_
bool	doRefAnalysis_
MonitorElement *	firstTauEt_
MonitorElement *	inputEvents_
MonitorElement *	l1doubleTauPath_
MonitorElement *	l1electronEt_
MonitorElement *	l1electronEta_
MonitorElement *	l1electronPhi_
MonitorElement *	l1electronTauPath_
edm::InputTag	l1ExtraElectrons_
edm::InputTag	l1ExtraJets_
edm::InputTag	l1ExtraMuons_
edm::InputTag	l1ExtraTaus_
MonitorElement *	l1jetEt_
MonitorElement *	l1jetEta_
MonitorElement *	l1jetEtaEffDenom_
MonitorElement *	l1jetEtaEffNum_
MonitorElement *	l1jetEtEffDenom_
MonitorElement *	l1jetEtEffNum_
MonitorElement *	l1jetPhi_
MonitorElement *	l1jetPhiEffDenom_
MonitorElement *	l1jetPhiEffNum_
MonitorElement *	l1muonEt_
MonitorElement *	l1muonEta_
MonitorElement *	l1muonPhi_
MonitorElement *	l1muonTauPath_
MonitorElement *	l1tauEt_
MonitorElement *	l1tauEta_
MonitorElement *	l1tauEtaEffDenom_
MonitorElement *	l1tauEtaEffNum_
MonitorElement *	l1tauEtEffDenom_
MonitorElement *	l1tauEtEffNum_
MonitorElement *	l1tauEtRes_
MonitorElement *	l1tauPhi_
MonitorElement *	l1tauPhiEffDenom_
MonitorElement *	l1tauPhiEffNum_
double	matchDeltaR_
double	maxEt_
ComparePt	ptSort
MonitorElement *	secondTauEt_

Detailed Description

Definition at line 19 of file HLTTauDQML1Plotter.h.

Constructor & Destructor Documentation

HLTTauDQML1Plotter::HLTTauDQML1Plotter	(	const edm::ParameterSet &	ps,
		int	etbins,
		int	etabins,
		int	phibins,
		double	maxpt,
		bool	ref,
		double	dr,
		std::string	dqmBaseFolder
	)

Definition at line 3 of file HLTTauDQML1Plotter.cc.

References binsEt_, binsEta_, binsPhi_, DQMStore::book1D(), DQMStore::book2D(), doRefAnalysis_, HLTTauDQMPlotter::dqmBaseFolder_, alignCSCRings::e, firstTauEt_, edm::ParameterSet::getParameter(), MonitorElement::getTH1F(), edm::ParameterSet::getUntrackedParameter(), inputEvents_, l1doubleTauPath_, l1electronEt_, l1electronEta_, l1electronPhi_, l1electronTauPath_, l1ExtraElectrons_, l1ExtraJets_, l1ExtraMuons_, l1ExtraTaus_, l1jetEt_, l1jetEta_, l1jetEtaEffDenom_, l1jetEtaEffNum_, l1jetEtEffDenom_, l1jetEtEffNum_, l1jetPhi_, l1jetPhiEffDenom_, l1jetPhiEffNum_, l1muonEt_, l1muonEta_, l1muonPhi_, l1muonTauPath_, l1tauEt_, l1tauEta_, l1tauEtaEffDenom_, l1tauEtaEffNum_, l1tauEtEffDenom_, l1tauEtEffNum_, l1tauEtRes_, l1tauPhi_, l1tauPhiEffDenom_, l1tauPhiEffNum_, matchDeltaR_, maxEt_, HLTTauDQMPlotter::name_, DQMStore::removeContents(), secondTauEt_, DQMStore::setCurrentFolder(), HLTTauDQMPlotter::store_, HLTTauDQMPlotter::triggerTag(), HLTTauDQMPlotter::triggerTag_, HLTTauDQMPlotter::triggerTagAlias_, HLTTauDQMPlotter::validity_, and cms::Exception::what().

                                                                                                                                                                    {
    //Initialize Plotter
    name_ = "HLTTauDQML1Plotter";
    
    //Process PSet
    try {
        triggerTag_       = ps.getUntrackedParameter<std::string>("DQMFolder");
        triggerTagAlias_  = ps.getUntrackedParameter<std::string>("Alias","");
        l1ExtraTaus_      = ps.getParameter<edm::InputTag>("L1Taus");
        l1ExtraJets_      = ps.getParameter<edm::InputTag>("L1Jets");
        l1ExtraElectrons_ = ps.getParameter<edm::InputTag>("L1Electrons");
        l1ExtraMuons_     = ps.getParameter<edm::InputTag>("L1Muons");
        doRefAnalysis_    = ref;
        dqmBaseFolder_    = dqmBaseFolder;
        matchDeltaR_      = dr;
        maxEt_            = maxpt;
        binsEt_           = etbins;
        binsEta_          = etabins;
        binsPhi_          = phibins;
        validity_         = true;
    } catch ( cms::Exception &e ) {
        edm::LogInfo("HLTTauDQML1Plotter::HLTTauDQML1Plotter") << e.what() << std::endl;
        validity_ = false;
        return;
    }
    
    if (store_) {
        //Create the histograms
        store_->setCurrentFolder(triggerTag());
        store_->removeContents();
        
        l1tauEt_ = store_->book1D("L1TauEt","L1 #tau E_{T};L1 #tau E_{T};entries",binsEt_,0,maxEt_);
        l1tauEta_ = store_->book1D("L1TauEta","L1 #tau #eta;L1 #tau #eta;entries",binsEta_,-2.5,2.5);
        l1tauPhi_ = store_->book1D("L1TauPhi","L1 #tau #phi;L1 #tau #phi;entries",binsPhi_,-3.2,3.2);
        
        l1jetEt_ = store_->book1D("L1JetEt","L1 jet E_{T};L1 Central Jet E_{T};entries",binsEt_,0,maxEt_);
        l1jetEta_ = store_->book1D("L1JetEta","L1 jet #eta;L1 Central Jet #eta;entries",binsEta_,-2.5,2.5);
        l1jetPhi_ = store_->book1D("L1JetPhi","L1 jet #phi;L1 Central Jet #phi;entries",binsPhi_,-3.2,3.2);
        
        inputEvents_ = store_->book1D("InputEvents","Events Read;;entries",2,0,2);
        
        l1electronEt_ = store_->book1D("L1ElectronEt","L1 electron E_{T};L1 e/#gamma  E_{T};entries",binsEt_,0,maxEt_);
        l1electronEta_ = store_->book1D("L1ElectronEta","L1 electron #eta;L1 e/#gamma  #eta;entries",binsEta_,-2.5,2.5);
        l1electronPhi_ = store_->book1D("L1ElectronPhi","L1 electron #phi;L1 e/#gamma  #phi;entries",binsPhi_,-3.2,3.2);
        
        l1muonEt_ = store_->book1D("L1MuonEt","L1 muon p_{T};L1 #mu p_{T};entries",binsEt_,0,maxEt_);
        l1muonEta_ = store_->book1D("L1MuonEta","L1 muon #eta;L1 #mu #eta;entries",binsEta_,-2.5,2.5);
        l1muonPhi_ = store_->book1D("L1MuonPhi","L1 muon #phi;L1 #mu #phi;entries",binsPhi_,-3.2,3.2);
        
        l1doubleTauPath_ = store_->book2D("L1DoubleTau","L1 Double Tau Path E_{T};first L1 #tau p_{T};second L1 #tau p_{T}",binsEt_,0,maxEt_,binsEt_,0,maxEt_);
        l1muonTauPath_ = store_->book2D("L1MuonTau","L1 Muon Tau Path E_{T};first L1 #tau p_{T};first L1 #gamma p_{T}",binsEt_,0,maxEt_,binsEt_,0,maxEt_);
        l1electronTauPath_ = store_->book2D("L1ElectronTau","L1 Electron Tau Path E_{T};first L1 #mu p_{T};second L1 #mu p_{T}",binsEt_,0,maxEt_,binsEt_,0,maxEt_);
        
        firstTauEt_ = store_->book1D("L1LeadTauEt","L1 lead #tau E_{T}",binsEt_,0,maxEt_);
        firstTauEt_->getTH1F()->Sumw2();
        
        secondTauEt_ = store_->book1D("L1SecondTauEt","L1 second #tau E_{T}",binsEt_,0,maxEt_);
        secondTauEt_->getTH1F()->Sumw2();
        
        if (doRefAnalysis_) {
            l1tauEtRes_ = store_->book1D("L1TauEtResol","L1 #tau E_{T} resolution;[L1 #tau E_{T}-Ref #tau E_{T}]/Ref #tau E_{T};entries",40,-2,2);
            
            store_->setCurrentFolder(triggerTag()+"/EfficiencyHelpers");
            store_->removeContents();
            
            l1tauEtEffNum_ = store_->book1D("L1TauEtEffNum","L1 #tau E_{T} Efficiency Numerator",binsEt_,0,maxEt_);
            l1tauEtEffNum_->getTH1F()->Sumw2();
            
            l1tauEtEffDenom_ = store_->book1D("L1TauEtEffDenom","L1 #tau E_{T} Denominator",binsEt_,0,maxEt_);
            l1tauEtEffDenom_->getTH1F()->Sumw2();
            
            l1tauEtaEffNum_ = store_->book1D("L1TauEtaEffNum","L1 #tau #eta Efficiency",binsEta_,-2.5,2.5);
            l1tauEtaEffNum_->getTH1F()->Sumw2();
            
            l1tauEtaEffDenom_ = store_->book1D("L1TauEtaEffDenom","L1 #tau #eta Denominator",binsEta_,-2.5,2.5);
            l1tauEtaEffDenom_->getTH1F()->Sumw2();
            
            l1tauPhiEffNum_ = store_->book1D("L1TauPhiEffNum","L1 #tau #phi Efficiency",binsPhi_,-3.2,3.2);
            l1tauPhiEffNum_->getTH1F()->Sumw2();
            
            l1tauPhiEffDenom_ = store_->book1D("L1TauPhiEffDenom","L1 #tau #phi Denominator",binsPhi_,-3.2,3.2);
            l1tauPhiEffDenom_->getTH1F()->Sumw2();
            
            l1jetEtEffNum_ = store_->book1D("L1JetEtEffNum","L1 jet E_{T} Efficiency",binsEt_,0,maxEt_);
            l1jetEtEffNum_->getTH1F()->Sumw2();
            
            l1jetEtEffDenom_ = store_->book1D("L1JetEtEffDenom","L1 jet E_{T} Denominator",binsEt_,0,maxEt_);
            l1jetEtEffDenom_->getTH1F()->Sumw2();
            
            l1jetEtaEffNum_ = store_->book1D("L1JetEtaEffNum","L1 jet #eta Efficiency",binsEta_,-2.5,2.5);
            l1jetEtaEffNum_->getTH1F()->Sumw2();
            
            l1jetEtaEffDenom_ = store_->book1D("L1JetEtaEffDenom","L1 jet #eta Denominator",binsEta_,-2.5,2.5);
            l1jetEtaEffDenom_->getTH1F()->Sumw2();
            
            l1jetPhiEffNum_ = store_->book1D("L1JetPhiEffNum","L1 jet #phi Efficiency",binsPhi_,-3.2,3.2);
            l1jetPhiEffNum_->getTH1F()->Sumw2();
            
            l1jetPhiEffDenom_ = store_->book1D("L1JetPhiEffDenom","L1 jet #phi Denominator",binsPhi_,-3.2,3.2);
            l1jetPhiEffDenom_->getTH1F()->Sumw2();
        }
    }
}

HLTTauDQML1Plotter::~HLTTauDQML1Plotter ( )

Definition at line 107 of file HLTTauDQML1Plotter.cc.

{
}

Member Function Documentation

void HLTTauDQML1Plotter::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::map< int, LVColl > &	refC
	)

Definition at line 114 of file HLTTauDQML1Plotter.cc.

References doRefAnalysis_, HI_PhotonSkim_cff::electrons, MonitorElement::Fill(), firstTauEt_, edm::Event::getByLabel(), i, inputEvents_, edm::HandleBase::isValid(), fwrapper::jets, l1doubleTauPath_, l1electronEt_, l1electronEta_, l1electronPhi_, l1electronTauPath_, l1ExtraElectrons_, l1ExtraJets_, l1ExtraMuons_, l1ExtraTaus_, l1jetEt_, l1jetEta_, l1jetEtaEffDenom_, l1jetEtaEffNum_, l1jetEtEffDenom_, l1jetEtEffNum_, l1jetPhi_, l1jetPhiEffDenom_, l1jetPhiEffNum_, l1muonEt_, l1muonEta_, l1muonPhi_, l1muonTauPath_, l1tauEt_, l1tauEta_, l1tauEtaEffDenom_, l1tauEtaEffNum_, l1tauEtEffDenom_, l1tauEtEffNum_, l1tauEtRes_, l1tauPhi_, l1tauPhiEffDenom_, l1tauPhiEffNum_, m, HLTTauDQMPlotter::match(), matchDeltaR_, patZpeak::muons, ptSort, secondTauEt_, and python::multivaluedict::sort().

                                                                                                                      {
    LVColl refTaus, refElectrons, refMuons;
    
    if ( doRefAnalysis_ ) {
        std::map<int,LVColl>::const_iterator iref;

        //Tau reference
        iref = refC.find(15);
        if ( iref != refC.end() ) refTaus = iref->second;
        
        //Electron reference
        iref = refC.find(11);
        if ( iref != refC.end() ) refElectrons = iref->second;
        
        //Muon reference
        iref = refC.find(13);
        if ( iref != refC.end() ) refMuons = iref->second;
        
        for ( LVColl::const_iterator iter = refTaus.begin(); iter != refTaus.end(); ++iter ) {
            l1tauEtEffDenom_->Fill(iter->pt());
            l1jetEtEffDenom_->Fill(iter->pt());
            
            l1tauEtaEffDenom_->Fill(iter->eta());
            l1jetEtaEffDenom_->Fill(iter->eta());
            
            l1tauPhiEffDenom_->Fill(iter->phi());
            l1jetPhiEffDenom_->Fill(iter->phi());
        }
    }
    
    //Analyze L1 Objects (Tau+Jets)
    edm::Handle<l1extra::L1JetParticleCollection> taus;
    edm::Handle<l1extra::L1JetParticleCollection> jets;
    edm::Handle<l1extra::L1EmParticleCollection> electrons;
    edm::Handle<l1extra::L1MuonParticleCollection> muons;
    
    LVColl pathTaus;
    LVColl pathMuons;
    LVColl pathElectrons;
    
    //Set Variables for the threshold plot
    LVColl l1taus;
    LVColl l1electrons;
    LVColl l1muons;
    LVColl l1jets;

    bool gotL1Taus = iEvent.getByLabel(l1ExtraTaus_,taus) && taus.isValid();
    bool gotL1Jets = iEvent.getByLabel(l1ExtraJets_,jets) && jets.isValid();
    bool gotL1Electrons = iEvent.getByLabel(l1ExtraElectrons_,electrons) && electrons.isValid();
    bool gotL1Muons = iEvent.getByLabel(l1ExtraMuons_,muons) && muons.isValid();
    
    if ( gotL1Taus ) {
        if ( taus->size() > 0 ) {
            if ( !doRefAnalysis_ ) {
                firstTauEt_->Fill((*taus)[0].pt());
                if ( taus->size() > 1 ) secondTauEt_->Fill((*taus)[0].pt());
            }
            for ( l1extra::L1JetParticleCollection::const_iterator i = taus->begin(); i != taus->end(); ++i ) {
                l1taus.push_back(i->p4());
                if ( !doRefAnalysis_ ) {
                    l1tauEt_->Fill(i->et());
                    l1tauEta_->Fill(i->eta());
                    l1tauPhi_->Fill(i->phi());
                    pathTaus.push_back(i->p4());
                }
            }
        }
    }
    if ( gotL1Jets ) {
        if ( jets->size() > 0 ) {
            for( l1extra::L1JetParticleCollection::const_iterator i = jets->begin(); i != jets->end(); ++i ) {  
                l1jets.push_back(i->p4());
                if ( !doRefAnalysis_ ) {
                    l1jetEt_->Fill(i->et());
                    l1jetEta_->Fill(i->eta());
                    l1jetPhi_->Fill(i->phi());
                    pathTaus.push_back(i->p4());
                }
            }
        }
    }
    if ( gotL1Electrons ) {
        if( electrons->size() > 0 ) {
            for ( l1extra::L1EmParticleCollection::const_iterator i = electrons->begin(); i != electrons->end(); ++i ) {
                l1electrons.push_back(i->p4());
                l1electronEt_->Fill(i->et());
                l1electronEta_->Fill(i->eta());
                l1electronPhi_->Fill(i->phi());
                pathElectrons.push_back(i->p4());
            }
        }
    }
    if ( gotL1Muons ) {
        if ( muons->size() > 0 ) {
            for ( l1extra::L1MuonParticleCollection::const_iterator i = muons->begin(); i != muons->end(); ++i ) {
                l1muons.push_back(i->p4());
                l1muonEt_->Fill(i->et());
                l1muonEta_->Fill(i->eta());
                l1muonPhi_->Fill(i->phi());
                pathMuons.push_back(i->p4());
            }
        }
    }
    
    //Now do the efficiency matching
    if ( doRefAnalysis_ ) {
        for ( LVColl::const_iterator i = refTaus.begin(); i != refTaus.end(); ++i ) {
            std::pair<bool,LV> m = match(*i,l1taus,matchDeltaR_);
            if ( m.first ) {
                l1tauEt_->Fill(m.second.pt());
                l1tauEta_->Fill(m.second.eta());
                l1tauPhi_->Fill(m.second.phi());
                l1tauEtEffNum_->Fill(i->pt());
                l1tauEtaEffNum_->Fill(i->eta());
                l1tauPhiEffNum_->Fill(i->phi());
                l1tauEtRes_->Fill((m.second.pt()-i->pt())/i->pt());
                pathTaus.push_back(m.second);
            }
        }
        
        for ( LVColl::const_iterator i = refTaus.begin(); i != refTaus.end(); ++i ) {
            std::pair<bool,LV> m = match(*i,l1jets,matchDeltaR_);
            if ( m.first ) {
                l1jetEt_->Fill(m.second.pt());
                l1jetEta_->Fill(m.second.eta());
                l1jetPhi_->Fill(m.second.phi());
                l1jetEtEffNum_->Fill(i->pt());
                l1jetEtaEffNum_->Fill(i->eta());
                l1jetPhiEffNum_->Fill(i->phi());
            }
        }
        
        for ( LVColl::const_iterator i = refElectrons.begin(); i != refElectrons.end(); ++i ) {
            std::pair<bool,LV> m = match(*i,l1electrons,matchDeltaR_);
            if( m.first ) {
                l1electronEt_->Fill(m.second.pt());
                l1electronEta_->Fill(m.second.eta());
                l1electronPhi_->Fill(m.second.phi());
                pathElectrons.push_back(m.second);
            }
        }
        
        for ( LVColl::const_iterator i = refMuons.begin(); i != refMuons.end(); ++i ) {
            std::pair<bool,LV> m = match(*i,l1muons,matchDeltaR_);
            if ( m.first ) {
                l1muonEt_->Fill(m.second.pt());
                l1muonEta_->Fill(m.second.eta());
                l1muonPhi_->Fill(m.second.phi());
                pathMuons.push_back(m.second);
            }
        }
    }
    
    
    //Fill the Threshold Monitoring
    if(pathTaus.size() > 1) std::sort(pathTaus.begin(),pathTaus.end(),ptSort);
    if(pathElectrons.size() > 1) std::sort(pathElectrons.begin(),pathElectrons.end(),ptSort);
    if(pathMuons.size() > 1) std::sort(pathMuons.begin(),pathMuons.end(),ptSort);
    
    if ( pathTaus.size() > 0 ) {
        firstTauEt_->Fill(pathTaus[0].pt());
        inputEvents_->Fill(0.5);
    }
    if ( pathTaus.size() > 1 ) {
        secondTauEt_->Fill(pathTaus[1].pt());
        inputEvents_->Fill(1.5);
    }
    if ( pathTaus.size() >= 2 ) {
        l1doubleTauPath_->Fill(pathTaus[0].pt(),pathTaus[1].pt());
    }
    if ( pathTaus.size() >= 1 && pathElectrons.size() >= 1 ) {
        l1electronTauPath_->Fill(pathTaus[0].pt(),pathElectrons[0].pt());
    }
    if ( pathTaus.size() >= 1 && pathMuons.size() >= 1 ) {
        l1muonTauPath_->Fill(pathTaus[0].pt(),pathMuons[0].pt());
    }
}