BmnRoot 26.10.0-18-g4e3414f9
Software framework of the BM@N experiment
Loading...
Searching...
No Matches
CbmStsFitPerformanceTask.cxx
Go to the documentation of this file.
1// -------------------------------------------------------------------------
2// ----- CbmStsFitPerformanceTask source file -----
3// ----- Created 02/02/05 by E. Kryshen -----
4// -------------------------------------------------------------------------
5
6#include "CbmStsFitPerformanceTask.h"
7
8#include "CbmKF.h"
9#include "CbmKFMath.h"
10#include "CbmKFPrimaryVertexFinder.h"
11#include "CbmKFTrack.h"
12#include "CbmKFTrackInterface.h"
13#include "CbmKFVertex.h"
14#include "CbmKFVertexInterface.h"
15#include "CbmMCTrack.h"
16#include "CbmMvdHit.h"
17#include "CbmPVFinderKF.h"
18#include "CbmStsHit.h"
19#include "CbmStsKFSecondaryVertexFinder.h"
20#include "CbmStsKFTrackFitter.h"
21#include "CbmStsTrack.h"
22#include "CbmTrackMatch.h"
23#include "CbmVertex.h"
24#include "FairMCApplication.h"
25#include "FairRootManager.h"
26#include "TDatabasePDG.h"
27#include "TF1.h"
28#include "TParticlePDG.h"
29#include "TVector3.h"
30
31#include <cmath>
32#include <iomanip>
33#include <iostream>
34
35using std::cout;
36using std::endl;
37using std::fabs;
38using std::vector;
39
40// -------------------------------------------------------------------------
41
42void writedir2current(TObject* obj)
43{
44 if (!obj->IsFolder())
45 obj->Write();
46 else {
47 TDirectory* cur = gDirectory;
48 TDirectory* sub = cur->mkdir(obj->GetName());
49 sub->cd();
50 TList* listSub = ((TDirectory*)obj)->GetList();
51 TIter it(listSub);
52 while (TObject* obj1 = it())
53 writedir2current(obj1);
54 cur->cd();
55 }
56}
57
58void CbmStsFitPerformanceTask::CreateTrackHisto(TH1D* hist[10], const char* name, const char* title)
59{
60 struct
61 {
62 const char* name;
63 const char* title;
64 Int_t n;
65 Double_t l, r;
66 } Table[10] = {{"x", "Residual X [#mum]", 100, -100., 100.},
67 {"y", "Residual Y [#mum]", 100, -100., 100.},
68 {"tx", "Residual Tx [mrad]", 100, -2., 2.},
69 {"ty", "Residual Ty [mrad]", 100, -2., 2.},
70 {"P", "Resolution P/Q [100%]", 100, -.1, .1},
71 {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
72 {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
73 {"ptx", "Pull Tx [residual/estimated_error]", 100, -10., 10.},
74 {"pty", "Pull Ty [residual/estimated_error]", 100, -10., 10.},
75 {"pQP", "Pull Q/P [residual/estimated_error]", 100, -10., 10.}};
76
77 for (int i = 0; i < 10; i++) {
78 char n[225], t[255];
79 sprintf(n, "%s_%s", name, Table[i].name);
80 sprintf(t, "%s %s", title, Table[i].title);
81 hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
82 }
83}
84
85void CbmStsFitPerformanceTask::CreateVertexHisto(TH1D* hist[9], const char* name, const char* title)
86{
87 struct
88 {
89 const char* name;
90 const char* title;
91 Int_t n;
92 Double_t l, r;
93 } Table[9] = {
94 {"x", "Residual X [#mum]", 100, -5., 5.},
95 {"y", "Residual Y [#mum]", 100, -5., 5.},
96 {"z", "Residual Z [#mum]", 100, -40., 40.},
97 {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
98 {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
99 {"pz", "Pull Z [residual/estimated_error]", 100, -10., 10.},
100 {"chi2", "Chi2/NDF", 100, 0., 10.},
101 {"prob", "Prob(Chi2,NDF)", 100, 0., 1.},
102 {"ntracks", "N tracks", 100, 0., 1000.},
103 };
104
105 for (int i = 0; i < 9; i++) {
106 char n[225], t[255];
107 sprintf(n, "%s_%s", name, Table[i].name);
108 sprintf(t, "%s %s", title, Table[i].title);
109 hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
110 }
111}
112
113void CbmStsFitPerformanceTask::CreateD0Histo(TH1D* hist[15], const char* name, const char* title)
114{
115 struct
116 {
117 const char* name;
118 const char* title;
119 Int_t n;
120 Double_t l, r;
121 } Table[14] = {{"x", "Residual X [#mum]", 100, -100., 100.},
122 {"y", "Residual Y [#mum]", 100, -100., 100.},
123 {"z", "Residual Z [#mum]", 100, -500., 500.},
124 {"px", "Pull X [residual/estimated_error]", 100, -10., 10.},
125 {"py", "Pull Y [residual/estimated_error]", 100, -10., 10.},
126 {"pz", "Pull Z [residual/estimated_error]", 100, -10., 10.},
127 {"chi2", "Chi2/NDF", 100, 0., 10.},
128 {"prob", "Prob(Chi2,NDF)", 100, 0., 1.},
129 {"mass", "Residual Mass", 100, -.1, .1},
130 {"pmass", "Pull Mass [residual/estimated_error]", 100, -10., 10.},
131 {"KaonP", "Kaon P resolution", 100, -.05, .05},
132 {"PionP", "Pion P resolution", 100, -.05, .05},
133 {"KaonP0", "Kaon P resolution before fit", 100, -.05, .05},
134 {"PionP0", "Pion P resolutionbefore fit", 100, -.05, .05}};
135
136 for (int i = 0; i < 14; i++) {
137 char n[225], t[255];
138 sprintf(n, "%s_%s", name, Table[i].name);
139 sprintf(t, "%s %s", title, Table[i].title);
140 hist[i] = new TH1D(n, t, Table[i].n, Table[i].l, Table[i].r);
141 }
142}
143
144// ----- Standard constructor ------------------------------------------
145CbmStsFitPerformanceTask::CbmStsFitPerformanceTask(const char* name, Int_t iVerbose)
146 : FairTask(name, iVerbose)
147 , fEvent(0)
148 , fVertexAnalysis(0)
149 , fD0Analysis(0)
150 , fTrackAnalysis(1)
151 ,
152
153 fMCTrackArray(0)
154 , ///< MCTracks
155 fStsPointArray(0)
156 , ///< StsPoints
157 fMvdPointArray(0)
158 , ///< StsPoints
159 fRecStsTrackArray(0)
160 , ///< Reconstructed StsTracks
161 fStsHitArray(0)
162 , ///< Sts hits
163 fMvdHitArray(0)
164 , ///< Sts hits
165 fPrimaryVertex(0)
166 , ///< Primary vertex
167 fSTSTrackMatch(0)
168 , ///< Related MC tracks
169
170 fhChi2(0)
171 , // x=chi2(), y=entries for all
172 fhProb(0)
173 , // x=Prob function(), y=entries for all
174 fhDP(0)
175 , fhDP2(0)
176 , fhDsP(0)
177 , fhDsP2(0)
178 ,
179
180 fhZMCf(0)
181 , fhZMCl(0)
182 , // z first/last of MC track
183 fhZRecof(0)
184 , fhZRecol(0)
185 , // z first/last of Reco track
186
187 fhRes_vs_Mom_f(0)
188 , fhRes_vs_Mom_l(0)
189 , // resolution vs momentum
190 fhExtraTracks2ndMVD(0)
191 , // extra tracks not detected in the second mvd chamber
192
193 // TH1D* fhFrst[10](),
194 // TH1D* fhMid[10](),
195 // TH1D* fhLast[10](),
196 // TH1D* fhImp[10](),
197 // TH1D* fhImpPi[10](),
198 // TH1D* fhVfit[10](),
199 // TH1D* fhVtx[9](),
200 // TH1D* fhV[13][9](),
201 fhPq()
202 ,
203 // fhD0[4][14](),
204
205 // fhHitDensity[10](),
206 // fhTrackDensity[8](),
207 fhTrackDensity0L(0)
208 ,
209
210 histodir(0)
211 , fFitter()
212{}
213// -------------------------------------------------------------------------
214
215// ----- Destructor ----------------------------------------------------
216CbmStsFitPerformanceTask::~CbmStsFitPerformanceTask() {}
217
218// ----- Init CbmStsFitPerformanceTask task -------------------------------
219InitStatus CbmStsFitPerformanceTask::Init()
220{
221 fEvent = 0;
222
223 TDirectory* curdir = gDirectory;
224 histodir = gDirectory->mkdir("StsFitPerformance");
225 histodir->cd();
226
227 gDirectory->mkdir("TrackFit");
228 gDirectory->cd("TrackFit");
229 {
230 fhChi2 = new TH1D("hChi2", "hChi2", 100, 0, 10);
231 fhProb = new TH1D("hProb", "hProb", 100, 0, 1.0);
232
233 fhDP = new TH1D("hDP", "hDP", 1000, -.005, .005);
234 fhDP2 = new TH2D("hDP2", "hDP2", 100, 0., 5.0, 1000, -.005, .005);
235
236 fhDsP = new TH1D("hDsP", "hDsP", 100, -1, 1);
237 fhDsP2 = new TH2D("hDsP2", "hDsP2", 100, 0., 5.0, 100, -1, 1);
238
239 fhZMCf = new TH1D("hZMCf", "h Z MC first", 102, -1.0, 101.0);
240 fhZRecof = new TH1D("hZRecof", "h Z Reco first", 102, -1.0, 101.0);
241 fhZMCl = new TH1D("hZMCl", "h Z MC last", 102, -1.0, 101.0);
242 fhZRecol = new TH1D("hZRecol", "h Z Reco last", 102, -1.0, 101.0);
243
244 fhRes_vs_Mom_f =
245 new TH2D("hRes_vs_Mom_f", "TX Resolusion vs Momentum (first hit)", 100, 0.0, 5.0, 100, -50.0, 50.0);
246 fhRes_vs_Mom_l =
247 new TH2D("hRes_vs_Mom_l", "TX Resolusion vs Momentum (last hit)", 100, 0.0, 5.0, 100, -10.0, 10.0);
248
249 fhExtraTracks2ndMVD =
250 new TH2D("hExtraTracks2ndMVD", "ExtraTracks in the 2nd MVD", 200, -10.0, 10.0, 200, -10.0, 10.0);
251
252 gDirectory->mkdir("AtFirstHit");
253 gDirectory->cd("AtFirstHit");
254 CreateTrackHisto(fhFrst, "fst", "at first STS Hit");
255 gDirectory->cd("..");
256 gDirectory->mkdir("AtLastHit");
257 gDirectory->cd("AtLastHit");
258 CreateTrackHisto(fhLast, "lst", "at last STS Hit");
259 gDirectory->cd("..");
260 gDirectory->mkdir("AtImpactPoint");
261 gDirectory->cd("AtImpactPoint");
262 CreateTrackHisto(fhImp, "imp", "at impact point");
263 gDirectory->cd("..");
264 gDirectory->mkdir("AtImpactPointPion");
265 gDirectory->cd("AtImpactPointPion");
266 CreateTrackHisto(fhImpPi, "impPi", "at impact point");
267 gDirectory->cd("..");
268 gDirectory->mkdir("InTheMiddle");
269 gDirectory->cd("InTheMiddle");
270 CreateTrackHisto(fhMid, "mid", "at 4th station");
271 gDirectory->cd("..");
272 gDirectory->mkdir("FittedToVertex");
273 gDirectory->cd("FittedToVertex");
274 CreateTrackHisto(fhVfit, "vfit", "for vertex fitted track");
275 gDirectory->cd("..");
276
277 gDirectory->mkdir("PSlidesOnP");
278 gDirectory->cd("PSlidesOnP");
279 fhPq = new TH2D("Pq", "Resolution P/Q at impact point vs P", 100, 0, 10, 100, -.1, .1);
280 gDirectory->cd("..");
281 }
282 gDirectory->cd("..");
283
284 for (int i = 0; i < 10; i++) {
285 char n[225], t[255];
286 sprintf(n, "hHitDens%i", i);
287 sprintf(t, "Hit Density, Sts station %i", i);
288 fhHitDensity[i] = new TH1D(n, t, 300, 0, 300);
289 }
290 fhTrackDensity[0] = new TH1D("hTrackDensity0", "Track Density 0cm", 300, 0, 300);
291 fhTrackDensity0L = new TH1D("hTrackDensity0L", "Track Density Line 0cm", 300, 0, 300);
292 fhTrackDensity[1] = new TH1D("hTrackDensity1", "Track Density 1cm", 300, 0, 300);
293 fhTrackDensity[2] = new TH1D("hTrackDensity2", "Track Density 2cm", 300, 0, 300);
294 fhTrackDensity[3] = new TH1D("hTrackDensity3", "Track Density 3cm", 300, 0, 300);
295 fhTrackDensity[4] = new TH1D("hTrackDensity4", "Track Density 4cm", 300, 0, 300);
296 fhTrackDensity[5] = new TH1D("hTrackDensity5", "Track Density 5cm", 300, 0, 300);
297 fhTrackDensity[6] = new TH1D("hTrackDensity10", "Track Density 10cm", 300, 0, 300);
298 fhTrackDensity[7] = new TH1D("hTrackDensity100", "Track Density 1m", 300, 0, 300);
299
300 gDirectory->mkdir("VertexFit");
301 gDirectory->cd("VertexFit");
302 {
303 CreateVertexHisto(fhVtx, "vtx", "for Primary Vertex");
304 gDirectory->mkdir("VertexOnNTracks");
305 gDirectory->cd("VertexOnNTracks");
306 for (int i = 0; i < 13; i++) {
307 char name[225], namedir[225], title[225];
308 if (i == 0) {
309 sprintf(namedir, "AllTracks");
310 sprintf(name, "Vall");
311 sprintf(title, "for Primary Vertex on all tracks");
312 } else {
313 sprintf(namedir, "%iTracks", i * 50);
314 sprintf(name, "V%i", i * 50);
315 sprintf(title, "for Primary Vertex on %i tracks", i * 50);
316 }
317 gDirectory->mkdir(namedir);
318 gDirectory->cd(namedir);
319 CreateVertexHisto(fhV[i], name, title);
320 gDirectory->cd("..");
321 }
322 gDirectory->cd("..");
323 }
324 gDirectory->cd("..");
325
326 gDirectory->mkdir("D0Fit");
327 gDirectory->cd("D0Fit");
328 {
329 gDirectory->mkdir("No constraints");
330 gDirectory->cd("No constraints");
331 CreateD0Histo(fhD0[0], "D0", "for D0 Sec. Vertex");
332 gDirectory->cd("..");
333 gDirectory->mkdir("Topological constraint");
334 gDirectory->cd("Topological constraint");
335 CreateD0Histo(fhD0[1], "D0T", "for D0 Topo Sec. Vertex");
336 gDirectory->cd("..");
337 gDirectory->mkdir("Mass constraint");
338 gDirectory->cd("Mass constraint");
339 CreateD0Histo(fhD0[2], "D0M", "for D0 Mass Sec. Vertex");
340 gDirectory->cd("..");
341 gDirectory->mkdir("Mass+Topological constraint");
342 gDirectory->cd("Mass+Topological constraint");
343 CreateD0Histo(fhD0[3], "D0TM", "for D0 Topo+Mass Sec. Vertex");
344 gDirectory->cd("..");
345 }
346 gDirectory->cd("..");
347
348 curdir->cd();
349 return ReInit();
350}
351
352// ----- ReInit CbmStsFitPerformanceTask task -------------------------------
353InitStatus CbmStsFitPerformanceTask::ReInit()
354{
355
356 FairRootManager* fManger = FairRootManager::Instance();
357 fMCTrackArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MCTrack"));
358 fStsPointArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsPoint"));
359 fMvdPointArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MvdPoint"));
360 fRecStsTrackArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsTrack"));
361 fStsHitArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsHit"));
362 fMvdHitArray = reinterpret_cast<TClonesArray*>(fManger->GetObject("MvdHit"));
363 fPrimaryVertex = reinterpret_cast<CbmVertex*>(fManger->GetObject("PrimaryVertex"));
364 fSTSTrackMatch = reinterpret_cast<TClonesArray*>(fManger->GetObject("StsTrackMatch"));
365 fFitter.Init();
366
367 return kSUCCESS;
368}
369// -------------------------------------------------------------------------
370
371// ----- Exec CbmStsFitPerformanceTask task -------------------------------
372void CbmStsFitPerformanceTask::Exec(Option_t* option)
373{
374 cout << "Event: " << ++fEvent << " ";
375
376 Int_t nTracks = fRecStsTrackArray->GetEntriesFast();
377 cout << " nTracks: " << nTracks << endl;
378
379 if (!fSTSTrackMatch)
380 return;
381
382 Double_t mc[6];
383
384 Int_t Quality[nTracks];
385
386 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
387 Quality[iTrack] = 0;
388 CbmStsTrack* track = (CbmStsTrack*)fRecStsTrackArray->At(iTrack);
389 if (!track)
390 continue;
391 CbmTrackMatch* m = (CbmTrackMatch*)fSTSTrackMatch->At(iTrack);
392 if (!m)
393 continue;
394 if (m->GetNofTrueHits() < 0.7 * (m->GetNofTrueHits() + m->GetNofWrongHits() + m->GetNofFakeHits()))
395 continue;
396 Int_t mcTrackID = m->GetMCTrackId();
397 if (mcTrackID < 0)
398 continue;
399 if (!IsLong(track))
400 continue;
401
402 CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTrackArray->At(mcTrackID);
403 if (!mcTrack)
404 continue;
405 if (fabs((mcTrack->GetStartZ())) > 1.)
406 continue;
407
408 if (mcTrack->GetMotherId() != -1)
409 continue;
410 Quality[iTrack] = 1;
411 }
412
413 if (0) {
414 // CbmKF &KF = *CbmKF::Instance();
415 int nStsHits = fStsHitArray->GetEntries();
416 int nMvdHits = fMvdHitArray->GetEntries();
417 cout << "Mvd hit density..." << endl;
418 for (int ih = 0; ih < nMvdHits; ih++) {
419 if (ih % 100 == 0)
420 cout << ih << endl;
421 CbmMvdHit* h1 = (CbmMvdHit*)fMvdHitArray->At(ih);
422 if (!h1)
423 continue;
424 double V[3] = {2 * h1->GetDx() * h1->GetDx(), 2 * 0, 2 * h1->GetDy() * h1->GetDy()};
425 Double_t v = 1. / (V[0] * V[2] - V[1] * V[1]);
426 V[0] *= v;
427 V[1] *= v;
428 V[2] *= v;
429 double D2 = 1.e10;
430 for (int jh = 0; jh < nMvdHits; jh++) {
431 if (ih == jh)
432 continue;
433 CbmMvdHit* h2 = (CbmMvdHit*)fMvdHitArray->At(jh);
434 if (!h2)
435 continue;
436 if (h1->GetStationNr() != h2->GetStationNr())
437 continue;
438 Double_t dx = h1->GetX() - h2->GetX();
439 Double_t dy = h1->GetY() - h2->GetY();
440 Double_t d2 = fabs(dx * dx * V[0] - 2 * dx * dy * V[1] + dy * dy * V[2]);
441 if (d2 < D2)
442 D2 = d2;
443 }
444 fhHitDensity[h1->GetStationNr() - 1]->Fill(sqrt(D2 / 2.));
445 }
446 cout << "Sts hit density..." << endl;
447 for (int ih = 0; ih < nStsHits; ih++) {
448 if (ih % 1000 == 0)
449 cout << ih << endl;
450 CbmStsHit* h1 = (CbmStsHit*)fStsHitArray->At(ih);
451 if (!h1)
452 continue;
453 double V[3] = {2 * h1->GetDx() * h1->GetDx(), 2 * h1->GetCovXY(), 2 * h1->GetDy() * h1->GetDy()};
454 Double_t v = 1. / (V[0] * V[2] - V[1] * V[1]);
455 V[0] *= v;
456 V[1] *= v;
457 V[2] *= v;
458 double D2 = 1.e10;
459 for (int jh = 0; jh < nStsHits; jh++) {
460 if (ih == jh)
461 continue;
462 CbmStsHit* h2 = (CbmStsHit*)fStsHitArray->At(jh);
463 if (!h2)
464 continue;
465 if (h1->GetStationNr() != h2->GetStationNr())
466 continue;
467 if (h1->GetDigi(1) >= 0) {
468 if (h1->GetDigi(0) != h2->GetDigi(0) && h1->GetDigi(1) != h2->GetDigi(1))
469 continue;
470 }
471 Double_t dx = h1->GetX() - h2->GetX();
472 Double_t dy = h1->GetY() - h2->GetY();
473 Double_t d2 = fabs(dx * dx * V[0] - 2 * dx * dy * V[1] + dy * dy * V[2]);
474 if (d2 < D2)
475 D2 = d2;
476 }
477 fhHitDensity[CbmKF::Instance()->MvdStationIDMap.size() + h1->GetStationNr() - 1]->Fill(sqrt(D2 / 2));
478 }
479 }
480
481 if (0) { // track density
482 cout << "Track density..." << endl;
483 bool flag[nTracks];
484 double sC[nTracks][8][15];
485 double sT[nTracks][8][5];
486 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
487 flag[iTrack] = 0;
488
489 CbmStsTrack* trackI = (CbmStsTrack*)fRecStsTrackArray->At(iTrack);
490 if (!IsLong(trackI))
491 continue;
492 flag[iTrack] = 1;
493 double z[8] = {0.2, 1, 2, 3, 4, 5, 10, 100};
494 for (int iz = 0; iz < 8; iz++) {
495 FairTrackParam paramI;
496 fFitter.Extrapolate(trackI, z[iz], &paramI);
497 CbmKFMath::CopyTrackParam2TC(&paramI, sT[iTrack][iz], sC[iTrack][iz]);
498 if (!finite(sC[iTrack][iz][0]) || sC[iTrack][iz][0] < 0 || sC[iTrack][iz][0] > 10.) {
499 flag[iTrack] = 0;
500 break;
501 }
502 }
503 }
504 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
505
506 if (iTrack % 10 == 0)
507 cout << iTrack << endl;
508 if (!flag[iTrack])
509 continue;
510 double Chi2[8];
511 for (int iz = 0; iz < 8; iz++)
512 Chi2[iz] = 1.e10;
513 double Chi2L = 1.e10;
514
515 for (Int_t jTrack = 0; jTrack < nTracks; jTrack++) {
516 if (jTrack == iTrack)
517 continue;
518 if (!flag[jTrack])
519 continue;
520
521 for (int iz = 0; iz < 8; iz++) {
522 Double_t C[15], d[5];
523 for (int i = 0; i < 15; i++)
524 C[i] = sC[iTrack][iz][i] + sC[jTrack][iz][i];
525 for (int i = 0; i < 5; i++)
526 d[i] = sT[iTrack][iz][i] - sT[jTrack][iz][i];
527 CbmKFMath::invS(C, 5);
528
529 double chi2 = 0;
530 for (int i = 0; i < 5; i++) {
531 double dCi = 0;
532 for (int j = 0; j < 5; j++)
533 dCi += d[j] * C[CbmKFMath::indexS(i, j)];
534 chi2 += dCi * d[i];
535 }
536 chi2 = fabs(chi2);
537 if (chi2 < Chi2[iz])
538 Chi2[iz] = chi2;
539
540 if (iz == 0) {
541 chi2 = 0;
542 for (int i = 0; i < 4; i++) {
543 double dCi = 0;
544 for (int j = 0; j < 4; j++)
545 dCi += d[j] * C[CbmKFMath::indexS(i, j)];
546 chi2 += dCi * d[i];
547 }
548 chi2 = fabs(chi2);
549 if (chi2 < Chi2L)
550 Chi2L = chi2;
551 }
552 }
553 }
554 for (int iz = 0; iz < 8; iz++) {
555 fhTrackDensity[iz]->Fill(sqrt(Chi2[iz] / 5));
556 }
557 fhTrackDensity0L->Fill(sqrt(Chi2L / 4));
558 }
559 }
560 if (fTrackAnalysis) {
561 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
562 if (Quality[iTrack] < 1)
563 continue;
564 CbmStsTrack* track = (CbmStsTrack*)fRecStsTrackArray->At(iTrack);
565 CbmTrackMatch* m = (CbmTrackMatch*)fSTSTrackMatch->At(iTrack);
566 CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTrackArray->At(m->GetMCTrackId());
567
568 if (mcTrack->GetMotherId() != -1)
569 continue; // not primary track //IK
570
571 // Get MC points;
572 vector<CbmStsPoint*> vPoints;
573 for (Int_t i = 0; i < track->GetNStsHits(); i++) {
574 Int_t hitID = track->GetStsHitIndex(i);
575 if (hitID < 0)
576 continue;
577 CbmStsHit* hit = (CbmStsHit*)fStsHitArray->At(hitID);
578 if (!hit)
579 continue;
580 Int_t pointID = hit->GetRefIndex();
581 if (pointID < 0)
582 continue;
583 CbmStsPoint* point = (CbmStsPoint*)fStsPointArray->At(pointID);
584 if (!point)
585 continue;
586 vPoints.push_back(point);
587 }
588 vector<CbmMvdPoint*> vMPoints;
589 for (Int_t i = 0; i < track->GetNMvdHits(); i++) {
590 Int_t hitID = track->GetMvdHitIndex(i);
591 if (hitID < 0)
592 continue;
593 CbmMvdHit* hit = (CbmMvdHit*)fMvdHitArray->At(hitID);
594 if (!hit)
595 continue;
596 Int_t pointID = hit->GetRefIndex();
597 if (pointID < 0)
598 continue;
599 CbmMvdPoint* point = (CbmMvdPoint*)fMvdPointArray->At(pointID);
600 if (!point)
601 continue;
602 vMPoints.push_back(point);
603 }
604 // impact mc track
605 Double_t mci[6];
606 Double_t pzi = mcTrack->GetPz();
607 if (fabs(pzi) > 1.e-4)
608 pzi = 1. / pzi;
609 mci[0] = mcTrack->GetStartX();
610 mci[1] = mcTrack->GetStartY();
611 mci[2] = mcTrack->GetPx() * pzi;
612 mci[3] = mcTrack->GetPy() * pzi;
613 mci[4] = (fabs(mcTrack->GetP()) > 1.e-4) ? GetCharge(mcTrack) / mcTrack->GetP() : 0;
614 mci[5] = mcTrack->GetStartZ();
615 if (!vPoints.empty()) {
616 if (track->GetNStsHits() + track->GetNMvdHits() >= 8) {
617 Double_t p1 = mcTrack->GetP();
618 TVector3 mom;
619 vPoints.back()->MomentumOut(mom);
620 Double_t p2 = mom.Mag();
621 Double_t s = p1 * p1 * TMath::Sqrt(TMath::Abs(track->GetParamFirst()->GetCovariance(4, 4)));
622 Double_t dp = (p1 - p2) * TMath::Sqrt(1 + mci[2] * mci[2] + mci[3] * mci[3]);
623 fhDP->Fill(dp);
624 fhDP2->Fill(p1, dp);
625 fhDsP->Fill(dp / s);
626 fhDsP2->Fill(p1, dp / s);
627 }
628 // first point
629 if (!vMPoints.empty())
630 FillMCStateVectors(vMPoints.front(), mc);
631 else
632 FillMCStateVectors(vPoints.front(), mc);
633 FillTrackHisto(mc, track, fhFrst);
634 fhZMCf->Fill(mc[5]);
635 fhZRecof->Fill(track->GetParamFirst()->GetZ());
636
637 // last point
638 FillMCStateVectors(vPoints.back(), mc, 1);
639 FillTrackHisto(mc, track, fhLast);
640 fhZMCl->Fill(mc[5]);
641 fhZRecol->Fill(track->GetParamLast()->GetZ());
642
643 // impact point
644
645 if (TMath::Abs(mcTrack->GetPdgCode()) == 211)
646 FillTrackHisto(mci, track, fhImpPi);
647 else
648 FillTrackHisto(mci, track, fhImp);
649
650 // 4th station (check smoother)
651
652 for (vector<CbmStsPoint*>::iterator i = vPoints.begin(); i != vPoints.end(); i++) {
653 int id = (*i)->GetDetectorID();
654 CbmKF& KF = *CbmKF::Instance();
655 if (KF.StsStationIDMap.find(id) == KF.StsStationIDMap.end())
656 continue;
657 if (KF.StsStationIDMap[id] != 3)
658 continue;
659 FillMCStateVectors(*i, mc, 1);
660 // FillTrackHisto( mc, track, fhMid );
661 break;
662 }
663 }
664
665 if (fPrimaryVertex && mcTrack->GetMotherId() == -1) {
666
667 // fit track to Primary Vertex
668
669 CbmStsTrack tt(*track);
670 fFitter.FitToVertex(&tt, fPrimaryVertex, tt.GetParamFirst());
671 // FillTrackHisto(mci,&tt,fhVfit);
672
673 // fill momentum resolution
674
675 double z = mci[5];
676 FairTrackParam param;
677 fFitter.Extrapolate(track, z, &param);
678 if (fabs(mci[4]) > 1.e-4 && fabs(param.GetQp()) > 1.e-4)
679 fhPq->Fill(fabs(1. / mci[4]), (mci[4] / param.GetQp() - 1.));
680 }
681
682 if (track->GetNDF() > 0) {
683 fhChi2->Fill(track->GetChi2() / track->GetNDF());
684 fhProb->Fill(TMath::Prob(track->GetChi2(), track->GetNDF()));
685 }
686 }
687 }
688
689 if (fPrimaryVertex) {
690
691 // find MC Primary vertex
692
693 TVector3 MC_V(0, 0, 0);
694 Bool_t Is_MC_V = 0;
695 {
696 TVector3 MC_Vcurr(0, 0, 0);
697 Int_t nvtracks = 0, nvtrackscurr = 0;
698 Int_t nMCTracks = fMCTrackArray->GetEntriesFast();
699 for (Int_t iTrack = 0; iTrack < nMCTracks; iTrack++) {
700 CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTrackArray->At(iTrack);
701 if (mcTrack->GetMotherId() != -1)
702 continue; // not primary track
703 double z = mcTrack->GetStartZ();
704 if (!Is_MC_V || fabs(z - MC_Vcurr.Z()) > 1.e-7) { // new vertex
705 Is_MC_V = 1;
706 if (nvtrackscurr > nvtracks) {
707 MC_V = MC_Vcurr;
708 nvtracks = nvtrackscurr;
709 }
710 mcTrack->GetStartVertex(MC_Vcurr);
711 nvtrackscurr = 1;
712 } else
713 nvtrackscurr++;
714 }
715 if (nvtrackscurr > nvtracks)
716 MC_V = MC_Vcurr;
717 }
718
719 if (Is_MC_V) {
720
721 // primary vertex fit performance
722
723 FillVertexHisto(MC_V, fPrimaryVertex, fhVtx);
724
725 if (fVertexAnalysis) {
726
727 CbmPVFinderKF Finder;
728 TClonesArray TracksToFit("CbmStsTrack");
729 Int_t N = 0;
730 for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
731 if (Quality[iTrack] < 1)
732 continue;
733 new (TracksToFit[N]) CbmStsTrack();
734 *(CbmStsTrack*)TracksToFit.At(N) = *(CbmStsTrack*)fRecStsTrackArray->At(iTrack);
735 N++;
736 if (N % 50 != 0)
737 continue;
738 Int_t i = N / 50;
739 if (i >= 13)
740 continue;
741 CbmVertex V;
742 Finder.FindPrimaryVertex(&TracksToFit, &V);
743 FillVertexHisto(MC_V, &V, fhV[i]);
744 }
745 CbmVertex V;
746 Finder.FindPrimaryVertex(&TracksToFit, &V);
747 FillVertexHisto(MC_V, &V, fhV[0]);
748 }
749
750 // D0 fit performance (if there are)
751
752 if (fD0Analysis && fabs(MC_V.Z()) < 1.e-5) {
753 // search for Kaon
754 for (Int_t iK = 0; iK < nTracks; iK++) {
755 if (Quality[iK] < 1)
756 continue;
757 CbmStsTrack* tK = (CbmStsTrack*)fRecStsTrackArray->At(iK);
758 CbmTrackMatch* m = (CbmTrackMatch*)fSTSTrackMatch->At(iK);
759 CbmMCTrack* mcK = (CbmMCTrack*)fMCTrackArray->At(m->GetMCTrackId());
760 if (mcK->GetMotherId() != -1)
761 continue; // not primary or D0 track
762 if (abs(mcK->GetPdgCode()) != 321)
763 continue;
764 double zK = mcK->GetPz();
765 if (zK - MC_V.Z() < 1.e-5)
766 continue; // primary
767 double MCPK = mcK->GetP();
768 fFitter.DoFit(tK, 321); // refit
769 // search for Pion
770 for (Int_t iP = 0; iP < nTracks; iP++) {
771 if (Quality[iP] < 1)
772 continue;
773 CbmStsTrack* tP = (CbmStsTrack*)fRecStsTrackArray->At(iP);
774 m = (CbmTrackMatch*)fSTSTrackMatch->At(iP);
775 CbmMCTrack* mcP = (CbmMCTrack*)fMCTrackArray->At(m->GetMCTrackId());
776 if (mcP->GetMotherId() != -1)
777 continue; // not primary or D0 track
778 if (abs(mcP->GetPdgCode()) != 211)
779 continue;
780 if (mcK->GetPdgCode() * mcP->GetPdgCode() >= 0)
781 continue; // same charge
782 double zP = mcP->GetStartZ();
783 if (fabs(zP - zK) > 1.e-8)
784 continue; // different vertex
785 double MCPP = mcP->GetP();
786
787 const double D0 = 1.8645;
788
789 TVector3 mc_;
790 mcK->GetStartVertex(mc_);
791
792 CbmStsKFSecondaryVertexFinder SVFinder;
793 SVFinder.AddTrack(tK);
794 SVFinder.AddTrack(tP);
795
796 for (int iconst = 0; iconst < 4; iconst++) {
797
798 switch (iconst) {
799 case 0:
800 SVFinder.SetMassConstraint(); // no constraints
801 SVFinder.SetTopoConstraint();
802 break;
803 case 1:
804 SVFinder.SetMassConstraint(); // Topo constraint
805 SVFinder.SetTopoConstraint(fPrimaryVertex);
806 break;
807 case 2:
808 SVFinder.SetMassConstraint(D0); // Mass constraint
809 SVFinder.SetTopoConstraint();
810 break;
811 case 3:
812 SVFinder.SetMassConstraint(D0); // Topo + Mass constraint
813 SVFinder.SetTopoConstraint(fPrimaryVertex);
814 break;
815 default:
816 break;
817 }
818 SVFinder.Fit();
819 CbmVertex sv;
820 // FairTrackParam KFitted, PFitted;
821 Double_t mass, mass_err;
822 SVFinder.GetVertex(sv);
823 // SVFinder.GetFittedTrack(0, &KFitted );
824 // SVFinder.GetFittedTrack(1, &PFitted );
825 SVFinder.GetMass(&mass, &mass_err);
826 if (sv.GetNDF() <= 0)
827 continue;
828 Double_t dx = sv.GetX() - mc_.X();
829 Double_t dy = sv.GetY() - mc_.Y();
830 Double_t dz = sv.GetZ() - mc_.Z();
831 Double_t sx = sv.GetCovariance(0, 0);
832 Double_t sy = sv.GetCovariance(1, 1);
833 Double_t sz = sv.GetCovariance(2, 2);
834 fhD0[iconst][0]->Fill(1.E4 * dx);
835 fhD0[iconst][1]->Fill(1.E4 * dy);
836 fhD0[iconst][2]->Fill(1.E4 * dz);
837 if (sx > 1.e-10)
838 fhD0[iconst][3]->Fill(dx / sqrt(sx));
839 if (sy > 1.e-10)
840 fhD0[iconst][4]->Fill(dy / sqrt(sy));
841 if (sz > 1.e-10)
842 fhD0[iconst][5]->Fill(dz / sqrt(sz));
843 if (sv.GetNDF() > 0) {
844 fhD0[iconst][6]->Fill(sv.GetChi2() / sv.GetNDF());
845 fhD0[iconst][7]->Fill(TMath::Prob(sv.GetChi2(), sv.GetNDF()));
846 }
847 fhD0[iconst][8]->Fill((mass - D0));
848 if (mass_err > 1.e-10)
849 fhD0[iconst][9]->Fill((mass - D0) / mass_err);
850 // fhD0[iconst][10]->Fill( ( fabs(1./KFitted.GetQp()) - MCPK)/MCPK );
851 // fhD0[iconst][11]->Fill( (fabs(1./PFitted.GetQp()) - MCPP)/MCPP );
852 if (fabs(tK->GetParamFirst()->GetQp()) > 1.e-4 && MCPK > 1.e-4)
853 fhD0[iconst][12]->Fill((fabs(1. / tK->GetParamFirst()->GetQp()) - MCPK) / MCPK);
854 if (fabs(tP->GetParamFirst()->GetQp()) > 1.e-4 && MCPP > 1.e-4)
855 fhD0[iconst][13]->Fill((fabs(1. / tP->GetParamFirst()->GetQp()) - MCPP) / MCPP);
856 }
857 }
858 }
859 }
860 }
861 } // vertex analysis
862}
863// -------------------------------------------------------------------------
864
865// ----- Finish CbmStsFitPerformanceTask task -----------------------------
870// -------------------------------------------------------------------------
871
872// -------------------------------------------------------------------------
873void CbmStsFitPerformanceTask::FillTrackHisto(const Double_t mc[6], CbmStsTrack* track, TH1D* hist[10])
874{
875 if ((mc[5] > 31.0) || (mc[5] < 29.0)) {
876 // cout << " Z out " << track->GetParamFirst()->GetZ() << endl;
877 // return;
878 }
879 // cout << "*Z in " << track->GetParamFirst()->GetZ() << endl;
880 double z = mc[5];
881 FairTrackParam param;
882 // cout<<1<<endl;
883 fFitter.Extrapolate(track, z, &param);
884 // cout<<2<<endl;
885
886 double t[6], c[15];
887 CbmKFMath::CopyTrackParam2TC(&param, t, c);
888 Bool_t ok = 1;
889 for (int i = 0; i < 6; i++)
890 ok = ok && finite(t[i]);
891 for (int i = 0; i < 15; i++)
892 ok = ok && finite(c[i]);
893 if (!ok)
894 return;
895 // fhExtraTracks2ndMVD->Fill(t[0], t[1]);
896
897 hist[0]->Fill(1.E4 * (t[0] - mc[0]));
898 hist[1]->Fill(1.E4 * (t[1] - mc[1]));
899 hist[2]->Fill(1.E3 * (t[2] - mc[2]));
900 hist[3]->Fill(1.E3 * (t[3] - mc[3]));
901 if (fabs(t[4]) > 1.e-10)
902 hist[4]->Fill((mc[4] / t[4] - 1.));
903 // if (z < 7.0) // first hit
904 // if ( fabs( t[4] )>1.e-10 ) fhRes_vs_Mom_f->Fill(fabs(1.0/t[4]),1.E3*(t[2] - mc[2]));
905 // if (z > 80.0) // last hit
906 // if ( fabs( t[4] )>1.e-10 ) fhRes_vs_Mom_l->Fill(fabs(1.0/t[4]),1.E3*(t[2] - mc[2]));
907
908 if (c[0] > 1.e-10)
909 hist[5]->Fill((t[0] - mc[0]) / sqrt(c[0]));
910 if (c[2] > 1.e-10)
911 hist[6]->Fill((t[1] - mc[1]) / sqrt(c[2]));
912 if (c[5] > 1.e-10)
913 hist[7]->Fill((t[2] - mc[2]) / sqrt(c[5]));
914 if (c[9] > 1.e-10)
915 hist[8]->Fill((t[3] - mc[3]) / sqrt(c[9]));
916 if (c[14] > 1.e-10)
917 hist[9]->Fill((t[4] - mc[4]) / sqrt(c[14]));
918}
919// -------------------------------------------------------------------------
920
921void CbmStsFitPerformanceTask::FillVertexHisto(TVector3& mc, CbmVertex* V, TH1D* hist[8])
922{
923 Double_t dx = V->GetX() - mc.X();
924 Double_t dy = V->GetY() - mc.Y();
925 Double_t dz = V->GetZ() - mc.Z();
926 Double_t s2x = V->GetCovariance(0, 0);
927 Double_t s2y = V->GetCovariance(1, 1);
928 Double_t s2z = V->GetCovariance(2, 2);
929
930 hist[0]->Fill(1.E4 * dx);
931 hist[1]->Fill(1.E4 * dy);
932 hist[2]->Fill(1.E4 * dz);
933 if (s2x > 1.e-10)
934 hist[3]->Fill(dx / sqrt(s2x));
935 if (s2y > 1.e-10)
936 hist[4]->Fill(dy / sqrt(s2y));
937 if (s2z > 1.e-10)
938 hist[5]->Fill(dz / sqrt(s2z));
939 hist[6]->Fill(V->GetChi2() / V->GetNDF());
940 hist[7]->Fill(TMath::Prob(V->GetChi2(), V->GetNDF()));
941 hist[8]->Fill(V->GetNTracks());
942}
943
944// -------------------------------------------------------------------------
945void CbmStsFitPerformanceTask::FillMCStateVectors(CbmStsPoint* point, Double_t mc[], Bool_t out)
946{
947 if (!point)
948 return;
949 Int_t mcTrackID = point->GetTrackID();
950 CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTrackArray->At(mcTrackID);
951 if (!mcTrack)
952 return;
953 Double_t q = GetCharge(mcTrack);
954
955 // Get MC state vector
956 TVector3 r, p;
957 if (!out) {
958 point->Momentum(p);
959 point->Position(r);
960 } else {
961 point->MomentumOut(p);
962 point->PositionOut(r);
963 }
964 double pzi = p.z();
965 if (fabs(pzi) > 1.e-4)
966 pzi = 1. / pzi;
967 mc[2] = p.x() * pzi;
968 mc[3] = p.y() * pzi;
969 mc[4] = p.Mag() > 1.e-4 ? q / p.Mag() : 0;
970 mc[0] = r.x();
971 mc[1] = r.y();
972 mc[5] = r.z();
973}
974
975void CbmStsFitPerformanceTask::FillMCStateVectors(CbmMvdPoint* point, Double_t mc[], Bool_t out)
976{
977 if (!point)
978 return;
979 Int_t mcTrackID = point->GetTrackID();
980 CbmMCTrack* mcTrack = (CbmMCTrack*)fMCTrackArray->At(mcTrackID);
981 if (!mcTrack)
982 return;
983 Double_t q = GetCharge(mcTrack);
984
985 // Get MC state vector
986 TVector3 r, p;
987 if (!out) {
988 point->Momentum(p);
989 point->Position(r);
990 } else {
991 point->MomentumOut(p);
992 point->PositionOut(r);
993 }
994 double pzi = p.z();
995 if (fabs(pzi) > 1.e-4)
996 pzi = 1. / pzi;
997 mc[2] = p.x() * pzi;
998 mc[3] = p.y() * pzi;
999 mc[4] = p.Mag() > 1.e-4 ? q / p.Mag() : 0;
1000 mc[0] = r.x();
1001 mc[1] = r.y();
1002 mc[5] = r.z();
1003}
1004
1005// ----- GetCharge ----------------------------------------------------
1006Double_t CbmStsFitPerformanceTask::GetCharge(CbmMCTrack* mcTrack)
1007{
1008 Double_t q;
1009 Int_t pdgCode = mcTrack->GetPdgCode();
1010 TParticlePDG* particlePDG = TDatabasePDG::Instance()->GetParticle(pdgCode);
1011 if (particlePDG)
1012 q = particlePDG->Charge() / 3.;
1013 else
1014 q = 0;
1015 return q;
1016}
1017
1018// -------------------------------------------------------------------------
1019Bool_t CbmStsFitPerformanceTask::IsLong(CbmStsTrack* track)
1020{
1021 Int_t nHits = track->GetNStsHits();
1022 if (nHits < 4)
1023 return 0;
1024 Int_t stmin = 1000, stmax = -1000;
1025 Int_t st, iHit, hitID;
1026 for (iHit = 0; iHit < nHits; iHit++) {
1027 hitID = track->GetStsHitIndex(iHit);
1028 st = ((CbmStsHit*)fStsHitArray->At(hitID))->GetDetectorID();
1029 if (st < stmin)
1030 stmin = st;
1031 if (st > stmax)
1032 stmax = st;
1033 }
1034 if (stmax - stmin + 1 < 4)
1035 return 0;
1036 return 1;
1037}
writedir2current
void writedir2current(TObject *obj)
Definition CbmStsFitPerformanceTask.cxx:42
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition P4_F32vec4.h:52
v
__m128 v
Definition P4_F32vec4.h:1
i
int i
Definition P4_F32vec4.h:22
m
__m128 m
Definition P4_F32vec4.h:27
Bool_t
bool Bool_t
Int_t
int Int_t
Double_t
double Double_t
Option_t
const char Option_t
gDirectory
#define gDirectory
CbmHit::GetCovXY
Double_t GetCovXY() const
Accessors.
Definition CbmHit.h:41
CbmKFMath::CopyTrackParam2TC
static void CopyTrackParam2TC(FairTrackParam *par, Double_t T[], Double_t C[])
Definition CbmKFMath.cxx:790
CbmKFMath::invS
static Bool_t invS(Double_t A[], Int_t N)
Definition CbmKFMath.cxx:225
CbmKFMath::indexS
static Int_t indexS(Int_t i, Int_t j)
Definition CbmKFMath.h:40
CbmKF
The CbmKF Kalman Filter algorithm.
Definition CbmKF.h:28
CbmKF::MvdStationIDMap
std::map< Int_t, Int_t > MvdStationIDMap
Definition CbmKF.h:74
CbmKF::Instance
static CbmKF * Instance()
Definition CbmKF.h:34
CbmKF::StsStationIDMap
std::map< Int_t, Int_t > StsStationIDMap
Definition CbmKF.h:75
CbmMCTrack
CbmMCTrack.h.
Definition CbmMCTrack.h:26
CbmMCTrack::GetPy
Double_t GetPy() const
Definition CbmMCTrack.h:59
CbmMCTrack::GetPz
Double_t GetPz() const
Definition CbmMCTrack.h:60
CbmMCTrack::GetPx
Double_t GetPx() const
Definition CbmMCTrack.h:58
CbmMCTrack::GetStartZ
Double_t GetStartZ() const
Definition CbmMCTrack.h:63
CbmMCTrack::GetStartY
Double_t GetStartY() const
Definition CbmMCTrack.h:62
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition CbmMCTrack.h:57
CbmMCTrack::GetP
Double_t GetP() const
Definition CbmMCTrack.h:68
CbmMCTrack::GetStartX
Double_t GetStartX() const
Definition CbmMCTrack.h:61
CbmMCTrack::GetStartVertex
void GetStartVertex(TVector3 &vertex) const
Definition CbmMCTrack.h:149
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Accessors.
Definition CbmMCTrack.h:56
CbmMvdHit
CbmMvdHit.h.
Definition CbmMvdHit.h:26
CbmMvdHit::GetStationNr
virtual Int_t GetStationNr() const
Definition CbmMvdHit.h:48
CbmMvdPoint
CbmMvdPoint.h.
Definition CbmMvdPoint.h:27
CbmMvdPoint::MomentumOut
void MomentumOut(TVector3 &mom)
Definition CbmMvdPoint.h:75
CbmMvdPoint::PositionOut
void PositionOut(TVector3 &pos)
Definition CbmMvdPoint.h:74
CbmPVFinderKF
CbmPVFinderKF.
Definition CbmPVFinderKF.h:13
CbmPVFinderKF::FindPrimaryVertex
Int_t FindPrimaryVertex(TClonesArray *tracks, CbmVertex *vertex)
Execution of PV finding.
Definition CbmPVFinderKF.cxx:10
CbmStsFitPerformanceTask::Exec
void Exec(Option_t *option)
Execute task.
Definition CbmStsFitPerformanceTask.cxx:372
CbmStsFitPerformanceTask::fMCTrackArray
TClonesArray * fMCTrackArray
MCTracks.
Definition CbmStsFitPerformanceTask.h:85
CbmStsFitPerformanceTask::FillMCStateVectors
void FillMCStateVectors(CbmStsPoint *point, Double_t mc[], Bool_t out=0)
This function fill state vectors t[], mc[] and covariance matrix c[] from the given FairTrackParam ob...
Definition CbmStsFitPerformanceTask.cxx:945
CbmStsFitPerformanceTask::IsLong
Bool_t IsLong(CbmStsTrack *track)
Returns 1 if track has >=8 measurements and stMaxID-stMinID>=4.
Definition CbmStsFitPerformanceTask.cxx:1019
CbmStsFitPerformanceTask::fMvdHitArray
TClonesArray * fMvdHitArray
Sts hits.
Definition CbmStsFitPerformanceTask.h:90
CbmStsFitPerformanceTask::fStsHitArray
TClonesArray * fStsHitArray
Sts hits.
Definition CbmStsFitPerformanceTask.h:89
CbmStsFitPerformanceTask::fPrimaryVertex
CbmVertex * fPrimaryVertex
Primary vertex.
Definition CbmStsFitPerformanceTask.h:91
CbmStsFitPerformanceTask::CbmStsFitPerformanceTask
CbmStsFitPerformanceTask(const char *name="CbmStsFitPerformanceTask", Int_t iVerbose=1)
Standard constructor.
Definition CbmStsFitPerformanceTask.cxx:145
CbmStsFitPerformanceTask::Init
InitStatus Init()
Initialization of the task.
Definition CbmStsFitPerformanceTask.cxx:219
CbmStsFitPerformanceTask::fSTSTrackMatch
TClonesArray * fSTSTrackMatch
Related MC tracks.
Definition CbmStsFitPerformanceTask.h:92
CbmStsFitPerformanceTask::fMvdPointArray
TClonesArray * fMvdPointArray
StsPoints.
Definition CbmStsFitPerformanceTask.h:87
CbmStsFitPerformanceTask::ReInit
InitStatus ReInit()
ReInitialization of the task.
Definition CbmStsFitPerformanceTask.cxx:353
CbmStsFitPerformanceTask::GetCharge
Double_t GetCharge(CbmMCTrack *mcTrack)
Definition CbmStsFitPerformanceTask.cxx:1006
CbmStsFitPerformanceTask::fRecStsTrackArray
TClonesArray * fRecStsTrackArray
Reconstructed StsTracks.
Definition CbmStsFitPerformanceTask.h:88
CbmStsFitPerformanceTask::CreateTrackHisto
void CreateTrackHisto(TH1D *hist[10], const char *name, const char *title)
Definition CbmStsFitPerformanceTask.cxx:58
CbmStsFitPerformanceTask::FillVertexHisto
void FillVertexHisto(TVector3 &mc, CbmVertex *V, TH1D *hist[8])
This function fills vertex pulls and residuals.
Definition CbmStsFitPerformanceTask.cxx:921
CbmStsFitPerformanceTask::FillTrackHisto
void FillTrackHisto(const Double_t mc[6], CbmStsTrack *track, TH1D *hist[10])
This function fills track pulls and residuals at certain z-position.
Definition CbmStsFitPerformanceTask.cxx:873
CbmStsFitPerformanceTask::CreateD0Histo
void CreateD0Histo(TH1D *hist[14], const char *name, const char *title)
Definition CbmStsFitPerformanceTask.cxx:113
CbmStsFitPerformanceTask::fStsPointArray
TClonesArray * fStsPointArray
StsPoints.
Definition CbmStsFitPerformanceTask.h:86
CbmStsFitPerformanceTask::CreateVertexHisto
void CreateVertexHisto(TH1D *hist[9], const char *name, const char *title)
Definition CbmStsFitPerformanceTask.cxx:85
CbmStsHit::GetStationNr
virtual Int_t GetStationNr() const
Definition CbmStsHit.h:67
CbmStsHit::GetDigi
Int_t GetDigi(Int_t iSide) const
Definition CbmStsHit.cxx:120
CbmStsKFSecondaryVertexFinder
The CbmStsKFSecondaryVertexFinder class.
Definition CbmStsKFSecondaryVertexFinder.h:21
CbmStsKFSecondaryVertexFinder::SetMassConstraint
void SetMassConstraint(Double_t MotherMass=-1)
Definition CbmStsKFSecondaryVertexFinder.cxx:41
CbmStsKFSecondaryVertexFinder::GetMass
void GetMass(Double_t *M, Double_t *Error)
Definition CbmStsKFSecondaryVertexFinder.cxx:98
CbmStsPoint::PositionOut
void PositionOut(TVector3 &pos)
Definition CbmStsPoint.h:74
CbmStsPoint::MomentumOut
void MomentumOut(TVector3 &mom)
Definition CbmStsPoint.h:75
CbmStsTrack::GetParamLast
FairTrackParam * GetParamLast()
Definition CbmStsTrack.h:70
CbmStsTrack::GetNMvdHits
Int_t GetNMvdHits() const
Definition CbmStsTrack.h:61
CbmStsTrack::GetMvdHitIndex
Int_t GetMvdHitIndex(Int_t iHit) const
Definition CbmStsTrack.h:63
CbmStsTrack::GetNStsHits
Int_t GetNStsHits() const
Accessors.
Definition CbmStsTrack.h:60
CbmStsTrack::GetChi2
Double_t GetChi2() const
Definition CbmStsTrack.h:66
CbmStsTrack::GetStsHitIndex
Int_t GetStsHitIndex(Int_t iHit) const
Definition CbmStsTrack.h:62
CbmStsTrack::GetParamFirst
FairTrackParam * GetParamFirst()
Definition CbmStsTrack.h:69
CbmStsTrack::GetNDF
Int_t GetNDF() const
Definition CbmStsTrack.h:67
CbmTrackMatch
CbmStsTrackMatch.h.
Definition CbmTrackMatch.h:16
CbmVertex
CbmVertex.h.
Definition CbmVertex.h:21
CbmVertex::GetZ
Double_t GetZ() const
Definition CbmVertex.h:60
CbmVertex::GetX
Double_t GetX() const
Accessors.
Definition CbmVertex.h:58
CbmVertex::GetChi2
Double_t GetChi2() const
Definition CbmVertex.h:61
CbmVertex::GetCovariance
Double_t GetCovariance(Int_t i, Int_t j) const
Definition CbmVertex.cxx:115
CbmVertex::GetY
Double_t GetY() const
Definition CbmVertex.h:59
CbmVertex::GetNDF
Int_t GetNDF() const
Definition CbmVertex.h:62
TDatabasePDG::Instance
static TDatabasePDG * Instance()
TDatabasePDG::GetParticle
TParticlePDG * GetParticle(const char *name) const
TDirectory::cd
virtual Bool_t cd()
TDirectory::mkdir
virtual TDirectory * mkdir(const char *name, const char *title="", Bool_t returnExistingDirectory=kFALSE)
TH1::Fill
virtual Int_t Fill(const char *name, Double_t w)
TObjArray::At
TObject * At(Int_t idx) const override
TObject::IsFolder
virtual Bool_t IsFolder() const
TObject::GetName
virtual const char * GetName() const
TObject::Write
virtual Int_t Write(const char *name=nullptr, Int_t option=0, Int_t bufsize=0)
TParticlePDG::Charge
Double_t Charge() const
TVector3::Z
Double_t Z() const
TVector3::Y
Double_t Y() const
TVector3::X
Double_t X() const
TVector3::z
Double_t z() const
TVector3::x
Double_t x() const
TVector3::Mag
Double_t Mag() const
TVector3::y
Double_t y() const
abs
RVec< PromoteType< T > > abs(const RVec< T > &v)
sqrt
RVec< PromoteType< T > > sqrt(const RVec< T > &v)
n
*brief user defined string literal for JSON values *sa std::size_t n
Definition json.hpp:20362
TMath::Prob
Double_t Prob(Double_t chi2, Int_t ndf)
TMath::Sqrt
Double_t Sqrt(Double_t x)
TMath::Abs
Double_t Abs(Double_t d)