CMS 3D CMS Logo

/data/doxygen/doxygen-1.7.3/gen/CMSSW_4_2_8/src/ElectroWeakAnalysis/ZMuMu/plugins/dimuonHLTFilterCheck.cc

Go to the documentation of this file.
00001 /* \class dimuonHLTFilterCheck
00002  * 
00003  * author: Davide Piccolo
00004  *
00005  * check HLTFilter for dimuon studies:
00006  *
00007  */
00008 
00009 #include "DataFormats/Common/interface/AssociationVector.h"
00010 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
00011 #include "DataFormats/Candidate/interface/CandMatchMap.h" 
00012 #include "FWCore/Framework/interface/EDAnalyzer.h"
00013 #include "DataFormats/Candidate/interface/Particle.h"
00014 #include "DataFormats/Candidate/interface/Candidate.h"
00015 #include "DataFormats/Candidate/interface/CandidateFwd.h"
00016 #include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
00017 #include "DataFormats/MuonReco/interface/Muon.h"
00018 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00019 #include "FWCore/Framework/interface/Event.h"
00020 #include "FWCore/Framework/interface/EventSetup.h"
00021 #include "FWCore/Utilities/interface/InputTag.h"
00022 #include "DataFormats/Candidate/interface/OverlapChecker.h"
00023 #include "DataFormats/Math/interface/deltaR.h"
00024 
00025 // access trigger results
00026 #include "FWCore/Common/interface/TriggerNames.h"
00027 #include <DataFormats/Common/interface/TriggerResults.h>
00028 #include <DataFormats/HLTReco/interface/TriggerEvent.h> 
00029 #include <DataFormats/HLTReco/interface/TriggerFilterObjectWithRefs.h>
00030 
00031 #include "TH1.h"
00032 #include "TH2.h"
00033 #include "TH3.h"
00034 #include <vector>
00035 #include <map>
00036 #include <string>
00037 using namespace edm;
00038 using namespace std;
00039 using namespace reco;
00040 using namespace trigger;
00041 
00042 class dimuonHLTFilterCheck : public edm::EDAnalyzer {
00043 public:
00044   dimuonHLTFilterCheck(const edm::ParameterSet& pset);
00045 private:
00046   virtual void analyze(const edm::Event& event, const edm::EventSetup& setup);
00047   vector<int> nDimuonsByType(const Handle<CandidateView> d);   
00048   vector<int> nMuonsByType(const Handle<CandidateView> d);   
00049   virtual void endJob();
00050   //  edm::InputTag zMuMu_, zMuMuMatchMap_; 
00051   InputTag triggerResultsTag, tracksTag, muonTag, anyDimuonTag;
00052  
00053  
00054   // general histograms
00055   
00056   // global counters
00057   int counterMatrix[5][5];  
00058 };
00059 
00060 #include "FWCore/ServiceRegistry/interface/Service.h"
00061 #include "CommonTools/UtilAlgos/interface/TFileService.h"
00062 #include "DataFormats/Common/interface/Handle.h"
00063 #include "DataFormats/Candidate/interface/Particle.h"
00064 #include "DataFormats/Candidate/interface/Candidate.h"
00065 #include "DataFormats/Common/interface/ValueMap.h"
00066 #include "DataFormats/Candidate/interface/CandAssociation.h"
00067 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
00068 #include "DataFormats/Math/interface/LorentzVector.h"
00069 #include "DataFormats/TrackReco/interface/Track.h"
00070 #include <iostream>
00071 #include <iterator>
00072 #include <cmath>
00073 using namespace std;
00074 using namespace reco;
00075 using namespace edm;
00076 
00077 dimuonHLTFilterCheck::dimuonHLTFilterCheck(const ParameterSet& pset) : 
00078   // trigger results
00079   triggerResultsTag(pset.getParameter<InputTag>("triggerResults")),
00080   tracksTag(pset.getParameter<InputTag>("tracks")), 
00081   muonTag(pset.getParameter<InputTag>("muons")), 
00082   anyDimuonTag(pset.getParameter<InputTag>("anyDimuon")) 
00083 {
00084   Service<TFileService> fs;
00085   
00086   
00087 // general histograms
00088   
00089 // general counters
00090   for (int i=0; i<5; i++) {
00091     for (int j=0;j<5;j++) {
00092       counterMatrix[i][j]=0;
00093     }
00094   }
00095 }
00096 
00097 void dimuonHLTFilterCheck::analyze(const Event& event, const EventSetup& setup) {
00098 
00099   Handle<TriggerResults> triggerResults;   // trigger response
00100   Handle<CandidateView> anyDimuon;         // any dimuon pair
00101   Handle<CandidateView> tracks;            // any track
00102   Handle<CandidateView> muons;             // any muon
00103   
00104   event.getByLabel( triggerResultsTag, triggerResults );
00105   event.getByLabel( anyDimuonTag, anyDimuon );
00106   event.getByLabel( tracksTag, tracks );
00107   event.getByLabel( muonTag, muons );
00108 
00109   const edm::TriggerNames & triggerNames = event.triggerNames(*triggerResults);
00110 
00111   // map of MU triggers of interest
00112   map<string,int> dimuonHLT_triggers;
00113   dimuonHLT_triggers.insert(make_pair("HLT1MuonPrescalePt3",0));
00114   dimuonHLT_triggers.insert(make_pair("HLT1MuonPrescalePt7x7",1));
00115   dimuonHLT_triggers.insert(make_pair("HLT1MuonIso",2));
00116   dimuonHLT_triggers.insert(make_pair("HLT1MuonNonIso15",3));
00117   dimuonHLT_triggers.insert(make_pair("HLT2MuonNonIso",4));
00118   // map of JET triggers of interest
00119   map<string,int> jetHLT_triggers;
00120   jetHLT_triggers.insert(make_pair("HLT1jetPE5",0));
00121   jetHLT_triggers.insert(make_pair("HLT1jetPE3",1));
00122   jetHLT_triggers.insert(make_pair("HLT1jetPE1",2));
00123   jetHLT_triggers.insert(make_pair("candHLT1jetPE7",3));
00124 
00125   bool trgMask[5];
00126   for (int i=0; i<5; i++) trgMask[i] = false;
00127 
00128   // table of possible dimuons
00129   string dimuonTableNames[10];
00130   dimuonTableNames[0] = "global-global";
00131   dimuonTableNames[1] = "global-trackerSta";
00132   dimuonTableNames[2] = "global-sta";
00133   dimuonTableNames[3] = "global-tracker";
00134   dimuonTableNames[4] = "trackerSta-trackerSta";
00135   dimuonTableNames[5] = "trackerSta-sta";
00136   dimuonTableNames[6] = "trackerSta-tracker";
00137   dimuonTableNames[7] = "sta-sta";
00138   dimuonTableNames[8] = "sta-tracker";
00139   dimuonTableNames[9] = "tracker-tracker";
00140   // table of possible muons
00141   string muonTableNames[10];
00142   muonTableNames[0] = "global";
00143   muonTableNames[1] = "trackerSta";
00144   muonTableNames[2] = "sta";
00145   muonTableNames[3] = "tracker";
00146 
00147   cout << "-------------------NEW event---------------------------" << endl;
00148   // check the dimuon reconstruction
00149   vector<int> dimuonTable;
00150   dimuonTable = nDimuonsByType(anyDimuon);
00151   // check the muon reconstruction
00152   vector<int> muonTable;
00153   muonTable = nMuonsByType(muons);
00154 
00155   if ( triggerResults.product()->wasrun() ){
00156       //      cout << "at least one path out of " << triggerResults.product()->size() << " ran? " << triggerResults.product()->wasrun() << endl;
00157       
00158     if ( triggerResults.product()->accept() ) 
00159       {
00160         //  cout << endl << "at least one path accepted? " << triggerResults.product()->accept() << endl;
00161         
00162         const unsigned int n_TriggerResults( triggerResults.product()->size() );
00163         for ( unsigned int itrig( 0 ); itrig < n_TriggerResults; ++itrig )
00164           {
00165             if ( triggerResults.product()->accept( itrig ) )
00166               {
00167                 map<string,int>::iterator iterMuHLT = dimuonHLT_triggers.find(triggerNames.triggerName( itrig ));
00168                 if (iterMuHLT != dimuonHLT_triggers.end()) {
00169                   cout << "ecco la chiave Mu HLT " << (*iterMuHLT).second << endl;
00170                   if (triggerResults.product()->state( itrig )==1) trgMask[(*iterMuHLT).second] = true;
00171                   }   // end if key found
00172                 map<string,int>::iterator iterjetHLT = jetHLT_triggers.find(triggerNames.triggerName( itrig ));
00173                 if (iterjetHLT != jetHLT_triggers.end()) {
00174                   cout << "ecco la chiave jet HLT " << (*iterjetHLT).second << endl;
00175                   }   // end if key found
00176                 
00177               }  // end if trigger accepted
00178           }   // end loop on triggerResults
00179       } // end if at least one triggerResult accepted
00180   }  // end if wasRun
00181   if ( muonTable[0]>1) {
00182     for(unsigned int i = 0; i < muons->size(); ++i) { //loop on candidates
00183       const Candidate & muCand = (*muons)[i]; //the candidate
00184       CandidateBaseRef muCandRef = muons->refAt(i);
00185       TrackRef muStaComponentRef = muCand.get<TrackRef,reco::StandAloneMuonTag>();  // standalone part of muon
00186       TrackRef muTrkComponentRef = muCand.get<TrackRef>();  // track part of muon
00187       if (muCandRef->isGlobalMuon()) {
00188         cout << "muCand : " << i << "  pt " << muCandRef->pt() << "  eta " << muCandRef->eta() << endl; 
00189         cout << "muCandStaComponent : " << i << "  pt " << muStaComponentRef->pt() << "  eta " << muStaComponentRef->eta() << endl; 
00190       }
00191     }
00192   }
00193   
00194   // fill counterMatrix
00195   for (int i=0; i<5; i++) {
00196     for (int j=0; j<5; j++) {
00197       if (trgMask[i] && trgMask[j]) counterMatrix[i][j]++;
00198     }
00199   }
00200 }  // end analyze
00201   
00202 vector<int> dimuonHLTFilterCheck::nDimuonsByType(const Handle<CandidateView> d) {
00203   vector<int> n_;
00204   int nCat = 10;    // number of dimuon categories (0 = glb-glb, 1 = glb-trkSta, 2 = glb-sta, 3 = glb-trk, 4 = trkSta-trkSta, 5 = trkSta-sta, 6 = trkSta-trk, 7 = sta-sta, 8 = sta-trk, 9  trk-trk)
00205   // reset vector
00206   for (int i=0; i<nCat; i++) n_.push_back(0);
00207   for(unsigned int i = 0; i < d->size(); ++i) { //loop on candidates
00208     //      const Candidate & dCand = (*d)[i]; //the candidate
00209     bool mu0global = false;
00210     bool mu0trackerSta = false;
00211     bool mu0sta = false;
00212     bool mu0tracker = false;
00213     bool mu1global = false;
00214     bool mu1trackerSta = false;
00215     bool mu1sta = false;
00216     bool mu1tracker = false;
00217     CandidateBaseRef dCandRef = d->refAt(i);
00218     const Candidate * mu0 = dCandRef->daughter(0);
00219     const Candidate * mu1 = dCandRef->daughter(1);
00220     if (mu0->isGlobalMuon()) mu0global=true;
00221     if (! mu0->isGlobalMuon() && mu0->isStandAloneMuon() && mu0->isTrackerMuon()) mu0trackerSta=true;
00222     if (! mu0->isGlobalMuon() && mu0->isStandAloneMuon() && ! mu0->isTrackerMuon()) mu0sta=true;
00223     if (! mu0->isGlobalMuon() && ! mu0->isStandAloneMuon() && mu0->isTrackerMuon()) mu0tracker=true;
00224     if (mu1->isGlobalMuon()) mu1global=true;
00225     if (! mu1->isGlobalMuon() && mu1->isStandAloneMuon() && mu1->isTrackerMuon()) mu1trackerSta=true;
00226     if (! mu1->isGlobalMuon() && mu1->isStandAloneMuon() && ! mu1->isTrackerMuon()) mu1sta=true;
00227     if (! mu1->isGlobalMuon() && ! mu1->isStandAloneMuon() && mu1->isTrackerMuon()) mu1tracker=true;
00228     
00229     if (mu0global && mu1global) n_[0]++;
00230     if ( (mu0global && mu1trackerSta) || (mu1global && mu0trackerSta) ) n_[1]++;
00231     if ( (mu0global && mu1sta) || (mu1global && mu0sta) ) n_[2]++;
00232     if ( (mu0global && mu1tracker) || (mu1global && mu0tracker) ) n_[3]++;
00233     if (mu0trackerSta && mu1trackerSta) n_[4]++;
00234     if ( (mu0trackerSta && mu1sta) || (mu1trackerSta && mu0sta) ) n_[5]++;
00235     if ( (mu0trackerSta && mu1tracker) || (mu1trackerSta && mu0tracker) ) n_[6]++;
00236     if (mu0sta && mu1sta) n_[7]++;
00237     if ( (mu0sta && mu1tracker) || (mu1sta && mu0tracker) ) n_[8]++;
00238     if (mu0tracker && mu1tracker) n_[9]++;
00239     
00240   }
00241   return n_;
00242 } 
00243   
00244 vector<int> dimuonHLTFilterCheck::nMuonsByType(const Handle<CandidateView> d) {
00245   vector<int> n_;
00246   int nCat = 4;    // number of muon categories (0 = glb, 1 = trkSta, 2 = sta, 3 = trk)
00247   // reset vector
00248   for (int i=0; i<nCat; i++) n_.push_back(0);
00249   for(unsigned int i = 0; i < d->size(); ++i) { //loop on candidates
00250     //      const Candidate & dCand = (*d)[i]; //the candidate
00251     bool muglobal = false;
00252     bool mutrackerSta = false;
00253     bool musta = false;
00254     bool mutracker = false;
00255     CandidateBaseRef muCandRef = d->refAt(i);
00256     if (muCandRef->isGlobalMuon()) muglobal=true;
00257     if (! muCandRef->isGlobalMuon() && muCandRef->isStandAloneMuon() && muCandRef->isTrackerMuon()) mutrackerSta=true;
00258     if (! muCandRef->isGlobalMuon() && muCandRef->isStandAloneMuon() && ! muCandRef->isTrackerMuon()) musta=true;
00259     if (! muCandRef->isGlobalMuon() && ! muCandRef->isStandAloneMuon() && muCandRef->isTrackerMuon()) mutracker=true;
00260     cout << "muglobal " << muglobal << " mutrackserSta " << mutrackerSta << " must " << musta << " mutracker " << mutracker << endl;
00261     if (muglobal) n_[0]++;
00262     if (mutrackerSta) n_[1]++;
00263     if (musta) n_[2]++;
00264     if (mutracker) n_[3]++;
00265     
00266   }
00267   return n_;
00268 } 
00269   
00270 void dimuonHLTFilterCheck::endJob() {
00271   
00272   cout << "------------------------------------  Counters  --------------------------------" << endl;
00273   for (int i=0; i<5; i++) {
00274     cout << "trg " << i << ": ";
00275     for (int j=0; j<5; j++) {
00276       cout << counterMatrix[i][j] << " ";
00277     }
00278     cout << endl;
00279   }
00280 }
00281 
00282 #include "FWCore/Framework/interface/MakerMacros.h"
00283 
00284 DEFINE_FWK_MODULE(dimuonHLTFilterCheck);
00285