#include <HLTTauDQMLitePathPlotter.h>

Classes
class	LVSorter

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &, const std::vector< LVColl > &)

	HLTTauDQMLitePathPlotter (const edm::ParameterSet &, int, int, int, double, bool, double)

	~HLTTauDQMLitePathPlotter ()

Private Member Functions
void	endJob ()

LVColl	getFilterCollection (size_t, int, const trigger::TriggerEvent &)

LVColl	getObjectCollection (int, const trigger::TriggerEvent &)

std::pair< bool, LV >	match (const LV &, const LVColl &, double)

Private Attributes
MonitorElement *	accepted_events

MonitorElement *	accepted_events_matched

int	binsEt_

int	binsEta_

int	binsPhi_

bool	doRefAnalysis_

std::vector< edm::InputTag >	filter_

std::vector< int >	LeptonType_

std::vector< MonitorElement * >	mass_distribution

double	matchDeltaR_

double	maxEt_

double	minEt_

std::vector< std::string >	name_

std::vector< unsigned >	nTriggeredLeptons_

std::vector< unsigned >	nTriggeredTaus_

MonitorElement *	ref_events

double	refLeptonPt_

double	refTauPt_

MonitorElement *	tauEt

MonitorElement *	tauEta

MonitorElement *	tauEtaEffDenom

MonitorElement *	tauEtaEffNum

MonitorElement *	tauEtEffDenom

MonitorElement *	tauEtEffNum

MonitorElement *	tauPhi

MonitorElement *	tauPhiEffDenom

MonitorElement *	tauPhiEffNum

std::vector< int >	TauType_

edm::InputTag	triggerEvent_
	InputTag of TriggerEventWithRefs to analyze. More...

std::string	triggerTag_

Detailed Description

Definition at line 33 of file HLTTauDQMLitePathPlotter.h.

Constructor & Destructor Documentation

HLTTauDQMLitePathPlotter::HLTTauDQMLitePathPlotter	(	const edm::ParameterSet &	ps,
		int	etbins,
		int	etabins,
		int	phibins,
		double	maxpt,
		bool	ref,
		double	dr
	)

Definition at line 4 of file HLTTauDQMLitePathPlotter.cc.

