CMSSW Reference Manual

HLTTauValidation::HLTTauValidation ( const edm::ParameterSet & ps ) [explicit]

Definition at line 4 of file HLTTauValidation.cc.

References accepted_events, accepted_events_matched, DQMStore::book1D(), doRefAnalysis_, filter_, k, MonitorElement::setBinLabel(), DQMStore::setCurrentFolder(), and triggerTag_.

00004                                                             : 
00005   triggerEventObject_(ps.getUntrackedParameter<edm::InputTag>("triggerEventObject")),
00006   refCollection_(ps.getUntrackedParameter<edm::InputTag>("refTauCollection")),
00007   refLeptonCollection_(ps.getUntrackedParameter<edm::InputTag>("refLeptonCollection")),
00008   triggerTag_(ps.getUntrackedParameter<std::string>("DQMFolder","DoubleTau")),
00009   filter_(ps.getUntrackedParameter<std::vector<edm::InputTag> >("Filter")),
00010   TauType_(ps.getUntrackedParameter<std::vector<int> >("TauType")),
00011   LeptonType_(ps.getUntrackedParameter<std::vector<int> >("LeptonType")),
00012   nTriggeredTaus_(ps.getUntrackedParameter<std::vector<unsigned> >("NTriggeredTaus")),
00013   nTriggeredLeptons_(ps.getUntrackedParameter<std::vector<unsigned> >("NTriggeredLeptons")),
00014   doRefAnalysis_(ps.getUntrackedParameter<bool>("DoReferenceAnalysis",false)),
00015   matchDeltaR_(ps.getUntrackedParameter<std::vector<double> >("MatchDeltaR"))
00016 {
00017   //initialize 
00018 
00019   //  for(size_t k=0;k<filter_.size();++k)
00020   //   NEventsPassed.push_back(0);
00021 
00022   //  for(size_t k=0;k<=filter_.size();++k)
00023   //    NEventsPassedMatched.push_back(0);
00024 
00025   //Declare DQM Store
00026   DQMStore* store = &*edm::Service<DQMStore>();
00027 
00028   if(store)
00029     {
00030       //Create the histograms
00031       store->setCurrentFolder(triggerTag_);
00032       accepted_events = store->book1D("Triggers","Accepted Events per path",filter_.size(),0,filter_.size());
00033       for(size_t k=0;k<filter_.size();++k)
00034         accepted_events->setBinLabel(k+1,filter_[k].label(),1);
00035 
00036       if(doRefAnalysis_)
00037         {
00038           accepted_events_matched = store->book1D("MatchedTriggers","Accepted +Matched Events per path",filter_.size()+1,0,filter_.size()+1);
00039           accepted_events_matched->setBinLabel(1,"RefEvents",1);
00040           for(size_t k=0;k<filter_.size();++k)
00041             accepted_events_matched->setBinLabel(k+2,filter_[k].label(),1);
00042         }
00043 
00044 
00045 
00046     }
00047 
00048 }

HLTTauValidation::~HLTTauValidation ( )

Definition at line 50 of file HLTTauValidation.cc.

00051 {
00052 }

void HLTTauValidation::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)			`[private, virtual]`

Implements edm::EDAnalyzer.

Definition at line 73 of file HLTTauValidation.cc.

References accepted_events, accepted_events_matched, doRefAnalysis_, eta, MonitorElement::Fill(), filter_, edm::Event::getByLabel(), getFilterCollection(), i, j, EgammaValidation_Zee_cff::leptons, LeptonType_, match(), matchDeltaR_, nTriggeredLeptons_, nTriggeredTaus_, HcalSimpleRecAlgoImpl::reco(), refCollection_, refLeptonCollection_, std, TauType_, and triggerEventObject_.

