CMS 3D CMS Logo
MuonRecoAnalyzer.cc
Go to the documentation of this file.
1 #include "DQMOffline/Muon/interface/MuonRecoAnalyzer.h"
2 
3 #include "DataFormats/Common/interface/Handle.h"
4 #include "DataFormats/MuonReco/interface/Muon.h"
5 #include "DataFormats/MuonReco/interface/MuonFwd.h"
6 #include "DataFormats/MuonReco/interface/MuonEnergy.h"
7 
8 #include "DataFormats/TrackReco/interface/Track.h"
9 #include "DataFormats/TrackReco/interface/TrackFwd.h"
10 
11 #include "FWCore/MessageLogger/interface/MessageLogger.h"
12 
13 #include <string>
14 #include "TMath.h"
15 using namespace std;
16 using namespace edm;
17 
18 
19 
20 MuonRecoAnalyzer::MuonRecoAnalyzer(const edm::ParameterSet& pSet) {
21  parameters = pSet;
22 
23  // Input booleans
24  IsminiAOD = parameters.getParameter<bool>("IsminiAOD");
25 
26  // the services:
27  theService = new MuonServiceProxy(parameters.getParameter<ParameterSet>("ServiceParameters"));
28  theMuonCollectionLabel_ = consumes<edm::View<reco::Muon> > (parameters.getParameter<edm::InputTag>("MuonCollection"));
29 
30  ptBin = parameters.getParameter<int>("ptBin");
31  ptMin = parameters.getParameter<double>("ptMin");
32  ptMax = parameters.getParameter<double>("ptMax");
33  pResBin = parameters.getParameter<int>("pResBin");
34  pResMin = parameters.getParameter<double>("pResMin");
35  pResMax = parameters.getParameter<double>("pResMax");
36  rhBin=parameters.getParameter<int>("rhBin");
37  rhMin=parameters.getParameter<double>("rhMin");
38  rhMax=parameters.getParameter<double>("rhMax");
39  pBin = parameters.getParameter<int>("pBin");
40  pMin = parameters.getParameter<double>("pMin");
41  pMax = parameters.getParameter<double>("pMax");
42  chi2Bin = parameters.getParameter<int>("chi2Bin");
43  chi2Min = parameters.getParameter<double>("chi2Min");
44  chi2Max = parameters.getParameter<double>("chi2Max");
45  phiBin = parameters.getParameter<int>("phiBin");
46  phiMin = parameters.getParameter<double>("phiMin");
47  phiMax = parameters.getParameter<double>("phiMax");
48  tunePBin= parameters.getParameter<int>("tunePBin");
49  tunePMax= parameters.getParameter<double>("tunePMax");
50  tunePMin= parameters.getParameter<double>("tunePMin");
51  thetaBin = parameters.getParameter<int>("thetaBin");
52  thetaMin = parameters.getParameter<double>("thetaMin");
53  thetaMax = parameters.getParameter<double>("thetaMax");
54  etaBin = parameters.getParameter<int>("etaBin");
55  etaMin = parameters.getParameter<double>("etaMin");
56  etaMax = parameters.getParameter<double>("etaMax");
57 
58  theFolder = parameters.getParameter<string>("folder");
59 }
60 
61 
62 MuonRecoAnalyzer::~MuonRecoAnalyzer() {
63  delete theService;
64 }
65 void MuonRecoAnalyzer::bookHistograms(DQMStore::IBooker & ibooker,
66  edm::Run const & /*iRun*/,
67  edm::EventSetup const & /* iSetup */){
68 
69  ibooker.cd();
70  ibooker.setCurrentFolder(theFolder);
71 
72  muReco = ibooker.book1D("muReco", "muon reconstructed tracks", 6, 1, 7);
73  muReco->setBinLabel(1,"glb+tk+sta");
74  muReco->setBinLabel(2,"glb+sta");
75  muReco->setBinLabel(3,"tk+sta");
76  muReco->setBinLabel(4,"tk");
77  muReco->setBinLabel(5,"sta");
78  muReco->setBinLabel(6,"calo");
79 
80  int binFactor = 4;
81 
83  // monitoring of eta parameter
85  std::string histname = "GlbMuon_";
86  etaGlbTrack .push_back(ibooker.book1D(histname+"Glb_eta", "#eta_{GLB}", etaBin, etaMin, etaMax));
87  etaGlbTrack .push_back(ibooker.book1D(histname+"Tk_eta", "#eta_{TKfromGLB}", etaBin, etaMin, etaMax));
88  etaGlbTrack .push_back(ibooker.book1D(histname+"Sta_eta", "#eta_{STAfromGLB}", etaBin, etaMin, etaMax));
89  etaResolution.push_back(ibooker.book1D("Res_TkGlb_eta", "#eta_{TKfromGLB} - #eta_{GLB}", etaBin*binFactor, etaMin/3000, etaMax/3000));
90  etaResolution.push_back(ibooker.book1D("Res_GlbSta_eta", "#eta_{GLB} - #eta_{STAfromGLB}", etaBin*binFactor, etaMin/100, etaMax/100));
91  etaResolution.push_back(ibooker.book1D("Res_TkSta_eta", "#eta_{TKfromGLB} - #eta_{STAfromGLB}", etaBin*binFactor, etaMin/100, etaMax/100));
92  etaResolution.push_back(ibooker.book2D("ResVsEta_TkGlb_eta", "(#eta_{TKfromGLB} - #eta_{GLB}) vs #eta_{GLB}", etaBin, etaMin, etaMax, etaBin*binFactor, etaMin/3000, etaMax/3000));
93  etaResolution.push_back(ibooker.book2D("ResVsEta_GlbSta_eta", "(#eta_{GLB} - #eta_{STAfromGLB}) vs #eta_{GLB}", etaBin, etaMin, etaMax, etaBin*binFactor, etaMin/100, etaMax/100));
94  etaResolution.push_back(ibooker.book2D("ResVsEta_TkSta_eta", "(#eta_{TKfromGLB} - #eta_{STAfromGLB}) vs #eta_{TKfromGLB}", etaBin, etaMin, etaMax, etaBin*binFactor, etaMin/100, etaMax/100));
95  etaPull = ibooker.book1D("Pull_TkSta_eta", "#eta_{TKfromGLB} - #eta_{GLB} / error", 100, -10, 10);
96  etaTrack = ibooker.book1D("TkMuon_eta", "#eta_{TK}", etaBin, etaMin, etaMax);
97  etaStaTrack = ibooker.book1D("StaMuon_eta", "#eta_{STA}", etaBin, etaMin, etaMax);
98  etaEfficiency.push_back(ibooker.book1D("StaEta", "#eta_{STAfromGLB}", etaBin, etaMin, etaMax));
99  etaEfficiency.push_back(ibooker.book1D("StaEta_ifCombinedAlso", "#eta_{STAfromGLB} if isGlb=true", etaBin, etaMin, etaMax));
100 
102  // monitoring of theta parameter
104  thetaGlbTrack.push_back(ibooker.book1D(histname+"Glb_theta", "#theta_{GLB}", thetaBin, thetaMin, thetaMax)); thetaGlbTrack[0]->setAxisTitle("rad");
105  thetaGlbTrack.push_back(ibooker.book1D(histname+"Tk_theta", "#theta_{TKfromGLB}", thetaBin, thetaMin, thetaMax)); thetaGlbTrack[1]->setAxisTitle("rad");
106  thetaGlbTrack.push_back(ibooker.book1D(histname+"Sta_theta", "#theta_{STAfromGLB}", thetaBin, thetaMin, thetaMax)); thetaGlbTrack[2]->setAxisTitle("rad");
107  thetaResolution.push_back(ibooker.book1D("Res_TkGlb_theta", "#theta_{TKfromGLB} - #theta_{GLB}", thetaBin*binFactor, -(thetaMax/3000), thetaMax/3000)); thetaResolution[0]->setAxisTitle("rad");
108  thetaResolution.push_back(ibooker.book1D("Res_GlbSta_theta", "#theta_{GLB} - #theta_{STAfromGLB}", thetaBin*binFactor,-(thetaMax/100), thetaMax/100));
109  thetaResolution[1]->setAxisTitle("rad");
110  thetaResolution.push_back(ibooker.book1D("Res_TkSta_theta", "#theta_{TKfromGLB} - #theta_{STAfromGLB}", thetaBin*binFactor, -(thetaMax/100), thetaMax/100));
111  thetaResolution[2]->setAxisTitle("rad");
112  thetaResolution.push_back(ibooker.book2D("ResVsTheta_TkGlb_theta", "(#theta_{TKfromGLB} - #theta_{GLB}) vs #theta_{GLB}", thetaBin, thetaMin, thetaMax, thetaBin*binFactor, -(thetaMax/3000), thetaMax/3000));
113  thetaResolution[3]->setAxisTitle("rad",1);
114  thetaResolution[3]->setAxisTitle("rad",2);
115  thetaResolution.push_back(ibooker.book2D("ResVsTheta_GlbSta_theta", "(#theta_{GLB} - #theta_{STAfromGLB}) vs #theta_{GLB}", thetaBin, thetaMin, thetaMax, thetaBin*binFactor, -(thetaMax/100), thetaMax/100));
116  thetaResolution[4]->setAxisTitle("rad",1);
117  thetaResolution[4]->setAxisTitle("rad",2);
118  thetaResolution.push_back(ibooker.book2D("ResVsTheta_TkSta_theta", "(#theta_{TKfromGLB} - #theta_{STAfromGLB}) vs #theta_{TKfromGLB}", thetaBin, thetaMin, thetaMax, thetaBin*binFactor, -(thetaMax/100), thetaMax/100));
119  thetaResolution[5]->setAxisTitle("rad",1);
120  thetaResolution[5]->setAxisTitle("rad",2);
121  thetaPull = ibooker.book1D("Pull_TkSta_theta", "#theta_{TKfromGLB} - #theta_{STAfromGLB} / error", 100,-10,10);
122  thetaTrack = ibooker.book1D("TkMuon_theta", "#theta_{TK}", thetaBin, thetaMin, thetaMax);
123  thetaTrack->setAxisTitle("rad");
124  thetaStaTrack = ibooker.book1D("StaMuon_theta", "#theta_{STA}", thetaBin, thetaMin, thetaMax);
125  thetaStaTrack->setAxisTitle("rad");
126 
127  // monitoring tunePMuonBestTrack Pt
128  tunePResolution = ibooker.book1D("Res_TuneP_pt", "Pt_{MuonBestTrack}-Pt_{tunePMuonBestTrack}/Pt_{MuonBestTrack}", tunePBin, tunePMin, tunePMax);
129 
130  // monitoring of phi paramater
131  phiGlbTrack.push_back(ibooker.book1D(histname+"Glb_phi", "#phi_{GLB}", phiBin, phiMin, phiMax));
132  phiGlbTrack[0]->setAxisTitle("rad");
133  phiGlbTrack.push_back(ibooker.book1D(histname+"Tk_phi", "#phi_{TKfromGLB}", phiBin, phiMin, phiMax));
134  phiGlbTrack[1]->setAxisTitle("rad");
135  phiGlbTrack.push_back(ibooker.book1D(histname+"Sta_phi", "#phi_{STAfromGLB}", phiBin, phiMin, phiMax));
136  phiGlbTrack[2]->setAxisTitle("rad");
137  phiResolution.push_back(ibooker.book1D("Res_TkGlb_phi", "#phi_{TKfromGLB} - #phi_{GLB}", phiBin*binFactor, phiMin/3000, phiMax/3000));
138  phiResolution[0]->setAxisTitle("rad");
139  phiResolution.push_back(ibooker.book1D("Res_GlbSta_phi", "#phi_{GLB} - #phi_{STAfromGLB}", phiBin*binFactor, phiMin/100, phiMax/100));
140  phiResolution[1]->setAxisTitle("rad");
141  phiResolution.push_back(ibooker.book1D("Res_TkSta_phi", "#phi_{TKfromGLB} - #phi_{STAfromGLB}", phiBin*binFactor, phiMin/100, phiMax/100));
142  phiResolution[2]->setAxisTitle("rad");
143  phiResolution.push_back(ibooker.book2D("ResVsPhi_TkGlb_phi", "(#phi_{TKfromGLB} - #phi_{GLB}) vs #phi_GLB", phiBin, phiMin, phiMax, phiBin*binFactor, phiMin/3000, phiMax/3000));
144  phiResolution[3]->setAxisTitle("rad",1);
145  phiResolution[3]->setAxisTitle("rad",2);
146  phiResolution.push_back(ibooker.book2D("ResVsPhi_GlbSta_phi", "(#phi_{GLB} - #phi_{STAfromGLB}) vs #phi_{GLB}", phiBin, phiMin, phiMax, phiBin*binFactor, phiMin/100, phiMax/100));
147  phiResolution[4]->setAxisTitle("rad",1);
148  phiResolution[4]->setAxisTitle("rad",2);
149  phiResolution.push_back(ibooker.book2D("ResVsPhi_TkSta_phi", "(#phi_{TKfromGLB} - #phi_{STAfromGLB}) vs #phi_{TKfromGLB}", phiBin, phiMin, phiMax, phiBin*binFactor, phiMin/100, phiMax/100));
150  phiResolution[5]->setAxisTitle("rad",1);
151  phiResolution[5]->setAxisTitle("rad",2);
152  phiPull = ibooker.book1D("Pull_TkSta_phi", "#phi_{TKfromGLB} - #phi_{STAfromGLB} / error", 100,-10,10);
153  phiTrack = ibooker.book1D("TkMuon_phi", "#phi_{TK}", phiBin, phiMin, phiMax);
154  phiTrack->setAxisTitle("rad");
155  phiStaTrack = ibooker.book1D("StaMuon_phi", "#phi_{STA}", phiBin, phiMin, phiMax);
156  phiStaTrack->setAxisTitle("rad");
157  phiEfficiency.push_back(ibooker.book1D("StaPhi", "#phi_{STAfromGLB}", phiBin, phiMin, phiMax));
158  phiEfficiency[0]->setAxisTitle("rad");
159  phiEfficiency.push_back(ibooker.book1D("StaPhi_ifCombinedAlso", "#phi_{STAfromGLB} if the isGlb=true", phiBin, phiMin, phiMax));
160  phiEfficiency[1]->setAxisTitle("rad");
161 
162  // monitoring of the chi2 parameter
163  chi2OvDFGlbTrack.push_back(ibooker.book1D(histname+"Glb_chi2OverDf", "#chi_{2}OverDF_{GLB}", chi2Bin, chi2Min, chi2Max));
164  chi2OvDFGlbTrack.push_back(ibooker.book1D(histname+"Tk_chi2OverDf", "#chi_{2}OverDF_{TKfromGLB}", phiBin, chi2Min, chi2Max));
165  chi2OvDFGlbTrack.push_back(ibooker.book1D(histname+"Sta_chi2OverDf", "#chi_{2}OverDF_{STAfromGLB}", chi2Bin, chi2Min, chi2Max));
166  chi2OvDFTrack = ibooker.book1D("TkMuon_chi2OverDf", "#chi_{2}OverDF_{TK}", chi2Bin, chi2Min, chi2Max);
167  chi2OvDFStaTrack = ibooker.book1D("StaMuon_chi2OverDf", "#chi_{2}OverDF_{STA}", chi2Bin, chi2Min, chi2Max);
168 //--------------------------
169  probchi2GlbTrack.push_back(ibooker.book1D(histname+"Glb_probchi", "Prob #chi_{GLB}", 120, chi2Min, 1.20));
170  probchi2GlbTrack.push_back(ibooker.book1D(histname+"Tk_probchi", "Prob #chi_{TKfromGLB}", 120, chi2Min, 1.20));
171  probchi2GlbTrack.push_back(ibooker.book1D(histname+"Sta_probchi", "Prob #chi_{STAfromGLB}", 120, chi2Min, 1.20));
172  probchi2Track=ibooker.book1D("TkMuon_probchi", "Prob #chi_{TK}", 120, chi2Min, 1.20);
173  probchi2StaTrack=ibooker.book1D("StaMuon_probchi", "Prob #chi_{STA}", 120, chi2Min, 1.20);
174 
175  // monitoring of the momentum
176  pGlbTrack.push_back(ibooker.book1D(histname+"Glb_p", "p_{GLB}", pBin, pMin, pMax));
177  pGlbTrack[0]->setAxisTitle("GeV");
178  pGlbTrack.push_back(ibooker.book1D(histname+"Tk_p", "p_{TKfromGLB}", pBin, pMin, pMax));
179  pGlbTrack[1]->setAxisTitle("GeV");
180  pGlbTrack.push_back(ibooker.book1D(histname+"Sta_p", "p_{STAfromGLB}", pBin, pMin, pMax));
181  pGlbTrack[2]->setAxisTitle("GeV");
182  pTrack = ibooker.book1D("TkMuon_p", "p_{TK}", pBin, pMin, pMax);
183  pTrack->setAxisTitle("GeV");
184  pStaTrack = ibooker.book1D("StaMuon_p", "p_{STA}", pBin, pMin, pMax);
185  pStaTrack->setAxisTitle("GeV");
186 
187  // monitoring of the transverse momentum
188  ptGlbTrack.push_back(ibooker.book1D(histname+"Glb_pt", "pt_{GLB}", ptBin, ptMin, ptMax));
189  ptGlbTrack[0]->setAxisTitle("GeV");
190  ptGlbTrack.push_back(ibooker.book1D(histname+"Tk_pt", "pt_{TKfromGLB}", ptBin, ptMin, ptMax));
191  ptGlbTrack[1]->setAxisTitle("GeV");
192  ptGlbTrack.push_back(ibooker.book1D(histname+"Sta_pt", "pt_{STAfromGLB}", ptBin, ptMin, ptMax));
193  ptGlbTrack[2]->setAxisTitle("GeV");
194  ptTrack = ibooker.book1D("TkMuon_pt", "pt_{TK}", ptBin, ptMin, ptMax);
195  ptTrack->setAxisTitle("GeV");
196  ptStaTrack = ibooker.book1D("StaMuon_pt", "pt_{STA}", ptBin, ptMin, pMax);
197  ptStaTrack->setAxisTitle("GeV");
198 
199  // monitoring of the muon charge
200  qGlbTrack.push_back(ibooker.book1D(histname+"Glb_q", "q_{GLB}", 5, -2.5, 2.5));
201  qGlbTrack.push_back(ibooker.book1D(histname+"Tk_q", "q_{TKfromGLB}", 5, -2.5, 2.5));
202  qGlbTrack.push_back(ibooker.book1D(histname+"Sta_q", "q_{STAformGLB}", 5, -2.5, 2.5));
203  qGlbTrack.push_back(ibooker.book1D(histname+"qComparison", "comparison between q_{GLB} and q_{TKfromGLB}, q_{STAfromGLB}", 8, 0.5, 8.5));
204  qGlbTrack[3]->setBinLabel(1,"qGlb=qSta");
205  qGlbTrack[3]->setBinLabel(2,"qGlb!=qSta");
206  qGlbTrack[3]->setBinLabel(3,"qGlb=qTk");
207  qGlbTrack[3]->setBinLabel(4,"qGlb!=qTk");
208  qGlbTrack[3]->setBinLabel(5,"qSta=qTk");
209  qGlbTrack[3]->setBinLabel(6,"qSta!=qTk");
210  qGlbTrack[3]->setBinLabel(7,"qGlb!=qSta,qGlb!=Tk");
211  qGlbTrack[3]->setBinLabel(8,"qGlb=qSta,qGlb=Tk");
212  qTrack = ibooker.book1D("TkMuon_q", "q_{TK}", 5, -2.5, 2.5);
213  qStaTrack = ibooker.book1D("StaMuon_q", "q_{STA}", 5, -2.5, 2.5);
214 
216  // monitoring of the momentum resolution
217  qOverpResolution.push_back(ibooker.book1D("Res_TkGlb_qOverp", "(q/p)_{TKfromGLB} - (q/p)_{GLB}", pResBin*binFactor*2, pResMin/10, pResMax/10));
218  qOverpResolution[0]->setAxisTitle("GeV^{-1}");
219  qOverpResolution.push_back(ibooker.book1D("Res_GlbSta_qOverp", "(q/p)_{GLB} - (q/p)_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
220  qOverpResolution[1]->setAxisTitle("GeV^{-1}");
221  qOverpResolution.push_back(ibooker.book1D("Res_TkSta_qOverp", "(q/p)_{TKfromGLB} - (q/p)_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
222  qOverpResolution[2]->setAxisTitle("GeV^{-1}");
223  qOverpPull = ibooker.book1D("Pull_TkSta_qOverp", "(q/p)_{TKfromGLB} - (q/p)_{STAfromGLB} / error", 100,-10,10);
224 
225  oneOverpResolution.push_back(ibooker.book1D("Res_TkGlb_oneOverp", "(1/p)_{TKfromGLB} - (1/p)_{GLB}", pResBin*binFactor*2, pResMin/10, pResMax/10));
226  oneOverpResolution[0]->setAxisTitle("GeV^{-1}");
227  oneOverpResolution.push_back(ibooker.book1D("Res_GlbSta_oneOverp", "(1/p)_{GLB} - (1/p)_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
228  oneOverpResolution[1]->setAxisTitle("GeV^{-1}");
229  oneOverpResolution.push_back(ibooker.book1D("Res_TkSta_oneOverp", "(q/p)_{TKfromGLB} - (q/p)_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
230  oneOverpResolution[2]->setAxisTitle("GeV^{-1}");
231  oneOverpPull = ibooker.book1D("Pull_TkSta_oneOverp", "(1/p)_{TKfromGLB} - (1/p)_{STAfromGLB} / error", 100,-10,10);
232 
233 
234  qOverptResolution.push_back(ibooker.book1D("Res_TkGlb_qOverpt", "(q/p_{t})_{TKfromGLB} - (q/p_{t})_{GLB}", pResBin*binFactor*2, pResMin/10, pResMax/10));
235  qOverptResolution[0]->setAxisTitle("GeV^{-1}");
236  qOverptResolution.push_back(ibooker.book1D("Res_GlbSta_qOverpt", "(q/p_{t})_{GLB} - (q/p_{t})_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
237  qOverptResolution[1]->setAxisTitle("GeV^{-1}");
238  qOverptResolution.push_back(ibooker.book1D("Res_TkSta_qOverpt", "(q/p_{t})_{TKfromGLB} - (q/p_{t})_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
239  qOverptResolution[2]->setAxisTitle("GeV^{-1}");
240  qOverptPull = ibooker.book1D("Pull_TkSta_qOverpt", "(q/pt)_{TKfromGLB} - (q/pt)_{STAfromGLB} / error", 100,-10,10);
241 
242  oneOverptResolution.push_back(ibooker.book1D("Res_TkGlb_oneOverpt", "(1/p_{t})_{TKfromGLB} - (1/p_{t})_{GLB}", pResBin*binFactor*2, pResMin/10, pResMax/10));
243  oneOverptResolution[0]->setAxisTitle("GeV^{-1}");
244  oneOverptResolution.push_back(ibooker.book1D("Res_GlbSta_oneOverpt", "(1/p_{t})_{GLB} - (1/p_{t})_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
245  oneOverptResolution[1]->setAxisTitle("GeV^{-1}");
246  oneOverptResolution.push_back(ibooker.book1D("Res_TkSta_oneOverpt", "(1/p_{t})_{TKfromGLB} - (1/p_{t})_{STAfromGLB}", pResBin*binFactor, pResMin, pResMax));
247  oneOverptResolution[2]->setAxisTitle("GeV^{-1}");
248  oneOverptResolution.push_back(ibooker.book2D("ResVsEta_TkGlb_oneOverpt", "(#eta_{TKfromGLB} - #eta_{GLB}) vs (1/p_{t})_{GLB}", etaBin, etaMin, etaMax, pResBin*binFactor*2, pResMin/10, pResMax/10));
249  oneOverptResolution[3]->setAxisTitle("GeV^{-1}",2);
250  oneOverptResolution.push_back(ibooker.book2D("ResVsEta_GlbSta_oneOverpt", "(#eta_{GLB} - #eta_{STAfromGLB} vs (1/p_{t})_{GLB}", etaBin, etaMin, etaMax, pResBin*binFactor, pResMin, pResMax));
251  oneOverptResolution[4]->setAxisTitle("GeV^{-1}",2);
252  oneOverptResolution.push_back(ibooker.book2D("ResVsEta_TkSta_oneOverpt", "(#eta_{TKfromGLB} - #eta_{STAfromGLB}) vs (1/p_{t})_{TKfromGLB}", etaBin, etaMin, etaMax, pResBin*binFactor, pResMin, pResMax));
253  oneOverptResolution[5]->setAxisTitle("GeV^{-1}",2);
254  oneOverptResolution.push_back(ibooker.book2D("ResVsPhi_TkGlb_oneOverpt", "(#phi_{TKfromGLB} - #phi_{GLB}) vs (1/p_{t})_{GLB}", phiBin, phiMin, phiMax, pResBin*binFactor*2, pResMin/10, pResMax/10));
255  oneOverptResolution[6]->setAxisTitle("rad",1);
256  oneOverptResolution[6]->setAxisTitle("GeV^{-1}",2);
257  oneOverptResolution.push_back(ibooker.book2D("ResVsPhi_GlbSta_oneOverpt", "(#phi_{GLB} - #phi_{STAfromGLB} vs (1/p_{t})_{GLB}", phiBin, phiMin, phiMax, pResBin*binFactor, pResMin, pResMax));
258  oneOverptResolution[7]->setAxisTitle("rad",1);
259  oneOverptResolution[7]->setAxisTitle("GeV^{-1}",2);
260  oneOverptResolution.push_back(ibooker.book2D("ResVsPhi_TkSta_oneOverpt", "(#phi_{TKfromGLB} - #phi_{STAfromGLB}) vs (1/p_{t})_{TKfromGLB}", phiBin, phiMin, phiMax, pResBin*binFactor, pResMin, pResMax));
261  oneOverptResolution[8]->setAxisTitle("rad",1);
262  oneOverptResolution[8]->setAxisTitle("GeV^{-1}",2);
263  oneOverptResolution.push_back(ibooker.book2D("ResVsPt_TkGlb_oneOverpt", "((1/p_{t})_{TKfromGLB} - (1/p_{t})_{GLB}) vs (1/p_{t})_{GLB}", ptBin/5, ptMin, ptMax/100, pResBin*binFactor*2, pResMin/10, pResMax/10));
264  oneOverptResolution[9]->setAxisTitle("GeV^{-1}",1);
265  oneOverptResolution[9]->setAxisTitle("GeV^{-1}",2);
266  oneOverptResolution.push_back(ibooker.book2D("ResVsPt_GlbSta_oneOverpt", "((1/p_{t})_{GLB} - (1/p_{t})_{STAfromGLB} vs (1/p_{t})_{GLB}", ptBin/5, ptMin, ptMax/100, pResBin*binFactor, pResMin, pResMax));
267  oneOverptResolution[10]->setAxisTitle("GeV^{-1}",1);
268  oneOverptResolution[10]->setAxisTitle("GeV^{-1}",2);
269  oneOverptResolution.push_back(ibooker.book2D("ResVsPt_TkSta_oneOverpt", "((1/p_{t})_{TKfromGLB} - (1/p_{t})_{STAfromGLB}) vs (1/p_{t})_{TKfromGLB}", ptBin/5, ptMin, ptMax/100, pResBin*binFactor, pResMin, pResMax));
270  oneOverptResolution[11]->setAxisTitle("GeV^{-1}",1);
271  oneOverptResolution[11]->setAxisTitle("GeV^{-1}",2);
272  oneOverptPull = ibooker.book1D("Pull_TkSta_oneOverpt", "(1/pt)_{TKfromGLB} - (1/pt)_{STAfromGLB} / error", 100,-10,10);
273 
275  // monitoring of the phi-eta
276  phiVsetaGlbTrack.push_back(ibooker.book2D(histname+"Glb_phiVSeta", "#phi vs #eta (GLB)", etaBin/2, etaMin, etaMax, phiBin/2, phiMin, phiMax));
277  phiVsetaGlbTrack.push_back(ibooker.book2D(histname+"Tk_phiVSeta", "#phi vs #eta (TKfromGLB)", etaBin/2, etaMin, etaMax, phiBin/2, phiMin, phiMax));
278  phiVsetaGlbTrack.push_back(ibooker.book2D(histname+"Sta_phiVseta", "#phi vs #eta (STAfromGLB)", etaBin/2, etaMin, etaMax, phiBin/2, phiMin, phiMax));
279 
280 
282  // monitoring of the recHits provenance
283  rhAnalysis.push_back(ibooker.book1D("StaRh_Frac_inGlb", "recHits_{STAinGLB} / recHits_{GLB}", rhBin, rhMin, rhMax));
284  rhAnalysis.push_back(ibooker.book1D("TkRh_Frac_inGlb", "recHits_{TKinGLB} / recHits_{GLB}", rhBin, rhMin, rhMax));
285  rhAnalysis.push_back(ibooker.book1D("StaRh_inGlb_Div_RhAssoSta", "recHits_{STAinGLB} / recHits_{STAfromGLB}", rhBin, rhMin, rhMax));
286  rhAnalysis.push_back(ibooker.book1D("TkRh_inGlb_Div_RhAssoTk", "recHits_{TKinGLB} / recHits_{TKfromGLB}", rhBin, rhMin, rhMax));
287  rhAnalysis.push_back(ibooker.book1D("GlbRh_Div_RhAssoStaTk", "recHits_{GLB} / (recHits_{TKfromGLB}+recHits_{STAfromGLB})", rhBin, rhMin, rhMax));
288  rhAnalysis.push_back(ibooker.book1D("invalidRh_Frac_inTk", "Invalid recHits / rechits_{GLB}", rhBin, rhMin, rhMax));
289 
291  // monitoring of the muon system rotation w.r.t. tracker
292  muVStkSytemRotation.push_back(ibooker.book2D("muVStkSytemRotation_posMu", "pT_{TK} / pT_{GLB} vs pT_{GLB} for #mu^{+}", 50,0,200,100,0.8,1.2));
293  muVStkSytemRotation.push_back(ibooker.book2D("muVStkSytemRotation_negMu", "pT_{TK} / pT_{GLB} vs pT_{GLB} for #mu^{-}", 50,0,200,100,0.8,1.2));
294 
295 }
296 
297 void MuonRecoAnalyzer::GetRes( reco::TrackRef t1, reco::TrackRef t2, string par, float &res, float &pull){
298 
299  float p1=0, p2=0, p1e=1, p2e=1;
300 
301  if(par == "eta") {
302  p1 = t1->eta(); p1e = t1->etaError();
303  p2 = t2->eta(); p2e = t2->etaError();
304  }
305  else if(par == "theta") {
306  p1 = t1->theta(); p1e = t1->thetaError();
307  p2 = t2->theta(); p2e = t2->thetaError();
308  }
309  else if(par == "phi") {
310  p1 = t1->phi(); p1e = t1->phiError();
311  p2 = t2->phi(); p2e = t2->phiError();
312  }
313  else if(par == "qOverp") {
314  p1 = t1->charge()/t1->p(); p1e = t1->qoverpError();
315  p2 = t2->charge()/t2->p(); p2e = t2->qoverpError();
316  }
317  else if(par == "oneOverp") {
318  p1 = 1./t1->p(); p1e = t1->qoverpError();
319  p2 = 1./t2->p(); p2e = t2->qoverpError();
320  }
321  else if(par == "qOverpt") {
322  p1 = t1->charge()/t1->pt(); p1e = t1->ptError()*p1*p1;
323  p2 = t2->charge()/t2->pt(); p2e = t2->ptError()*p2*p2;
324  }
325  else if(par == "oneOverpt") {
326  p1 = 1./t1->pt(); p1e = t1->ptError()*p1*p1;
327  p2 = 1./t2->pt(); p2e = t2->ptError()*p2*p2;
328  }
329 
330  res = p1 - p2;
331  if(p1e!=0 || p2e!=0) pull = res / sqrt(p1e*p1e + p2e*p2e);
332  else pull = -99;
333  return;
334 }
335 void MuonRecoAnalyzer::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup){
336  LogTrace(metname)<<"[MuonRecoAnalyzer] Analyze the mu";
337  theService->update(iSetup);
338 
339  // Take the muon container
340  edm::Handle<edm::View<reco::Muon> > muons;
341  iEvent.getByToken(theMuonCollectionLabel_,muons);
342 
343 
344  float res=0, pull=0;
345  if(!muons.isValid()) return;
346 
347  for (edm::View<reco::Muon>::const_iterator muon = muons->begin(); muon != muons->end(); ++muon){
348 
349  if(muon->isGlobalMuon()) {
350  LogTrace(metname)<<"[MuonRecoAnalyzer] The mu is global - filling the histos";
351  if(muon->isTrackerMuon() && muon->isStandAloneMuon())
352  muReco->Fill(1);
353  if(!(muon->isTrackerMuon()) && muon->isStandAloneMuon())
354  muReco->Fill(2);
355  if(!muon->isStandAloneMuon())
356  LogTrace(metname)<<"[MuonRecoAnalyzer] ERROR: the mu is global but not standalone!";
357 
358  // get the track combinig the information from both the Tracker and the Spectrometer
359  reco::TrackRef recoCombinedGlbTrack = muon->combinedMuon();
360 
361  // get the track using only the tracker data
362  reco::TrackRef recoTkGlbTrack = muon->track();
363  // get the track using only the mu spectrometer data
364  reco::TrackRef recoStaGlbTrack = muon->standAloneMuon();
365 
366  etaGlbTrack[0]->Fill(recoCombinedGlbTrack->eta());
367  etaGlbTrack[1]->Fill(recoTkGlbTrack->eta());
368  etaGlbTrack[2]->Fill(recoStaGlbTrack->eta());
369 
370  phiVsetaGlbTrack[0]->Fill(recoCombinedGlbTrack->eta(), recoCombinedGlbTrack->phi());
371  phiVsetaGlbTrack[1]->Fill(recoTkGlbTrack->eta() , recoTkGlbTrack->phi());
372  phiVsetaGlbTrack[2]->Fill(recoStaGlbTrack->eta() , recoStaGlbTrack->phi());
373 
374  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "eta", res, pull);
375  etaResolution[0]->Fill(res);
376  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "eta", res, pull);
377  etaResolution[1]->Fill(res);
378  GetRes(recoTkGlbTrack, recoStaGlbTrack, "eta", res, pull);
379  etaResolution[2]->Fill(res);
380  etaPull->Fill(pull);
381 
382  etaResolution[3]->Fill(recoCombinedGlbTrack->eta(), recoTkGlbTrack->eta()-recoCombinedGlbTrack->eta());
383  etaResolution[4]->Fill(recoCombinedGlbTrack->eta(), -recoStaGlbTrack->eta()+recoCombinedGlbTrack->eta());
384  etaResolution[5]->Fill(recoCombinedGlbTrack->eta(), recoTkGlbTrack->eta()-recoStaGlbTrack->eta());
385 
386 
387  thetaGlbTrack[0]->Fill(recoCombinedGlbTrack->theta());
388  thetaGlbTrack[1]->Fill(recoTkGlbTrack->theta());
389  thetaGlbTrack[2]->Fill(recoStaGlbTrack->theta());
390  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "theta", res, pull);
391  thetaResolution[0]->Fill(res);
392 
393  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "theta", res, pull);
394  thetaResolution[1]->Fill(res);
395 
396  GetRes(recoTkGlbTrack, recoStaGlbTrack, "theta", res, pull);
397  thetaResolution[2]->Fill(res);
398  thetaPull->Fill(pull);
399 
400  thetaResolution[3]->Fill(recoCombinedGlbTrack->theta(), recoTkGlbTrack->theta()-recoCombinedGlbTrack->theta());
401  thetaResolution[4]->Fill(recoCombinedGlbTrack->theta(), -recoStaGlbTrack->theta()+recoCombinedGlbTrack->theta());
402  thetaResolution[5]->Fill(recoCombinedGlbTrack->theta(), recoTkGlbTrack->theta()-recoStaGlbTrack->theta());
403 
404 
405  phiGlbTrack[0]->Fill(recoCombinedGlbTrack->phi());
406  phiGlbTrack[1]->Fill(recoTkGlbTrack->phi());
407  phiGlbTrack[2]->Fill(recoStaGlbTrack->phi());
408  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "phi", res, pull);
409  phiResolution[0]->Fill(res);
410  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "phi", res, pull);
411  phiResolution[1]->Fill(res);
412  GetRes(recoTkGlbTrack, recoStaGlbTrack, "phi", res, pull);
413  phiResolution[2]->Fill(res);
414  phiPull->Fill(pull);
415  phiResolution[3]->Fill(recoCombinedGlbTrack->phi(), recoTkGlbTrack->phi()-recoCombinedGlbTrack->phi());
416  phiResolution[4]->Fill(recoCombinedGlbTrack->phi(), -recoStaGlbTrack->phi()+recoCombinedGlbTrack->phi());
417  phiResolution[5]->Fill(recoCombinedGlbTrack->phi(), recoTkGlbTrack->phi()-recoStaGlbTrack->phi());
418 
419  chi2OvDFGlbTrack[0]->Fill(recoCombinedGlbTrack->normalizedChi2());
420  chi2OvDFGlbTrack[1]->Fill(recoTkGlbTrack->normalizedChi2());
421  chi2OvDFGlbTrack[2]->Fill(recoStaGlbTrack->normalizedChi2());
422  //-------------------------
423  // double probchi = TMath::Prob(recoCombinedGlbTrack->normalizedChi2(),recoCombinedGlbTrack->ndof());
424  // cout << "rellenando histos."<<endl;
425  probchi2GlbTrack[0]->Fill(TMath::Prob(recoCombinedGlbTrack->chi2(),recoCombinedGlbTrack->ndof()));
426  probchi2GlbTrack[1]->Fill(TMath::Prob(recoTkGlbTrack->chi2(),recoTkGlbTrack->ndof()));
427  probchi2GlbTrack[2]->Fill(TMath::Prob(recoStaGlbTrack->chi2(),recoStaGlbTrack->ndof()));
428  // cout << "rellenados histos."<<endl;
429  //-------------------------
430 
431  pGlbTrack[0]->Fill(recoCombinedGlbTrack->p());
432  pGlbTrack[1]->Fill(recoTkGlbTrack->p());
433  pGlbTrack[2]->Fill(recoStaGlbTrack->p());
434 
435  ptGlbTrack[0]->Fill(recoCombinedGlbTrack->pt());
436  ptGlbTrack[1]->Fill(recoTkGlbTrack->pt());
437  ptGlbTrack[2]->Fill(recoStaGlbTrack->pt());
438 
439  qGlbTrack[0]->Fill(recoCombinedGlbTrack->charge());
440  qGlbTrack[1]->Fill(recoTkGlbTrack->charge());
441  qGlbTrack[2]->Fill(recoStaGlbTrack->charge());
442  if(recoCombinedGlbTrack->charge()==recoStaGlbTrack->charge()) qGlbTrack[3]->Fill(1);
443  else qGlbTrack[3]->Fill(2);
444  if(recoCombinedGlbTrack->charge()==recoTkGlbTrack->charge()) qGlbTrack[3]->Fill(3);
445  else qGlbTrack[3]->Fill(4);
446  if(recoStaGlbTrack->charge()==recoTkGlbTrack->charge()) qGlbTrack[3]->Fill(5);
447  else qGlbTrack[3]->Fill(6);
448  if(recoCombinedGlbTrack->charge()!=recoStaGlbTrack->charge() && recoCombinedGlbTrack->charge()!=recoTkGlbTrack->charge()) qGlbTrack[3]->Fill(7);
449  if(recoCombinedGlbTrack->charge()==recoStaGlbTrack->charge() && recoCombinedGlbTrack->charge()==recoTkGlbTrack->charge()) qGlbTrack[3]->Fill(8);
450 
451  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "qOverp", res, pull);
452  qOverpResolution[0]->Fill(res);
453  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "qOverp", res, pull);
454  qOverpResolution[1]->Fill(res);
455  GetRes(recoTkGlbTrack, recoStaGlbTrack, "qOverp", res, pull);
456  qOverpResolution[2]->Fill(res);
457  qOverpPull->Fill(pull);
458 
459 
460  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "oneOverp", res, pull);
461  oneOverpResolution[0]->Fill(res);
462  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "oneOverp", res, pull);
463  oneOverpResolution[1]->Fill(res);
464  GetRes(recoTkGlbTrack, recoStaGlbTrack, "oneOverp", res, pull);
465  oneOverpResolution[2]->Fill(res);
466  oneOverpPull->Fill(pull);
467 
468 
469  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "qOverpt", res, pull);
470  qOverptResolution[0]->Fill(res);
471  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "qOverpt", res, pull);
472  qOverptResolution[1]->Fill(res);
473  GetRes(recoTkGlbTrack, recoStaGlbTrack, "qOverpt", res, pull);
474  qOverptResolution[2]->Fill(res);
475  qOverptPull->Fill(pull);
476 
477  GetRes(recoTkGlbTrack, recoCombinedGlbTrack, "oneOverpt", res, pull);
478  oneOverptResolution[0]->Fill(res);
479  GetRes(recoCombinedGlbTrack, recoStaGlbTrack, "oneOverpt", res, pull);
480  oneOverptResolution[1]->Fill(res);
481  GetRes(recoTkGlbTrack, recoStaGlbTrack, "oneOverpt", res, pull);
482  oneOverptResolution[2]->Fill(res);
483  oneOverptPull->Fill(pull);
484 
485 
486  // //--- Test new tunePMuonBestTrack() method from Muon.h
487 
488  reco::TrackRef recoBestTrack = muon->muonBestTrack();
489 
490  reco::TrackRef recoTunePBestTrack = muon->tunePMuonBestTrack();
491 
492  double bestTrackPt = recoBestTrack->pt();
493 
494  double tunePBestTrackPt = recoTunePBestTrack->pt();
495 
496  double tunePBestTrackRes = (bestTrackPt - tunePBestTrackPt) / bestTrackPt;
497 
498  tunePResolution->Fill(tunePBestTrackRes);
499 
500  oneOverptResolution[3]->Fill(recoCombinedGlbTrack->eta(),(1/recoTkGlbTrack->pt())-(1/recoCombinedGlbTrack->pt()));
501  oneOverptResolution[4]->Fill(recoCombinedGlbTrack->eta(),-(1/recoStaGlbTrack->pt())+(1/recoCombinedGlbTrack->pt()));
502  oneOverptResolution[5]->Fill(recoCombinedGlbTrack->eta(),(1/recoTkGlbTrack->pt())-(1/recoStaGlbTrack->pt()));
503  oneOverptResolution[6]->Fill(recoCombinedGlbTrack->phi(),(1/recoTkGlbTrack->pt())-(1/recoCombinedGlbTrack->pt()));
504  oneOverptResolution[7]->Fill(recoCombinedGlbTrack->phi(),-(1/recoStaGlbTrack->pt())+(1/recoCombinedGlbTrack->pt()));
505  oneOverptResolution[8]->Fill(recoCombinedGlbTrack->phi(),(1/recoTkGlbTrack->pt())-(1/recoStaGlbTrack->pt()));
506  oneOverptResolution[9]->Fill(recoCombinedGlbTrack->pt(),(1/recoTkGlbTrack->pt())-(1/recoCombinedGlbTrack->pt()));
507  oneOverptResolution[10]->Fill(recoCombinedGlbTrack->pt(),-(1/recoStaGlbTrack->pt())+(1/recoCombinedGlbTrack->pt()));
508  oneOverptResolution[11]->Fill(recoCombinedGlbTrack->pt(),(1/recoTkGlbTrack->pt())-(1/recoStaGlbTrack->pt()));
509 
510 
511  if (!IsminiAOD){
512  // valid hits Glb track
513  double rhGlb = recoCombinedGlbTrack->found();
514  // valid hits Glb track from Tracker
515  double rhGlb_StaProvenance=0;
516  // valid hits Glb track from Sta system
517  double rhGlb_TkProvenance=0;
518 
519 
520 
521  for (trackingRecHit_iterator recHit = recoCombinedGlbTrack->recHitsBegin();
522  recHit!=recoCombinedGlbTrack->recHitsEnd(); ++recHit){
523 
524  if((*recHit)->isValid()){
525  DetId id = (*recHit)->geographicalId();
526  if (id.det() == DetId::Muon)
527  rhGlb_StaProvenance++;
528  if (id.det() == DetId::Tracker)
529  rhGlb_TkProvenance++;
530  }
531  }
532  // valid hits Sta track associated to Glb track
533  double rhStaGlb = recoStaGlbTrack->recHitsSize();
534  // valid hits Traker track associated to Glb track
535  double rhTkGlb = recoTkGlbTrack->found();
536  // invalid hits Traker track associated to Glb track
537  double rhTkGlb_notValid = recoTkGlbTrack->lost();
538 
539  // fill the histos
540  rhAnalysis[0]->Fill(rhGlb_StaProvenance/rhGlb);
541  rhAnalysis[1]->Fill(rhGlb_TkProvenance/rhGlb);
542  rhAnalysis[2]->Fill(rhGlb_StaProvenance/rhStaGlb);
543  rhAnalysis[3]->Fill(rhGlb_TkProvenance/rhTkGlb);
544  rhAnalysis[4]->Fill(rhGlb/(rhStaGlb+rhTkGlb));
545  rhAnalysis[5]->Fill(rhTkGlb_notValid/rhGlb);
546  }
547  // aligment plots (mu system w.r.t. tracker rotation)
548  if(recoCombinedGlbTrack->charge()>0)
549  muVStkSytemRotation[0]->Fill(recoCombinedGlbTrack->pt(),recoTkGlbTrack->pt()/recoCombinedGlbTrack->pt());
550  else
551  muVStkSytemRotation[1]->Fill(recoCombinedGlbTrack->pt(),recoTkGlbTrack->pt()/recoCombinedGlbTrack->pt());
552  }
553 
554 
555 
556  if(muon->isTrackerMuon() && !(muon->isGlobalMuon())) {
557  LogTrace(metname)<<"[MuonRecoAnalyzer] The mu is tracker only - filling the histos";
558  if(muon->isStandAloneMuon())
559  muReco->Fill(3);
560  if(!(muon->isStandAloneMuon()))
561  muReco->Fill(4);
562 
563  // get the track using only the tracker data
564  reco::TrackRef recoTrack = muon->track();
565 
566  etaTrack->Fill(recoTrack->eta());
567  thetaTrack->Fill(recoTrack->theta());
568  phiTrack->Fill(recoTrack->phi());
569  chi2OvDFTrack->Fill(recoTrack->normalizedChi2());
570  probchi2Track->Fill(TMath::Prob(recoTrack->chi2(),recoTrack->ndof()));
571  pTrack->Fill(recoTrack->p());
572  ptTrack->Fill(recoTrack->pt());
573  qTrack->Fill(recoTrack->charge());
574 
575  }
576 
577  if(muon->isStandAloneMuon() && !(muon->isGlobalMuon())) {
578  LogTrace(metname)<<"[MuonRecoAnalyzer] The mu is STA only - filling the histos";
579  if(!(muon->isTrackerMuon()))
580  muReco->Fill(5);
581 
582  // get the track using only the mu spectrometer data
583  reco::TrackRef recoStaTrack = muon->standAloneMuon();
584 
585  etaStaTrack->Fill(recoStaTrack->eta());
586  thetaStaTrack->Fill(recoStaTrack->theta());
587  phiStaTrack->Fill(recoStaTrack->phi());
588  chi2OvDFStaTrack->Fill(recoStaTrack->normalizedChi2());
589  probchi2StaTrack->Fill(TMath::Prob(recoStaTrack->chi2(),recoStaTrack->ndof()));
590  pStaTrack->Fill(recoStaTrack->p());
591  ptStaTrack->Fill(recoStaTrack->pt());
592  qStaTrack->Fill(recoStaTrack->charge());
593 
594  }
595 
596  if(muon->isCaloMuon() && !(muon->isGlobalMuon()) && !(muon->isTrackerMuon()) && !(muon->isStandAloneMuon()))
597  muReco->Fill(6);
598 
599  //efficiency plots
600 
601  // get the track using only the mu spectrometer data
602  reco::TrackRef recoStaGlbTrack = muon->standAloneMuon();
603 
604  if(muon->isStandAloneMuon()){
605  etaEfficiency[0]->Fill(recoStaGlbTrack->eta());
606  phiEfficiency[0]->Fill(recoStaGlbTrack->phi());
607  }
608  if(muon->isStandAloneMuon() && muon->isGlobalMuon()){
609  etaEfficiency[1]->Fill(recoStaGlbTrack->eta());
610  phiEfficiency[1]->Fill(recoStaGlbTrack->phi());
611  }
612  }
613 
614 
615 
616 }
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:6
MuonRecoAnalyzer::~MuonRecoAnalyzer
virtual ~MuonRecoAnalyzer()
Destructor.
Definition: MuonRecoAnalyzer.cc:62
CSCSegmentAlgorithmDF_cfi.chi2Max
chi2Max
Definition: CSCSegmentAlgorithmDF_cfi.py:11
edm::Event::getByToken
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:457
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:44
DQMStore::IBooker::cd
void cd(void)
Definition: DQMStore.cc:269
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
metProducer_cfi.parameters
parameters
Definition: metProducer_cfi.py:59
MonitorElement::setBinLabel
void setBinLabel(int bin, const std::string &label, int axis=1)
set bin label for x, y or z axis (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:924
ALCARECOTkAlBeamHalo_cff.etaMin
etaMin
GeV.
Definition: ALCARECOTkAlBeamHalo_cff.py:31
res
Definition: Electron.h:4
MuonRecoAnalyzer::analyze
void analyze(const edm::Event &, const edm::EventSetup &) override
Inizialize parameters for histo binning.
Definition: MuonRecoAnalyzer.cc:335
AlignmentTrackSelector_cfi.phiMin
phiMin
Definition: AlignmentTrackSelector_cfi.py:18
iEvent
int iEvent
Definition: GenABIO.cc:230
reco::t2
auto const T2 &decltype(t1.eta()) t2
Definition: deltaR.h:16
ALCARECOTkAlMinBias_cff.pMin
pMin
GeV.
Definition: ALCARECOTkAlMinBias_cff.py:35
HcalObjRepresent::Fill
void Fill(HcalDetId &id, double val, std::vector< TH2F > &depth)
Definition: HcalObjRepresent.h:611
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:18
conversionPostprocessing_cfi.etaBin
etaBin
Definition: conversionPostprocessing_cfi.py:18
DQMStore::IBooker::book1D
MonitorElement * book1D(Args &&...args)
Definition: DQMStore.h:115
ALCARECOTkAlBeamHalo_cff.ptMin
ptMin
Definition: ALCARECOTkAlBeamHalo_cff.py:29
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:74
ALCARECOTkAlBeamHalo_cff.etaMax
etaMax
Definition: ALCARECOTkAlBeamHalo_cff.py:32
p2
double p2[4]
Definition: TauolaWrapper.h:90
LogTrace
#define LogTrace(id)
Definition: PFTrackAlgoTools.cc:504
MuonRecoAnalyzer::GetRes
void GetRes(reco::TrackRef t1, reco::TrackRef t2, std::string par, float &res, float &pull)
Definition: MuonRecoAnalyzer.cc:297
MuonRecoAnalyzer::bookHistograms
void bookHistograms(DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override
Definition: MuonRecoAnalyzer.cc:65
DetId
Definition: DetId.h:18
DQMStore::IBooker::setCurrentFolder
void setCurrentFolder(const std::string &fullpath)
Definition: DQMStore.cc:277
MuonServiceProxy_cff.MuonServiceProxy
MuonServiceProxy
Definition: MuonServiceProxy_cff.py:15
DQMStore::IBooker::book2D
MonitorElement * book2D(Args &&...args)
Definition: DQMStore.h:133
AlignmentTrackSelector_cfi.ptMax
ptMax
Definition: AlignmentTrackSelector_cfi.py:12
electronCleaner_cfi.muons
muons
Definition: electronCleaner_cfi.py:12
edm
HLT enums.
Definition: AlignableModifier.h:17
p1
double p1[4]
Definition: TauolaWrapper.h:89
edm::View::const_iterator
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:86
muonME0DigisPreReco_cfi.phiResolution
phiResolution
Definition: muonME0DigisPreReco_cfi.py:9
AlignmentTrackSelector_cfi.pMax
pMax
Definition: AlignmentTrackSelector_cfi.py:14
muonME0DigisPreReco_cfi.etaResolution
etaResolution
Definition: muonME0DigisPreReco_cfi.py:10
AlignmentTrackSelector_cfi.phiMax
phiMax
Definition: AlignmentTrackSelector_cfi.py:17
conversionPostprocessing_cfi.phiBin
phiBin
Definition: conversionPostprocessing_cfi.py:23
MonitorElement::setAxisTitle
void setAxisTitle(const std::string &title, int axis=1)
set x-, y- or z-axis title (axis=1, 2, 3 respectively)
Definition: MonitorElement.cc:955
muonBadTrackFilter_cfi.chi2Min
chi2Min
Definition: muonBadTrackFilter_cfi.py:8
trackingRecHit_iterator
TrackingRecHitCollection::base::const_iterator trackingRecHit_iterator
iterator over a vector of reference to TrackingRecHit in the same collection
Definition: TrackingRecHitFwd.h:19
edm::Run
Definition: Run.h:42
MuonRecoAnalyzer::MuonRecoAnalyzer
MuonRecoAnalyzer(const edm::ParameterSet &)
Constructor.
Definition: MuonRecoAnalyzer.cc:20
Generated for CMSSW Reference Manual by doxygen 1.8.11