CbmRoot
CbmMvdQa.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmMvdQa source file -----
3 // ----- Created 12/01/15 by P. Sitzmann -----
4 // ------------------------------------------------------------------------
5 
6 //-- Include from Cbm --//
7 #include "CbmMvdQa.h"
8 #include "CbmMvdDigi.h"
9 #include "CbmMvdHit.h"
10 #include "CbmMvdPoint.h"
11 #include "CbmMvdStationPar.h"
12 #include "CbmStsTrack.h"
13 
14 
15 #include "CbmGlobalTrack.h"
16 #include "CbmLink.h"
17 #include "CbmMCTrack.h"
18 #include "CbmMatch.h"
19 #include "CbmTrackMatchNew.h"
20 #include "CbmVertex.h"
21 
22 #include "CbmMvdDetector.h"
23 #include "CbmMvdSensor.h"
24 
25 #include "tools/CbmMvdGeoHandler.h"
26 
27 
28 //-- Include from Fair --//
29 #include "FairLogger.h"
30 #include "FairTrackParam.h"
31 
32 
33 //-- Include from Root --//
34 #include "TCanvas.h"
35 #include "TClonesArray.h"
36 #include "TH1F.h"
37 #include "TH2F.h"
38 #include "TMath.h"
39 #include "TStyle.h"
40 #include <TFile.h>
41 
42 //-- Include from C++ --//
43 #include <iostream>
44 
45 
46 using std::cout;
47 using std::endl;
48 using std::flush;
49 
50 // ----- Default constructor -------------------------------------------
51 CbmMvdQa::CbmMvdQa() : CbmMvdQa("MvdQa", 0, 0) {}
52 // -------------------------------------------------------------------------
53 
54 
55 // ----- Standard constructor ------------------------------------------
56 CbmMvdQa::CbmMvdQa(const char* name, Int_t iMode, Int_t iVerbose)
57  : FairTask(name, iVerbose)
58  , foutFile(nullptr)
59  , fNHitsOfLongTracks(0)
60  , fEventNumber(0)
61  , fminHitReq(0)
62  , fMvdRecoRatio(0.)
63  , fBadTrack(0)
64  , fUsedTracks(0)
65  , fnrOfMergedHits(0)
66  , fFirstMvdPos(0)
67  , fnrTrackslowP(0)
68  , fnrTracksHighP(0)
69  , flow(0)
70  , fmid(0)
71  , fhigh(0)
72  , fStsTrackArray(nullptr)
73  , fStsTrackArrayP(nullptr)
74  , fStsTrackArrayN(nullptr)
75  , fStsTrackMatches(nullptr)
76  , fGlobalTrackArray(nullptr)
77  , fListMCTracks(nullptr)
78  , fMCTrackArrayP(nullptr)
79  , fMCTrackArrayN(nullptr)
80  , fMcPoints(nullptr)
81  , fMvdDigis(nullptr)
82  , fMvdCluster(nullptr)
83  , fMvdHits(nullptr)
84  , fMvdHitMatchArray(nullptr)
85  , fMvdDigiMatchArray(nullptr)
86  , fBadTracks(nullptr)
87  , fInfoArray(nullptr)
88  , fMC1F()
89  , fMC2F()
90  , fDigi1F()
91  , fDigi2F()
92  , fHits1F()
93  , fHits2F()
94  , fTracks1F()
95  , fTracks2F()
96  , fPrimVtx(nullptr)
97  , fSecVtx(nullptr)
98  , fDetector(nullptr)
99  , useMcQa(kFALSE)
100  , useDigiQa(kFALSE)
101  , useHitQa(kFALSE)
102  , useTrackQa(kFALSE)
103  , fMode(iMode)
104  , fdraw(kFALSE) {}
105 // -------------------------------------------------------------------------
106 
107 
108 // ----- Destructor ----------------------------------------------------
109 CbmMvdQa::~CbmMvdQa() { ; }
110 // -------------------------------------------------------------------------
111 
112 // -------------------------------------------------------------------------
113 InitStatus CbmMvdQa::Init() {
114  cout << "--------------------------------------------------------------------"
115  "-----"
116  << endl
117  << "-I- " << GetName() << "::Init: "
118  << " Start Initilisation " << endl
119  << "--------------------------------------------------------------------"
120  "-----"
121  << endl;
122 
123  FairRootManager* ioman = FairRootManager::Instance();
124  if (!ioman) {
125  cout << "-E- " << GetName() << "::Init: "
126  << "RootManager not instantised!" << endl;
127  return kFATAL;
128  }
129  fBadTracks = new TClonesArray("CbmStsTrack", 5000);
130  ioman->Register(
131  "BadTracks", "sts", fBadTracks, IsOutputBranchPersistent("BadTracks"));
132 
133  fStsTrackMatches = (TClonesArray*) ioman->GetObject("StsTrackMatch");
134  fStsTrackArray = (TClonesArray*) ioman->GetObject("StsTrack");
135  fGlobalTrackArray = (TClonesArray*) ioman->GetObject("GlobalTrack");
136 
137  if (!fStsTrackArray) {
138  Fatal("CbmMvdQa: StsTrackArray not found (!)", " That's bad. ");
139  }
140 
141  fMcPoints =
142  (TClonesArray*) ioman->GetObject("MvdPileUpMC"); // PileUp Mc points
143  fMvdDigis = (TClonesArray*) ioman->GetObject("MvdDigi");
144  fMvdCluster = (TClonesArray*) ioman->GetObject("MvdCluster");
145  fMvdHits = (TClonesArray*) ioman->GetObject("MvdHit");
146  fMvdHitMatchArray = (TClonesArray*) ioman->GetObject("MvdHitMatch");
147  fMvdDigiMatchArray = (TClonesArray*) ioman->GetObject("MvdDigiMatch");
148 
149  if (fMvdHits->GetEntriesFast() != fMvdHitMatchArray->GetEntriesFast())
150  cout << endl
151  << "MvdHit and MvdHitMatch Arrays do not have the same size" << endl;
152 
153  // fPrimVtx = (CbmVertex*) ioman->GetObject("PrimaryVertex");
154  // Get pointer to PrimaryVertex object from IOManager if it exists
155  // The old name for the object is "PrimaryVertex" the new one
156  // "PrimaryVertex." Check first for the new name
157  fPrimVtx = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex."));
158  if (nullptr == fPrimVtx) {
159  fPrimVtx = dynamic_cast<CbmVertex*>(ioman->GetObject("PrimaryVertex"));
160  }
161  if (nullptr == fPrimVtx) {
162  // LOG(fatal) << "No primary vertex";
163  }
164 
165  fListMCTracks = (TClonesArray*) ioman->GetObject("MCTrack");
166 
167  if (!fMcPoints) {
168  cout << endl << "Mvd Pile Up Mc array missing";
169  return kFATAL;
170  }
171  fDetector = CbmMvdDetector::Instance();
172  fDetector->Init();
173 
174  CbmMvdStationPar* fPar = fDetector->GetParameterFile();
175  fFirstMvdPos = fPar->GetZPosition(0);
176 
177  fnrTrackslowP = 0;
178  fnrTracksHighP = 0;
179  flow = 0;
180  fmid = 0;
181  fhigh = 0;
182 
183  SetupHistograms();
184 
185  cout << "--------------------------------------------------------------------"
186  "-----"
187  << endl
188  << "-I- " << GetName() << "::Init: "
189  << " Finished Initialisation " << endl
190  << "--------------------------------------------------------------------"
191  "-----"
192  << endl;
193  return kSUCCESS;
194 }
195 
196 // -------------------------------------------------------------------------
197 void CbmMvdQa::SetupHistograms() {
198  if (useMcQa) SetupMCHistograms();
199  if (useDigiQa) SetupDigiHistograms();
200  if (useHitQa) SetupHitHistograms();
201  if (useTrackQa) SetupTrackHistograms();
202 }
203 // -------------------------------------------------------------------------
204 
205 // -------------------------------------------------------------------------
206 void CbmMvdQa::SetupMCHistograms() {
207  // fMC1F[] = new TH1F("fMC1F[]","",100, 0, 100);
208  // fMC1F[]->GetXaxis()->SetTitle("");
209  // fMC1F[]->GetYaxis()->SetTitle("");
210 
211  fMC1F[0] =
212  new TH1F("fMC1F[0]", "Matching efficientcy in the mvd", 100, 0, 1.5);
213  fMC1F[0]->GetXaxis()->SetTitle(" 1 - (Incorrect / Total) ");
214  fMC1F[0]->GetYaxis()->SetTitle("Entries");
215 
216  // fMC2F[] = new TH2F("fMC2F[]","",100, 0, 100, 100, 0, 100);
217  // fMC2F[]->GetXaxis()->SetTitle("");
218  // fMC2F[]->GetYaxis()->SetTitle("");
219 
220  fMC2F[0] = new TH2F(
221  "fMC2F[0]", "MC-Distribution on the first Station", 100, 0, 10, 100, 0, 10);
222  fMC2F[0]->GetXaxis()->SetTitle("X-Pos[cm]");
223  fMC2F[0]->GetYaxis()->SetTitle("Y-Pos[cm]");
224 }
225 // -------------------------------------------------------------------------
226 
227 // -------------------------------------------------------------------------
228 void CbmMvdQa::SetupDigiHistograms() {
229  // fDigi1F[] = new TH1F("fDigi1F[]","",100, 0, 100);
230  // fDigi1F[]->GetXaxis()->SetTitle("");
231  // fDigi1F[]->GetYaxis()->SetTitle("");
232 
233  fDigi1F[0] =
234  new TH1F("fDigi1F[0]", "Number of digis per MC-Point", 100, 0, 30);
235  fDigi1F[0]->GetXaxis()->SetTitle("number of digis");
236  fDigi1F[0]->GetYaxis()->SetTitle("entries");
237 
238  fDigi1F[1] =
239  new TH1F("fDigi1F[1]", "Number of MC-Point per Digi", 100, 0, 10);
240  fDigi1F[1]->GetXaxis()->SetTitle("number of MC-Points");
241  fDigi1F[1]->GetYaxis()->SetTitle("entries");
242 
243  // fDigi2F[] = new TH2F("fDigi2F[]","",100, 0, 100, 100, 0, 100);
244  // fDigi2F[]->GetXaxis()->SetTitle("");
245  // fDigi2F[]->GetYaxis()->SetTitle("");
246 
247  fDigi2F[0] =
248  new TH2F("fDigi2F[0]",
249  "Distribution of digis on worst spot on the first MVD statio",
250  100,
251  -4,
252  0,
253  100,
254  -2,
255  5);
256  fDigi2F[0]->GetXaxis()->SetTitle("x [cm]");
257  fDigi2F[0]->GetYaxis()->SetTitle("y [cm]");
258 
259  fDigi2F[1] = new TH2F("fDigi2F[1]",
260  "Distribution of digis on first MVD station",
261  100,
262  -4,
263  4,
264  100,
265  -4,
266  4);
267  fDigi2F[1]->GetXaxis()->SetTitle("x [cm]");
268  fDigi2F[1]->GetYaxis()->SetTitle("y [cm]");
269 
270  fDigi2F[2] = new TH2F("fDigi2F[2]",
271  "Distribution of digis on second MVD station",
272  100,
273  -8,
274  8,
275  100,
276  8,
277  8);
278  fDigi2F[2]->GetXaxis()->SetTitle("x [cm]");
279  fDigi2F[2]->GetYaxis()->SetTitle("y [cm]");
280 
281  fDigi2F[3] = new TH2F("fDigi2F[3]",
282  "Distribution of digis on third MVD station",
283  100,
284  -12,
285  12,
286  100,
287  -12,
288  12);
289  fDigi2F[3]->GetXaxis()->SetTitle("x [cm]");
290  fDigi2F[3]->GetYaxis()->SetTitle("y [cm]");
291 
292  fDigi2F[4] = new TH2F("fDigi2F[4]",
293  "Distribution of digis on fourth MVD station",
294  100,
295  -16,
296  16,
297  100,
298  -16,
299  16);
300  fDigi2F[4]->GetXaxis()->SetTitle("x [cm]");
301  fDigi2F[4]->GetYaxis()->SetTitle("y [cm]");
302 }
303 // -------------------------------------------------------------------------
304 
305 // -------------------------------------------------------------------------
306 void CbmMvdQa::SetupHitHistograms() {
307  // fHits1F[] = new TH1F("fHits1F[]","",100, 0, 100);
308  // fHits1F[]->GetXaxis()->SetTitle("");
309  // fHits1F[]->GetYaxis()->SetTitle("");
310 
311  fHits1F[0] = new TH1F("fHits1F[0]", "Hit per Digi", 100, 0, 3);
312  fHits1F[0]->GetXaxis()->SetTitle("number of hits");
313  fHits1F[0]->GetYaxis()->SetTitle("entries");
314 
315  fHits1F[1] = new TH1F("fHits1F[1]", "Digis Per Hit", 100, 0, 12);
316  fHits1F[1]->GetXaxis()->SetTitle("number of digis");
317  fHits1F[1]->GetYaxis()->SetTitle("entries");
318 
319  fHits1F[2] = new TH1F(
320  "fHits1F[2]", "Error in x position of reconstructed hit", 1000, -100, 100);
321  fHits1F[2]->GetXaxis()->SetTitle("x_hit - x_mc [mu m]");
322  fHits1F[2]->GetYaxis()->SetTitle("entries");
323 
324  fHits1F[3] = new TH1F(
325  "fHits1F[3]", "Error in y position of reconstructed hit", 1000, -100, 100);
326  fHits1F[3]->GetXaxis()->SetTitle("y_hit - y_mc [mu m]");
327  fHits1F[3]->GetYaxis()->SetTitle("entries");
328 
329  fHits1F[4] = new TH1F(
330  "fHits1F[4]", "Pull in x position of reconstructed hit", 1000, -20, 20);
331  fHits1F[4]->GetXaxis()->SetTitle("x_error / xRes");
332  fHits1F[4]->GetYaxis()->SetTitle("entries");
333 
334  fHits1F[5] = new TH1F(
335  "fHits1F[5]", "Pull in y position of reconstructed hit", 1000, -20, 20);
336  fHits1F[5]->GetXaxis()->SetTitle("y_error / yRes");
337  fHits1F[5]->GetYaxis()->SetTitle("entries");
338 
339 
340  fHits2F[0] =
341  new TH2F("fHits2F[0]",
342  "Distribution of Hits in worst spot on the first Station",
343  100,
344  -2.1,
345  -0.4,
346  100,
347  -1.5,
348  1.5);
349  fHits2F[0]->GetXaxis()->SetTitle("x [cm]");
350  fHits2F[0]->GetYaxis()->SetTitle("y [cm]");
351 
352  // fHits2F[] = new TH2F("fHits2F[]","",100, 0, 100, 100, 0, 100);
353  // fHits2F[]->GetXaxis()->SetTitle("");
354  // fHits2F[]->GetYaxis()->SetTitle("");
355 }
356 // -------------------------------------------------------------------------
357 
358 // -------------------------------------------------------------------------
359 void CbmMvdQa::SetupTrackHistograms() {
360 
361  fTracks1F[0] =
362  new TH1F("fTracks1F[0]", "reconstructed tracks in bins of p", 300, 0, 3);
363  fTracks1F[0]->GetXaxis()->SetTitle("Momentum [GeV]");
364  fTracks1F[0]->GetYaxis()->SetTitle("Entries");
365 
366  fTracks1F[1] = new TH1F(
367  "fTracks1F[1]", "track reconstruction efficiency in bins of p", 300, 0, 3);
368  fTracks1F[1]->GetXaxis()->SetTitle("Momentum [GeV]");
369  fTracks1F[1]->GetYaxis()->SetTitle("correct reco / all reco");
370 
371  fTracks1F[2] =
372  new TH1F("fTracks1F[2]", "tracks with 4 hits in the mvd", 200, 0, 15);
373  fTracks1F[2]->GetXaxis()->SetTitle("Momentum [GeV]");
374  fTracks1F[2]->GetYaxis()->SetTitle("Entries");
375 
376  fTracks1F[3] = new TH1F(
377  "fTracks1F[3]", "tracks with 4 correct hits in the mvd", 200, 0, 15);
378  fTracks1F[3]->GetXaxis()->SetTitle("Momentum [GeV]");
379  fTracks1F[3]->GetYaxis()->SetTitle("Entries");
380 
381  fTracks1F[4] = new TH1F("fTracks1F[4]",
382  "correct reconstructed tracks with 4 hits in the mvd",
383  200,
384  0,
385  15);
386  fTracks1F[4]->GetXaxis()->SetTitle("Momentum [GeV]");
387  fTracks1F[4]->GetYaxis()->SetTitle("Entries");
388 
389  fTracks1F[5] = new TH1F(
390  "fTracks1F[5]", "Resolution in x at z = z Mc Vertex", 1000, -0.02, 0.02);
391  fTracks1F[5]->GetXaxis()->SetTitle("x [cm]");
392  fTracks1F[5]->GetYaxis()->SetTitle("Entries");
393 
394  fTracks1F[6] = new TH1F(
395  "fTracks1F[6]", "Resolution in y at z = z Mc Vertex", 1000, -0.02, 0.02);
396  fTracks1F[6]->GetXaxis()->SetTitle("y [cm]");
397  fTracks1F[6]->GetYaxis()->SetTitle("Entries");
398 
399  fTracks1F[7] = new TH1F("fTracks1F[7]",
400  "Resolution in x at z = z Mc Vertex, 4 mvd hits",
401  1000,
402  -0.02,
403  0.02);
404  fTracks1F[7]->GetXaxis()->SetTitle("x [cm]");
405  fTracks1F[7]->GetYaxis()->SetTitle("Entries");
406 
407  fTracks1F[8] = new TH1F("fTracks1F[8]",
408  "Resolution in y at z = z Mc Vertex, 4 mvd hits",
409  1000,
410  -0.02,
411  0.02);
412  fTracks1F[8]->GetXaxis()->SetTitle("y [cm]");
413  fTracks1F[8]->GetYaxis()->SetTitle("Entries");
414 
415  fTracks1F[9] =
416  new TH1F("fTracks1F[9]",
417  "Resolution in x at z = z Mc Vertex, hit in first mvd",
418  1000,
419  -0.02,
420  0.02);
421  fTracks1F[9]->GetXaxis()->SetTitle("x [cm]");
422  fTracks1F[9]->GetYaxis()->SetTitle("Entries");
423 
424  fTracks1F[10] =
425  new TH1F("fTracks1F[10]",
426  "Resolution in y at z = z Mc Vertex, hit in first mvd",
427  1000,
428  -0.02,
429  0.02);
430  fTracks1F[10]->GetXaxis()->SetTitle("y [cm]");
431  fTracks1F[10]->GetYaxis()->SetTitle("Entries");
432 
433  fTracks1F[11] =
434  new TH1F("fTracks1F[11]",
435  "Resolution in x at z = z Mc Vertex, no hit in first mvd",
436  1000,
437  -0.02,
438  0.02);
439  fTracks1F[11]->GetXaxis()->SetTitle("x [cm]");
440  fTracks1F[11]->GetYaxis()->SetTitle("Entries");
441 
442  fTracks1F[12] =
443  new TH1F("fTracks1F[12]",
444  "Resolution in y at z = z Mc Vertex, no hit in first mvd",
445  1000,
446  -0.02,
447  0.02);
448  fTracks1F[12]->GetXaxis()->SetTitle("y [cm]");
449  fTracks1F[12]->GetYaxis()->SetTitle("Entries");
450 
451  fTracks1F[13] =
452  new TH1F("fTracks1F[13]",
453  "Resolution in x at z = z Mc Vertex, true hit in first mvd",
454  1000,
455  -0.02,
456  0.02);
457  fTracks1F[13]->GetXaxis()->SetTitle("x [cm]");
458  fTracks1F[13]->GetYaxis()->SetTitle("Entries");
459 
460  fTracks1F[14] =
461  new TH1F("fTracks1F[14]",
462  "Resolution in y at z = z Mc Vertex, true hit in first mvd",
463  1000,
464  -0.02,
465  0.02);
466  fTracks1F[14]->GetXaxis()->SetTitle("y [cm]");
467  fTracks1F[14]->GetYaxis()->SetTitle("Entries");
468 
469  fTracks1F[15] =
470  new TH1F("fTracks1F[15]",
471  "Resolution in x at z = z Mc Vertex, wrong hit in first mvd",
472  1000,
473  -0.02,
474  0.02);
475  fTracks1F[15]->GetXaxis()->SetTitle("x [cm]");
476  fTracks1F[15]->GetYaxis()->SetTitle("Entries");
477 
478  fTracks1F[16] =
479  new TH1F("fTracks1F[16]",
480  "Resolution in y at z = z Mc Vertex, wrong hit in first mvd",
481  1000,
482  -0.02,
483  0.02);
484  fTracks1F[16]->GetXaxis()->SetTitle("y [cm]");
485  fTracks1F[16]->GetYaxis()->SetTitle("Entries");
486 
487  fTracks1F[17] = new TH1F(
488  "fTracks1F[17]",
489  "Chi Squard over NDF of Tracks with wrong attached hit in first Mvd",
490  100,
491  0,
492  10);
493  fTracks1F[17]->GetXaxis()->SetTitle("chi^2 / NDF");
494  fTracks1F[17]->GetYaxis()->SetTitle("Entries");
495 
496  fTracks1F[18] =
497  new TH1F("fTracks1F[18]",
498  "Chi Squard over NDF of Tracks with correct hit in first Mvd",
499  100,
500  0,
501  10);
502  fTracks1F[18]->GetXaxis()->SetTitle("chi^2 / NDF");
503  fTracks1F[18]->GetYaxis()->SetTitle("Entries");
504 
505  fTracks1F[19] =
506  new TH1F("fTracks1F[19]",
507  "Chi Squard over NDF of all Tracks with hit in first Mvd",
508  100,
509  0,
510  10);
511  fTracks1F[19]->GetXaxis()->SetTitle("chi^2 / NDF");
512  fTracks1F[19]->GetYaxis()->SetTitle("Entries");
513 
514  fTracks1F[20] = new TH1F(
515  "fTracks1F[20]", "Impactparam Tracks with ChiSq/NDF > 1", 100, 0, 0.10);
516  fTracks1F[20]->GetXaxis()->SetTitle("impactparam R [cm]");
517  fTracks1F[20]->GetYaxis()->SetTitle("Entries");
518 
519  fTracks1F[21] = new TH1F(
520  "fTracks1F[21]", "Impactparam Tracks with ChiSq/NDF <= 1", 100, 0, 0.1);
521  fTracks1F[21]->GetXaxis()->SetTitle("impactparam R [cm]");
522  fTracks1F[21]->GetYaxis()->SetTitle("Entries");
523 
524  fTracks1F[22] = new TH1F("fTracks1F[22]",
525  "Resolution in x at z = z Mc Vertex, wrong hit in "
526  "first mvd, Positive Tracks",
527  100,
528  -0.1,
529  0.1);
530  fTracks1F[22]->GetXaxis()->SetTitle("x [cm]");
531  fTracks1F[22]->GetYaxis()->SetTitle("Entries");
532 
533  fTracks1F[23] = new TH1F("fTracks1F[23]",
534  "Resolution in x at z = z Mc Vertex, wrong hit in "
535  "first mvd, Negative Tracks",
536  100,
537  -0.1,
538  0.1);
539  fTracks1F[23]->GetXaxis()->SetTitle("x [cm]");
540  fTracks1F[23]->GetYaxis()->SetTitle("Entries");
541 
542  fTracks1F[24] = new TH1F(
543  "fTracks1F[24]",
544  "Impactparam X Tracks with ChiSq/NDF > 1, wrong hit in first station",
545  100,
546  -0.10,
547  0.10);
548  fTracks1F[24]->GetXaxis()->SetTitle("x [cm]");
549  fTracks1F[24]->GetYaxis()->SetTitle("Entries");
550 
551  fTracks1F[25] = new TH1F(
552  "fTracks1F[25]",
553  "Impactparam x Tracks with ChiSq/NDF <= 1, wrong hit in first station",
554  100,
555  -0.10,
556  0.10);
557  fTracks1F[25]->GetXaxis()->SetTitle("x [cm]");
558  fTracks1F[25]->GetYaxis()->SetTitle("Entries");
559 
560  fTracks1F[26] = new TH1F("fTracks1F[26]",
561  "Impactparam X Tracks with momentum >= 1 GeV, wrong "
562  "hit in first station, p Tracks",
563  100,
564  -0.10,
565  0.10);
566  fTracks1F[26]->GetXaxis()->SetTitle("x [cm]");
567  fTracks1F[26]->GetYaxis()->SetTitle("Entries");
568 
569  fTracks1F[27] = new TH1F("fTracks1F[27]",
570  "Impactparam X Tracks with momentum < 1 GeV, wrong "
571  "hit in first station, p Tracks",
572  100,
573  -0.10,
574  0.10);
575  fTracks1F[27]->GetXaxis()->SetTitle("x [cm]");
576  fTracks1F[27]->GetYaxis()->SetTitle("Entries");
577 
578  fTracks1F[28] = new TH1F("fTracks1F[28]",
579  "Impactparam X Tracks with momentum >= 1 GeV, wrong "
580  "hit in first station, n Tracks",
581  100,
582  -0.10,
583  0.10);
584  fTracks1F[28]->GetXaxis()->SetTitle("x [cm]");
585  fTracks1F[28]->GetYaxis()->SetTitle("Entries");
586 
587  fTracks1F[29] = new TH1F("fTracks1F[29]",
588  "Impactparam X Tracks with momentum < 1 GeV, wrong "
589  "hit in first station, n Tracks",
590  100,
591  -0.10,
592  0.10);
593  fTracks1F[29]->GetXaxis()->SetTitle("x [cm]");
594  fTracks1F[29]->GetYaxis()->SetTitle("Entries");
595 
596  fTracks1F[30] =
597  new TH1F("fTracks1F[30]",
598  "mc x position of correct hit - x pos of wrongly attached hit",
599  100,
600  -0.01,
601  0.01);
602  fTracks1F[30]->GetXaxis()->SetTitle("x [mu m]");
603  fTracks1F[30]->GetYaxis()->SetTitle("Entries");
604 
605  fTracks1F[31] =
606  new TH1F("fTracks1F[31]",
607  "mc y position of correct hit - y pos of wrongly attached hit",
608  100,
609  -0.01,
610  0.01);
611  fTracks1F[31]->GetXaxis()->SetTitle("y [mu m]");
612  fTracks1F[31]->GetYaxis()->SetTitle("Entries");
613 
614  fTracks1F[32] =
615  new TH1F("fTracks1F[32]",
616  "Resolution in x at z = z Mc Vertex, 4 mvd hits, trueOverAll == 1",
617  1000,
618  -0.02,
619  0.02);
620  fTracks1F[32]->GetXaxis()->SetTitle("x [cm]");
621  fTracks1F[32]->GetYaxis()->SetTitle("Entries");
622 
623  fTracks1F[33] =
624  new TH1F("fTracks1F[33]",
625  "Resolution in y at z = z Mc Vertex, 4 mvd hits, trueOverAll == 1",
626  1000,
627  -0.02,
628  0.02);
629  fTracks1F[33]->GetXaxis()->SetTitle("y [cm]");
630  fTracks1F[33]->GetYaxis()->SetTitle("Entries");
631 
632 
633  fTracks2F[0] = new TH2F("fTracks2F[0]",
634  "Momentumresolution all Tracks",
635  200,
636  0,
637  15,
638  100,
639  -0.2,
640  0.2);
641  fTracks2F[0]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
642  fTracks2F[0]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
643 
644  fTracks2F[1] = new TH2F("fTracks2F[1]",
645  "Momentumresolution correct reconstructed Tracks",
646  200,
647  0,
648  15,
649  100,
650  -0.2,
651  0.2);
652  fTracks2F[1]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
653  fTracks2F[1]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
654 
655  fTracks2F[2] = new TH2F("fTracks2F[2]",
656  "Momentumresolution Tracks with 4 hits in the mvd",
657  200,
658  0,
659  15,
660  100,
661  -0.2,
662  0.2);
663  fTracks2F[2]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
664  fTracks2F[2]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
665 
666  fTracks2F[3] =
667  new TH2F("fTracks2F[3]",
668  "Momentumresolution Tracks with 4 correct hits in the mvd",
669  200,
670  0,
671  15,
672  100,
673  -0.2,
674  0.2);
675  fTracks2F[3]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
676  fTracks2F[3]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
677 
678  fTracks2F[4] = new TH2F(
679  "fTracks2F[4]",
680  "Momentumresolution correct reconstructed Tracks with 4 hits in the mvd",
681  200,
682  0,
683  15,
684  100,
685  -0.2,
686  0.2);
687  fTracks2F[4]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
688  fTracks2F[4]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
689 
690  fTracks2F[5] =
691  new TH2F("fTracks2F[5]",
692  "Momentumresolution Tracks with hit in the first mvd station",
693  200,
694  0,
695  15,
696  100,
697  -0.2,
698  0.2);
699  fTracks2F[5]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
700  fTracks2F[5]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
701 
702  fTracks2F[6] =
703  new TH2F("fTracks2F[6]",
704  "Momentumresolution Tracks with no hit in the first mvd station",
705  200,
706  0,
707  15,
708  100,
709  -0.2,
710  0.2);
711  fTracks2F[6]->GetXaxis()->SetTitle("MC-Momentum [GeV]");
712  fTracks2F[6]->GetYaxis()->SetTitle("MC-Momentum - Reco-Momentum [GeV]");
713 
714  fTracks2F[7] = new TH2F("fTracks2F[7]",
715  "Position of wrong attached Hit in first Mvd Station",
716  200,
717  -3,
718  3,
719  200,
720  -3,
721  3);
722  fTracks2F[7]->GetXaxis()->SetTitle("x [cm]");
723  fTracks2F[7]->GetYaxis()->SetTitle("y [cm]");
724 
725  fTracks2F[8] = new TH2F("fTracks2F[8]",
726  "Position of wrong attached Hit in first Mvd "
727  "Station, with good ChiSq over NDF",
728  200,
729  -3,
730  3,
731  200,
732  -3,
733  3);
734  fTracks2F[8]->GetXaxis()->SetTitle("x [cm]");
735  fTracks2F[8]->GetYaxis()->SetTitle("y [cm]");
736 
737  fTracks2F[9] = new TH2F("fTracks2F[9]",
738  "Propability to pick up the wrong hit on the first "
739  "MVD Station 2 bins cut at 1.5 GeV",
740  2,
741  0,
742  1,
743  2,
744  0,
745  1);
746  fTracks2F[9]->GetXaxis()->SetBinLabel(1, "0 - 1 GeV");
747  fTracks2F[9]->GetXaxis()->SetBinLabel(2, "1 - 1.5 GeV");
748  fTracks2F[9]->GetYaxis()->SetBinLabel(1, "wrong Hit");
749  fTracks2F[9]->GetYaxis()->SetBinLabel(2, "correct Hit");
750 
751  fTracks2F[10] =
752  new TH2F("fTracks2F[10]",
753  "Vertexresolution of wrong attached Hit in first Mvd Station",
754  200,
755  -0.04,
756  0.04,
757  200,
758  -0.01,
759  0.01);
760  fTracks2F[10]->GetXaxis()->SetTitle("X at glVertex [cm]");
761  fTracks2F[10]->GetYaxis()->SetTitle("Y at glVertex [cm] ");
762 
763  fTracks2F[11] = new TH2F("fTracks2F[11]",
764  "Propability to pick up the wrong hit on the first "
765  "MVD Station 2 bins cut at 0.5 , 1 GeV",
766  3,
767  0,
768  1.5,
769  2,
770  0,
771  1);
772  fTracks2F[11]->GetXaxis()->SetBinLabel(1, "0 - 0.5 GeV");
773  fTracks2F[11]->GetXaxis()->SetBinLabel(2, "0.5 - 1 GeV");
774  fTracks2F[11]->GetXaxis()->SetBinLabel(3, "1 - 1.5 GeV");
775  fTracks2F[11]->GetYaxis()->SetBinLabel(1, "wrong Hit");
776  fTracks2F[11]->GetYaxis()->SetBinLabel(2, "correct Hit");
777 }
778 // -------------------------------------------------------------------------
779 
780 // -------------------------------------------------------------------------
781 void CbmMvdQa::Exec(Option_t* /*opt*/) {
782  fEventNumber++;
783  if (fEventNumber % 10 == 0)
784  LOG(info) << "CbmMvdQa is running Event " << fEventNumber;
785 
786  if (useMcQa) ExecMCQa();
787  if (useDigiQa) ExecDigiQa();
788  if (useHitQa) ExecHitQa();
789  if (useTrackQa) ExecTrackQa();
790 }
791 // -------------------------------------------------------------------------
792 
793 // -------------------------------------------------------------------------
794 void CbmMvdQa::ExecMCQa() {
795  Int_t nrMcPoints = fMcPoints->GetEntriesFast();
796 
797  for (Int_t i = 0; i < nrMcPoints; ++i) {
798  CbmMvdPoint* curMc = (CbmMvdPoint*) fMcPoints->At(i);
799  if (curMc->GetZ() < fFirstMvdPos + 1) {
800  fMC2F[0]->Fill(curMc->GetX(), curMc->GetY());
801  }
802  }
803 }
804 // -------------------------------------------------------------------------
805 
806 // -------------------------------------------------------------------------
807 void CbmMvdQa::ExecDigiQa() {
808  Int_t nrDigis = fMvdDigis->GetEntriesFast();
809  Int_t nrSensor = fDetector->GetSensorArraySize();
810  Int_t nrMcPoints = fMcPoints->GetEntriesFast();
811 
812  Int_t digisPerMcPoints[nrMcPoints]; // = {0};
813  Int_t McPointsPerDigi[nrDigis]; // = {0};
814 
815  for (Int_t i = 0; i < nrDigis; i++) {
816  CbmMvdDigi* curDigi = (CbmMvdDigi*) fMvdDigis->At(i);
817  CbmMatch* curMatch = (CbmMatch*) fMvdDigiMatchArray->At(i);
818  Int_t nrOfContributors = curMatch->GetNofLinks();
819  for (Int_t j = 0; j < nrOfContributors; j++) {
820  digisPerMcPoints[curMatch->GetLink(j).GetIndex()]++;
821  }
822  McPointsPerDigi[i] = nrOfContributors;
823 
824  for (Int_t n = 0; n < nrSensor; n++) {
825  CbmMvdSensor* curSens = fDetector->GetSensor(n);
826  Double_t lab[3] = {0., 0., 0.};
827  if (curSens->GetDetectorID() == curDigi->GetDetectorId()) {
828  curSens->PixelToTop(curDigi->GetPixelX(), curDigi->GetPixelY(), lab);
829  if (curSens->GetZ() < 6)
830  fDigi2F[1]->Fill(lab[0], lab[1]);
831  else if (curSens->GetZ() < 11)
832  fDigi2F[2]->Fill(lab[0], lab[1]);
833  else if (curSens->GetZ() < 16)
834  fDigi2F[3]->Fill(lab[0], lab[1]);
835  else
836  fDigi2F[4]->Fill(lab[0], lab[1]);
837 
838  if (lab[0] > -2 && lab[0] <= -0.5 && lab[1] >= -1.5 && lab[1] <= 1.5) {
839  fDigi2F[0]->Fill(lab[0], lab[1]);
840  }
841  }
842  }
843  }
844 
845  for (Int_t i = 0; i < nrMcPoints; i++)
846  fDigi1F[0]->Fill(digisPerMcPoints[i]);
847 
848  for (Int_t i = 0; i < nrDigis; i++)
849  fDigi1F[1]->Fill(McPointsPerDigi[i]);
850 }
851 // -------------------------------------------------------------------------
852 
853 // -------------------------------------------------------------------------
854 void CbmMvdQa::ExecHitQa() {
855  Int_t nrHits = fMvdHits->GetEntriesFast();
856  // Int_t nrDigis = fMvdDigis->GetEntriesFast();
857 
858  Int_t DigisPerHit[nrHits];
859 
860  Float_t xRes = 3.8;
861  Float_t yRes = 4.8;
862 
863  for (Int_t k = 0; k < nrHits; k++) {
864  CbmMvdHit* curHit = (CbmMvdHit*) fMvdHits->At(k);
865  CbmMatch* curMatch = (CbmMatch*) fMvdHitMatchArray->At(k);
866  CbmMvdPoint* curMc =
867  (CbmMvdPoint*) fMcPoints->At(curMatch->GetMatchedLink().GetIndex());
868  Float_t xErr = 10000 * (curHit->GetX() - curMc->GetX());
869  Float_t yErr = 10000 * (curHit->GetY() - curMc->GetY());
870 
871 
872  CbmMvdCluster* curCluster =
873  (CbmMvdCluster*) fMvdCluster->At(curHit->GetClusterIndex());
874  DigisPerHit[k] = curCluster->GetTotalDigisInCluster();
875 
876  if (curHit->GetX() > -2 && curHit->GetX() <= -0.5 && curHit->GetY() >= -1.5
877  && curHit->GetY() <= 1.5) {
878  fHits2F[0]->Fill(curHit->GetX(), curHit->GetY());
879  }
880 
881  fHits1F[2]->Fill(xErr);
882  fHits1F[3]->Fill(yErr);
883  fHits1F[4]->Fill(xErr / xRes);
884  fHits1F[5]->Fill(yErr / yRes);
885  }
886 
887  for (Int_t i = 0; i < nrHits; i++)
888  fHits1F[1]->Fill(DigisPerHit[i]);
889 }
890 // -------------------------------------------------------------------------
891 
892 // -------------------------------------------------------------------------
893 void CbmMvdQa::ExecTrackQa() {
894 
895  CbmStsTrack* stsTrack;
896 
897  Int_t nTracks = fStsTrackArray->GetEntriesFast();
898  Int_t nMcTracks = fListMCTracks->GetEntriesFast();
899  Int_t nGlobalTracks = fGlobalTrackArray->GetEntriesFast();
900  Int_t mcMatchId;
901  Int_t nHitsMvd;
902 
903  CbmTrackMatchNew* trackMatch;
904  CbmMCTrack* mcTrack;
905  CbmGlobalTrack* glTrack;
906 
907  Bool_t hasHitFirst, hasHitFirstTrue;
908 
909  Float_t glX, glY, ChiSqOverNDF, glP, mcP, trueOverAll, glQP;
910  Float_t mcPosFirst[3] = {0};
911  Float_t hitFirst[2];
912 
913  LOG(debug) << " CbmMvdQa: Entries: " << nTracks << " StsTracks from "
914  << nMcTracks << " McTracks";
915 
916  // --- Loop over reconstructed tracks ---
917  for (Int_t itr = 0; itr < nGlobalTracks; itr++) {
918  glTrack = (CbmGlobalTrack*) fGlobalTrackArray->At(itr);
919 
920  stsTrack = (CbmStsTrack*) fStsTrackArray->At(glTrack->GetStsTrackIndex());
921  trackMatch =
922  (CbmTrackMatchNew*) fStsTrackMatches->At(glTrack->GetStsTrackIndex());
923  mcMatchId = trackMatch->GetMatchedLink().GetIndex();
924  if (mcMatchId > -1)
925  mcTrack = (CbmMCTrack*) fListMCTracks->At(mcMatchId);
926  else
927  continue;
928 
929  SetMatches(mcMatchId, stsTrack);
930  hasHitFirst = HasHitFirstMvd(stsTrack);
931  hasHitFirstTrue = HasHitFirstTrue(mcMatchId, stsTrack);
932 
933  glX = glTrack->GetParamVertex()->GetX();
934  glY = glTrack->GetParamVertex()->GetY();
935  ChiSqOverNDF = stsTrack->GetChiSq() / stsTrack->GetNDF();
936  glQP = stsTrack->GetParamFirst()->GetQp();
937  glP = fabs(1 / glQP);
938  mcP = mcTrack->GetP();
939  GetFirstMCPos(stsTrack, mcPosFirst);
940  GetFirstMvdHitPos(stsTrack, hitFirst);
941 
942  trueOverAll = trackMatch->GetTrueOverAllHitsRatio();
943  nHitsMvd = stsTrack->GetNofMvdHits();
944 
945  if (hasHitFirst) {
946  if (mcP < 1.5) {
947  fnrTrackslowP++;
948  if (mcP >= 1)
949  fhigh++;
950  else if (mcP >= 0.5)
951  fmid++;
952  else
953  flow++;
954  } else
955  fnrTracksHighP++;
956  }
957 
958 
959  fTracks1F[0]->Fill(glP, 1);
960  if (trueOverAll == 1.) fTracks1F[1]->Fill(glP, 1);
961 
962  if (nHitsMvd == 4) {
963  fTracks1F[2]->Fill(glP, 1);
964  if (fMvdRecoRatio == 1.) fTracks1F[3]->Fill(glP, 1);
965  if (trueOverAll == 1.) {
966  fTracks1F[4]->Fill(glP, 1);
967  fTracks1F[32]->Fill(glX);
968  fTracks1F[33]->Fill(glY);
969  }
970  }
971 
972  fTracks1F[5]->Fill(glX);
973  fTracks1F[6]->Fill(glY);
974 
975  if (nHitsMvd == 4) {
976  fTracks1F[7]->Fill(glX);
977  fTracks1F[8]->Fill(glY);
978  }
979 
980  if (hasHitFirst) {
981  fTracks1F[9]->Fill(glX);
982  fTracks1F[10]->Fill(glY);
983  fTracks1F[19]->Fill(ChiSqOverNDF);
984  } else {
985  fTracks1F[11]->Fill(glX);
986  fTracks1F[12]->Fill(glY);
987  }
988 
989  if (hasHitFirstTrue) {
990  fTracks1F[13]->Fill(glX);
991  fTracks1F[14]->Fill(glY);
992  fTracks1F[18]->Fill(ChiSqOverNDF);
993  }
994 
995  if (!hasHitFirstTrue && hasHitFirst) {
996  fTracks1F[15]->Fill(glX);
997  fTracks1F[16]->Fill(glY);
998  fTracks2F[10]->Fill(glX, glY);
999  fTracks1F[17]->Fill(ChiSqOverNDF);
1000 
1001  fTracks1F[30]->Fill(mcPosFirst[0] - hitFirst[0]);
1002  fTracks1F[31]->Fill(mcPosFirst[1] - hitFirst[1]);
1003 
1004  if (glQP >= 0) {
1005  fTracks1F[22]->Fill(glX);
1006  if (mcP >= 1)
1007  fTracks1F[26]->Fill(glX);
1008  else
1009  fTracks1F[27]->Fill(glX);
1010  }
1011  if (glQP < 0) {
1012  fTracks1F[23]->Fill(glX);
1013  if (mcP >= 1)
1014  fTracks1F[28]->Fill(glX);
1015  else
1016  fTracks1F[29]->Fill(glX);
1017  }
1018  if (ChiSqOverNDF > 1)
1019  fTracks1F[24]->Fill(glX);
1020  else
1021  fTracks1F[25]->Fill(glX);
1022  }
1023 
1024  if (ChiSqOverNDF > 1) {
1025  fTracks1F[20]->Fill(sqrt((glX * glX) + (glY * glY)));
1026  } else {
1027  fTracks1F[21]->Fill(sqrt((glX * glX) + (glY * glY)));
1028  }
1029 
1030 
1031  fTracks2F[0]->Fill(mcP, mcP - glP);
1032  if (trueOverAll == 1.) fTracks2F[1]->Fill(mcP, mcP - glP);
1033 
1034  if (nHitsMvd == 4) {
1035  fTracks2F[2]->Fill(mcP, mcP - glP);
1036  if (fMvdRecoRatio == 1.) fTracks2F[3]->Fill(mcP, mcP - glP);
1037  if (trueOverAll == 1.) fTracks2F[4]->Fill(mcP, mcP - glP);
1038  }
1039 
1040  if (hasHitFirst)
1041  fTracks2F[5]->Fill(mcP, mcP - glP);
1042  else
1043  fTracks2F[6]->Fill(mcP, mcP - glP);
1044 
1045  if (!hasHitFirstTrue && hasHitFirst) {
1046  fTracks2F[7]->Fill(hitFirst[0], hitFirst[1]);
1047  if (ChiSqOverNDF <= 1) fTracks2F[8]->Fill(hitFirst[0], hitFirst[1]);
1048  if (mcP < 1.5) {
1049  fTracks2F[9]->Fill(0.1, 0.1);
1050  if (mcP >= 1)
1051  fTracks2F[11]->Fill(1.25, 0.1);
1052  else if (mcP >= 0.5)
1053  fTracks2F[11]->Fill(0.75, 0.1);
1054  else
1055  fTracks2F[11]->Fill(0.25, 0.1);
1056  } else
1057  fTracks2F[9]->Fill(0.70, 0.1);
1058  }
1059 
1060  if (hasHitFirstTrue) {
1061  if (mcP < 1.5) {
1062  fTracks2F[9]->Fill(0.1, 0.70);
1063  if (mcP >= 1)
1064  fTracks2F[11]->Fill(1.25, 0.7);
1065  else if (mcP >= 0.5)
1066  fTracks2F[11]->Fill(0.75, 0.7);
1067  else
1068  fTracks2F[11]->Fill(0.25, 0.7);
1069  } else
1070  fTracks2F[9]->Fill(0.70, 0.70);
1071  }
1072  }
1073 }
1074 // -------------------------------------------------------------------------
1075 void CbmMvdQa::GetFirstMvdHitPos(CbmStsTrack* stsTrack, Float_t* hitPos) {
1076  Int_t nrMvdHits = stsTrack->GetNofMvdHits();
1077  for (Int_t itr = 0; itr < nrMvdHits; itr++) {
1078  CbmMvdHit* curHit =
1079  (CbmMvdHit*) fMvdHits->At(stsTrack->GetMvdHitIndex(itr));
1080  if (curHit->GetZ() < fFirstMvdPos + 1) {
1081  hitPos[0] = curHit->GetX();
1082  hitPos[1] = curHit->GetY();
1083  return;
1084  }
1085  }
1086 }
1087 // -------------------------------------------------------------------------
1088 Bool_t CbmMvdQa::HasHitFirstMvd(CbmStsTrack* stsTrack) {
1089  Int_t nrMvdHits = stsTrack->GetNofMvdHits();
1090  for (Int_t itr = 0; itr < nrMvdHits; itr++) {
1091  CbmMvdHit* curHit =
1092  (CbmMvdHit*) fMvdHits->At(stsTrack->GetMvdHitIndex(itr));
1093  if (curHit->GetZ() < fFirstMvdPos + 1) return kTRUE;
1094  }
1095 
1096  return kFALSE;
1097 }
1098 // -------------------------------------------------------------------------
1099 
1100 // -------------------------------------------------------------------------
1101 Bool_t CbmMvdQa::HasHitFirstTrue(Int_t MCtrackID, CbmStsTrack* stsTrack) {
1102  Int_t nrOfMvdHits = stsTrack->GetNofMvdHits();
1103  Int_t nrOfLinks = 0;
1104  Int_t mcTrackId = 0;
1105  const CbmMvdPoint* point = NULL;
1106  for (Int_t iHit = 0; iHit < nrOfMvdHits; iHit++) {
1107  CbmMatch* mvdMatch =
1108  (CbmMatch*) fMvdHitMatchArray->At(stsTrack->GetMvdHitIndex(iHit));
1109  if (mvdMatch) {
1110  nrOfLinks = mvdMatch->GetNofLinks();
1111  } else {
1112  continue; // any kind of error in the matching
1113  }
1114  for (Int_t iLink = 0; iLink < nrOfLinks; iLink++) {
1115  Int_t pointIndex = mvdMatch->GetLink(iLink).GetIndex();
1116  if (pointIndex < fMcPoints->GetEntriesFast())
1117  point = (CbmMvdPoint*) fMcPoints->At(pointIndex);
1118  if (NULL == point) {
1119  continue; //delta or background event
1120  } else
1121  mcTrackId = point->GetTrackID();
1122  if (mcTrackId == MCtrackID && point->GetZOut() < fFirstMvdPos + 1) {
1123  return kTRUE;
1124  }
1125  }
1126  }
1127 
1128  return kFALSE;
1129 }
1130 // -------------------------------------------------------------------------
1131 
1132 // -------------------------------------------------------------------------
1133 void CbmMvdQa::GetFirstMCPos(CbmStsTrack* stsTrack, Float_t* pos) {
1134  Int_t nrOfMvdHits = stsTrack->GetNofMvdHits();
1135  Int_t nrOfLinks = 0;
1136  const CbmMvdPoint* point = NULL;
1137  for (Int_t iHit = 0; iHit < nrOfMvdHits; iHit++) {
1138  CbmMatch* mvdMatch =
1139  (CbmMatch*) fMvdHitMatchArray->At(stsTrack->GetMvdHitIndex(iHit));
1140  if (mvdMatch) {
1141  nrOfLinks = mvdMatch->GetNofLinks();
1142  } else {
1143  continue; // any kind of error in the matching
1144  }
1145  for (Int_t iLink = 0; iLink < nrOfLinks; iLink++) {
1146  Int_t pointIndex = mvdMatch->GetLink(iLink).GetIndex();
1147  if (pointIndex < fMcPoints->GetEntriesFast())
1148  point = (CbmMvdPoint*) fMcPoints->At(pointIndex);
1149  if (NULL == point) {
1150  continue; //delta or background event
1151  } else if (point->GetZOut() < fFirstMvdPos + 1) {
1152  pos[0] = point->GetX();
1153  pos[1] = point->GetY();
1154  pos[2] = point->GetZOut();
1155  return;
1156  }
1157  }
1158  }
1159 }
1160 // -------------------------------------------------------------------------
1161 
1162 
1163 // -------------------------------------------------------------------------
1164 void CbmMvdQa::SetMatches(Int_t MCtrackID, CbmStsTrack* stsTrack) {
1165 
1166  Int_t nrOfMvdHits = stsTrack->GetNofMvdHits();
1167  Int_t mcTrackId = 0;
1168  Float_t falseCounter = 0;
1169  Bool_t hasTrack;
1170  Int_t nrOfLinks = 0;
1171  fMvdRecoRatio = 0.;
1172  const CbmMvdPoint* point = NULL;
1173  for (Int_t iHit = 0; iHit < nrOfMvdHits; iHit++) {
1174  hasTrack = kFALSE;
1175  CbmMatch* mvdMatch =
1176  (CbmMatch*) fMvdHitMatchArray->At(stsTrack->GetMvdHitIndex(iHit));
1177  if (mvdMatch) {
1178  nrOfLinks = mvdMatch->GetNofLinks();
1179  if (nrOfLinks > 1) fnrOfMergedHits++;
1180  } else {
1181  continue; // any kind of error in the matching
1182  }
1183  for (Int_t iLink = 0; iLink < nrOfLinks; iLink++) {
1184  Int_t pointIndex = mvdMatch->GetLink(iLink).GetIndex();
1185  if (pointIndex < fMcPoints->GetEntriesFast())
1186  point = (CbmMvdPoint*) fMcPoints->At(pointIndex);
1187  if (NULL == point) {
1188  continue; //delta or background event
1189  } else
1190  mcTrackId = point->GetTrackID();
1191  if (mcTrackId == MCtrackID) { hasTrack = kTRUE; }
1192  }
1193  if (!hasTrack) falseCounter++;
1194  }
1195  Float_t counter = (Float_t) falseCounter / (Float_t) nrOfMvdHits;
1196  fMvdRecoRatio = (Float_t) 1.0 - (Float_t) counter;
1197 
1198 
1199  if (useMcQa) fMC1F[0]->Fill(fMvdRecoRatio);
1200 }
1201 // -------------------------------------------------------------------------
1202 
1203 //-----------------------------------------------------------------------------------------
1204 void CbmMvdQa::Finish() {
1205  foutFile->cd();
1206 
1207  if (useMcQa) FinishMCQa();
1208  if (useDigiQa) FinishDigiQa();
1209  if (useHitQa) FinishHitQa();
1210  if (useTrackQa) FinishTrackQa();
1211 
1212  foutFile->Write();
1213 }
1214 //-----------------------------------------------------------------------------------------
1215 
1216 //-----------------------------------------------------------------------------------------
1217 void CbmMvdQa::FinishMCQa() {
1218  if (fdraw) {
1219  TCanvas* mcCanvas1 = new TCanvas();
1220  mcCanvas1->cd();
1221  fMC1F[0]->Draw();
1222  }
1223 
1224  fMC1F[0]->Write();
1225 }
1226 //-----------------------------------------------------------------------------------------
1227 
1228 //-----------------------------------------------------------------------------------------
1229 void CbmMvdQa::FinishDigiQa() {
1230  if (fdraw) {
1231  TCanvas* digiCanvas1a = new TCanvas();
1232  digiCanvas1a->cd();
1233  fDigi1F[0]->Draw();
1234 
1235  TCanvas* digiCanvas1b = new TCanvas();
1236  digiCanvas1b->cd();
1237  fDigi1F[1]->Draw();
1238  }
1239 
1240  fDigi1F[0]->Write();
1241  fDigi1F[1]->Write();
1242 }
1243 //-----------------------------------------------------------------------------------------
1244 
1245 //-----------------------------------------------------------------------------------------
1246 void CbmMvdQa::FinishHitQa() {
1247  if (fdraw) {
1248  // TCanvas* hitCanvas1a = new TCanvas();
1249  // fHits1F[0]->Draw();
1250 
1251  TCanvas* hitCanvas1b = new TCanvas();
1252  hitCanvas1b->cd();
1253  fHits1F[1]->Draw();
1254 
1255  TCanvas* hitCanvas1c = new TCanvas();
1256  hitCanvas1c->cd();
1257  fHits1F[2]->Draw();
1258 
1259  TCanvas* hitCanvas1d = new TCanvas();
1260  hitCanvas1d->cd();
1261  fHits1F[3]->Draw("COL");
1262 
1263  TCanvas* hitCanvas1e = new TCanvas();
1264  hitCanvas1e->cd();
1265  fHits1F[4]->Draw();
1266 
1267  TCanvas* hitCanvas1f = new TCanvas();
1268  hitCanvas1f->cd();
1269  fHits1F[5]->Draw();
1270 
1271 
1272  TCanvas* hitCanvas2a = new TCanvas();
1273  hitCanvas2a->cd();
1274  fHits2F[0]->Draw("COL");
1275  }
1276 
1277  for (Int_t i = 0; i < 6; i++) {
1278  fHits1F[i]->Write();
1279  }
1280 
1281 
1282  fHits2F[0]->Write();
1283 }
1284 //-----------------------------------------------------------------------------------------
1285 
1286 //-----------------------------------------------------------------------------------------
1287 void CbmMvdQa::FinishTrackQa() {
1288 
1289  fTracks1F[1]->Divide(fTracks1F[0]);
1290 
1291  if (fdraw) {
1292  TCanvas* TrackCanvas1 = new TCanvas();
1293  TrackCanvas1->Divide(3, 2);
1294  TrackCanvas1->cd(1);
1295  fTracks1F[0]->Draw();
1296  TrackCanvas1->cd(2);
1297  fTracks1F[1]->Draw();
1298  TrackCanvas1->cd(3);
1299  fTracks1F[2]->Draw();
1300  TrackCanvas1->cd(4);
1301  fTracks1F[3]->Draw();
1302  TrackCanvas1->cd(5);
1303  fTracks1F[4]->Draw();
1304 
1305  TCanvas* TrackCanvas1b = new TCanvas();
1306  TrackCanvas1b->Divide(2, 2);
1307  TrackCanvas1b->cd(1);
1308  fTracks1F[5]->Draw();
1309  TrackCanvas1b->cd(2);
1310  fTracks1F[6]->Draw();
1311  TrackCanvas1b->cd(3);
1312  fTracks1F[7]->Draw();
1313  TrackCanvas1b->cd(4);
1314  fTracks1F[8]->Draw();
1315 
1316  TCanvas* TrackCanvas1c = new TCanvas();
1317  TrackCanvas1c->Divide(2, 2);
1318  TrackCanvas1c->cd(1);
1319  fTracks1F[9]->Draw();
1320  TrackCanvas1c->cd(2);
1321  fTracks1F[10]->Draw();
1322  TrackCanvas1c->cd(3);
1323  fTracks1F[11]->Draw();
1324  TrackCanvas1c->cd(4);
1325  fTracks1F[12]->Draw();
1326 
1327  TCanvas* TrackCanvas1d = new TCanvas();
1328  TrackCanvas1d->Divide(2, 2);
1329  TrackCanvas1d->cd(1);
1330  fTracks1F[13]->Draw();
1331  TrackCanvas1d->cd(2);
1332  fTracks1F[14]->Draw();
1333  TrackCanvas1d->cd(3);
1334  fTracks1F[15]->Draw();
1335  TrackCanvas1d->cd(4);
1336  fTracks1F[16]->Draw();
1337 
1338  TCanvas* TrackCanvas1e = new TCanvas();
1339  TrackCanvas1e->Divide(2, 2);
1340  TrackCanvas1e->cd(1);
1341  fTracks1F[17]->Draw();
1342  TrackCanvas1e->cd(2);
1343  fTracks1F[18]->Draw();
1344  TrackCanvas1e->cd(3);
1345  fTracks1F[19]->Draw();
1346  TrackCanvas1e->cd(4);
1347  //fTracks1F[16]->Draw();
1348 
1349  TCanvas* TrackCanvas1f = new TCanvas();
1350  TrackCanvas1f->Divide(2, 2);
1351  TrackCanvas1f->cd(1);
1352  fTracks1F[20]->Draw();
1353  TrackCanvas1f->cd(2);
1354  fTracks1F[21]->Draw();
1355  TrackCanvas1f->cd(3);
1356  //fTracks1F[19]->Draw();
1357  TrackCanvas1f->cd(4);
1358  //fTracks1F[16]->Draw();
1359 
1360  TCanvas* TrackCanvas1g = new TCanvas();
1361  TrackCanvas1g->Divide(2, 2);
1362  TrackCanvas1g->cd(1);
1363  fTracks1F[22]->Draw();
1364  TrackCanvas1g->cd(2);
1365  fTracks1F[23]->Draw();
1366  TrackCanvas1g->cd(3);
1367  fTracks1F[24]->Draw();
1368  TrackCanvas1g->cd(4);
1369  fTracks1F[25]->Draw();
1370 
1371  TCanvas* TrackCanvas1h = new TCanvas();
1372  TrackCanvas1h->Divide(2, 2);
1373  TrackCanvas1h->cd(1);
1374  fTracks1F[26]->Draw();
1375  TrackCanvas1h->cd(2);
1376  fTracks1F[27]->Draw();
1377  TrackCanvas1h->cd(3);
1378  fTracks1F[28]->Draw();
1379  TrackCanvas1h->cd(4);
1380  fTracks1F[29]->Draw();
1381 
1382  TCanvas* TrackCanvas1i = new TCanvas();
1383  TrackCanvas1i->Divide(2, 2);
1384  TrackCanvas1i->cd(1);
1385  fTracks1F[30]->Draw();
1386  TrackCanvas1i->cd(2);
1387  fTracks1F[31]->Draw();
1388  }
1389 
1390  for (Int_t k = 0; k < f1FSize; k++) {
1391  fTracks1F[k]->Write();
1392  }
1393 
1394  fTracks2F[9]->SetBinContent(
1395  1, 1, 100 * (fTracks2F[9]->GetBinContent(1, 1) / fnrTrackslowP));
1396  fTracks2F[9]->SetBinContent(
1397  1, 2, 100 * (fTracks2F[9]->GetBinContent(1, 2) / fnrTrackslowP));
1398  fTracks2F[9]->SetBinContent(
1399  2, 1, 100 * (fTracks2F[9]->GetBinContent(2, 1) / fnrTracksHighP));
1400  fTracks2F[9]->SetBinContent(
1401  2, 2, 100 * (fTracks2F[9]->GetBinContent(2, 2) / fnrTracksHighP));
1402 
1403  fTracks2F[11]->SetBinContent(
1404  1, 1, 100 * (fTracks2F[11]->GetBinContent(1, 1) / flow));
1405  fTracks2F[11]->SetBinContent(
1406  1, 2, 100 * (fTracks2F[11]->GetBinContent(1, 2) / flow));
1407  fTracks2F[11]->SetBinContent(
1408  2, 1, 100 * (fTracks2F[11]->GetBinContent(2, 1) / fmid));
1409  fTracks2F[11]->SetBinContent(
1410  2, 2, 100 * (fTracks2F[11]->GetBinContent(2, 2) / fmid));
1411  fTracks2F[11]->SetBinContent(
1412  3, 1, 100 * (fTracks2F[11]->GetBinContent(3, 1) / fhigh));
1413  fTracks2F[11]->SetBinContent(
1414  3, 2, 100 * (fTracks2F[11]->GetBinContent(3, 2) / fhigh));
1415 
1416  if (fdraw) {
1417  TCanvas* TrackCanvas2 = new TCanvas();
1418  TrackCanvas2->Divide(3, 2);
1419  TrackCanvas2->cd(1);
1420  fTracks2F[0]->Draw("colz");
1421  TrackCanvas2->cd(2);
1422  fTracks2F[1]->Draw("colz");
1423  TrackCanvas2->cd(3);
1424  fTracks2F[2]->Draw("colz");
1425  TrackCanvas2->cd(4);
1426  fTracks2F[3]->Draw("colz");
1427  TrackCanvas2->cd(5);
1428  fTracks2F[4]->Draw("colz");
1429 
1430 
1431  TCanvas* TrackCanvas2b = new TCanvas();
1432  TrackCanvas2b->Divide(2, 2);
1433  TrackCanvas2b->cd(1);
1434  fTracks2F[5]->Draw("colz");
1435  TrackCanvas2b->cd(2);
1436  fTracks2F[6]->Draw("colz");
1437 
1438 
1439  TCanvas* BadTracks = new TCanvas();
1440  BadTracks->Divide(2, 2);
1441  BadTracks->cd(1);
1442  fTracks2F[7]->Draw("colz");
1443  BadTracks->cd(2);
1444  fTracks2F[8]->Draw("colz");
1445  BadTracks->cd(3);
1446  fTracks2F[9]->DrawCopy("TEXT");
1447  BadTracks->cd(4);
1448  fTracks2F[10]->Draw("colz");
1449 
1450  fTracks2F[9]->SetContour(10);
1451  fTracks2F[11]->SetContour(10);
1452 
1453  gStyle->SetPaintTextFormat("4.1f %");
1454 
1455  TCanvas* asd = new TCanvas();
1456  asd->cd();
1457  fTracks2F[9]->SetMarkerSize(4);
1458  fTracks2F[9]->Draw("TEXT COLZ");
1459  TCanvas* asd2 = new TCanvas();
1460  asd2->cd();
1461  fTracks2F[11]->SetMarkerSize(4);
1462  fTracks2F[11]->Draw("TEXT COLZ");
1463  }
1464 
1465 
1466  for (Int_t i = 0; i < f2FSize; i++) {
1467  fTracks2F[i]->Write();
1468  }
1469 }
1470 //-----------------------------------------------------------------------------------------
1471 
1472 
1473 /*
1474 // -------------------------------------------------------------------------
1475 Double_t CbmMvdQa::GetImpactParameterRadius( CbmLitTrackParam t ){
1476 
1477  Double_t imx = t.GetX();
1478  Double_t imy = t.GetY();
1479  Double_t imr = sqrt(imx*imx + imy*imy);
1480 
1481  return imr;
1482 }
1483 // -------------------------------------------------------------------------
1484 
1485 
1486 //--------------------------------------------------------------------------
1487 Double_t CbmMvdQa::GetImpactParameterX( CbmLitTrackParam t ){
1488 
1489 Double_t imx = t.GetX();
1490 
1491  return imx;
1492 }
1493 // -------------------------------------------------------------------------
1494 
1495 
1496 //--------------------------------------------------------------------------
1497 Double_t CbmMvdQa::GetImpactParameterY( CbmLitTrackParam t ){
1498 
1499  Double_t imy = t.GetY();
1500 
1501  return imy;
1502 }
1503 // -------------------------------------------------------------------------
1504 
1505 
1506 
1507 //-----------------------------------------------------------------------------------------
1508 Double_t CbmMvdQa::GetTransverseMomentum( CbmLitTrackParam t ){
1509 
1510 const std::vector<double> state= t.GetStateVector();
1511 
1512 Float_t pz = GetMomentumZ(t);
1513 Float_t px = state[2] * pz;
1514 Float_t py = state[3] * pz;
1515 
1516 Double_t pt = sqrt(px * px + py * py);
1517 
1518  return pt;
1519 }
1520 //-----------------------------------------------------------------------------------------
1521 
1522 
1523 //-----------------------------------------------------------------------------------------
1524 Double_t CbmMvdQa::GetMomentum( CbmLitTrackParam t ){
1525 
1526  Float_t p = fabs(1.F / t.GetQp());
1527 
1528  return p;
1529 }
1530 //-----------------------------------------------------------------------------------------
1531 
1532 //-----------------------------------------------------------------------------------------
1533 Double_t CbmMvdQa::GetMomentumZ( CbmLitTrackParam t ){
1534 
1535  const std::vector<double> state= t.GetStateVector();
1536 
1537 Float_t pz = sqrt(GetMomentum(t) * GetMomentum(t) / (state[2] * state[2] + state[3] * state[3] + 1));
1538 
1539  return pz;
1540 }
1541 //-----------------------------------------------------------------------------------------
1542 
1543 
1544 //-----------------------------------------------------------------------------------------
1545 Double_t CbmMvdQa::GetAngle( CbmLitTrackParam t ){
1546 
1547  Float_t angle_rad = std::atan(GetTransverseMomentum(t) / GetMomentumZ(t));
1548  Float_t rad_to_grad = ( 180 / TMath::Pi() );
1549  Float_t angle_grad = angle_rad * rad_to_grad;
1550 //cout << endl << "calc angle of " << angle_grad << " from rad angle " << angle_rad << endl;
1551  return angle_grad;
1552 }
1553 //-----------------------------------------------------------------------------------------
1554  */
1555 //-----------------------------------------------------------------------------------------
1556 ClassImp(CbmMvdQa);
CbmMvdDetector::Instance
static CbmMvdDetector * Instance()
Definition: CbmMvdDetector.cxx:47
CbmMvdQa::useDigiQa
Bool_t useDigiQa
Definition: CbmMvdQa.h:122
CbmMvdDigi::GetPixelY
Int_t GetPixelY()
Definition: CbmMvdDigi.cxx:143
CbmHit::GetZ
Double_t GetZ() const
Definition: CbmHit.h:70
CbmMvdSensor::GetDetectorID
Int_t GetDetectorID() const
Definition: CbmMvdSensor.h:63
CbmMatch::GetMatchedLink
const CbmLink & GetMatchedLink() const
Definition: CbmMatch.h:37
CbmTrack::GetChiSq
Double_t GetChiSq() const
Definition: CbmTrack.h:58
CbmMvdDetector.h
CbmMatch
Definition: CbmMatch.h:22
CbmMvdSensor::GetZ
Double_t GetZ() const
Definition: CbmMvdSensor.h:75
CbmVertex.h
CbmMvdQa::useMcQa
Bool_t useMcQa
Definition: CbmMvdQa.h:121
CbmMvdQa::ExecHitQa
void ExecHitQa()
Definition: CbmMvdQa.cxx:854
CbmTrackMatchNew::GetTrueOverAllHitsRatio
Double_t GetTrueOverAllHitsRatio() const
Definition: CbmTrackMatchNew.h:35
CbmPixelHit::GetX
Double_t GetX() const
Definition: CbmPixelHit.h:83
CbmMatch::GetLink
const CbmLink & GetLink(Int_t i) const
Definition: CbmMatch.h:35
CbmMatch::GetNofLinks
Int_t GetNofLinks() const
Definition: CbmMatch.h:38
CbmMvdStationPar::GetZPosition
Double_t GetZPosition(Int_t stationNumber) const
Definition: CbmMvdStationPar.cxx:82
CbmMvdDetector::GetParameterFile
CbmMvdStationPar * GetParameterFile()
Definition: CbmMvdDetector.h:111
CbmMvdDetector::GetSensor
CbmMvdSensor * GetSensor(UInt_t nSensor)
Definition: CbmMvdDetector.h:112
CbmPixelHit::GetY
Double_t GetY() const
Definition: CbmPixelHit.h:84
CbmMvdQa::useTrackQa
Bool_t useTrackQa
Definition: CbmMvdQa.h:124
CbmMvdDigi.h
CbmMvdQa::fnrOfMergedHits
Int_t fnrOfMergedHits
Definition: CbmMvdQa.h:69
CbmMvdCluster::GetTotalDigisInCluster
Short_t GetTotalDigisInCluster()
Definition: CbmMvdCluster.h:46
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:41
CbmMvdDetector::Init
void Init()
Definition: CbmMvdDetector.cxx:278
CbmMvdQa::~CbmMvdQa
~CbmMvdQa()
Definition: CbmMvdQa.cxx:109
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMvdSensor.h
CbmMvdQa::ExecDigiQa
void ExecDigiQa()
Definition: CbmMvdQa.cxx:807
CbmMvdQa::flow
Int_t flow
Definition: CbmMvdQa.h:76
CbmGlobalTrack.h
CbmMvdQa::foutFile
TFile * foutFile
Definition: CbmMvdQa.h:58
CbmMvdQa::fPrimVtx
CbmVertex * fPrimVtx
Definition: CbmMvdQa.h:116
CbmMvdQa::fStsTrackMatches
TClonesArray * fStsTrackMatches
Definition: CbmMvdQa.h:83
CbmMvdQa::fEventNumber
Int_t fEventNumber
Definition: CbmMvdQa.h:64
CbmMvdQa::fmid
Int_t fmid
Definition: CbmMvdQa.h:77
CbmMvdCluster
Definition: CbmMvdCluster.h:27
CbmMvdQa::fTracks1F
TH1F * fTracks1F[f1FSize]
Definition: CbmMvdQa.h:113
CbmMvdQa::GetFirstMCPos
void GetFirstMCPos(CbmStsTrack *stsTrack, Float_t *pos)
Definition: CbmMvdQa.cxx:1133
CbmMvdQa::SetupTrackHistograms
void SetupTrackHistograms()
Definition: CbmMvdQa.cxx:359
lab
Double_t lab[3]
Definition: CbmMvdSensorDigiToHitTask.cxx:62
CbmMvdQa::fDigi2F
TH2F * fDigi2F[30]
Definition: CbmMvdQa.h:108
CbmMatch.h
CbmMvdQa::fMvdDigiMatchArray
TClonesArray * fMvdDigiMatchArray
Definition: CbmMvdQa.h:96
CbmMvdQa::HasHitFirstMvd
Bool_t HasHitFirstMvd(CbmStsTrack *stsTrack)
Definition: CbmMvdQa.cxx:1088
CbmMvdHit
Definition: CbmMvdHit.h:29
CbmMvdGeoHandler.h
Helper class to extract information from the GeoManager. Addapted from TrdGeoHandler byFlorian Uhlig ...
CbmGlobalTrack::GetParamVertex
const CbmTrackParam * GetParamVertex() const
Definition: CbmGlobalTrack.h:45
CbmMvdQa::FinishMCQa
void FinishMCQa()
Definition: CbmMvdQa.cxx:1217
CbmMvdQa::fDetector
CbmMvdDetector * fDetector
Definition: CbmMvdQa.h:119
CbmStsTrack::GetNofMvdHits
Int_t GetNofMvdHits() const
Definition: CbmStsTrack.h:84
CbmMvdPoint.h
CbmMvdQa::f1FSize
static const Int_t f1FSize
Definition: CbmMvdQa.h:101
CbmMvdSensor
Definition: CbmMvdSensor.h:40
CbmStsTrack.h
Data class for STS tracks.
CbmGlobalTrack::GetStsTrackIndex
Int_t GetStsTrackIndex() const
Definition: CbmGlobalTrack.h:38
CbmMvdPoint
Definition: CbmMvdPoint.h:28
CbmMvdQa::fBadTracks
TClonesArray * fBadTracks
Definition: CbmMvdQa.h:97
CbmMvdQa::ExecTrackQa
void ExecTrackQa()
Definition: CbmMvdQa.cxx:893
CbmMvdQa::Finish
void Finish()
Definition: CbmMvdQa.cxx:1204
CbmMvdQa::fMvdRecoRatio
Float_t fMvdRecoRatio
Definition: CbmMvdQa.h:66
CbmMvdQa::fnrTracksHighP
Int_t fnrTracksHighP
Definition: CbmMvdQa.h:75
CbmMvdQa::HasHitFirstTrue
Bool_t HasHitFirstTrue(Int_t MCtrackID, CbmStsTrack *stsTrack)
Definition: CbmMvdQa.cxx:1101
CbmMvdQa::useHitQa
Bool_t useHitQa
Definition: CbmMvdQa.h:123
CbmMvdQa::fGlobalTrackArray
TClonesArray * fGlobalTrackArray
Definition: CbmMvdQa.h:84
CbmTrackMatchNew.h
CbmVertex
Definition: CbmVertex.h:26
CbmMvdStationPar.h
CbmMvdQa::fMvdHits
TClonesArray * fMvdHits
Definition: CbmMvdQa.h:94
CbmTrack::GetNDF
Int_t GetNDF() const
Definition: CbmTrack.h:59
CbmMvdQa::GetFirstMvdHitPos
void GetFirstMvdHitPos(CbmStsTrack *stsTrack, Float_t *hitPos)
Definition: CbmMvdQa.cxx:1075
CbmMvdSensor::PixelToTop
void PixelToTop(Int_t pixelNumberX, Int_t pixelNumberY, Double_t *lab)
Definition: CbmMvdSensor.cxx:624
CbmMvdQa::fMvdHitMatchArray
TClonesArray * fMvdHitMatchArray
Definition: CbmMvdQa.h:95
CbmMvdQa::SetupHitHistograms
void SetupHitHistograms()
Definition: CbmMvdQa.cxx:306
CbmTrack::GetParamFirst
const FairTrackParam * GetParamFirst() const
Definition: CbmTrack.h:61
CbmMvdQa::FinishHitQa
void FinishHitQa()
Definition: CbmMvdQa.cxx:1246
CbmMvdPoint::GetZOut
Double_t GetZOut() const
Definition: CbmMvdPoint.h:72
ClassImp
ClassImp(CbmMvdQa)
CbmMvdQa::ExecMCQa
void ExecMCQa()
Definition: CbmMvdQa.cxx:794
CbmMvdQa::SetupMCHistograms
void SetupMCHistograms()
Definition: CbmMvdQa.cxx:206
CbmMvdQa::fHits1F
TH1F * fHits1F[30]
Definition: CbmMvdQa.h:110
CbmMvdQa::fMvdDigis
TClonesArray * fMvdDigis
Definition: CbmMvdQa.h:92
CbmGlobalTrack
Definition: CbmGlobalTrack.h:26
counter
int counter
Definition: CbmMvdSensorDigiToHitTask.cxx:72
CbmMvdQa::fMC1F
TH1F * fMC1F[30]
Definition: CbmMvdQa.h:104
CbmMCTrack.h
CbmMvdQa::fHits2F
TH2F * fHits2F[30]
Definition: CbmMvdQa.h:111
CbmMvdQa::fMcPoints
TClonesArray * fMcPoints
Definition: CbmMvdQa.h:91
CbmMvdDetector::GetSensorArraySize
Int_t GetSensorArraySize()
Definition: CbmMvdDetector.h:70
CbmMvdQa::Exec
void Exec(Option_t *opt)
Definition: CbmMvdQa.cxx:781
CbmMCTrack
Definition: CbmMCTrack.h:34
CbmMvdQa::fListMCTracks
TClonesArray * fListMCTracks
Definition: CbmMvdQa.h:87
CbmMvdQa::fTracks2F
TH2F * fTracks2F[f2FSize]
Definition: CbmMvdQa.h:114
CbmMvdHit.h
CbmMvdQa::fMC2F
TH2F * fMC2F[30]
Definition: CbmMvdQa.h:105
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:60
CbmMvdQa
Definition: CbmMvdQa.h:33
CbmMvdStationPar
Definition: CbmMvdStationPar.h:22
CbmMvdDigi
Definition: CbmMvdDigi.h:21
CbmStsTrack::GetMvdHitIndex
Int_t GetMvdHitIndex(Int_t iHit) const
Definition: CbmStsTrack.h:70
CbmMvdQa::SetupHistograms
void SetupHistograms()
Definition: CbmMvdQa.cxx:197
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmMvdHit::GetClusterIndex
Int_t GetClusterIndex() const
Definition: CbmMvdHit.h:63
CbmMvdQa::fhigh
Int_t fhigh
Definition: CbmMvdQa.h:78
CbmMvdDigi::GetPixelX
Int_t GetPixelX()
Definition: CbmMvdDigi.cxx:141
CbmMvdQa::fdraw
Bool_t fdraw
Definition: CbmMvdQa.h:128
CbmTrackMatchNew
Definition: CbmTrackMatchNew.h:19
CbmMvdQa::fMvdCluster
TClonesArray * fMvdCluster
Definition: CbmMvdQa.h:93
CbmMvdQa::Init
InitStatus Init()
Definition: CbmMvdQa.cxx:113
CbmMvdQa::FinishDigiQa
void FinishDigiQa()
Definition: CbmMvdQa.cxx:1229
CbmMvdQa::SetupDigiHistograms
void SetupDigiHistograms()
Definition: CbmMvdQa.cxx:228
CbmStsTrack
Definition: CbmStsTrack.h:37
PairAnalysisStyler::Fill
static Int_t Fill[]
Definition: PairAnalysisStyleDefs.h:82
CbmMvdQa::SetMatches
void SetMatches(Int_t MCtrackID, CbmStsTrack *stsTrack)
Definition: CbmMvdQa.cxx:1164
CbmMvdQa::FinishTrackQa
void FinishTrackQa()
Definition: CbmMvdQa.cxx:1287
CbmMCTrack::GetP
Double_t GetP() const
Definition: CbmMCTrack.h:100
CbmMvdQa::fDigi1F
TH1F * fDigi1F[30]
Definition: CbmMvdQa.h:107
CbmMvdQa::fStsTrackArray
TClonesArray * fStsTrackArray
Definition: CbmMvdQa.h:80
CbmMvdQa::CbmMvdQa
CbmMvdQa()
Definition: CbmMvdQa.cxx:51
CbmMvdDigi::GetDetectorId
Int_t GetDetectorId()
Definition: CbmMvdDigi.h:57
CbmMvdQa::fnrTrackslowP
Int_t fnrTrackslowP
Definition: CbmMvdQa.h:74
CbmMvdQa::f2FSize
static const Int_t f2FSize
Definition: CbmMvdQa.h:102
CbmMvdQa.h
CbmMvdQa::fFirstMvdPos
Int_t fFirstMvdPos
Definition: CbmMvdQa.h:71