00074 {
00075   using namespace std;
00076   using namespace edm;
00077   using namespace reco;
00078   using namespace l1extra;
00079   using namespace trigger;
00080 
00081   //Look at the reference collection (i.e MC)
00082   Handle<LVColl> refC;
00083   Handle<LVColl> refCL;
00084 
00085   bool tau_ok=true;
00086   bool lepton_ok=true;
00087 
00088   bool isGoodReferenceEvent=false;
00089 
00090   if(doRefAnalysis_)
00091     {
00092       //Tau reference
00093       if(iEvent.getByLabel(refCollection_,refC))
00094         if(refC->size()<nTriggeredTaus_[0])
00095           {
00096             tau_ok = false;
00097           }
00098         else
00099           {
00100             double et=0.;
00101             double eta=0.;
00102             
00103             for(size_t j = 0;j<refC->size();++j)
00104               {
00105                 if((*refC)[j].Et()>et)
00106                   {
00107                     et=(*refC)[j].Et();
00108                     eta = (*refC)[j].Eta();
00109                   }
00110                 
00111               }
00112          
00113         }
00114   
00115       //lepton reference
00116       if(iEvent.getByLabel(refLeptonCollection_,refCL))
00117         if(refCL->size()<nTriggeredLeptons_[0])
00118           {
00119             lepton_ok = false;
00120           }
00121     
00122       
00123       if(lepton_ok&&tau_ok)
00124         {
00125           accepted_events_matched->Fill(0.5);
00126           isGoodReferenceEvent=true;
00127         }
00128     }
00129 
00130 
00131   //get The triggerEvent
00132 
00133 
00134   Handle<TriggerEventWithRefs> trigEv;
00135   if(iEvent.getByLabel(triggerEventObject_,trigEv))
00136     {
00137 
00138       if (trigEv.isValid()) 
00139         {
00140 
00141           //Loop through the filters
00142           for(size_t i=0;i<filter_.size();++i)
00143             {
00144         
00145               size_t ID =trigEv->filterIndex(filter_[i]);
00146               if(ID!=trigEv->size())
00147                 {
00148                       LVColl leptons = getFilterCollection(ID,LeptonType_[i],*trigEv);
00149                       LVColl taus = getFilterCollection(ID,TauType_[i],*trigEv);
00150 
00151                       //Fired
00152                       if(leptons.size()>=nTriggeredLeptons_[i+1]&&taus.size()>=nTriggeredTaus_[i+1])
00153                         {
00154                           accepted_events->Fill(i+0.5);
00155                           //Now do the matching only though if we have a good reference event
00156                           if(doRefAnalysis_)
00157                           if(isGoodReferenceEvent)
00158                             {
00159                               
00160                               size_t nT=0;
00161                                 for(size_t j=0;j<taus.size();++j)
00162                                   {
00163                                     if(match(taus[j],*refC,matchDeltaR_[i]))
00164                                       nT++;
00165 
00166                                   }
00167                               size_t nL=0;
00168                                 for(size_t j=0;j<leptons.size();++j)
00169                                   {
00170                                     if(match(leptons[j],*refCL,matchDeltaR_[i]))
00171                                       nL++;
00172 
00173                                   }
00174                                 if(nT>=nTriggeredTaus_[i+1]&&nL>=nTriggeredLeptons_[i+1])
00175                                   accepted_events_matched->Fill(i+1.5);
00176                         }
00177                     }
00178                 }
00179             }
00180         }
00181     }
00182 }