References accepted_events, accepted_events_matched, binsEt_, binsEta_, binsPhi_, DQMStore::book1D(), doRefAnalysis_, filter_, MonitorElement::getTH1F(), gen::k, mass_distribution, maxEt_, name_, nTriggeredLeptons_, nTriggeredTaus_, ref_events, MonitorElement::setBinLabel(), DQMStore::setCurrentFolder(), tauEt, tauEta, tauEtaEffDenom, tauEtaEffNum, tauEtEffDenom, tauEtEffNum, tauPhi, tauPhiEffDenom, tauPhiEffNum, and triggerTag_.

                                                                                                                                               : 
   triggerEvent_(ps.getUntrackedParameter<edm::InputTag>("triggerEventObject")),
   triggerTag_(ps.getUntrackedParameter<std::string>("DQMFolder","DoubleTau")),
   filter_(ps.getUntrackedParameter<std::vector<edm::InputTag> >("Filter")),
   name_(ps.getUntrackedParameter<std::vector<std::string> >("PathName")),
   TauType_(ps.getUntrackedParameter<std::vector<int> >("TauType")),
   LeptonType_(ps.getUntrackedParameter<std::vector<int> >("LeptonType")),
   nTriggeredTaus_(ps.getUntrackedParameter<std::vector<unsigned> >("NTriggeredTaus")),
   nTriggeredLeptons_(ps.getUntrackedParameter<std::vector<unsigned> >("NTriggeredLeptons")),
   doRefAnalysis_(ref),
   matchDeltaR_(dr),
   maxEt_(maxpt),
   binsEt_(etbins),
   binsEta_(etabins),
   binsPhi_(phibins),
   refTauPt_(ps.getUntrackedParameter<double>("refTauPt",20)),
   refLeptonPt_(ps.getUntrackedParameter<double>("refLeptonPt",15))
 {
   //initialize 
 
   //  for(size_t k=0;k<filter_.size();++k)
   //   NEventsPassed.push_back(0);
 
   //  for(size_t k=0;k<=filter_.size();++k)
   //    NEventsPassedMatched.push_back(0);
 
   //Declare DQM Store
   DQMStore* store = &*edm::Service<DQMStore>();
 
   if(store)
     {
       
       //Create the histograms
       store->setCurrentFolder(triggerTag_);
       accepted_events = store->book1D("PathTriggerBits","Accepted Events per path",filter_.size(),0,filter_.size());
       
       for(size_t k=0;k<filter_.size();++k)
     {
     
       accepted_events->setBinLabel(k+1,name_[k],1);
       if( nTriggeredTaus_[k]>=2 || (nTriggeredTaus_[k]>=1 && nTriggeredLeptons_[k]>=1)){ 
         mass_distribution.push_back(store->book1D(("mass_"+name_[k]),("Mass Distribution for "+name_[k]),100,0,500)); 
       }
     }
       
       if(doRefAnalysis_)
     {
       accepted_events_matched = store->book1D("MatchedPathTriggerBits","Accepted +Matched Events per path",filter_.size(),0,filter_.size());
       accepted_events_matched->getTH1F()->Sumw2();
 
       for(size_t k=0;k<filter_.size();++k)
         accepted_events_matched->setBinLabel(k+1,name_[k],1);
 
       ref_events = store->book1D("RefEvents","Reference Events per path",filter_.size(),0,filter_.size());
       ref_events->getTH1F()->Sumw2();
 
       for(size_t k=0;k<filter_.size();++k)
         ref_events->setBinLabel(k+1,name_[k],1);
     }
 
 
       tauEt          = store->book1D("TrigTauEt","#tau E_{t}",binsEt_,0,maxEt_);
       tauEta         = store->book1D("TrigTauEta","#tau #eta",binsEta_,-2.5,2.5);
       tauPhi         = store->book1D("TrigTauPhi","#tau #phi",binsPhi_,-3.2,3.2);
 
       if(doRefAnalysis_)
     {
 
       tauEtEffNum   = store->book1D("TrigTauEtEffNum"," #tau E_{t} Efficiency",binsEt_,0,maxEt_);
       tauEtEffNum->getTH1F()->Sumw2();
 
       tauEtEffDenom = store->book1D("TrigTauEtEffDenom"," #tau E_{t} Denominator",binsEt_,0,maxEt_);
       tauEtEffDenom->getTH1F()->Sumw2();
 
       tauEtaEffNum   = store->book1D("TrigTauEtaEffNum"," #tau #eta Efficiency",binsEta_,-2.5,2.5);
       tauEtaEffNum->getTH1F()->Sumw2();
 
       tauEtaEffDenom = store->book1D("TrigTauEtaEffDenom"," #tau #eta Denominator",binsEta_,-2.5,2.5);
       tauEtaEffDenom->getTH1F()->Sumw2();
 
       tauPhiEffNum   = store->book1D("TrigTauPhiEffNum"," #tau #phi Efficiency",binsPhi_,-3.2,3.2);
       tauPhiEffNum->getTH1F()->Sumw2();
 
       tauPhiEffDenom = store->book1D("TrigTauPhiEffDenom"," #tau #phi Denominator",binsPhi_,-3.2,3.2);
       tauPhiEffDenom->getTH1F()->Sumw2();
 
     }
     }
 }

HLTTauDQMLitePathPlotter::~HLTTauDQMLitePathPlotter ( )

Definition at line 95 of file HLTTauDQMLitePathPlotter.cc.

96 {

97 }

Member Function Documentation

void HLTTauDQMLitePathPlotter::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const std::vector< LVColl > &	refC
	)

Definition at line 104 of file HLTTauDQMLitePathPlotter.cc.

