CMS 3D CMS Logo
ZMuMuPerformances.cc
Go to the documentation of this file.
1 /* \class ZMuMuPerformances
2  *
3  * author: Davide Piccolo
4  *
5  * ZMuMu Performances:
6  * check charge mis-id for standAlone and global muons,
7  * check standAlne resolution vs track resolution
8  *
9  */
10 
11 #include "DataFormats/Common/interface/AssociationVector.h"
12 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
13 #include "DataFormats/Candidate/interface/CandMatchMap.h"
14 #include "FWCore/Framework/interface/EDAnalyzer.h"
15 #include "DataFormats/Candidate/interface/Particle.h"
16 #include "DataFormats/Candidate/interface/Candidate.h"
17 #include "DataFormats/Candidate/interface/CandidateFwd.h"
18 #include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
19 #include "DataFormats/MuonReco/interface/Muon.h"
20 #include "FWCore/ParameterSet/interface/ParameterSet.h"
21 #include "FWCore/Framework/interface/Event.h"
22 #include "FWCore/Framework/interface/EventSetup.h"
23 #include "FWCore/Utilities/interface/InputTag.h"
24 #include "DataFormats/Candidate/interface/OverlapChecker.h"
25 #include "DataFormats/Math/interface/deltaR.h"
26 #include "DataFormats/Candidate/interface/Particle.h"
27 #include "DataFormats/Candidate/interface/Candidate.h"
28 #include "DataFormats/Common/interface/ValueMap.h"
29 #include "DataFormats/Candidate/interface/CandAssociation.h"
30 #include "DataFormats/HepMCCandidate/interface/GenParticle.h"
31 #include "TH1.h"
32 #include "TH2.h"
33 #include "TH3.h"
34 #include <vector>
35 
36 using namespace edm;
37 using namespace std;
38 using namespace reco;
39 
40 typedef ValueMap<float> IsolationCollection;
41 
42 class ZMuMuPerformances : public edm::EDAnalyzer {
43 public:
44  ZMuMuPerformances(const edm::ParameterSet &pset);
45 
46 private:
47  void analyze(const edm::Event &event, const edm::EventSetup &setup) override;
48  bool check_ifZmumu(const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2);
49  float getParticlePt(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2);
50  float getParticleEta(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2);
51  float getParticlePhi(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2);
52  Particle::LorentzVector getParticleP4(const int ipart,
53  const Candidate *dauGen0,
54  const Candidate *dauGen1,
55  const Candidate *dauGen2);
56  void endJob() override;
57 
58  EDGetTokenT<CandidateView> zMuMuToken_;
59  EDGetTokenT<GenParticleMatch> zMuMuMatchMapToken_;
60  EDGetTokenT<CandidateView> zMuTrackToken_;
61  EDGetTokenT<GenParticleMatch> zMuTrackMatchMapToken_;
62  EDGetTokenT<CandidateView> zMuStandAloneToken_;
63  EDGetTokenT<GenParticleMatch> zMuStandAloneMatchMapToken_;
64  EDGetTokenT<CandidateView> muonsToken_;
65  EDGetTokenT<GenParticleMatch> muonMatchMapToken_;
66  EDGetTokenT<IsolationCollection> muonIsoToken_;
67  EDGetTokenT<CandidateView> tracksToken_;
68  EDGetTokenT<IsolationCollection> trackIsoToken_;
69  EDGetTokenT<GenParticleCollection> genParticlesToken_;
70 
71  bool noCut_;
72  double zMassMin_, zMassMax_;
73  double ptminPlus_, ptmaxPlus_, etaminPlus_, etamaxPlus_;
74  double ptminMinus_, ptmaxMinus_, etaminMinus_, etamaxMinus_, isomax_;
75 
76  double etamax_, ptmin_, massMin_, massMax_, isoMax_;
77 
78  reco::CandidateBaseRef globalMuonCandRef_, trackMuonCandRef_, standAloneMuonCandRef_;
79  OverlapChecker overlap_;
80 
81  // general histograms
82  TH1D *h_n_globalMuon_perEvent, *h_n_staOnlyMuon_perEvent, *h_n_trackerOnlyMuon_perEvent,
83  *h_n_trackerStaOnlyMuon_perEvent;
84  TH1D *h_n_globalMuon_perEvent_MCmatch, *h_n_staOnlyMuon_perEvent_MCmatch, *h_n_trackerOnlyMuon_perEvent_MCmatch;
85  TH1D *h_n_trackerStaOnlyMuon_perEvent_MCmatch, *h_n_tracks_perEvent;
86  TH1D *h_n_zMuMu_perEvent, *h_n_zMuSta_perEvent, *h_n_zMuTrack_perEvent;
87 
88  // zMuMu inv mass
89  TH1D *h_zMuMuMassSameSign, *h_zMuMuMassSameSign_MCmatch, *h_zMuMuMassOppositeSign;
90  // histograms with MC truth
91  // charge truth
92  TH1D *h_GlobalMuonChargeTimeGenCharge, *h_TrackerMuonChargeTimeGenCharge;
93  // resolution respect to gen particles
94  TH1D *h_GlobalMuonEtaMinusGenEta, *h_TrackerMuonEtaMinusGenEta, *h_GlobalMuonPtMinusGenPt, *h_TrackerMuonPtMinusGenPt;
95  TH1D *h_GlobalMuonStaComponentEtaMinusGenEta, *h_GlobalMuonStaComponentPtMinusGenPt;
96  TH2D *h_DEtaGlobalGenvsEtaGen, *h_DPtGlobalGenvsPtGen, *h_DEtaGlobalStaComponentGenvsEtaGen,
97  *h_DPtGlobalStaComponentGenvsPtGen;
98  TH2D *h_DPtGlobalGenvsEtaGen, *h_DPtGlobalStaComponentGenvsEtaGen;
99  // resolution respect to gen particles for ZMuMuTagged events
100  TH1D *h_GlobalMuonEtaMinusGenEta_ZMuMuTagged;
101  TH1D *h_GlobalMuonPtMinusGenPt_ZMuMuTagged;
102  TH1D *h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged, *h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged;
103  TH2D *h_DEtaGlobalGenvsEtaGen_ZMuMuTagged, *h_DPtGlobalGenvsPtGen_ZMuMuTagged;
104  TH2D *h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged, *h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged;
105  TH2D *h_DPtGlobalGenvsEtaGen_ZMuMuTagged, *h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged;
106  TH2D *h_DPtTrackGenvsPtGen_ZMuMuTagged, *h_DPtTrackGenvsEtaGen_ZMuMuTagged;
107 
108  // histograms for cynematic of ZMuMutagged muons for STA performances studies
109  TH1D *h_zMuTrackMass_ZMuMuTagged, *h_etaTrack_ZMuMuTagged, *h_phiTrack_ZMuMuTagged, *h_ptTrack_ZMuMuTagged,
110  *h_DRTrack_ZMuMuTagged;
111  // histograms for cynematic of ZMuMutagged muons when StandAlone has wrong charge
112  TH1D *h_zMuTrackMass_wrongStaCharge_ZMuMuTagged, *h_etaTrack_wrongStaCharge_ZMuMuTagged;
113  TH1D *h_phiTrack_wrongStaCharge_ZMuMuTagged, *h_ptTrack_wrongStaCharge_ZMuMuTagged,
114  *h_DRTrack_wrongStaCharge_ZMuMuTagged;
115 
116  // hisograms for performances of Standlone when Sta has correct charge
117  TH1D *h_zMuStaMass_correctStaCharge_ZMuMuTagged, *h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged;
118  TH2D *h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged;
119  TH2D *h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged;
120 
121  // histograms for cynematic of ZMuMutagged muons for TRK performances studies
122  TH1D *h_zMuStaMass_ZMuMuTagged, *h_etaSta_ZMuMuTagged, *h_phiSta_ZMuMuTagged, *h_ptSta_ZMuMuTagged,
123  *h_DRSta_ZMuMuTagged;
124  // histograms for cynematic of ZMuMutagged muons when TRK has wrong charge
125  TH1D *h_zMuStaMass_wrongTrkCharge_ZMuMuTagged, *h_etaSta_wrongTrkCharge_ZMuMuTagged;
126  TH1D *h_phiSta_wrongTrkCharge_ZMuMuTagged, *h_ptSta_wrongTrkCharge_ZMuMuTagged, *h_DRSta_wrongTrkCharge_ZMuMuTagged;
127 
128  // histograms for cynematic of ZMuTracktagged muons with unMatchd StandAlone for STA performances studies
129  TH1D *h_zMuTrackMass_ZMuTrackTagged, *h_etaTrack_ZMuTrackTagged, *h_phiTrack_ZMuTrackTagged,
130  *h_ptTrack_ZMuTrackTagged, *h_DRTrack_ZMuTrackTagged;
131  // histograms for cynematic of ZMuTracktagged muons when unMatched StandAlone has wrong charge
132  TH1D *h_zMuTrackMass_wrongStaCharge_ZMuTrackTagged, *h_etaTrack_wrongStaCharge_ZMuTrackTagged;
133  TH1D *h_phiTrack_wrongStaCharge_ZMuTrackTagged, *h_ptTrack_wrongStaCharge_ZMuTrackTagged,
134  *h_DRTrack_wrongStaCharge_ZMuTrackTagged;
135 
136  // histograms for cynematic of ZMuStatagged muons with unMatchd Track for Track performances studies
137  TH1D *h_zMuStaMass_ZMuStaTagged, *h_etaSta_ZMuStaTagged, *h_phiSta_ZMuStaTagged, *h_ptSta_ZMuStaTagged;
138  // histograms for cynematic of ZMuStatagged muons when unMatched Track has wrong charge
139  TH1D *h_zMuStaMass_wrongTrkCharge_ZMuStaTagged, *h_etaSta_wrongTrkCharge_ZMuStaTagged;
140  TH1D *h_phiSta_wrongTrkCharge_ZMuStaTagged, *h_ptSta_wrongTrkCharge_ZMuStaTagged;
141 
142  // global counters
143  int totalNumberOfZfound; // total number of events with Z found
144  int totalNumberOfZpassed; // total number of Z that pass cynematical cuts at generator level
145 
146  int nZMuMuSameSign; // number of ZMuMu SameSIgn (no Cuts)
147  int nZMuMuSameSign_mcMatched; // number of ZMuMu Same Sign (no cuts) MCmatch
148 
149  int n_goodTrack_ZMuMutagged; // total number of tracks selected and tagged to study Sta charge
150  int n_correctStaCharge_ZMuMutagged; // total number of tracks selected and tagged with correct charge of Sta
151  int n_wrongStaCharge_ZMuMutagged; // total number of tracks selected and tagged with wrong charge of Sta
152 
153  int n_goodSta_ZMuMutagged; // total number of standAlone selected and tagged to study Trk charge
154  int n_correctTrkCharge_ZMuMutagged; // total number of standAlone selected and tagged with correct charge of Trk
155  int n_wrongTrkCharge_ZMuMutagged; // total number of standAlone selected and tagged with wrong charge of Trk
156 
157  int n_goodTrack_ZMuTracktagged; // number of traks selected and tagged to study Sta charge (for ZMuTrack colllection no ZMuMu found)
158  int n_correctStaCharge_ZMuTracktagged; // total number of tracks selected and tagged with correct charge of unMatched Sta
159  int n_wrongStaCharge_ZMuTracktagged; // total number of tracks selected and tagged with wrong charge of unMatched Sta
160  int n_StaNotFound_ZMuTracktagged; // total number of tracks selected and tagged with no STA found
161 
162  int n_goodSta_ZMuStatagged; // number of sta selected and tagged to study Trk charge (for ZMuSta collection no ZMuMu found)
163  int n_correctTrkCharge_ZMuStatagged; // total number of sta selected and tagged with correct charge of unMatched track
164  int n_wrongTrkCharge_ZMuStatagged; // total number of sta selected and tagged with wrong charge of unMatched track
165  int n_TrkNotFound_ZMuStatagged; // total number of selected selected and tagged with no Trk found
166 
167  int n_OneGoodZMuTrack; // total number with just 1 good ZMuTrack found
168  int n_MultipleGoodZMuTrack; // total number with more than 1 good ZMuTrack found
169  int numberOfMatchedZMuSta_;
170  int n_ZMuStaTaggedMatched;
171 };
172 
173 #include "FWCore/ServiceRegistry/interface/Service.h"
174 #include "CommonTools/UtilAlgos/interface/TFileService.h"
175 #include "DataFormats/Common/interface/Handle.h"
176 #include "DataFormats/Math/interface/LorentzVector.h"
177 #include "DataFormats/TrackReco/interface/Track.h"
178 #include <iostream>
179 #include <iterator>
180 #include <cmath>
181 
182 ZMuMuPerformances::ZMuMuPerformances(const ParameterSet &pset)
183  : zMuMuToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuMu"))),
184  zMuMuMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuMuMatchMap"))),
185  zMuTrackToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuTrack"))),
186  zMuTrackMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuTrackMatchMap"))),
187  zMuStandAloneToken_(consumes<CandidateView>(pset.getParameter<InputTag>("zMuStandAlone"))),
188  zMuStandAloneMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("zMuStandAloneMatchMap"))),
189  muonsToken_(consumes<CandidateView>(pset.getParameter<InputTag>("muons"))),
190  muonMatchMapToken_(mayConsume<GenParticleMatch>(pset.getParameter<InputTag>("muonMatchMap"))),
191  muonIsoToken_(mayConsume<IsolationCollection>(pset.getParameter<InputTag>("muonIso"))),
192  tracksToken_(consumes<CandidateView>(pset.getParameter<InputTag>("tracks"))),
193  trackIsoToken_(mayConsume<IsolationCollection>(pset.getParameter<InputTag>("trackIso"))),
194  genParticlesToken_(consumes<GenParticleCollection>(pset.getParameter<InputTag>("genParticles"))),
195 
196  noCut_(pset.getParameter<bool>("noCut")),
197 
198  zMassMin_(pset.getUntrackedParameter<double>("zMassMin")),
199  zMassMax_(pset.getUntrackedParameter<double>("zMassMax")),
200  ptminPlus_(pset.getUntrackedParameter<double>("ptminPlus")),
201  ptmaxPlus_(pset.getUntrackedParameter<double>("ptmaxPlus")),
202  etaminPlus_(pset.getUntrackedParameter<double>("etaminPlus")),
203  etamaxPlus_(pset.getUntrackedParameter<double>("etamaxPlus")),
204  ptminMinus_(pset.getUntrackedParameter<double>("ptminMinus")),
205  ptmaxMinus_(pset.getUntrackedParameter<double>("ptmaxMinus")),
206  etaminMinus_(pset.getUntrackedParameter<double>("etaminMinus")),
207  etamaxMinus_(pset.getUntrackedParameter<double>("etamaxMinus")),
208  isomax_(pset.getUntrackedParameter<double>("isomax")) {
209  Service<TFileService> fs;
210 
211  // cut setting
212  etamax_ = etamaxPlus_;
213  ptmin_ = ptminPlus_;
214  massMin_ = zMassMin_;
215  massMax_ = zMassMax_;
216  isoMax_ = isomax_;
217 
218  // general histograms
219  h_n_globalMuon_perEvent = fs->make<TH1D>("n_globalMuon_perEvent", "n.of globalMuons per Event", 6, -.5, 5.5);
220  h_n_staOnlyMuon_perEvent =
221  fs->make<TH1D>("n_staOnlyMuon_perEvent", "n.of standAlone Only Muons per Event", 6, -.5, 5.5);
222  h_n_trackerOnlyMuon_perEvent =
223  fs->make<TH1D>("n_trackerOnlyMuon_perEvent", "n.of tracker Only Muons per Event", 6, -.5, 5.5);
224  h_n_trackerStaOnlyMuon_perEvent =
225  fs->make<TH1D>("n_trackerStaOnlyMuon_perEvent", "n.of tracker & StandAlone Only Muons per Event", 6, -.5, 5.5);
226  h_n_globalMuon_perEvent_MCmatch =
227  fs->make<TH1D>("n_globalMuon_perEvent_MCmatch", "n.of globalMuons per Event (MCmatch)", 6, -.5, 5.5);
228  h_n_staOnlyMuon_perEvent_MCmatch =
229  fs->make<TH1D>("n_staOnlyMuon_perEvent_MCmatch", "n.of standAlone Only Muons per Event (MCmatch)", 6, -.5, 5.5);
230  h_n_trackerOnlyMuon_perEvent_MCmatch =
231  fs->make<TH1D>("n_trackerOnlyMuon_perEvent_MCmatch", "n.of tracker Only Muons per Event (MCmatch)", 6, -.5, 5.5);
232  h_n_trackerStaOnlyMuon_perEvent_MCmatch = fs->make<TH1D>(
233  "n_trackerStaOnlyMuon_perEvent_MCmatch", "n.of tracker & StandAlone Only Muons per Event (MCmatch)", 6, -.5, 5.5);
234  h_n_tracks_perEvent = fs->make<TH1D>("n_tracks_perEvent", "n.of tracks per Event", 100, -.5, 99.5);
235  h_n_zMuMu_perEvent = fs->make<TH1D>("n_zMuMu_perEvent", "n.of global-global muons per Event", 6, -.5, 5.5);
236  h_n_zMuSta_perEvent = fs->make<TH1D>("n_zMuSta_perEvent", "n.of global-sta muons per Event", 6, -.5, 5.5);
237  h_n_zMuTrack_perEvent = fs->make<TH1D>("n_zMuTrack_perEvent", "n.of global-track muons per Event", 100, -.5, 99.5);
238 
239  // zMuMu inv mass
240  h_zMuMuMassSameSign = fs->make<TH1D>("zMuMuMassSameSign", "inv Mass ZMuMu cand SameSign", 100, 0., 200.);
241  h_zMuMuMassOppositeSign = fs->make<TH1D>("zMuMuMassOppositeSign", "inv Mass ZMuMu cand OppositeSign", 100, 0., 200.);
242  h_zMuMuMassSameSign_MCmatch =
243  fs->make<TH1D>("zMuMuMassSameSign_MCmatch", "inv Mass ZMuMu cand SameSign (MC match)", 100, 0., 200.);
244 
245  // histograms for MC truth
246  // charge truth
247  h_GlobalMuonChargeTimeGenCharge =
248  fs->make<TH1D>("GlobalMuonChargeTimeGenCharge", "charge global mu times charge generated mu", 3, -1.5, 1.5);
249  h_TrackerMuonChargeTimeGenCharge =
250  fs->make<TH1D>("TrackerMuonChargeTimeGenCharge", "charge Tracker mu times charge generated mu", 3, -1.5, 1.5);
251  // resolution respect to gen particles
252  h_GlobalMuonEtaMinusGenEta =
253  fs->make<TH1D>("GlobalMuonEtaMinusGenEta", "global mu Eta minus generated mu Eta", 100, -.005, .005);
254  h_GlobalMuonPtMinusGenPt =
255  fs->make<TH1D>("GlobalMuonPtMinusGenPtoverPt", "global mu Pt minus generated mu Pt over Pt", 100, -.5, .5);
256  h_GlobalMuonStaComponentEtaMinusGenEta = fs->make<TH1D>(
257  "GlobalMuonStaComponentEtaMinusGenEta", "global mu Sta cmponent Eta minus generated mu Eta", 100, -.5, .5);
258  h_GlobalMuonStaComponentPtMinusGenPt = fs->make<TH1D>("GlobalMuonStaComponentPtMinusGenPtoerPt",
259  "global mu Sta component Pt minus generated mu Pt over Pt",
260  100,
261  -1.,
262  1.);
263  h_TrackerMuonEtaMinusGenEta =
264  fs->make<TH1D>("TrackerMuonEtaMinusGenEta", "Tracker mu Eta minus Eta generated mu", 100, -.005, .005);
265  h_TrackerMuonPtMinusGenPt =
266  fs->make<TH1D>("TrackerMuonPtMinusenPtoverPt", "Tracker mu Pt minus Pt generated mu over Pt", 100, -.5, .5);
267 
268  h_DEtaGlobalGenvsEtaGen =
269  fs->make<TH2D>("h_DEtaGlobalGenvsEtaGen", "Eta global - Eta Gen vs Eta gen", 50, -2.5, 2.5, 100, -.005, .005);
270  h_DEtaGlobalStaComponentGenvsEtaGen = fs->make<TH2D>("h_DEtaGlobalStaComponentGenvsEtaGen",
271  "Eta Sta component of a Global - Eta Gen vs Eta gen",
272  50,
273  -2.5,
274  2.5,
275  100,
276  -.5,
277  .5);
278  h_DPtGlobalGenvsPtGen =
279  fs->make<TH2D>("h_DPtGlobalGenovePtvsPtGen", "Pt global - Pt Gen over Pt vs Pt gen", 50, 0., 100., 100, -.5, .5);
280  h_DPtGlobalStaComponentGenvsPtGen = fs->make<TH2D>("h_DPtGlobalStaComponentGenoverPtvsPtGen",
281  "Pt Sta component of a Global - Pt Gen over Pt vs Pt gen",
282  50,
283  0.,
284  100.,
285  100,
286  -1.,
287  1.);
288 
289  // resolution respect to gen particles for ZMuMuTagged events
290  h_GlobalMuonEtaMinusGenEta_ZMuMuTagged =
291  fs->make<TH1D>("GlobalMuonEtaMinusGenEta_ZMuMuTagged", "global mu Eta minus generated mu Eta", 100, -.005, .005);
292  h_GlobalMuonPtMinusGenPt_ZMuMuTagged = fs->make<TH1D>(
293  "GlobalMuonPtMinusGenPtoverPt_ZMuMuTagged", "global mu Pt minus generated mu Pt over Pt", 100, -.5, .5);
294  h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged =
295  fs->make<TH1D>("GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged",
296  "global mu Sta cmponent Eta minus generated mu Eta",
297  100,
298  -.5,
299  .5);
300  h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged =
301  fs->make<TH1D>("GlobalMuonStaComponentPtMinusGenPtoverPt_ZMuMuTagged",
302  "global mu Sta component Pt minus generated mu Pt over Pt",
303  100,
304  -1.,
305  1.);
306  h_DEtaGlobalGenvsEtaGen_ZMuMuTagged = fs->make<TH2D>(
307  "h_DEtaGlobalGenvsEtaGen_ZMuMuTagged", "Eta global - Eta Gen vs Eta gen", 50, -2.5, 2.5, 100, -.005, .005);
308  h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged = fs->make<TH2D>("h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged",
309  "Eta Sta component of a Global - Eta Gen vs Eta gen",
310  50,
311  -2.5,
312  2.5,
313  100,
314  -.5,
315  .5);
316  h_DPtGlobalGenvsPtGen_ZMuMuTagged = fs->make<TH2D>(
317  "h_DPtGlobalGenOverPtvsPtGen_ZMuMuTagged", "Pt global - Pt Gen vs Pt gen over Pt", 50, 0., 100., 100, -.5, .5);
318  h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged =
319  fs->make<TH2D>("h_DPtGlobalStaComponentGenoverPtvsPtGen_ZMuMuTagged",
320  "Pt Sta component of a Global - Pt Gen over Pt vs Pt gen",
321  50,
322  0.,
323  100.,
324  100,
325  -1.,
326  1.);
327  h_DPtGlobalGenvsEtaGen_ZMuMuTagged = fs->make<TH2D>(
328  "h_DPtGlobalGenOverPtvsEtaGen_ZMuMuTagged", "Pt global - Pt Gen over Pt vs Eta gen", 50, -2.5, 2.5, 100, -.5, .5);
329  h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged =
330  fs->make<TH2D>("h_DPtGlobalStaComponentGenoverPtvsEtaGen_ZMuMuTagged",
331  "Pt Sta component of a Global - Pt Gen over Pt vs Eta gen",
332  50,
333  -2.5,
334  2.5,
335  100,
336  -1.,
337  1.);
338  h_DPtTrackGenvsPtGen_ZMuMuTagged = fs->make<TH2D>(
339  "h_DPtTrackGenOverPtvsPtGen_ZMuMuTagged", "Pt track - Pt Gen vs Pt gen over Pt", 50, 0., 100., 100, -.5, .5);
340  h_DPtTrackGenvsEtaGen_ZMuMuTagged = fs->make<TH2D>(
341  "h_DPtTrackGenOverPtvsEtaGen_ZMuMuTagged", "Pt track - Pt Gen over Pt vs Eta gen", 50, -2.5, 2.5, 100, -.5, .5);
342 
343  // histograms for cynematic of ZMuMutagged muons for Sta performances studies
344  h_zMuTrackMass_ZMuMuTagged =
345  fs->make<TH1D>("zMuTrackMass_ZMuMuTagged", "inv Mass ZMuTrack cand (global-global)", 100, 0., 200.);
346  h_etaTrack_ZMuMuTagged = fs->make<TH1D>("etaTrack_ZMuMuTagged", "eta of Track (global-global)", 50, -2.5, 2.5);
347  h_phiTrack_ZMuMuTagged = fs->make<TH1D>("phiTrack_ZMuMuTagged", "phi of Track (global-global)", 50, -3.1415, 3.1415);
348  h_ptTrack_ZMuMuTagged = fs->make<TH1D>("ptTrack_ZMuMuTagged", "pt of Track (global-global)", 100, 0., 100.);
349  h_DRTrack_ZMuMuTagged = fs->make<TH1D>("DRTrackSta_ZMuMuTagged", "DR track-sta (global-global)", 100, 0., 5.);
350 
351  // histograms for cynematic of ZMuMutagged muons when StandAlone has wrong charge
352  h_zMuTrackMass_wrongStaCharge_ZMuMuTagged = fs->make<TH1D>(
353  "zMuTrackMass_wrongStaCharge_ZMuMuTagged", "inv Mass ZMuTrack cand (global-global wrongStaCharge)", 100, 0., 200.);
354  h_etaTrack_wrongStaCharge_ZMuMuTagged = fs->make<TH1D>(
355  "etaTrack_wrongStaCharge_ZMuMuTagged", "eta of Track (global-global wrongStaCharge)", 50, -2.5, 2.5);
356  h_phiTrack_wrongStaCharge_ZMuMuTagged = fs->make<TH1D>(
357  "phiTrack_wrongStaCharge_ZMuMuTagged", "phi of Track (global-global wrongStaCharge)", 50, -3.1415, 3.1415);
358  h_ptTrack_wrongStaCharge_ZMuMuTagged =
359  fs->make<TH1D>("ptTrack_wrongStaCharge_ZMuMuTagged", "pt of Track (global-global wrongStaCharge)", 100, 0., 100.);
360  h_DRTrack_wrongStaCharge_ZMuMuTagged = fs->make<TH1D>(
361  "DRTrackSta_wrongStaCharge_ZMuMuTagged", "DR track-sta (global-global wrongStaCharge)", 100, 0., 5.);
362 
363  // hisograms for performances of StandAlone when StandAlone has correct charge
364  h_zMuStaMass_correctStaCharge_ZMuMuTagged = fs->make<TH1D>(
365  "zMuStaMass_correctStaCharge_ZMuMuTagged", "inv Mass ZMuSta cand (global-global correctStaCharge)", 100, 0., 200.);
366  h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged =
367  fs->make<TH1D>("ptStaMinusptTrackoverPT_correctStaCharge_ZMuMuTagged",
368  "ptSta - ptTrack over Pt (global-global correctStaCharge)",
369  100,
370  -1.,
371  1.);
372  h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged =
373  fs->make<TH2D>("ptStaMinusptTrackoverPt_vsPtTracker_correctStaCharge_ZMuMuTagged",
374  "ptSta - ptTrack over Pt vs ptTrack (global-global correctStaCharge)",
375  100,
376  0.,
377  100.,
378  100,
379  -1.,
380  1.);
381  h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged =
382  fs->make<TH2D>("ptStaMinusptTrackoverPt_vsEtaTracker_correctStaCharge_ZMuMuTagged",
383  "ptSta - ptTrack over Pt vs etaTrack (global-global correctStaCharge)",
384  100,
385  -2.5,
386  2.5,
387  100,
388  -1.,
389  1.);
390 
391  // histograms for cynematic of ZMuMutagged muons for TRK performances studies
392  h_zMuStaMass_ZMuMuTagged =
393  fs->make<TH1D>("zMuStaMass_ZMuMuTagged", "inv Mass ZMuSta cand (global-global)", 100, 0., 200.);
394  h_etaSta_ZMuMuTagged = fs->make<TH1D>("etaSta_ZMuMuTagged", "eta of Sta (global-global)", 50, -2.5, 2.5);
395  h_phiSta_ZMuMuTagged = fs->make<TH1D>("phiSta_ZMuMuTagged", "phi of Sta (global-global)", 50, -3.1415, 3.1415);
396  h_ptSta_ZMuMuTagged = fs->make<TH1D>("ptSta_ZMuMuTagged", "pt of Sta (global-global)", 100, 0., 100.);
397  h_DRSta_ZMuMuTagged =
398  fs->make<TH1D>("DRTrackSta_ZMuMuTagged_staSelected", "DR track-sta sta selected (global-global)", 100, 0., 5.);
399 
400  // histograms for cynematic of ZMuMutagged muons when Track has wrong charge
401  h_zMuStaMass_wrongTrkCharge_ZMuMuTagged = fs->make<TH1D>(
402  "zMuStaMass_wrongTrkCharge_ZMuMuTagged", "inv Mass ZMuSta cand (global-global wrongTrkCharge)", 100, 0., 200.);
403  h_etaSta_wrongTrkCharge_ZMuMuTagged =
404  fs->make<TH1D>("etaSta_wrongTrkCharge_ZMuMuTagged", "eta of Sta (global-global wrongTrkCharge)", 50, -2.5, 2.5);
405  h_phiSta_wrongTrkCharge_ZMuMuTagged = fs->make<TH1D>(
406  "phiSta_wrongTrkCharge_ZMuMuTagged", "phi of Sta (global-global wrongTrkCharge)", 50, -3.1415, 3.1415);
407  h_ptSta_wrongTrkCharge_ZMuMuTagged =
408  fs->make<TH1D>("ptSta_wrongTrkCharge_ZMuMuTagged", "pt of Sta (global-global wrongTrkCharge)", 100, 0., 100.);
409  h_DRSta_wrongTrkCharge_ZMuMuTagged = fs->make<TH1D>(
410  "DRTrackSta_wrongTrkCharge_ZMuMuTagged", "DR track-sta (global-global wrongTrkCharge)", 100, 0., 5.);
411 
412  //
413  // ****************************************************************************************************
414  // histograms for cynematic of ZMuTracktagged muons with unMatched StandAlone
415  h_zMuTrackMass_ZMuTrackTagged =
416  fs->make<TH1D>("zMuTrackMass_ZMuTrackTagged", "inv Mass ZMuTrack cand (global-track)", 100, 0., 200.);
417  h_etaTrack_ZMuTrackTagged = fs->make<TH1D>("etaTrack_ZMuTrackTagged", "eta of Track (global-track)", 50, -2.5, 2.5);
418  h_phiTrack_ZMuTrackTagged =
419  fs->make<TH1D>("phiTrack_ZMuTrackTagged", "phi of Track (global-track)", 50, -3.1415, 3.1415);
420  h_ptTrack_ZMuTrackTagged = fs->make<TH1D>("ptTrack_ZMuTrackTagged", "pt of Track (global-track)", 100, 0., 100.);
421  h_DRTrack_ZMuTrackTagged = fs->make<TH1D>("DRTrackSta_ZMuTrackTagged", "DR track-sta (global-track)", 100, 0., 5.);
422 
423  // histograms for cynematic of ZMuTracktagged muons when unMatched StandAlone has wrong charge
424  h_zMuTrackMass_wrongStaCharge_ZMuTrackTagged =
425  fs->make<TH1D>("zMuTrackMass_wrongStaCharge_ZMuTrackTagged",
426  "inv Mass ZMuTrack cand (global-track wrongUnMatcehdStaCharge)",
427  100,
428  0.,
429  200.);
430  h_etaTrack_wrongStaCharge_ZMuTrackTagged = fs->make<TH1D>(
431  "etaTrack_wrongStaCharge_ZMuTrackTagged", "eta of Track (global-track wrongUnMatchedStaCharge)", 50, -2.5, 2.5);
432  h_phiTrack_wrongStaCharge_ZMuTrackTagged = fs->make<TH1D>("phiTrack_wrongStaCharge_ZMuTrackTagged",
433  "phi of Track (global-track wrongUnMatchedStaCharge)",
434  50,
435  -3.1415,
436  3.1415);
437  h_ptTrack_wrongStaCharge_ZMuTrackTagged = fs->make<TH1D>(
438  "ptTrack_wrongStaCharge_ZMuTrackTagged", "pt of Track (global-track wrongUnMatchedStaCharge)", 100, 0., 100.);
439  h_DRTrack_wrongStaCharge_ZMuTrackTagged = fs->make<TH1D>(
440  "DRTrackSta_wrongStaCharge_ZMuTrackTagged", "DR track-sta (global-track wrongUnMatchedStaCharge)", 100, 0., 5.);
441 
442  // histograms for cynematic of ZMuStatagged muons with unMatched Track
443  h_zMuStaMass_ZMuStaTagged =
444  fs->make<TH1D>("zMuStaMass_ZMuStaTagged", "inv Mass ZMuSta cand (global-sta)", 100, 0., 200.);
445  h_etaSta_ZMuStaTagged = fs->make<TH1D>("etaSta_ZMuStaTagged", "eta of Sta (global-sta)", 50, -2.5, 2.5);
446  h_phiSta_ZMuStaTagged = fs->make<TH1D>("phiSta_ZMuStaTagged", "phi of Sta (global-sta)", 50, -3.1415, 3.1415);
447  h_ptSta_ZMuStaTagged = fs->make<TH1D>("ptSta_ZMuStaTagged", "pt of Sta (global-sta)", 100, 0., 100.);
448 
449  // histograms for cynematic of ZMuStatagged muons when unMatched track has wrong charge
450  h_zMuStaMass_wrongTrkCharge_ZMuStaTagged = fs->make<TH1D>("zMuStaMass_wrongTrkCharge_ZMuStaTagged",
451  "inv Mass ZMuSta cand (global-sta wrongUnMatcehdTrkCharge)",
452  100,
453  0.,
454  200.);
455  h_etaSta_wrongTrkCharge_ZMuStaTagged = fs->make<TH1D>(
456  "etaSta_wrongTrkCharge_ZMuStaTagged", "eta of Sta (global-sta wrongUnMatchedTrkCharge)", 50, -2.5, 2.5);
457  h_phiSta_wrongTrkCharge_ZMuStaTagged = fs->make<TH1D>(
458  "phiSta_wrongTrkCharge_ZMuStaTagged", "phi of Sta (global-sta wrongUnMatchedTrkCharge)", 50, -3.1415, 3.1415);
459  h_ptSta_wrongTrkCharge_ZMuStaTagged = fs->make<TH1D>(
460  "ptSta_wrongTrkCharge_ZMuStaTagged", "pt of Sta (global-sta wrongUnMatchedTrkCharge)", 100, 0., 100.);
461 
462  // clear global counters
463  totalNumberOfZfound = 0;
464  totalNumberOfZpassed = 0;
465  nZMuMuSameSign_mcMatched = 0;
466  nZMuMuSameSign = 0;
467  n_goodTrack_ZMuMutagged = 0;
468  n_correctStaCharge_ZMuMutagged = 0;
469  n_wrongStaCharge_ZMuMutagged = 0;
470  n_goodSta_ZMuMutagged = 0;
471  n_correctTrkCharge_ZMuMutagged = 0;
472  n_wrongTrkCharge_ZMuMutagged = 0;
473  n_goodTrack_ZMuTracktagged = 0;
474  n_correctStaCharge_ZMuTracktagged = 0;
475  n_wrongStaCharge_ZMuTracktagged = 0;
476  n_StaNotFound_ZMuTracktagged = 0;
477 
478  n_goodSta_ZMuStatagged = 0;
479  n_correctTrkCharge_ZMuStatagged = 0;
480  n_wrongTrkCharge_ZMuStatagged = 0;
481  n_TrkNotFound_ZMuStatagged = 0;
482 
483  n_OneGoodZMuTrack = 0;
484  n_MultipleGoodZMuTrack = 0;
485  numberOfMatchedZMuSta_ = 0;
486  n_ZMuStaTaggedMatched = 0;
487 }
488 
489 void ZMuMuPerformances::analyze(const Event &event, const EventSetup &setup) {
490  Handle<CandidateView> zMuMu;
491  Handle<GenParticleMatch> zMuMuMatchMap; //Map of Z made by Mu global + Mu global (can be used also for same sign Zmumu)
492  Handle<CandidateView> zMuTrack;
493  Handle<GenParticleMatch> zMuTrackMatchMap; //Map of Z made by Mu + Track
494  Handle<CandidateView> zMuStandAlone;
495  Handle<GenParticleMatch> zMuStandAloneMatchMap; //Map of Z made by Mu + StandAlone
496  Handle<CandidateView> muons; //Collection of Muons
497  Handle<GenParticleMatch> muonMatchMap;
498  Handle<IsolationCollection> muonIso;
499  Handle<CandidateView> tracks; //Collection of Tracks
500  Handle<IsolationCollection> trackIso;
501  Handle<GenParticleCollection> genParticles; // Collection of Generatd Particles
502 
503  event.getByToken(zMuMuToken_, zMuMu);
504  event.getByToken(zMuTrackToken_, zMuTrack);
505  event.getByToken(zMuStandAloneToken_, zMuStandAlone);
506  event.getByToken(muonsToken_, muons);
507  event.getByToken(tracksToken_, tracks);
508  event.getByToken(genParticlesToken_, genParticles);
509 
510  /*
511  cout << "********* zMuMu size : " << zMuMu->size() << endl;
512  cout << "********* zMuMuSameSign size : " << zMuMuSameSign->size() << endl;
513  cout << "********* zMuStandAlone size : " << zMuStandAlone->size() << endl;
514  cout << "********* zMuTrack size : " << zMuTrack->size() << endl;
515  cout << "********* muons size : " << muons->size()<< endl;
516  cout << "********* standAlone size : " << standAlone->size()<< endl;
517  cout << "********* tracks size : " << tracks->size()<< endl;
518  cout << "********* generated size : " << genParticles->size()<< endl;
519  cout << "***************************************************" << endl;
520  */
521 
522  int n_globalMuon_perEvent = 0;
523  int n_staOnlyMuon_perEvent = 0;
524  int n_trackerOnlyMuon_perEvent = 0;
525  int n_trackerStaOnlyMuon_perEvent = 0;
526  int n_globalMuon_perEvent_MCmatch = 0;
527  int n_staOnlyMuon_perEvent_MCmatch = 0;
528  int n_trackerOnlyMuon_perEvent_MCmatch = 0;
529  int n_trackerStaOnlyMuon_perEvent_MCmatch = 0;
530 
531  for (unsigned int j = 0; j < muons->size(); ++j) {
532  CandidateBaseRef muCandRef = muons->refAt(j);
533  const Candidate &muCand = (*muons)[j]; //the candidate
534  const reco::Muon &muon = dynamic_cast<const reco::Muon &>(muCand);
535  reco::TrackRef innerTrackRef = muon.track();
536  reco::TrackRef outerTrackRef = muon.standAloneMuon();
537  TrackRef muStaComponentRef = muCand.get<TrackRef, reco::StandAloneMuonTag>(); // standalone part of muon
538  TrackRef muTrkComponentRef = muCand.get<TrackRef>(); // track part of muon
539  GenParticleRef muonMatch = (*muonMatchMap)[muCandRef];
540  if (muCandRef->isGlobalMuon() == 1)
541  n_globalMuon_perEvent++;
542  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 0 && muCandRef->isStandAloneMuon() == 1)
543  n_staOnlyMuon_perEvent++;
544  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1 && muCandRef->isStandAloneMuon() == 0)
545  n_trackerOnlyMuon_perEvent++;
546  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1 && muCandRef->isStandAloneMuon() == 1)
547  n_trackerStaOnlyMuon_perEvent++;
548 
549  if (muonMatch.isNonnull()) {
550  if (muCandRef->isGlobalMuon() == 1)
551  n_globalMuon_perEvent_MCmatch++;
552  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 0 && muCandRef->isStandAloneMuon() == 1)
553  n_staOnlyMuon_perEvent_MCmatch++;
554  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1 && muCandRef->isStandAloneMuon() == 0)
555  n_trackerOnlyMuon_perEvent_MCmatch++;
556  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1 && muCandRef->isStandAloneMuon() == 1)
557  n_trackerStaOnlyMuon_perEvent_MCmatch++;
558  double productCharge = muCandRef->charge() * muonMatch->charge();
559  if (muCandRef->isGlobalMuon() == 1) {
560  h_GlobalMuonChargeTimeGenCharge->Fill(productCharge);
561  h_GlobalMuonEtaMinusGenEta->Fill(muCandRef->eta() - muonMatch->eta());
562  h_GlobalMuonPtMinusGenPt->Fill((muCandRef->pt() - muonMatch->pt()) / muonMatch->pt());
563  h_GlobalMuonStaComponentEtaMinusGenEta->Fill(muStaComponentRef->eta() - muonMatch->eta());
564  h_GlobalMuonStaComponentPtMinusGenPt->Fill((muStaComponentRef->pt() - muonMatch->pt()) / muonMatch->pt());
565  h_DEtaGlobalGenvsEtaGen->Fill(muonMatch->eta(), muCandRef->eta() - muonMatch->eta());
566  h_DPtGlobalGenvsPtGen->Fill(muonMatch->pt(), (muCandRef->pt() - muonMatch->pt()) / muonMatch->pt());
567  h_DEtaGlobalStaComponentGenvsEtaGen->Fill(muonMatch->eta(), muStaComponentRef->eta() - muonMatch->eta());
568  h_DPtGlobalStaComponentGenvsPtGen->Fill(muonMatch->pt(),
569  (muStaComponentRef->pt() - muonMatch->pt()) / muonMatch->pt());
570  }
571  if (muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1) {
572  h_TrackerMuonChargeTimeGenCharge->Fill(productCharge);
573  h_TrackerMuonEtaMinusGenEta->Fill(muCandRef->eta() - muonMatch->eta());
574  h_TrackerMuonPtMinusGenPt->Fill((muCandRef->pt() - muonMatch->pt()) / muonMatch->pt());
575  }
576  }
577  }
578  h_n_globalMuon_perEvent->Fill(n_globalMuon_perEvent);
579  h_n_staOnlyMuon_perEvent->Fill(n_staOnlyMuon_perEvent);
580  h_n_trackerOnlyMuon_perEvent->Fill(n_trackerOnlyMuon_perEvent);
581  h_n_trackerStaOnlyMuon_perEvent->Fill(n_trackerStaOnlyMuon_perEvent);
582  h_n_globalMuon_perEvent_MCmatch->Fill(n_globalMuon_perEvent_MCmatch);
583  h_n_staOnlyMuon_perEvent_MCmatch->Fill(n_staOnlyMuon_perEvent_MCmatch);
584  h_n_trackerOnlyMuon_perEvent_MCmatch->Fill(n_trackerOnlyMuon_perEvent_MCmatch);
585  h_n_trackerStaOnlyMuon_perEvent_MCmatch->Fill(n_trackerStaOnlyMuon_perEvent_MCmatch);
586  h_n_tracks_perEvent->Fill(tracks->size());
587 
588  h_n_zMuMu_perEvent->Fill(zMuMu->size());
589  h_n_zMuSta_perEvent->Fill(zMuStandAlone->size());
590  h_n_zMuTrack_perEvent->Fill(zMuTrack->size());
591 
592  // std::cout<<"Run-> "<<event.id().run()<<std::endl;
593  // std::cout<<"Event-> "<<event.id().event()<<std::endl;
594 
595  // loop on ZMuMu
596  if (!zMuMu->empty()) {
597  event.getByToken(zMuMuMatchMapToken_, zMuMuMatchMap);
598  event.getByToken(muonIsoToken_, muonIso);
599  event.getByToken(muonMatchMapToken_, muonMatchMap);
600  float muGenplus_pt = 0, muGenminus_pt = 0, muGenplus_eta = 100, muGenminus_eta = 100;
601  for (unsigned int i = 0; i < zMuMu->size(); ++i) { //loop on candidates
602  const Candidate &zMuMuCand = (*zMuMu)[i]; //the candidate
603  CandidateBaseRef zMuMuCandRef = zMuMu->refAt(i);
604  GenParticleRef zMuMuMatch = (*zMuMuMatchMap)[zMuMuCandRef];
605  bool isMCMatched = false;
606  if (zMuMuMatch.isNonnull()) {
607  isMCMatched = true; // ZMuMu matched
608  if (zMuMuMatch->pdgId() == 23 && zMuMuMatch->status() == 3 && zMuMuMatch->numberOfDaughters() == 3) {
609  // Z0 decays in mu+ mu-, the 3rd daughter is the same Z0
610  const Candidate *dauGen0 = zMuMuMatch->daughter(0);
611  const Candidate *dauGen1 = zMuMuMatch->daughter(1);
612  const Candidate *dauGen2 = zMuMuMatch->daughter(2);
613  if (check_ifZmumu(dauGen0, dauGen1, dauGen2)) { // Z0 in mu+ mu-
614  muGenplus_pt = getParticlePt(-13, dauGen0, dauGen1, dauGen2);
615  muGenminus_pt = getParticlePt(13, dauGen0, dauGen1, dauGen2);
616  muGenplus_eta = getParticleEta(-13, dauGen0, dauGen1, dauGen2);
617  muGenminus_eta = getParticleEta(13, dauGen0, dauGen1, dauGen2);
618  Particle::LorentzVector pZ(0, 0, 0, 0);
619  Particle::LorentzVector muplusp4 = getParticleP4(-13, dauGen0, dauGen1, dauGen2);
620  Particle::LorentzVector muminusp4 = getParticleP4(13, dauGen0, dauGen1, dauGen2);
621  pZ = muplusp4 + muminusp4;
622  } // en if is Z
623  } // end if is Z->mumu
624  }
625 
626  TrackRef as1 = zMuMuCand.daughter(0)->get<TrackRef, reco::StandAloneMuonTag>(); // standalone part of ZMuMu cand0
627  TrackRef as2 = zMuMuCand.daughter(1)->get<TrackRef, reco::StandAloneMuonTag>(); // standalone part of ZMuMu cand1
628  TrackRef a1 = zMuMuCand.daughter(0)->get<TrackRef, reco::CombinedMuonTag>(); // global part of ZMuMu cand0
629  TrackRef a2 = zMuMuCand.daughter(1)->get<TrackRef, reco::CombinedMuonTag>(); // global part of ZMuMu cand1
630  TrackRef at1 = zMuMuCand.daughter(0)->get<TrackRef>(); // tracker part of ZMuMu cand0
631  TrackRef at2 = zMuMuCand.daughter(1)->get<TrackRef>(); // tracker part of ZMuMu cand1
632 
633  math::XYZTLorentzVector ps1(as1->px(), as1->py(), as1->pz(), as1->p());
634  math::XYZTLorentzVector ps2(as2->px(), as2->py(), as2->pz(), as2->p());
635  math::XYZTLorentzVector pg1(a1->px(), a1->py(), a1->pz(), a1->p());
636  math::XYZTLorentzVector pg2(a2->px(), a2->py(), a2->pz(), a2->p());
637  math::XYZTLorentzVector ptrk1(at1->px(), at1->py(), at1->pz(), at1->p());
638  math::XYZTLorentzVector ptrk2(at2->px(), at2->py(), at2->pz(), at2->p());
639 
640  // double mass2global = (pg1+pg2).mass(); // inv. Mass done with the two global muons (is th same like m)
641  double massGlobalSta =
642  (pg1 + ps2).mass(); // inv. mass done with the global daughter(0) and the Sta part of Daughter(1)
643  double massStaGlobal =
644  (ps1 + pg2).mass(); // inv. mass done with the global daughter(1) and the Sta part of Daughter(0)
645  // double mass2Tracker = (ptrk1+ptrk2).mass(); // inv. mass done with the two tracker compnents
646  double massGlobalTracker =
647  (pg1 + ptrk2).mass(); // inv. mass done with the global daughter(0) and the tracker part of Daughter(1)
648  double massTrackerGlobal =
649  (ptrk1 + pg2).mass(); // inv. mass done with the global daughter(1) and the tracker part of Daughter(0)
650  double etaGlobal1 = a1->eta();
651  double etaGlobal2 = a2->eta();
652  double etaSta1 = as1->eta();
653  double etaSta2 = as2->eta();
654  double etaTracker1 = at1->eta();
655  double etaTracker2 = at2->eta();
656  // double phiGlobal1 = a1->phi();
657  // double phiGlobal2 = a2->phi();
658  double phiSta1 = as1->phi();
659  double phiSta2 = as2->phi();
660  double phiTracker1 = at1->phi();
661  double phiTracker2 = at2->phi();
662  double ptGlobal1 = a1->pt();
663  double ptGlobal2 = a2->pt();
664  double ptSta1 = as1->pt();
665  double ptSta2 = as2->pt();
666  double ptTracker1 = at1->pt();
667  double ptTracker2 = at2->pt();
668  double chargeGlobal1 = a1->charge();
669  double chargeGlobal2 = a2->charge();
670  double chargeSta1 = as1->charge();
671  double chargeSta2 = as2->charge();
672  double chargeTracker1 = at1->charge();
673  double chargeTracker2 = at2->charge();
674  double DR1 = deltaR(etaSta1, phiSta1, etaTracker1, phiTracker1);
675  double DR2 = deltaR(etaSta2, phiSta2, etaTracker2, phiTracker2);
676 
677  if (chargeGlobal1 == chargeGlobal2) {
678  nZMuMuSameSign++;
679  h_zMuMuMassSameSign->Fill(zMuMuCand.mass());
680  if (isMCMatched) {
681  nZMuMuSameSign_mcMatched++;
682  h_zMuMuMassSameSign_MCmatch->Fill(zMuMuCand.mass());
683  }
684  } else {
685  h_zMuMuMassOppositeSign->Fill(zMuMuCand.mass());
686  }
687 
688  bool etaCut = false;
689  bool ptCut = false;
690  //bool isoCut = false;
691  bool massCut = false;
692 
693  // ******************************************************************************************************************************
694  // Start study for StandAlone charge mis-id: select global-global events according to global1+track2 (or global2+track1)
695  // *******************************************************************************************************************************
696 
697  // cynematical cuts for Zglobal1Track2
698  if (abs(etaGlobal1) < etamax_ && abs(etaTracker2) < etamax_)
699  etaCut = true;
700  if (ptGlobal1 > ptmin_ && ptTracker2 > ptmin_)
701  ptCut = true;
702  if (massGlobalTracker > massMin_ && massGlobalTracker < massMax_)
703  massCut = true;
704 
705  if (noCut_) {
706  etaCut = true;
707  ptCut = true;
708  massCut = true;
709  }
710 
711  if (etaCut && ptCut && massCut) {
712  // check first global1-track2 if they have opposite charge and if global1 has consistent charge between sta and track
713  if (chargeSta1 == chargeTracker1 &&
714  chargeTracker1 != chargeTracker2) { // event tagged to study StandAlone2 charge
715  n_goodTrack_ZMuMutagged++;
716  h_zMuTrackMass_ZMuMuTagged->Fill(massGlobalTracker); // inv mass global+tracker part
717  h_etaTrack_ZMuMuTagged->Fill(etaTracker2); // eta of tagged track
718  h_phiTrack_ZMuMuTagged->Fill(phiTracker2); // phi of tagged track
719  h_ptTrack_ZMuMuTagged->Fill(ptTracker2); // pt of tagged track
720  h_DRTrack_ZMuMuTagged->Fill(DR2); // DR between sta2 and tracker2 for tagged track
721 
722  if (isMCMatched) { // if MC match .. resolution plots of global1 respect to gen particles
723  double etaGen, ptGen;
724  if (chargeGlobal1 == 1) {
725  etaGen = muGenplus_eta;
726  ptGen = muGenplus_pt;
727  } else {
728  etaGen = muGenminus_eta;
729  ptGen = muGenminus_pt;
730  }
731  h_GlobalMuonEtaMinusGenEta_ZMuMuTagged->Fill(etaGlobal1 - etaGen);
732  h_GlobalMuonPtMinusGenPt_ZMuMuTagged->Fill((ptGlobal1 - ptGen) / ptGen);
733  h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged->Fill(etaSta1 - etaGen);
734  h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged->Fill((ptSta1 - ptGen) / ptGen);
735  h_DEtaGlobalGenvsEtaGen_ZMuMuTagged->Fill(etaGen, etaGlobal1 - etaGen);
736  h_DPtGlobalGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptGlobal1 - ptGen) / ptGen);
737  h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged->Fill(etaGen, etaSta1 - etaGen);
738  h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptSta1 - ptGen) / ptGen);
739  h_DPtGlobalGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptGlobal1 - ptGen) / ptGen);
740  h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptSta1 - ptGen) / ptGen);
741  h_DPtTrackGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptTracker1 - ptGen) / ptGen);
742  h_DPtTrackGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptTracker1 - ptGen) / ptGen);
743 
744  } // end if MC Match
745 
746  if (chargeSta2 == chargeTracker2) { // StandAlone2 has correct charge
747  n_correctStaCharge_ZMuMutagged++;
748  h_zMuStaMass_correctStaCharge_ZMuMuTagged->Fill(
749  massGlobalSta); // inv mass of global-Sta part for correct charge muons
750  h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged->Fill((ptSta2 - ptTracker2) / ptTracker2);
751  h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged->Fill(etaTracker2,
752  (ptSta2 - ptTracker2) / ptTracker2);
753  h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged->Fill(ptTracker2,
754  (ptSta2 - ptTracker2) / ptTracker2);
755  // qui posso aggiungere plot col MC match
756  }
757  if (chargeSta2 != chargeTracker2) { // StandAlone2 has wrong charge
758  n_wrongStaCharge_ZMuMutagged++;
759  h_zMuTrackMass_wrongStaCharge_ZMuMuTagged->Fill(
760  massGlobalTracker); // inv mass global+tracker part (wrong Sta charge)
761  h_etaTrack_wrongStaCharge_ZMuMuTagged->Fill(etaTracker2); // eta of tagged track (wrong Sta charge)
762  h_phiTrack_wrongStaCharge_ZMuMuTagged->Fill(phiTracker2); // phi of tagged track (wrong Sta charge)
763  h_ptTrack_wrongStaCharge_ZMuMuTagged->Fill(ptTracker2); // pt of tagged track (wrong Sta charge)
764  h_DRTrack_wrongStaCharge_ZMuMuTagged->Fill(
765  DR2); // DR between sta2 and tracker2 for tagged track (wrong Sta charge)
766  }
767  } // end if check chrge global1-tracker2
768  } // end if cut selection
769 
770  // cynematical cuts for Zglobal2Track1
771  etaCut = false;
772  ptCut = false;
773  massCut = false;
774  //isoCut = false;
775  if (abs(etaGlobal2) < etamax_ && abs(etaTracker1) < etamax_)
776  etaCut = true;
777  if (ptGlobal2 > ptmin_ && ptTracker1 > ptmin_)
778  ptCut = true;
779  if (massTrackerGlobal > massMin_ && massTrackerGlobal < massMax_)
780  massCut = true;
781 
782  if (noCut_) {
783  etaCut = true;
784  ptCut = true;
785  massCut = true;
786  }
787 
788  if (etaCut && ptCut && massCut) {
789  // check global2-track1 if they have opposite charge and if global2 has consistent charge between sta and track
790  if (chargeSta2 == chargeTracker2 &&
791  chargeTracker1 != chargeTracker2) { // event tagged to study StandAlone2 charge
792  n_goodTrack_ZMuMutagged++;
793  h_zMuTrackMass_ZMuMuTagged->Fill(massTrackerGlobal); // inv mass global+tracker part
794  h_etaTrack_ZMuMuTagged->Fill(etaTracker1); // eta of tagged track
795  h_phiTrack_ZMuMuTagged->Fill(phiTracker1); // phi of tagged track
796  h_ptTrack_ZMuMuTagged->Fill(ptTracker1); // pt of tagged track
797  h_DRTrack_ZMuMuTagged->Fill(DR1); // DR between sta1 and tracker1 for tagged track
798 
799  // qui posso aggiungere plot col MC match
800  if (isMCMatched) { // if MC match .. resolution plots of global2 respect to gen particles
801  double etaGen, ptGen;
802  if (chargeGlobal2 == 1) {
803  etaGen = muGenplus_eta;
804  ptGen = muGenplus_pt;
805  } else {
806  etaGen = muGenminus_eta;
807  ptGen = muGenminus_pt;
808  }
809  h_GlobalMuonEtaMinusGenEta_ZMuMuTagged->Fill(etaGlobal2 - etaGen);
810  h_GlobalMuonPtMinusGenPt_ZMuMuTagged->Fill((ptGlobal2 - ptGen) / ptGen);
811  h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged->Fill(etaSta2 - etaGen);
812  h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged->Fill((ptSta2 - ptGen) / ptGen);
813  h_DEtaGlobalGenvsEtaGen_ZMuMuTagged->Fill(etaGen, etaGlobal2 - etaGen);
814  h_DPtGlobalGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptGlobal2 - ptGen) / ptGen);
815  h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged->Fill(etaGen, etaSta2 - etaGen);
816  h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptSta2 - ptGen) / ptGen);
817  h_DPtGlobalGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptGlobal2 - ptGen) / ptGen);
818  h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptSta2 - ptGen) / ptGen);
819  h_DPtTrackGenvsPtGen_ZMuMuTagged->Fill(ptGen, (ptTracker2 - ptGen) / ptGen);
820  h_DPtTrackGenvsEtaGen_ZMuMuTagged->Fill(etaGen, (ptTracker2 - ptGen) / ptGen);
821  } // end if MC Match
822 
823  if (chargeSta1 == chargeTracker1) { // StandAlone1 has correct charge
824  n_correctStaCharge_ZMuMutagged++;
825  h_zMuStaMass_correctStaCharge_ZMuMuTagged->Fill(
826  massStaGlobal); // inv mass of Sta-global part for correct charge muons
827  h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged->Fill((ptSta1 - ptTracker1) / ptTracker1);
828  h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged->Fill(etaTracker1,
829  (ptSta1 - ptTracker1) / ptTracker1);
830  h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged->Fill(ptTracker1,
831  (ptSta1 - ptTracker1) / ptTracker1);
832  }
833  if (chargeSta1 != chargeTracker1) { // StandAlone2 has wrong charge
834  n_wrongStaCharge_ZMuMutagged++;
835  h_zMuTrackMass_wrongStaCharge_ZMuMuTagged->Fill(
836  massTrackerGlobal); // inv mass global+tracker part (wrong Sta charge)
837  h_etaTrack_wrongStaCharge_ZMuMuTagged->Fill(etaTracker1); // eta of tagged track (wrong Sta charge)
838  h_phiTrack_wrongStaCharge_ZMuMuTagged->Fill(phiTracker1); // phi of tagged track (wrong Sta charge)
839  h_ptTrack_wrongStaCharge_ZMuMuTagged->Fill(ptTracker1); // pt of tagged track (wrong Sta charge)
840  h_DRTrack_wrongStaCharge_ZMuMuTagged->Fill(
841  DR1); // DR between sta1 and tracker1 for tagged track (wrong Sta charge)
842  }
843  } // end if check charge global1-tracker2
844  } // end if cuts
845 
846  // ******************************************************************************************************************************
847  // Start study for tracker charge mis-id: select global-global events according to global1+staComponent2 (or global2+staComponent1)
848  // *******************************************************************************************************************************
849 
850  etaCut = false;
851  ptCut = false;
852  //isoCut = false;
853  massCut = false;
854 
855  // cynematical cuts for Zglobal1Sta2
856  if (abs(etaGlobal1) < etamax_ && abs(etaSta2) < etamax_)
857  etaCut = true;
858  if (ptGlobal1 > ptmin_ && ptSta2 > ptmin_)
859  ptCut = true;
860  if (massGlobalSta > massMin_ && massGlobalSta < massMax_)
861  massCut = true;
862 
863  if (noCut_) {
864  etaCut = true;
865  ptCut = true;
866  massCut = true;
867  }
868 
869  if (etaCut && ptCut && massCut) {
870  // check first global1-sta2 if they have opposite charge and if global1 has consistent charge between sta and track
871  if (chargeSta1 == chargeTracker1 && chargeTracker1 != chargeSta2) { // event tagged to study track2 charge
872  n_goodSta_ZMuMutagged++;
873  h_zMuStaMass_ZMuMuTagged->Fill(massGlobalSta); // inv mass global+sta part
874  h_etaSta_ZMuMuTagged->Fill(etaSta2); // eta of tagged sta
875  h_phiSta_ZMuMuTagged->Fill(phiSta2); // phi of tagged sta
876  h_ptSta_ZMuMuTagged->Fill(ptSta2); // pt of tagged sta
877  h_DRSta_ZMuMuTagged->Fill(DR2); // DR between sta2 and tracker2 for tagged sta
878 
879  if (chargeSta2 == chargeTracker2) { // track2 has correct charge
880  n_correctTrkCharge_ZMuMutagged++;
881  // qui posso aggiungere plot col MC match
882  }
883  if (chargeSta2 != chargeTracker2) { // track2 has wrong charge
884  n_wrongTrkCharge_ZMuMutagged++;
885  h_zMuStaMass_wrongTrkCharge_ZMuMuTagged->Fill(
886  massGlobalSta); // inv mass global+sta part (wrong Trk charge)
887  h_etaSta_wrongTrkCharge_ZMuMuTagged->Fill(etaSta2); // eta of tagged sta (wrong trk charge)
888  h_phiSta_wrongTrkCharge_ZMuMuTagged->Fill(phiSta2); // phi of tagged sta (wrong Trk charge)
889  h_ptSta_wrongTrkCharge_ZMuMuTagged->Fill(ptSta2); // pt of tagged sta (wrong Trk charge)
890  h_DRSta_wrongTrkCharge_ZMuMuTagged->Fill(
891  DR2); // DR between sta2 and tracker2 for tagged sta (wrong trk charge)
892  }
893  } // end if check chrge global1-sta2
894  } // end if cut selection
895 
896  etaCut = false;
897  ptCut = false;
898  //isoCut = false;
899  massCut = false;
900 
901  // cynematical cuts for Zglobal2Sta1
902  if (abs(etaGlobal2) < etamax_ && abs(etaSta1) < etamax_)
903  etaCut = true;
904  if (ptGlobal2 > ptmin_ && ptSta1 > ptmin_)
905  ptCut = true;
906  if (massStaGlobal > massMin_ && massStaGlobal < massMax_)
907  massCut = true;
908 
909  if (noCut_) {
910  etaCut = true;
911  ptCut = true;
912  massCut = true;
913  }
914 
915  if (etaCut && ptCut && massCut) {
916  // check first global2-sta1 if they have opposite charge and if global2 has consistent charge between sta and track
917  if (chargeSta2 == chargeTracker2 && chargeTracker2 != chargeSta1) { // event tagged to study track1 charge
918  n_goodSta_ZMuMutagged++;
919  h_zMuStaMass_ZMuMuTagged->Fill(massStaGlobal); // inv mass global+sta part
920  h_etaSta_ZMuMuTagged->Fill(etaSta1); // eta of tagged sta
921  h_phiSta_ZMuMuTagged->Fill(phiSta1); // phi of tagged sta
922  h_ptSta_ZMuMuTagged->Fill(ptSta1); // pt of tagged sta
923  h_DRSta_ZMuMuTagged->Fill(DR1); // DR between sta1 and tracker1 for tagged sta
924 
925  if (chargeSta1 == chargeTracker1) { // track1 has correct charge
926  n_correctTrkCharge_ZMuMutagged++;
927  // qui posso aggiungere plot col MC match
928  }
929  if (chargeSta1 != chargeTracker1) { // track1 has wrong charge
930  n_wrongTrkCharge_ZMuMutagged++;
931  h_zMuStaMass_wrongTrkCharge_ZMuMuTagged->Fill(
932  massStaGlobal); // inv mass global+sta part (wrong Trk charge)
933  h_etaSta_wrongTrkCharge_ZMuMuTagged->Fill(etaSta1); // eta of tagged sta (wrong trk charge)
934  h_phiSta_wrongTrkCharge_ZMuMuTagged->Fill(phiSta1); // phi of tagged sta (wrong Trk charge)
935  h_ptSta_wrongTrkCharge_ZMuMuTagged->Fill(ptSta1); // pt of tagged sta (wrong Trk charge)
936  h_DRSta_wrongTrkCharge_ZMuMuTagged->Fill(
937  DR1); // DR between sta2 and tracker2 for tagged sta (wrong trk charge)
938  }
939  } // end if check chrge global2-sta1
940  } // end if cut selection
941 
942  } // end loop on ZMuMu cand
943  } // end if ZMuMu size > 0
944 
945  // loop on ZMuTrack in order to recover some unMatched StandAlone
946 
947  //double LargerDRCut=2.; // larger DR cut to recover unMatched Sta
948  int taggedZ_index = -1; // index of Z with minimum DR respect to unMatched Sta
949  int taggedMuon_index = -1; // index of Sta muon with minimum DR respect to unMatched track
950  int n_ZMuTrackTagged_inEvent = 0; // number of tagged Z in the event
951  if (!zMuTrack->empty() && zMuMu->empty()) { // check ZMuTrack just if no ZMuMu has been found in the event
952  event.getByToken(zMuTrackMatchMapToken_, zMuTrackMatchMap);
953  for (unsigned int i = 0; i < zMuTrack->size(); ++i) { //loop on candidates
954  const Candidate &zMuTrackCand = (*zMuTrack)[i]; //the candidate
955  CandidateBaseRef zMuTrackCandRef = zMuTrack->refAt(i);
956  GenParticleRef zMuTrackMatch = (*zMuTrackMatchMap)[zMuTrackCandRef];
957  //bool isMCMatched = false;
958  //if(zMuTrackMatch.isNonnull()) isMCMatched = true; // ZMuTrack matched
959  // forzo isMCMatched
960  // isMCMatched = true;
961 
962  double m = zMuTrackCand.mass();
963  CandidateBaseRef zglobalDaughter = zMuTrackCand.daughter(0)->masterClone();
964  CandidateBaseRef ztrackerDaughter = zMuTrackCand.daughter(1)->masterClone();
965  TrackRef zglobalDaughter_StaComponentRef = zMuTrackCand.daughter(0)->get<TrackRef, reco::StandAloneMuonTag>();
966  // standalone part of global component of ZMuMu
967  TrackRef zglobalDaughter_TrackComponentRef = zMuTrackCand.daughter(0)->get<TrackRef>();
968  // track part Of the global component of ZMuMu
969  double ZtrackerDaughterCharge = ztrackerDaughter->charge();
970  double ZtrackerDaughterPt = ztrackerDaughter->pt();
971  double ZtrackerDaughterEta = ztrackerDaughter->eta();
972  double ZtrackerDaughterPhi = ztrackerDaughter->phi();
973  double ZglobalDaughterPt = zglobalDaughter->pt();
974  double ZglobalDaughterEta = zglobalDaughter->eta();
975  double ZglobalDaughter_StaComponentCharge = zglobalDaughter_StaComponentRef->charge();
976  double ZglobalDaughter_TrackComponentCharge = zglobalDaughter_TrackComponentRef->charge();
977 
978  //*********************************************************************************************************************
979  // study of standAlone charge mis-id and efficiency selecting ZMuTrack events (tag the index of Z and of muon)
980  // for Sta charge mis-id just use unMatched standAlone muons trackerMuons that are standAlone Muons but no globalMuons
981  // ********************************************************************************************************************
982  // cynematical cuts for ZMuTrack
983  bool etaCut = false;
984  bool ptCut = false;
985  // bool isoCut = false;
986  bool massCut = false;
987  if (abs(ZglobalDaughterEta) < etamax_ && abs(ZtrackerDaughterEta) < etamax_)
988  etaCut = true;
989  if (ZglobalDaughterPt > ptmin_ && ZtrackerDaughterPt > ptmin_)
990  ptCut = true;
991  if (m > massMin_ && m < massMax_)
992  massCut = true;
993 
994  if (noCut_) {
995  etaCut = true;
996  ptCut = true;
997  massCut = true;
998  }
999  if (etaCut && ptCut && massCut && ZglobalDaughter_StaComponentCharge == ZglobalDaughter_TrackComponentCharge &&
1000  ZglobalDaughter_TrackComponentCharge !=
1001  ZtrackerDaughterCharge) { // cynematic cuts and global charge consistent and opposite tracker charge
1002  n_ZMuTrackTagged_inEvent++;
1003 
1004  // posso inserire istogrammi eta e pt track per studio Sta efficiency
1005  // ...
1006 
1007  for (unsigned int j = 0; j < muons->size(); ++j) {
1008  CandidateBaseRef muCandRef = muons->refAt(j);
1009  const Candidate &muCand = (*muons)[j]; //the candidate
1010  TrackRef muStaComponentRef = muCand.get<TrackRef, reco::StandAloneMuonTag>(); // standalone part of muon
1011  TrackRef muTrkComponentRef = muCand.get<TrackRef>(); // track part of muon
1012 
1013  if (muCandRef->isStandAloneMuon() == 1 && muCandRef->isGlobalMuon() == 0 && muCandRef->isTrackerMuon() == 1) {
1014  double muEta = muCandRef->eta();
1015  double muPhi = muCandRef->phi();
1016  // check DeltaR between Sta muon and tracks of ZMuTrack
1017  double DRmuSta_trackOfZ = deltaR(muEta, muPhi, ZtrackerDaughterEta, ZtrackerDaughterPhi);
1018  if (DRmuSta_trackOfZ == 0) { // match track track ... standalone-muTracker
1019  taggedZ_index = i;
1020  taggedMuon_index = j;
1021  } // end check minimum DR
1022  } // end if isStandAlone
1023  } // end loop on muon candidates
1024  } // end cynematic cuts
1025 
1026  } // end loop on zMuTrack size
1027  } // end if zMuTrack size > 0
1028 
1029  // analyze the tagged ZMuTRack and the Sta muons with minimal DR
1030  if (n_ZMuTrackTagged_inEvent > 0) { // at Least one ZMuTRack tagged
1031 
1032  if (taggedZ_index == -1) { // StandAlone inefficient
1033  n_StaNotFound_ZMuTracktagged++;
1034  // h_etaTrack_StaNotFound_ZMuTrackTagged->Fill(ztrackerDaughter->eta());
1035  } else {
1036  const Candidate &zMuTrackCand = (*zMuTrack)[taggedZ_index]; //the candidate tagged
1037  CandidateBaseRef zMuTrackCandRef = zMuTrack->refAt(taggedZ_index);
1038  double m = zMuTrackCand.mass();
1039  CandidateBaseRef zglobalDaughter = zMuTrackCand.daughter(0)->masterClone();
1040  CandidateBaseRef ztrackerDaughter = zMuTrackCand.daughter(1)->masterClone();
1041  TrackRef zglobalDaughter_StaComponentRef = zMuTrackCand.daughter(0)->get<TrackRef, reco::StandAloneMuonTag>();
1042  // standalone part of global component of ZMuMu
1043  TrackRef zglobalDaughter_TrackComponentRef = zMuTrackCand.daughter(0)->get<TrackRef>();
1044  // track part Of the global component of ZMuMu
1045  double ZtrackerDaughterCharge = ztrackerDaughter->charge();
1046  double ZtrackerDaughterPt = ztrackerDaughter->pt();
1047  double ZtrackerDaughterEta = ztrackerDaughter->eta();
1048  double ZtrackerDaughterPhi = ztrackerDaughter->phi();
1049 
1050  CandidateBaseRef muCandRef = muons->refAt(taggedMuon_index); // the tagged muon
1051  const Candidate &muCand = (*muons)[taggedMuon_index]; //the candidate
1052  TrackRef muStaComponentRef = muCand.get<TrackRef, reco::StandAloneMuonTag>(); // standalone part of muon
1053  TrackRef muTrkComponentRef = muCand.get<TrackRef>(); // track part of muon
1054 
1055  double muEta = muStaComponentRef->eta();
1056  double muPhi = muStaComponentRef->phi();
1057  double muCharge = muStaComponentRef->charge();
1058  // check DeltaR between Sta muon and tracks of ZMuTrack
1059  double DRmuSta_trackOfZ = deltaR(muEta, muPhi, ZtrackerDaughterEta, ZtrackerDaughterPhi);
1060 
1061  n_goodTrack_ZMuTracktagged++;
1062  h_zMuTrackMass_ZMuTrackTagged->Fill(m); // inv mass ZMuTrack for tagged events
1063  h_etaTrack_ZMuTrackTagged->Fill(ZtrackerDaughterEta); // eta of tagged track
1064  h_phiTrack_ZMuTrackTagged->Fill(ZtrackerDaughterPhi); // phi of tagged track
1065  h_ptTrack_ZMuTrackTagged->Fill(ZtrackerDaughterPt); // pt of tagged track
1066  h_DRTrack_ZMuTrackTagged->Fill(DRmuSta_trackOfZ); // DR between sta1 and tracker1 for tagged track
1067 
1068  // check StandAlone charge
1069  if (muCharge != ZtrackerDaughterCharge) { // wrong Sta charge
1070  n_wrongStaCharge_ZMuTracktagged++; // number of events wrong charge for unMatched Sta
1071  h_zMuTrackMass_wrongStaCharge_ZMuTrackTagged->Fill(
1072  m); // inv mass ZMuTrack for tagged events wrong unMatched Sta charge
1073  h_etaTrack_wrongStaCharge_ZMuTrackTagged->Fill(
1074  ZtrackerDaughterEta); // eta of tagged track wrong unMatched Sta charge
1075  h_phiTrack_wrongStaCharge_ZMuTrackTagged->Fill(
1076  ZtrackerDaughterPhi); // phi of tagged track wrong unMatched Sta charge
1077  h_ptTrack_wrongStaCharge_ZMuTrackTagged->Fill(
1078  ZtrackerDaughterPt); // pt of tagged track wrong unMatched Sta charge
1079  h_DRTrack_wrongStaCharge_ZMuTrackTagged->Fill(
1080  DRmuSta_trackOfZ); // DR between unMatched Sta and tracker for wrong sta charge
1081  } else { // correct Sta charge
1082  n_correctStaCharge_ZMuTracktagged++; // number of events correct charge for unMatched Sta
1083  } // end if Sta charge check
1084  } // end if StandAlone is present
1085  } // end if zMuTrack tagged
1086 
1087  //*********************************************************************************************************************
1088  // study of track charge mis-id and efficiency selecting ZMuSta events
1089  // for Track charge mis-id just use unMatched standAlone muons trackerMuons that are standAlone Muons but no globalMuons
1090  // ********************************************************************************************************************
1091 
1092  // loop on ZMuSta in order to recover some unMatched StandAlone
1093  bool isZMuStaMatched = false;
1094  //LargerDRCut=2.; // larger DR cut to recover unMatched Sta
1095  taggedZ_index = -1; // index of Z with minimum DR respect to unMatched Sta
1096  taggedMuon_index = -1; // index of Sta muon with minimum DR respect to unMatched track
1097  int n_ZMuStaTagged_inEvent = 0; // number of tagged Z in the event
1098  if (!zMuStandAlone->empty()) { // check ZMuSta just if no ZMuMu has been found in the event
1099  event.getByToken(zMuStandAloneMatchMapToken_, zMuStandAloneMatchMap);
1100  for (unsigned int i = 0; i < zMuStandAlone->size(); ++i) { //loop on candidates
1101  const Candidate &zMuStaCand = (*zMuStandAlone)[i]; //the candidate
1102  CandidateBaseRef zMuStaCandRef = zMuStandAlone->refAt(i);
1103 
1104  GenParticleRef zMuStaMatch = (*zMuStandAloneMatchMap)[zMuStaCandRef];
1105  if (zMuStaMatch.isNonnull()) { // ZMuSta Macthed
1106  numberOfMatchedZMuSta_++;
1107  isZMuStaMatched = true;
1108  }
1109 
1110  double m = zMuStaCand.mass();
1111  CandidateBaseRef zglobalDaughter = zMuStaCand.daughter(0)->masterClone();
1112  CandidateBaseRef zstandaloneDaughter = zMuStaCand.daughter(1)->masterClone();
1113  int iglb = 0;
1114  int ista = 1;
1115  if (zglobalDaughter->isGlobalMuon() == 0 && zstandaloneDaughter->isGlobalMuon() == 1) { // invert definition
1116  CandidateBaseRef buffer = zglobalDaughter;
1117  zglobalDaughter = zstandaloneDaughter;
1118  zstandaloneDaughter = buffer;
1119  iglb = 1;
1120  ista = 0;
1121  }
1122  TrackRef zglobalDaughter_StaComponentRef = zMuStaCand.daughter(iglb)->get<TrackRef, reco::StandAloneMuonTag>();
1123  // standalone part of global component of ZMuMu
1124  TrackRef zglobalDaughter_TrackComponentRef = zMuStaCand.daughter(iglb)->get<TrackRef>();
1125  // track part Of the global component of ZMuMu
1126  TrackRef zstaDaughter_StaComponentRef = zMuStaCand.daughter(ista)->get<TrackRef, reco::StandAloneMuonTag>();
1127  // standalone part of global component of ZMuMu
1128  TrackRef zstaDaughter_TrackComponentRef = zMuStaCand.daughter(ista)->get<TrackRef>();
1129  // track part Of the global component of ZMuMu
1130  double ZglobalDaughterPt = zglobalDaughter->pt();
1131  double ZglobalDaughterEta = zglobalDaughter->eta();
1132 
1133  double ZstaDaughter_StaComponentCharge = zstaDaughter_StaComponentRef->charge();
1134  double ZstaDaughter_StaComponentPt = zstaDaughter_StaComponentRef->pt();
1135  double ZstaDaughter_StaComponentEta = zstaDaughter_StaComponentRef->eta();
1136  double ZstaDaughter_StaComponentPhi = zstaDaughter_StaComponentRef->phi();
1137  double ZstaDaughter_TrackComponentCharge = zstaDaughter_TrackComponentRef->charge();
1138 
1139  double ZglobalDaughter_StaComponentCharge = zglobalDaughter_StaComponentRef->charge();
1140  double ZglobalDaughter_TrackComponentCharge = zglobalDaughter_TrackComponentRef->charge();
1141 
1142  // cynematical cuts for ZMuSta
1143  bool etaCut = false;
1144  bool ptCut = false;
1145  // bool isoCut = false;
1146  bool massCut = false;
1147  if (abs(ZglobalDaughterEta) < etamax_ && abs(ZstaDaughter_StaComponentEta) < etamax_)
1148  etaCut = true;
1149  if (ZglobalDaughterPt > ptmin_ && ZstaDaughter_StaComponentPt > ptmin_)
1150  ptCut = true;
1151  if (m > massMin_ && m < massMax_)
1152  massCut = true; // dovrei usare la massa fatta con la sola parte sta
1153  // (Se è anche trackerMu non è cosi')
1154  if (noCut_) {
1155  etaCut = true;
1156  ptCut = true;
1157  massCut = true;
1158  }
1159  if (etaCut && ptCut && massCut && ZglobalDaughter_StaComponentCharge == ZglobalDaughter_TrackComponentCharge &&
1160  ZglobalDaughter_StaComponentCharge !=
1161  ZstaDaughter_StaComponentCharge) { // cynematic cuts and global charge consistent and opposite sta charge
1162  n_ZMuStaTagged_inEvent++;
1163  if (isZMuStaMatched)
1164  n_ZMuStaTaggedMatched++;
1165  // posso inserire istogrammi eta e pt track per studio Sta efficiency
1166  // ...
1167  if (zstandaloneDaughter->isStandAloneMuon() == 1 &&
1168  zstandaloneDaughter->isTrackerMuon() == 1) { // track matched
1169  n_goodSta_ZMuStatagged++;
1170  h_zMuStaMass_ZMuStaTagged->Fill(m); // inv mass ZMuSta for tagged events
1171  h_etaSta_ZMuStaTagged->Fill(ZstaDaughter_StaComponentEta); // eta of tagged sta
1172  h_phiSta_ZMuStaTagged->Fill(ZstaDaughter_StaComponentPhi); // phi of tagged sta
1173  h_ptSta_ZMuStaTagged->Fill(ZstaDaughter_StaComponentPt); // pt of tagged sta
1174 
1175  // check Track charge
1176  if (ZstaDaughter_StaComponentCharge != ZstaDaughter_TrackComponentCharge) { // wrong Trk charge
1177  n_wrongTrkCharge_ZMuStatagged++; // number of events wrong track charge for unMatched track
1178  h_zMuStaMass_wrongTrkCharge_ZMuStaTagged->Fill(
1179  m); // inv mass ZMuSta for tagged evts wrong unMatched track charge
1180  h_etaSta_wrongTrkCharge_ZMuStaTagged->Fill(
1181  ZstaDaughter_StaComponentEta); // eta of tagged sta wrong unMatched track charge
1182  h_phiSta_wrongTrkCharge_ZMuStaTagged->Fill(
1183  ZstaDaughter_StaComponentPhi); // phi of tagged sta wrong unMatched track charge
1184  h_ptSta_wrongTrkCharge_ZMuStaTagged->Fill(
1185  ZstaDaughter_StaComponentPt); // pt of tagged sta wrong unMatched track charge
1186  } else { // correct Sta charge
1187  n_correctTrkCharge_ZMuStatagged++; // number of events correct charge for unMatched Sta
1188  } // end if Sta charge check
1189 
1190  } else { // tracker inefficient
1191  n_TrkNotFound_ZMuStatagged++;
1192  }
1193  } // end cynematic cuts
1194  if (n_ZMuStaTagged_inEvent == 0) {
1195  }
1196 
1197  } // end loop on zMuSta candidates
1198  } // end check ZMuSta size
1199 
1200 } // end analyze
1201 
1202 bool ZMuMuPerformances::check_ifZmumu(const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2) {
1203  int partId0 = dauGen0->pdgId();
1204  int partId1 = dauGen1->pdgId();
1205  int partId2 = dauGen2->pdgId();
1206  bool muplusFound = false;
1207  bool muminusFound = false;
1208  bool ZFound = false;
1209  if (partId0 == 13 || partId1 == 13 || partId2 == 13)
1210  muminusFound = true;
1211  if (partId0 == -13 || partId1 == -13 || partId2 == -13)
1212  muplusFound = true;
1213  if (partId0 == 23 || partId1 == 23 || partId2 == 23)
1214  ZFound = true;
1215  return (muplusFound && muminusFound && ZFound);
1216 }
1217 
1218 float ZMuMuPerformances::getParticlePt(const int ipart,
1219  const Candidate *dauGen0,
1220  const Candidate *dauGen1,
1221  const Candidate *dauGen2) {
1222  int partId0 = dauGen0->pdgId();
1223  int partId1 = dauGen1->pdgId();
1224  int partId2 = dauGen2->pdgId();
1225  float ptpart = 0.;
1226  if (partId0 == ipart) {
1227  for (unsigned int k = 0; k < dauGen0->numberOfDaughters(); ++k) {
1228  const Candidate *dauMuGen = dauGen0->daughter(k);
1229  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1230  ptpart = dauMuGen->pt();
1231  }
1232  }
1233  }
1234  if (partId1 == ipart) {
1235  for (unsigned int k = 0; k < dauGen1->numberOfDaughters(); ++k) {
1236  const Candidate *dauMuGen = dauGen1->daughter(k);
1237  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1238  ptpart = dauMuGen->pt();
1239  }
1240  }
1241  }
1242  if (partId2 == ipart) {
1243  for (unsigned int k = 0; k < dauGen2->numberOfDaughters(); ++k) {
1244  const Candidate *dauMuGen = dauGen2->daughter(k);
1245  if (abs(dauMuGen->pdgId()) == ipart && dauMuGen->status() == 1) {
1246  ptpart = dauMuGen->pt();
1247  }
1248  }
1249  }
1250  return ptpart;
1251 }
1252 
1253 float ZMuMuPerformances::getParticleEta(const int ipart,
1254  const Candidate *dauGen0,
1255  const Candidate *dauGen1,
1256  const Candidate *dauGen2) {
1257  int partId0 = dauGen0->pdgId();
1258  int partId1 = dauGen1->pdgId();
1259  int partId2 = dauGen2->pdgId();
1260  float etapart = 0.;
1261  if (partId0 == ipart) {
1262  for (unsigned int k = 0; k < dauGen0->numberOfDaughters(); ++k) {
1263  const Candidate *dauMuGen = dauGen0->daughter(k);
1264  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1265  etapart = dauMuGen->eta();
1266  }
1267  }
1268  }
1269  if (partId1 == ipart) {
1270  for (unsigned int k = 0; k < dauGen1->numberOfDaughters(); ++k) {
1271  const Candidate *dauMuGen = dauGen1->daughter(k);
1272  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1273  etapart = dauMuGen->eta();
1274  }
1275  }
1276  }
1277  if (partId2 == ipart) {
1278  for (unsigned int k = 0; k < dauGen2->numberOfDaughters(); ++k) {
1279  const Candidate *dauMuGen = dauGen2->daughter(k);
1280  if (abs(dauMuGen->pdgId()) == ipart && dauMuGen->status() == 1) {
1281  etapart = dauMuGen->eta();
1282  }
1283  }
1284  }
1285  return etapart;
1286 }
1287 
1288 float ZMuMuPerformances::getParticlePhi(const int ipart,
1289  const Candidate *dauGen0,
1290  const Candidate *dauGen1,
1291  const Candidate *dauGen2) {
1292  int partId0 = dauGen0->pdgId();
1293  int partId1 = dauGen1->pdgId();
1294  int partId2 = dauGen2->pdgId();
1295  float phipart = 0.;
1296  if (partId0 == ipart) {
1297  for (unsigned int k = 0; k < dauGen0->numberOfDaughters(); ++k) {
1298  const Candidate *dauMuGen = dauGen0->daughter(k);
1299  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1300  phipart = dauMuGen->phi();
1301  }
1302  }
1303  }
1304  if (partId1 == ipart) {
1305  for (unsigned int k = 0; k < dauGen1->numberOfDaughters(); ++k) {
1306  const Candidate *dauMuGen = dauGen1->daughter(k);
1307  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1308  phipart = dauMuGen->phi();
1309  }
1310  }
1311  }
1312  if (partId2 == ipart) {
1313  for (unsigned int k = 0; k < dauGen2->numberOfDaughters(); ++k) {
1314  const Candidate *dauMuGen = dauGen2->daughter(k);
1315  if (abs(dauMuGen->pdgId()) == ipart && dauMuGen->status() == 1) {
1316  phipart = dauMuGen->phi();
1317  }
1318  }
1319  }
1320  return phipart;
1321 }
1322 
1323 Particle::LorentzVector ZMuMuPerformances::getParticleP4(const int ipart,
1324  const Candidate *dauGen0,
1325  const Candidate *dauGen1,
1326  const Candidate *dauGen2) {
1327  int partId0 = dauGen0->pdgId();
1328  int partId1 = dauGen1->pdgId();
1329  int partId2 = dauGen2->pdgId();
1330  Particle::LorentzVector p4part(0., 0., 0., 0.);
1331  if (partId0 == ipart) {
1332  for (unsigned int k = 0; k < dauGen0->numberOfDaughters(); ++k) {
1333  const Candidate *dauMuGen = dauGen0->daughter(k);
1334  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1335  p4part = dauMuGen->p4();
1336  }
1337  }
1338  }
1339  if (partId1 == ipart) {
1340  for (unsigned int k = 0; k < dauGen1->numberOfDaughters(); ++k) {
1341  const Candidate *dauMuGen = dauGen1->daughter(k);
1342  if (dauMuGen->pdgId() == ipart && dauMuGen->status() == 1) {
1343  p4part = dauMuGen->p4();
1344  }
1345  }
1346  }
1347  if (partId2 == ipart) {
1348  for (unsigned int k = 0; k < dauGen2->numberOfDaughters(); ++k) {
1349  const Candidate *dauMuGen = dauGen2->daughter(k);
1350  if (abs(dauMuGen->pdgId()) == ipart && dauMuGen->status() == 1) {
1351  p4part = dauMuGen->p4();
1352  }
1353  }
1354  }
1355  return p4part;
1356 }
1357 
1358 void ZMuMuPerformances::endJob() {
1359  cout << "------------------------------------ Counters --------------------------------" << endl;
1360  cout << "totalNumberOfZfound = " << totalNumberOfZfound << endl;
1361  cout << "totalNumberOfZpassed = " << totalNumberOfZpassed << endl;
1362  cout << "Number Of ZMuMu Same Sign (no cuts) " << nZMuMuSameSign << endl;
1363  cout << "Number Of ZMuMu Same Sign (no cuts) MC matched " << nZMuMuSameSign_mcMatched << endl;
1364 
1365  cout << "------------------------------------ Counters for standAlone charge mis-id studies "
1366  "--------------------------------"
1367  << endl;
1368  cout << " number of goodTracks tagged for ZMuMu collection = " << n_goodTrack_ZMuMutagged << endl;
1369  cout << " number of goodTracks tagged for ZMuMu collection (correct Sta charge) = " << n_correctStaCharge_ZMuMutagged
1370  << endl;
1371  cout << " number of goodTracks tagged for ZMuMu collection (wrong Sta charge) = " << n_wrongStaCharge_ZMuMutagged
1372  << endl
1373  << endl;
1374  cout << " number of goodTracks tagged for ZMuTrack collection unMatchedSTA = " << n_goodTrack_ZMuTracktagged << endl;
1375  cout << " number of goodTracks tagged for ZMuTrack collection unMatchedSTA (correct Sta charge) = "
1376  << n_correctStaCharge_ZMuTracktagged << endl;
1377  cout << " number of goodTracks tagged for ZMuTrack collection unMatchedSTA (wrong Sta charge) = "
1378  << n_wrongStaCharge_ZMuTracktagged << endl
1379  << endl;
1380  cout << " number of goodTracks tagged for ZMuTrack collection (No STA found) = " << n_StaNotFound_ZMuTracktagged
1381  << endl;
1382 
1383  cout << "------------------------------------ Counters for Track charge mis-id studies "
1384  "--------------------------------"
1385  << endl;
1386  cout << " number of goodStandAlone tagged for ZMuMu collection = " << n_goodSta_ZMuMutagged << endl;
1387  cout << " number of goodStandAlone tagged for ZMuMu collection (correct Trk charge) = "
1388  << n_correctTrkCharge_ZMuMutagged << endl;
1389  cout << " number of goodStandAlone tagged for ZMuMu collection (wrong Trk charge) = " << n_wrongTrkCharge_ZMuMutagged
1390  << endl
1391  << endl;
1392  cout << " number of goodSta tagged for ZMuSta collection unMatchedTrk = " << n_goodSta_ZMuStatagged << endl;
1393  cout << " number of goodSta tagged for ZMuSta collection unMatchedTrk (correct Trk charge) = "
1394  << n_correctTrkCharge_ZMuStatagged << endl;
1395  cout << " number of goodSta tagged for ZMuSta collection unMatchedTrk (wrong Trk charge) = "
1396  << n_wrongTrkCharge_ZMuStatagged << endl
1397  << endl;
1398  cout << " number of goodSta tagged for ZMuSta collection (No Trk found) = " << n_TrkNotFound_ZMuStatagged << endl;
1399  cout << " number of ZMuSta mactched = " << numberOfMatchedZMuSta_ << endl;
1400  cout << " number of ZMuSta Tagged matched = " << n_ZMuStaTaggedMatched << endl;
1401 }
1402 
1403 #include "FWCore/Framework/interface/MakerMacros.h"
1404 
1405 DEFINE_FWK_MODULE(ZMuMuPerformances);
ZMuMuPerformances::getParticlePhi
float getParticlePhi(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2)
Definition: ZMuMuPerformances.cc:1288
muonMatch_cfi.muonMatch
muonMatch
Definition: muonMatch_cfi.py:8
ZMuMuPerformances::trackIsoToken_
EDGetTokenT< IsolationCollection > trackIsoToken_
Definition: ZMuMuPerformances.cc:68
reco::GenParticleCollection
std::vector< GenParticle > GenParticleCollection
collection of GenParticles
Definition: GenParticleFwd.h:13
ZMuMuPerformances::getParticleEta
float getParticleEta(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2)
Definition: ZMuMuPerformances.cc:1253
reco::Muon::track
TrackRef track() const override
reference to a Track
Definition: Muon.h:46
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
ZMuMuPerformances::h_etaSta_wrongTrkCharge_ZMuMuTagged
TH1D * h_etaSta_wrongTrkCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:125
mps_fire.i
i
Definition: mps_fire.py:341
ZMuMuPerformances::h_etaSta_wrongTrkCharge_ZMuStaTagged
TH1D * h_etaSta_wrongTrkCharge_ZMuStaTagged
Definition: ZMuMuPerformances.cc:139
ZMuMuPerformances::h_TrackerMuonEtaMinusGenEta
TH1D * h_TrackerMuonEtaMinusGenEta
Definition: ZMuMuPerformances.cc:94
ZMuMuPerformances::h_phiSta_wrongTrkCharge_ZMuMuTagged
TH1D * h_phiSta_wrongTrkCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:126
reco::Candidate::isStandAloneMuon
virtual bool isStandAloneMuon() const =0
ZMuMuPerformances::h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged
TH1D * h_GlobalMuonStaComponentPtMinusGenPt_ZMuMuTagged
Definition: ZMuMuPerformances.cc:102
ZMuMuPerformances::h_GlobalMuonStaComponentPtMinusGenPt
TH1D * h_GlobalMuonStaComponentPtMinusGenPt
Definition: ZMuMuPerformances.cc:95
ZMuMuPerformances::h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged
TH1D * h_ptStaMinusptTrack_correctStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:117
ZMuMuPerformances::genParticlesToken_
EDGetTokenT< GenParticleCollection > genParticlesToken_
Definition: ZMuMuPerformances.cc:69
reco::Candidate::daughter
virtual const Candidate * daughter(size_type i) const =0
return daughter at a given position, i = 0, ... numberOfDaughters() - 1 (read only mode) ...
PbPb_ZMuSkimMuonDPG_cff.deltaR
deltaR
Definition: PbPb_ZMuSkimMuonDPG_cff.py:63
reco::StandAloneMuonTag
stand alone muon component tag
Definition: RecoCandidate.h:77
ZMuMuPerformances::h_DRTrack_wrongStaCharge_ZMuTrackTagged
TH1D * h_DRTrack_wrongStaCharge_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:133
muonDTDigis_cfi.pset
pset
Definition: muonDTDigis_cfi.py:27
IsolationCollection
ValueMap< float > IsolationCollection
Definition: ZMuMuPerformances.cc:40
edm::View::size
size_type size() const
ZMuMuPerformances::h_zMuTrackMass_ZMuTrackTagged
TH1D * h_zMuTrackMass_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:129
TFileService::make
T * make(const Args &...args) const
make new ROOT object
Definition: TFileService.h:64
ZMuMuPerformances::h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged
TH2D * h_ptStaMinusptTrack_vsEtaTracker_correctStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:118
ZMuMuPerformances::h_GlobalMuonStaComponentEtaMinusGenEta
TH1D * h_GlobalMuonStaComponentEtaMinusGenEta
Definition: ZMuMuPerformances.cc:95
ZMuMuPerformances::check_ifZmumu
bool check_ifZmumu(const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2)
Definition: ZMuMuPerformances.cc:1202
analyze
example_stream void analyze(const edm::Event &, const edm::EventSetup &) override
ZMuMuPerformances::h_n_globalMuon_perEvent_MCmatch
TH1D * h_n_globalMuon_perEvent_MCmatch
Definition: ZMuMuPerformances.cc:84
ZMuMuPerformances::h_DPtTrackGenvsPtGen_ZMuMuTagged
TH2D * h_DPtTrackGenvsPtGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:106
ZMuMuPerformances::getParticlePt
float getParticlePt(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2)
Definition: ZMuMuPerformances.cc:1218
ZMuMuPerformances::h_DPtGlobalStaComponentGenvsPtGen
TH2D * h_DPtGlobalStaComponentGenvsPtGen
Definition: ZMuMuPerformances.cc:96
edm::View::refAt
RefToBase< value_type > refAt(size_type i) const
fftjetproducer_cfi.etaCut
etaCut
Definition: fftjetproducer_cfi.py:168
ZMuMuPerformances::overlap_
OverlapChecker overlap_
Definition: ZMuMuPerformances.cc:79
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
reco::Candidate::isTrackerMuon
virtual bool isTrackerMuon() const =0
reco::Candidate::status
virtual int status() const =0
status word
ZMuMuPerformances::h_ptTrack_wrongStaCharge_ZMuMuTagged
TH1D * h_ptTrack_wrongStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:113
ZMuMuPerformances::h_etaTrack_wrongStaCharge_ZMuMuTagged
TH1D * h_etaTrack_wrongStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:112
ZMuMuPerformances::muonMatchMapToken_
EDGetTokenT< GenParticleMatch > muonMatchMapToken_
Definition: ZMuMuPerformances.cc:65
ZMuMuPerformances::h_n_trackerStaOnlyMuon_perEvent_MCmatch
TH1D * h_n_trackerStaOnlyMuon_perEvent_MCmatch
Definition: ZMuMuPerformances.cc:85
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
ZMuMuPerformances::h_n_trackerStaOnlyMuon_perEvent
TH1D * h_n_trackerStaOnlyMuon_perEvent
Definition: ZMuMuPerformances.cc:82
ZMuMuPerformances::h_zMuStaMass_correctStaCharge_ZMuMuTagged
TH1D * h_zMuStaMass_correctStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:117
ZMuMuPerformances::h_zMuStaMass_wrongTrkCharge_ZMuMuTagged
TH1D * h_zMuStaMass_wrongTrkCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:125
reco::Candidate::p4
virtual const LorentzVector & p4() const =0
four-momentum Lorentz vector
ZMuMuPerformances::h_DPtGlobalGenvsEtaGen_ZMuMuTagged
TH2D * h_DPtGlobalGenvsEtaGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:105
reco::Candidate::pdgId
virtual int pdgId() const =0
PDG identifier.
ZMuMuPerformances::tracksToken_
EDGetTokenT< CandidateView > tracksToken_
Definition: ZMuMuPerformances.cc:67
ZMuMuPerformances::zMuTrackToken_
EDGetTokenT< CandidateView > zMuTrackToken_
Definition: ZMuMuPerformances.cc:60
ZMuMuPerformances::zMuStandAloneMatchMapToken_
EDGetTokenT< GenParticleMatch > zMuStandAloneMatchMapToken_
Definition: ZMuMuPerformances.cc:63
visualization-live-secondInstance_cfg.m
m
Definition: visualization-live-secondInstance_cfg.py:60
edm::View::empty
bool empty() const
ZMuMuPerformances::h_n_trackerOnlyMuon_perEvent
TH1D * h_n_trackerOnlyMuon_perEvent
Definition: ZMuMuPerformances.cc:82
ZMuMuPerformances::zMuTrackMatchMapToken_
EDGetTokenT< GenParticleMatch > zMuTrackMatchMapToken_
Definition: ZMuMuPerformances.cc:61
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
ZMuMuPerformances::h_zMuStaMass_wrongTrkCharge_ZMuStaTagged
TH1D * h_zMuStaMass_wrongTrkCharge_ZMuStaTagged
Definition: ZMuMuPerformances.cc:139
ZMuMuPerformances::h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged
TH2D * h_DPtGlobalStaComponentGenvsEtaGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:105
testProducerWithPsetDescEmpty_cfi.a2
a2
Definition: testProducerWithPsetDescEmpty_cfi.py:35
ZMuMuPerformances::h_DPtGlobalStaComponentGenvsEtaGen
TH2D * h_DPtGlobalStaComponentGenvsEtaGen
Definition: ZMuMuPerformances.cc:98
ZMuMuPerformances::h_DRSta_wrongTrkCharge_ZMuMuTagged
TH1D * h_DRSta_wrongTrkCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:126
ZMuMuPerformances::h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged
TH2D * h_DEtaGlobalStaComponentGenvsEtaGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:104
ZMuMuPerformances::trackMuonCandRef_
reco::CandidateBaseRef trackMuonCandRef_
Definition: ZMuMuPerformances.cc:78
ZMuMuPerformances::ZMuMuPerformances
ZMuMuPerformances(const edm::ParameterSet &pset)
Definition: ZMuMuPerformances.cc:182
ZMuMuPerformances::h_DPtTrackGenvsEtaGen_ZMuMuTagged
TH2D * h_DPtTrackGenvsEtaGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:106
singleTopDQM_cfi.setup
setup
SETUP
Definition: singleTopDQM_cfi.py:36
ZMuMuPerformances::h_n_staOnlyMuon_perEvent_MCmatch
TH1D * h_n_staOnlyMuon_perEvent_MCmatch
Definition: ZMuMuPerformances.cc:84
ZMuMuPerformances::muonIsoToken_
EDGetTokenT< IsolationCollection > muonIsoToken_
Definition: ZMuMuPerformances.cc:66
ZMuMuPerformances::h_GlobalMuonEtaMinusGenEta_ZMuMuTagged
TH1D * h_GlobalMuonEtaMinusGenEta_ZMuMuTagged
Definition: ZMuMuPerformances.cc:100
ZMuMuPerformances::h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged
TH1D * h_GlobalMuonStaComponentEtaMinusGenEta_ZMuMuTagged
Definition: ZMuMuPerformances.cc:102
reco::Muon::standAloneMuon
TrackRef standAloneMuon() const override
reference to a stand-alone muon Track
Definition: Muon.h:49
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
ZMuMuPerformances::endJob
void endJob() override
Definition: ZMuMuPerformances.cc:1358
ZMuMuPerformances::h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged
TH2D * h_ptStaMinusptTrack_vsPtTracker_correctStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:119
electrons_cff.bool
bool
Definition: electrons_cff.py:371
ZMuMuPerformances::h_phiSta_wrongTrkCharge_ZMuStaTagged
TH1D * h_phiSta_wrongTrkCharge_ZMuStaTagged
Definition: ZMuMuPerformances.cc:140
ZMuMuPerformances::h_zMuTrackMass_wrongStaCharge_ZMuTrackTagged
TH1D * h_zMuTrackMass_wrongStaCharge_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:132
ZMuMuPerformances::h_DPtGlobalGenvsPtGen_ZMuMuTagged
TH2D * h_DPtGlobalGenvsPtGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:103
reco::Candidate::masterClone
virtual const CandidateBaseRef & masterClone() const =0
reco::Candidate::isGlobalMuon
virtual bool isGlobalMuon() const =0
ZMuMuAnalysisNtupler_cff.zMuMu
zMuMu
zMuMu vector of PSet is common to all categories except zMuTrk category
Definition: ZMuMuAnalysisNtupler_cff.py:340
reco::Candidate::eta
virtual double eta() const =0
momentum pseudorapidity
ZMuMuPerformances::h_TrackerMuonChargeTimeGenCharge
TH1D * h_TrackerMuonChargeTimeGenCharge
Definition: ZMuMuPerformances.cc:92
reco::Candidate::pt
virtual double pt() const =0
transverse momentum
reco::CombinedMuonTag
conbined muon component tag
Definition: RecoCandidate.h:79
ZMuMuPerformances::h_n_trackerOnlyMuon_perEvent_MCmatch
TH1D * h_n_trackerOnlyMuon_perEvent_MCmatch
Definition: ZMuMuPerformances.cc:84
reco::Candidate::mass
virtual double mass() const =0
mass
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
ZMuMuPerformances::h_DRTrack_wrongStaCharge_ZMuMuTagged
TH1D * h_DRTrack_wrongStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:113
ZMuMuPerformances::h_GlobalMuonPtMinusGenPt_ZMuMuTagged
TH1D * h_GlobalMuonPtMinusGenPt_ZMuMuTagged
Definition: ZMuMuPerformances.cc:101
ZMuMuPerformances::zMuStandAloneToken_
EDGetTokenT< CandidateView > zMuStandAloneToken_
Definition: ZMuMuPerformances.cc:62
ZMuMuPerformances::h_ptSta_wrongTrkCharge_ZMuStaTagged
TH1D * h_ptSta_wrongTrkCharge_ZMuStaTagged
Definition: ZMuMuPerformances.cc:140
ZMuMuPerformances::h_ptSta_wrongTrkCharge_ZMuMuTagged
TH1D * h_ptSta_wrongTrkCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:126
reco::Candidate::charge
virtual int charge() const =0
electric charge
jetfilter_cfi.ptCut
ptCut
Definition: jetfilter_cfi.py:6
ZMuMuPerformances::zMuMuToken_
EDGetTokenT< CandidateView > zMuMuToken_
Definition: ZMuMuPerformances.cc:58
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
edm
HLT enums.
Definition: AlignableModifier.h:19
ZMuMuPerformances::zMuMuMatchMapToken_
EDGetTokenT< GenParticleMatch > zMuMuMatchMapToken_
Definition: ZMuMuPerformances.cc:59
ZMuMuPerformances::h_GlobalMuonChargeTimeGenCharge
TH1D * h_GlobalMuonChargeTimeGenCharge
Definition: ZMuMuPerformances.cc:92
reco::Candidate::get
T get() const
get a component
Definition: Candidate.h:222
ZMuMuPerformances::h_zMuMuMassSameSign_MCmatch
TH1D * h_zMuMuMassSameSign_MCmatch
Definition: ZMuMuPerformances.cc:89
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
ZMuMuPerformances::h_zMuTrackMass_wrongStaCharge_ZMuMuTagged
TH1D * h_zMuTrackMass_wrongStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:112
genParticles2HepMC_cfi.genParticles
genParticles
Definition: genParticles2HepMC_cfi.py:4
gather_cfg.cout
cout
Definition: gather_cfg.py:144
ZMuMuPerformances::h_etaTrack_wrongStaCharge_ZMuTrackTagged
TH1D * h_etaTrack_wrongStaCharge_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:132
ZMuMuPerformances::h_DEtaGlobalGenvsEtaGen_ZMuMuTagged
TH2D * h_DEtaGlobalGenvsEtaGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:103
ZMuMuPerformances::h_DEtaGlobalStaComponentGenvsEtaGen
TH2D * h_DEtaGlobalStaComponentGenvsEtaGen
Definition: ZMuMuPerformances.cc:96
ZMuMuPerformances::h_phiTrack_wrongStaCharge_ZMuTrackTagged
TH1D * h_phiTrack_wrongStaCharge_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:133
reco::Candidate::numberOfDaughters
virtual size_type numberOfDaughters() const =0
number of daughters
ZMuMuPerformances::h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged
TH2D * h_DPtGlobalStaComponentGenvsPtGen_ZMuMuTagged
Definition: ZMuMuPerformances.cc:104
reco::Candidate::phi
virtual double phi() const =0
momentum azimuthal angle
ZMuMuPerformances::muonsToken_
EDGetTokenT< CandidateView > muonsToken_
Definition: ZMuMuPerformances.cc:64
ZMuMuPerformances::analyze
void analyze(const edm::Event &event, const edm::EventSetup &setup) override
Definition: ZMuMuPerformances.cc:489
ZMuMuPerformances::getParticleP4
Particle::LorentzVector getParticleP4(const int ipart, const Candidate *dauGen0, const Candidate *dauGen1, const Candidate *dauGen2)
Definition: ZMuMuPerformances.cc:1323
event
Definition: event.py:1
reco::JetExtendedAssociation::LorentzVector
math::PtEtaPhiELorentzVectorF LorentzVector
Definition: JetExtendedAssociation.h:25
ZMuMuPerformances::h_ptTrack_wrongStaCharge_ZMuTrackTagged
TH1D * h_ptTrack_wrongStaCharge_ZMuTrackTagged
Definition: ZMuMuPerformances.cc:133
ZMuMuPerformances::h_phiTrack_wrongStaCharge_ZMuMuTagged
TH1D * h_phiTrack_wrongStaCharge_ZMuMuTagged
Definition: ZMuMuPerformances.cc:113
Generated for CMSSW Reference Manual by doxygen 1.8.11