void HLTTauValidation::endJob ( void ) [private, virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 59 of file HLTTauValidation.cc.

00060 {
00061   //Fill histograms
00062   //  for(size_t i=0;i<filter_.size();++i)
00063   //     accepted_events->setBinContent(i+1,NEventsPassed[i]);
00064 
00065 
00066   //For the matched events the zeroth bin is used to put the reference events
00067   // for(size_t i=0;i<filter_.size();++i)
00068   //    accepted_events_matched->setBinContent(i+1,NEventsPassedMatched[i+1]);
00069 }

LVColl HLTTauValidation::getFilterCollection	(	size_t	filterID,
		int	id,
		const trigger::TriggerEventWithRefs &	trigEv
	)			`[private]`

Definition at line 209 of file HLTTauValidation.cc.

References trigger::TriggerEventWithRefs::getObjects(), i, VarParsing::obj, out, trigger::TriggerElectron, trigger::TriggerL1IsoEG, trigger::TriggerL1Mu, trigger::TriggerL1NoIsoEG, trigger::TriggerL1TauJet, trigger::TriggerMuon, and trigger::TriggerTau.

Referenced by analyze().

00210 {
00211   using namespace trigger;
00212 
00213   LVColl out;
00214 
00215 
00216           if(id==trigger::TriggerL1IsoEG ||trigger::TriggerL1NoIsoEG) 
00217             {
00218               VRl1em obj;
00219               trigEv.getObjects(filterID,id,obj);
00220               for(size_t i=0;i<obj.size();++i)
00221                     out.push_back(obj[i]->p4());
00222             }
00223 
00224           if(id==trigger::TriggerL1Mu) 
00225             {
00226               VRl1muon obj;
00227               trigEv.getObjects(filterID,id,obj);
00228               for(size_t i=0;i<obj.size();++i)
00229                     out.push_back(obj[i]->p4());
00230             }
00231 
00232 
00233           if(id==trigger::TriggerMuon) 
00234             {
00235               VRmuon obj;
00236               trigEv.getObjects(filterID,id,obj);
00237               for(size_t i=0;i<obj.size();++i)
00238                     out.push_back(obj[i]->p4());
00239             }
00240 
00241           if(id==trigger::TriggerElectron) 
00242             {
00243               VRelectron obj;
00244               trigEv.getObjects(filterID,id,obj);
00245               for(size_t i=0;i<obj.size();++i)
00246                     out.push_back(obj[i]->p4());
00247             }
00248 
00249           if(id==trigger::TriggerL1TauJet) 
00250             {
00251               VRl1jet obj;
00252               trigEv.getObjects(filterID,id,obj);
00253               for(size_t i=0;i<obj.size();++i)
00254                     out.push_back(obj[i]->p4());
00255             }
00256 
00257           if(id==trigger::TriggerTau) 
00258             {
00259               VRjet obj;
00260               trigEv.getObjects(filterID,id,obj);
00261               for(size_t i=0;i<obj.size();++i)
00262                     out.push_back(obj[i]->p4());
00263             }
00264 
00265           return out;
00266 }

bool HLTTauValidation::match	(	const LV &	jet,
		const LVColl &	McInfo,
		double	dr
	)			`[private]`

Definition at line 189 of file HLTTauValidation.cc.

References it.

Referenced by analyze().

00190 {
00191  
00192   bool matched=false;
00193 
00194   if(McInfo.size()>0)
00195     for(std::vector<LV>::const_iterator it = McInfo.begin();it!=McInfo.end();++it)
00196       {
00197         double delta = ROOT::Math::VectorUtil::DeltaR(jet,*it);
00198         if(delta<dr)
00199           {
00200             matched=true;
00201           }
00202       }
00203 
00204   return matched;
00205 }

MonitorElement* HLTTauValidation::accepted_events [private]

Definition at line 76 of file HLTTauValidation.h.

Referenced by analyze(), and HLTTauValidation().

MonitorElement* HLTTauValidation::accepted_events_matched [private]

Definition at line 77 of file HLTTauValidation.h.

Referenced by analyze(), and HLTTauValidation().

bool HLTTauValidation::doRefAnalysis_ [private]

Definition at line 70 of file HLTTauValidation.h.

Referenced by analyze(), and HLTTauValidation().

std::vector<edm::InputTag> HLTTauValidation::filter_ [private]

Definition at line 62 of file HLTTauValidation.h.

Referenced by analyze(), and HLTTauValidation().

std::vector<int> HLTTauValidation::LeptonType_ [private]

Definition at line 64 of file HLTTauValidation.h.

Referenced by analyze().

std::vector<double> HLTTauValidation::matchDeltaR_ [private]

Definition at line 71 of file HLTTauValidation.h.

Referenced by analyze().

std::vector<unsigned> HLTTauValidation::nTriggeredLeptons_ [private]

Definition at line 68 of file HLTTauValidation.h.

Referenced by analyze().

std::vector<unsigned> HLTTauValidation::nTriggeredTaus_ [private]

Definition at line 67 of file HLTTauValidation.h.

Referenced by analyze().

edm::InputTag HLTTauValidation::refCollection_ [private]

Definition at line 55 of file HLTTauValidation.h.

Referenced by analyze().

edm::InputTag HLTTauValidation::refLeptonCollection_ [private]

Definition at line 56 of file HLTTauValidation.h.

Referenced by analyze().

std::vector<int> HLTTauValidation::TauType_ [private]

Definition at line 63 of file HLTTauValidation.h.

Referenced by analyze().

edm::InputTag HLTTauValidation::triggerEventObject_ [private]

InputTag of TriggerEventWithRefs to analyze.

Definition at line 52 of file HLTTauValidation.h.

Referenced by analyze().

std::string HLTTauValidation::triggerTag_ [private]

Definition at line 59 of file HLTTauValidation.h.

Referenced by HLTTauValidation().

HLTTauValidation Class Reference

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	HLTTauValidation (const edm::ParameterSet &)
	~HLTTauValidation ()
Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	endJob ()
LVColl	getFilterCollection (size_t, int, const trigger::TriggerEventWithRefs &)
bool	match (const LV &, const LVColl &, double)
Private Attributes
MonitorElement *	accepted_events
MonitorElement *	accepted_events_matched
bool	doRefAnalysis_
std::vector< edm::InputTag >	filter_
std::vector< int >	LeptonType_
std::vector< double >	matchDeltaR_
std::vector< unsigned >	nTriggeredLeptons_
std::vector< unsigned >	nTriggeredTaus_
edm::InputTag	refCollection_
edm::InputTag	refLeptonCollection_
std::vector< int >	TauType_
edm::InputTag	triggerEventObject_
	InputTag of TriggerEventWithRefs to analyze.
std::string	triggerTag_