References accepted_events, accepted_events_matched, doRefAnalysis_, MonitorElement::Fill(), filter_, edm::Event::getByLabel(), getFilterCollection(), i, edm::HandleBase::isValid(), j, EgammaValidation_Wenu_cff::leptons, LeptonType_, m, mass_distribution, match(), matchDeltaR_, nTriggeredLeptons_, nTriggeredTaus_, ref_events, refLeptonPt_, refTauPt_, findQualityFiles::size, tauEt, tauEta, tauEtaEffDenom, tauEtaEffNum, tauEtEffDenom, tauEtEffNum, tauPhi, tauPhiEffDenom, tauPhiEffNum, TauType_, and triggerEvent_.

 {
 
   std::vector<bool> isGoodReferenceEvent;
 
 
   LV highestRefTau(0.,0.,0.,0.0001);
   LVColl triggeredTaus;
 
   if(refC[0].size()>0)
     {
       for(unsigned int i=0;i<refC[0].size();++i)
     if((refC[0])[i].pt()>highestRefTau.pt())
       highestRefTau = (refC[0])[i];
     }
 
 
     
   //Fill ref collection for the filters
   if(doRefAnalysis_)
     for(size_t i=0;i<filter_.size();++i)
       {
     bool tau_ok=true;
     bool lepton_ok=true;
     //Tau reference
     if(refC[0].size()<nTriggeredTaus_[i])
       {
         tau_ok = false;
       }
       else
         {
           unsigned int highPtTaus=0;
           for(size_t j = 0;j<refC[0].size();++j)
         {
           if((refC[0])[j].Et()>refTauPt_)
             highPtTaus++;
         }
           if(highPtTaus<nTriggeredTaus_[i])
         {
           tau_ok = false;
         }
      
 
         }
 
   
       //lepton reference
     //lepton reference
     unsigned int highPtElectrons=0;
     unsigned int highPtMuons=0;
     if(refC.size()>1){      
         for(size_t j = 0;j<refC[1].size();++j)
             {
             if((refC[1])[j].Et()>refLeptonPt_)        
             highPtElectrons++;
             }
     }
     if(refC.size()>2){
         for(size_t j = 0;j<refC[2].size();++j)
             {
             if((refC[2])[j].Et()>refLeptonPt_)        
             highPtMuons++;
             }
     }
     if(highPtElectrons<nTriggeredLeptons_[0]&&LeptonType_[1]==11)
     {
         lepton_ok = false;
     }
     if(highPtMuons<nTriggeredLeptons_[0]&&LeptonType_[1]==13)
     {
         lepton_ok = false;
     }
       
       if(lepton_ok&&tau_ok)
     {
       ref_events->Fill(i+0.5);
       isGoodReferenceEvent.push_back(true);
     }
       else
       isGoodReferenceEvent.push_back(false);
     }
 
   edm::Handle<trigger::TriggerEvent> trigEv;
   //get The triggerEvent
 
   bool  gotTEV=iEvent.getByLabel(triggerEvent_,trigEv) && trigEv.isValid();
 
   if(gotTEV)
     {
 
       if (trigEv.isValid()) 
     {
       //Loop through the filters
       for(size_t i=0;i<filter_.size();++i)
         {
     
           size_t ID =trigEv->filterIndex(filter_[i]);
           if(ID!=trigEv->sizeFilters())
         {
               LVColl leptons = getFilterCollection(ID,LeptonType_[i],*trigEv);
               LVColl taus = getFilterCollection(ID,TauType_[i],*trigEv);
 
               //if this is the single tau trigger copy the collection for the turn on
               if(nTriggeredTaus_[i]==1&&nTriggeredLeptons_[i]==0)
             triggeredTaus=taus;
             
 
               //Fired
               if(leptons.size()>=nTriggeredLeptons_[i] && taus.size()>=nTriggeredTaus_[i])
             {
               accepted_events->Fill(i+0.5);
               //Now do the matching only though if we have a good reference event
 
               if(doRefAnalysis_)
                 {
                   if(isGoodReferenceEvent[i])
                 {
                   
                   size_t nT=0;
                   for(size_t j=0;j<taus.size();++j)
                     {
                       std::pair<bool,LV> m=match(taus[j],refC[0],matchDeltaR_); 
                       if(m.first)
                     nT++;
                     }
                   size_t nL=0;
                   for(size_t j=0;j<leptons.size();++j)
                   {
                     if(refC[1].size()>0){
                       if(match(leptons[j],refC[1],matchDeltaR_).first)
                         nL++;
                     }
                     if(refC[2].size()>0){
                       if(match(leptons[j],refC[2],matchDeltaR_).first)
                         nL++;
                     }
                   }
                   if(nT>=nTriggeredTaus_[i]&&nL>=nTriggeredLeptons_[i])
                     {
                       
                       accepted_events_matched->Fill(i+0.5);
                       if(nTriggeredTaus_[i]>=2&&refC[0].size()>=2)
                       {
                         
                         mass_distribution[i]->Fill(((refC[0])[0]+(refC[0])[1]).M());
                       }
                       else if(nTriggeredTaus_[i]>=1 && nTriggeredLeptons_[i]>=1)
                       {
                         
                         if(LeptonType_[i]==11&&refC[1].size()>=1) {mass_distribution[i]->Fill(((refC[0])[0]+(refC[1])[0]).M());}                      
                         if(LeptonType_[i]==13&&refC[2].size()>=1) {mass_distribution[i]->Fill(((refC[0])[0]+(refC[2])[0]).M());}
                         
                       }
                     }
                 }
 
 
 
                 }
               else
                 {
                           if(nTriggeredTaus_[i]>=2)
                       mass_distribution[i]->Fill((taus[0]+taus[1]).M());
                       else if(nTriggeredTaus_[i]>=1 && nTriggeredLeptons_[i]>=1)
                       mass_distribution[i]->Fill((taus[0]+leptons[0]).M());
                 }
             }
         }
         }
     
 
 
       //Do the object thing for the highest tau!
 
       if(triggeredTaus.size()>0)
         {
           LV highestTriggeredTau(0.,0.,0.,0.0001);
           for(unsigned int i=0;i<triggeredTaus.size();++i)
         if(triggeredTaus[i].pt()>highestTriggeredTau.pt())
           highestTriggeredTau = triggeredTaus[i];
       
         
           tauEt->Fill(highestTriggeredTau.pt());
           tauEta->Fill(highestTriggeredTau.eta());
           tauPhi->Fill(highestTriggeredTau.phi());
 
 
           if(doRefAnalysis_&&highestRefTau.pt()>5.)
         {
               tauEtEffDenom->Fill(highestRefTau.pt());
               tauEtaEffDenom->Fill(highestRefTau.eta());
               tauPhiEffDenom->Fill(highestRefTau.phi());
 
 
           if(ROOT::Math::VectorUtil::DeltaR(highestRefTau,highestTriggeredTau)<matchDeltaR_)
             {
               tauEtEffNum->Fill(highestRefTau.pt());
               tauEtaEffNum->Fill(highestRefTau.eta());
               tauPhiEffNum->Fill(highestRefTau.phi());
             }
         }
         }
     }
     }
 }

