Go to the documentation of this file.00001
00002
00003
00004
00005
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
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
00051 InputTag triggerResultsTag, tracksTag, muonTag, anyDimuonTag;
00052
00053
00054
00055
00056
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
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
00088
00089
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;
00100 Handle<CandidateView> anyDimuon;
00101 Handle<CandidateView> tracks;
00102 Handle<CandidateView> muons;
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
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
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
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
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
00149 vector<int> dimuonTable;
00150 dimuonTable = nDimuonsByType(anyDimuon);
00151
00152 vector<int> muonTable;
00153 muonTable = nMuonsByType(muons);
00154
00155 if ( triggerResults.product()->wasrun() ){
00156
00157
00158 if ( triggerResults.product()->accept() )
00159 {
00160
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 }
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 }
00176
00177 }
00178 }
00179 }
00180 }
00181 if ( muonTable[0]>1) {
00182 for(unsigned int i = 0; i < muons->size(); ++i) {
00183 const Candidate & muCand = (*muons)[i];
00184 CandidateBaseRef muCandRef = muons->refAt(i);
00185 TrackRef muStaComponentRef = muCand.get<TrackRef,reco::StandAloneMuonTag>();
00186 TrackRef muTrkComponentRef = muCand.get<TrackRef>();
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
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 }
00201
00202 vector<int> dimuonHLTFilterCheck::nDimuonsByType(const Handle<CandidateView> d) {
00203 vector<int> n_;
00204 int nCat = 10;
00205
00206 for (int i=0; i<nCat; i++) n_.push_back(0);
00207 for(unsigned int i = 0; i < d->size(); ++i) {
00208
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;
00247
00248 for (int i=0; i<nCat; i++) n_.push_back(0);
00249 for(unsigned int i = 0; i < d->size(); ++i) {
00250
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