void HLTTauDQMLitePathPlotter::endJob ( )

private

LVColl HLTTauDQMLitePathPlotter::getFilterCollection	(	size_t	index,
		int	id,
		const trigger::TriggerEvent &	trigEv
	)

private

Definition at line 362 of file HLTTauDQMLitePathPlotter.cc.

References a, trigger::TriggerEvent::filterKeys(), trigger::TriggerEvent::getObjects(), i, dbtoconf::out, trigger::TriggerObject::px(), trigger::TriggerObject::py(), trigger::TriggerObject::pz(), trigger::TriggerEvent::sizeFilters(), and mathSSE::sqrt().

Referenced by analyze().

 {
 
 
   //Create output Collection
   LVColl out;
       //get All the final trigger objects
      const trigger::TriggerObjectCollection& TOC(trigEv.getObjects());
      
       //filter index
       if(index!=trigEv.sizeFilters())
     {
       const trigger::Keys& KEYS = trigEv.filterKeys(index);
       for(size_t i = 0;i<KEYS.size();++i)
         {
           const trigger::TriggerObject& TO(TOC[KEYS[i]]);
           LV a(TO.px(),TO.py(),TO.pz(),sqrt(TO.px()*TO.px()+TO.py()*TO.py()+TO.pz()*TO.pz()));
         out.push_back(a);
         }
     }
 
   return out;
 }

LVColl HLTTauDQMLitePathPlotter::getObjectCollection	(	int	id,
		const trigger::TriggerEvent &	trigEv
	)

private

Definition at line 340 of file HLTTauDQMLitePathPlotter.cc.

References a, abs, relval_parameters_module::energy, trigger::TriggerEvent::getObjects(), i, and dbtoconf::out.

 {
 
 
 
         trigger::TriggerObjectCollection triggerObjects;
     triggerObjects = trigEv.getObjects();
 
     LVColl out;
     for(unsigned int i=0;i<triggerObjects.size();++i)
        if(abs(triggerObjects[i].id()) == id)
        {
          LV a(triggerObjects[i].px(),triggerObjects[i].py(),triggerObjects[i].pz(),triggerObjects[i].energy());
          out.push_back(a);
        }
 
 
     return out;
 }

std::pair< bool, LV > HLTTauDQMLitePathPlotter::match	(	const LV &	jet,
		const LVColl &	McInfo,
		double	dr
	)

private

Definition at line 317 of file HLTTauDQMLitePathPlotter.cc.

References delta, connectstrParser::o, and dbtoconf::out.

Referenced by analyze().

 {
  
   bool matched=false;
   LV out;
 
   if(McInfo.size()>0)
     for(std::vector<LV>::const_iterator it = McInfo.begin();it!=McInfo.end();++it)
       {
     double delta = ROOT::Math::VectorUtil::DeltaR(jet,*it);
     if(delta<dr)
       {
         matched=true;
         out = *it;
       }
       }
 
   std::pair<bool,LV> o = std::make_pair(matched,out);
   return o;
 }