AliRoot Core  3dc7879 (3dc7879)
AliMFTTracker.cxx
Go to the documentation of this file.
1 /*************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15 
16 
17 #include "TTree.h"
18 #include "TSystem.h"
19 #include "TMath.h"
20 #include "TArrayF.h"
21 #include "TGrid.h"
22 
23 #include "AliCodeTimer.h"
24 #include "AliLog.h"
25 #include "AliGeomManager.h"
26 #include "AliESDEvent.h"
27 #include "AliESDMuonTrack.h"
28 #include "AliESDMuonGlobalTrack.h"
29 #include "AliMFTTracker.h"
30 #include "AliMFTTrack.h"
31 #include "AliRun.h"
32 #include "AliRunLoader.h"
33 #include "AliHeader.h"
34 #include "AliGenEventHeader.h"
35 #include "AliMFT.h"
36 #include "AliMUONTrackExtrap.h"
37 #include "AliMUONTrack.h"
38 #include "AliMUONESDInterface.h"
39 #include "AliMuonForwardTrack.h"
40 #include "AliMUONConstants.h"
41 #include "AliMUONRawClusterV2.h"
42 #include "AliMFTTrack.h"
43 #include "AliMFTTrackFinder.h"
44 #include "AliMFTCATrack.h"
45 #include "AliMFTCACell.h"
46 #include "AliMFTGeometry.h"
47 #include "AliMFTHalfSegmentation.h"
50 #include "AliMUONTrackParam.h"
51 
53 ClassImp(AliMFTTracker);
55 
57 
62  AliTracker(),
63  fESD(0),
64  fMFT(0),
65  fSegmentation(NULL),
66  fTrackFinder(0),
67  fNPlanesMFT(0),
68  fNPlanesMFTAnalyzed(0),
69  fSigmaClusterCut(2),
70  fScaleSigmaClusterCut(1.),
71  fNMaxMissingMFTClusters(0),
72  fGlobalTrackingDiverged(kFALSE),
73  fCandidateTracks(0),
74  fMFTTracks(0),
75  fMUONTrack(0),
76  fCurrentTrack(0),
77  fFinalBestCandidate(0),
78  fXExtrapVertex(0),
79  fYExtrapVertex(0),
80  fZExtrapVertex(0),
81  fXExtrapVertexError(0),
82  fYExtrapVertexError(0),
83  fXVertexMC(0),
84  fYVertexMC(0),
85  fZVertexMC(0),
86  fBransonCorrection(kFALSE)
87 {
90  if (!fSegmentation) AliFatal("No segmentation available");
91 
92  fMFT = (AliMFT*) gAlice->GetDetector("MFT");
94  fTrackFinder->Init(gSystem->ExpandPathName("$(ALICE_ROOT)/ITSMFT/MFT/data/param_10ch.txt" ));
96  AliMUONTrackExtrap::SetField(); // set the magnetic field for track extrapolations
97 
98  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
99  fMFTClusterArray[iPlane] = new TClonesArray("AliMFTCluster");
100  fMFTClusterArrayFront[iPlane] = new TClonesArray("AliMFTCluster");
101  fMFTClusterArrayBack[iPlane] = new TClonesArray("AliMFTCluster");
102  fMFTClusterArray[iPlane] -> SetOwner(kTRUE);
103  fMFTClusterArrayFront[iPlane] -> SetOwner(kTRUE);
104  fMFTClusterArrayBack[iPlane] -> SetOwner(kTRUE);
105  fMinResearchRadiusAtPlane[iPlane] = 0.;
106  }
107 
108  fCandidateTracks = new TClonesArray("AliMuonForwardTrack",50000);
109  fMFTTracks = new TClonesArray("AliMFTTrack",100);
110  fMFTTracks -> SetOwner(kTRUE);
111 
112 }
113 
114 //====================================================================================================================================================
115 
117 
118  // destructor
119 
120  delete fTrackFinder;
121 
122  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
123  fMFTClusterArray[iPlane] -> Delete();
124  delete fMFTClusterArray[iPlane];
125  delete fMFTClusterArrayFront[iPlane];
126  delete fMFTClusterArrayBack[iPlane];
127  }
128 
129  delete fCandidateTracks;
130  delete fMFTTracks;
131 
132 }
133 
134 //==============================================================================================
141 Int_t AliMFTTracker::LoadClusters(TTree *cTree) {
142 
143  AliCodeTimerAuto("",0);
144 
145  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
146  AliDebug(1, Form("Setting Address for Branch Plane_%02d", iPlane));
147  cTree->SetBranchAddress(Form("Plane_%02d",iPlane), &fMFTClusterArray[iPlane]);
148  }
149 
150  if (!cTree->GetEvent()) return kFALSE;
151  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
152  AliInfo(Form("plane %02d: nClusters = %d", iPlane, fMFTClusterArray[iPlane]->GetEntries()));
153  }
154 
155  //AddClustersFromUnderlyingEvent();
156  //AddClustersFromPileUpEvents();
157 
159 
161 
162  return 0;
163 
164 }
165 //==============================================================================================
169 
171 
172  AliCodeTimerAuto("",0);
173 
174  Int_t nTracks = fTrackFinder->GetNtracks();
175  AliMFTCATrack * catrack = NULL;
176  for (Int_t i = 0 ; i < nTracks; i++) {
177  catrack = fTrackFinder->GetTrack(i);
178  new ((*fMFTTracks)[i]) AliMFTTrack(catrack);
179  LinearFit((AliMFTTrack*)fMFTTracks->At(i));
180  }
181 
182 }
183 
184 //==============================================================================================
185 
187 
188  //--------------------------------------------------------------------
189  // This function unloads MFT clusters
190  //--------------------------------------------------------------------
191 
192  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
193  fMFTClusterArray[iPlane] -> Clear("C");
194  fMFTClusterArrayFront[iPlane] -> Clear("C");
195  fMFTClusterArrayBack[iPlane] -> Clear("C");
196  }
197 
198 }
199 
200 //==============================================================================================
201 
203  AliCodeTimerAuto("",0);
204 
205  // Int_t nGlobalTrack = 0;
206  //--------------------------------------------------------------------
207  // This functions reconstructs the Muon Forward Tracks
208  // The clusters must be already loaded !
209  //--------------------------------------------------------------------
210 
211  // Tree of AliMuonForwardTrack objects. Created outside the ESD framework for cross-check purposes
212 
213  Double_t xVertex = 0., yVertex = 0., zVertex = 0.;
214  Double_t zvr[2] = {0.,0.};
215 
216  const AliESDVertex* esdVert = event->GetVertex();
217  if (esdVert->GetNContributors() > 0 || !strcmp(esdVert->GetTitle(),"vertexer: smearMC")) {
218  xVertex = esdVert->GetX();
219  yVertex = esdVert->GetY();
220  zVertex = esdVert->GetZ();
221  zvr[0] = zVertex - 3.*AliMFTConstants::fPrimaryVertexResZ; // 5 microns
222  zvr[1] = zVertex + 3.*AliMFTConstants::fPrimaryVertexResZ;
223  GetVertexFromMC();
224  } else {
225  printf("No vertex in ESD! Get it from MC.\n");
226  GetVertexFromMC();
227  xVertex = fXExtrapVertex;
228  yVertex = fYExtrapVertex;
229  zVertex = fZExtrapVertex;
230  zvr[0] = zVertex - 3.*AliMFTConstants::fPrimaryVertexResZ; // 5 microns
231  zvr[1] = zVertex + 3.*AliMFTConstants::fPrimaryVertexResZ;
232  }
233 
234  //printf("Vertex: %f %f %f \n",zvr[0],zvr[1],zVertex);
235  fTrackFinder->SetZVertRange(zvr,zVertex);
236 
240 
241  LoadTracks();
242 
243  //AliInfo(" ------ Print TrackFinder Out -------");
244  //
245  //fTrackFinder->PrintAll();
246 
247  AliInfo("Track Finder Done");
248  // Reconstruction of the MFT tracks from the Tracks found by the Cellular Automaton
249 
251  trackReco->EventReconstruct(fMFTTracks);
252  // ----> Standalone track reconstruction done
253 
254  Int_t nTracksMUON = event->GetNumberOfMuonTracks();
255  Int_t nTracksMFT = fTrackFinder->GetNtracks();
256 
257  AliMFTCATrack * caTrack = NULL;
258  AliMUONTrack * muonTrack = NULL;
259  AliMFTCACell * caCell = NULL;
260  AliMuonForwardTrack * mfwdTrack = NULL;
261 
262  Double_t equivalentSilicon = 0.0028;
263  Double_t equivalentSiliconBeforeFront = 0.0028;
264  Double_t equivalentSiliconBeforeBack = 0.0050;
265 
266  Double_t zEndOfMFTTrack,
270  Int_t planeID[AliMFTConstants::fNMaxPlanes];
271 
272  Double_t phic, phicp, phis;
273  Short_t trackCharge;
274  Double_t caTrackPhi, caTrackThe, caTrackOrg[3], caTrackBegOfAbs[3];
275  Double_t Ux, Uy, Uz, Tx, Ty, Tz;
276  Double_t addChi2TrackAtCluster = 0.;
277  AliMUONTrackParam trackParamMM, trackParamMM0;
278  AliMUONRawCluster *muonCluster = 0x0;
279 
281  for (Int_t i = 0; i < AliMFTConstants::fNMaxPlanes; i++) {
282  mftCluster[i] = 0x0;
283  }
284 
285  Bool_t saveAllMatch = kTRUE;
286 
287  Double_t chi2cut = 2.0;
288 
289  AliInfo(Form("Number of ESD MUON tracks: %d\n", nTracksMUON));
290 
291  TFile *outputFileMFTTracks = new TFile("MFT.Tracks.root", "update");
292 
293  Int_t myEventID = 0;
294  while (outputFileMFTTracks->cd(Form("Event%d",myEventID))) myEventID++;
295  outputFileMFTTracks->mkdir(Form("Event%d",myEventID));
296  outputFileMFTTracks->cd(Form("Event%d",myEventID));
297 
298  TTree *outputTreeMFTTracks = new TTree("MFTTracks", "Tree of MFT tracks");
299  TClonesArray *mftTracks = new TClonesArray("AliMFTCATrack");
300  outputTreeMFTTracks->Branch("tracks", &mftTracks);
301 
302  TTree *outputTreeMuonForwardTracks = new TTree("MuonForwardTracks", "Tree of muon forward racks");
303  TClonesArray *mfwdTracks = new TClonesArray("AliMuonForwardTrack");
304  outputTreeMuonForwardTracks->Branch("tracks", &mfwdTracks);
305 
306  TTree *outputTreeEvent = new TTree("Events", "Tree of events");
307  outputTreeEvent->Branch("fXVertexMC", &fXVertexMC);
308  outputTreeEvent->Branch("fYVertexMC", &fYVertexMC);
309  outputTreeEvent->Branch("fZVertexMC", &fZVertexMC);
310 
311  TTree *outputTreeMFTCells = new TTree("MFTCells", "Tree of MFT CA cells");
312  TClonesArray *mftCells = new TClonesArray("AliMFTCACell");
313  outputTreeMFTCells->Branch("cells", &mftCells);
314 
315  Int_t iTrack=0, iTrackMatchA=0, iTrackMatchB=0, iTotalCells=0;
316  while (iTrack < nTracksMUON) {
317 
318  const AliESDMuonTrack *esdTrack = event->GetMuonTrack(iTrack);
319 
320  trackCharge = esdTrack->Charge();
321 
322  if (muonTrack) delete muonTrack;
323  muonTrack = new AliMUONTrack();
324  AliMUONESDInterface::ESDToMUON(*esdTrack, *muonTrack, kFALSE);
325 
326  if (!muonTrack->GetTrackParamAtCluster()->First()) {
327  AliInfo("Skipping track, no parameters available!!!");
328  iTrack++;
329  continue;
330  }
331  //printf("Muon track %d start chi2: %f , %f , %d \n",iTrack,muonTrack->GetGlobalChi2(),muonTrack->GetGlobalChi2()/muonTrack->GetNDF(),muonTrack->GetNDF());
332 
333  if (mfwdTrack) delete mfwdTrack;
334  mfwdTrack = new AliMuonForwardTrack(*muonTrack);
335 
336  // go with the track param to the vertex x,y,z (with Branson) or
337  // to vertex z (without Branson)
338 
339  trackParamMM = (*((AliMUONTrackParam*)(mfwdTrack->GetTrackParamAtCluster()->First())));
340 
341  if (fBransonCorrection) {
343  } else {
345  }
346  // copy to save this track param
347  trackParamMM0 = trackParamMM;
348 
349  for (Int_t iTrackMFT = 0 ; iTrackMFT < nTracksMFT; iTrackMFT++) {
350 
351  caTrack = fTrackFinder->GetTrack(iTrackMFT);
352 
353  caTrackPhi = caTrack->GetPhi();
354  caTrackThe = caTrack->GetTheta();
355  caTrackOrg[0] = caTrack->GetVertX();
356  caTrackOrg[1] = caTrack->GetVertY();
357  caTrackOrg[2] = caTrack->GetVertZ();
358 
359  caTrackPhi *= TMath::DegToRad();
360  caTrackThe *= TMath::DegToRad();
361 
362  Ux = TMath::Sin(caTrackThe)*TMath::Cos(caTrackPhi);
363  Uy = TMath::Sin(caTrackThe)*TMath::Sin(caTrackPhi);
364  Uz = TMath::Cos(caTrackThe);
365  /*
366  caTrackBegOfAbs[2] = zBegOfAbsorber;
367 
368  Tz = caTrackBegOfAbs[2] - caTrackOrg[2];
369  caTrackBegOfAbs[0] = caTrackOrg[0] + Ux*Tz;
370  caTrackBegOfAbs[1] = caTrackOrg[1] + Uy*Tz;
371 
372  printf("CATrack: %3d %10.4f %10.4f %10.4f %d \n",iTrackMFT,caTrackBegOfAbs[0],caTrackBegOfAbs[1],caTrackBegOfAbs[2],caTrack->GetMCindex());
373  */
374  // extract hit x,y,z from the cells
375  Int_t mftClsId1, mftClsId2, layer1, layer2;
376  Int_t nptr = 0;
377  AliMFTCluster *cls1, *cls2;
378  for (Int_t iCell = 0; iCell < caTrack->GetNcells(); iCell++) {
379 
380  caCell = caTrack->GetCell(iCell);
381  caTrack->SetCellGID(iCell,iTotalCells);
382 
383  mftClsId1 = caCell->GetMFTClsId()[0];
384  mftClsId2 = caCell->GetMFTClsId()[1];
385  layer1 = caCell->GetLayers()[0];
386  layer2 = caCell->GetLayers()[1];
387  if (layer1%2 == 0) { // FRONT
388  cls1 = (AliMFTCluster*)fMFTClusterArrayFront[layer1/2]->At(mftClsId1);
389  } else { // BACK
390  cls1 = (AliMFTCluster*)fMFTClusterArrayBack[layer1/2]->At(mftClsId1);
391  }
392  if (layer2%2 == 0) { // FRONT
393  cls2 = (AliMFTCluster*)fMFTClusterArrayFront[layer2/2]->At(mftClsId2);
394  } else { // BACK
395  cls2 = (AliMFTCluster*)fMFTClusterArrayBack[layer2/2]->At(mftClsId2);
396  }
397 
398  //printf("Cell %5d MFTClsId %5d %5d \n",iCell,mftClsId1,mftClsId2);
399  //printf("Cls1: %10.4f %10.4f %10.4f \n",cls1->GetX(),cls1->GetY(),cls1->GetZ());
400  //printf("Cls2: %10.4f %10.4f %10.4f \n",cls2->GetX(),cls2->GetY(),cls2->GetZ());
401 
402  new ((*mftCells)[iTotalCells++]) AliMFTCACell(*caCell);
403 
404  if (nptr == 0) {
405  xTr[nptr] = caCell->GetHit2()[0];
406  yTr[nptr] = caCell->GetHit2()[1];
407  zTr[nptr] = caCell->GetHit2()[2];
408  planeID[nptr] = caCell->GetLayers()[1];
409  mftCluster[nptr] = cls2;
410  nptr++;
411  xTr[nptr] = caCell->GetHit1()[0];
412  yTr[nptr] = caCell->GetHit1()[1];
413  zTr[nptr] = caCell->GetHit1()[2];
414  planeID[nptr] = caCell->GetLayers()[0];
415  mftCluster[nptr] = cls1;
416  nptr++;
417  } else {
418  xTr[nptr] = caCell->GetHit1()[0];
419  yTr[nptr] = caCell->GetHit1()[1];
420  zTr[nptr] = caCell->GetHit1()[2];
421  planeID[nptr] = caCell->GetLayers()[0];
422  mftCluster[nptr] = cls1;
423  nptr++;
424  }
425  } // end loop over cells
426 
427  // estimate the charge sign
428  phis = 0.;
429  for (Int_t iptr = 0; iptr < nptr; iptr++) {
430  phic = TMath::ATan(yTr[iptr]/xTr[iptr])*TMath::RadToDeg();
431  phic += 90.;
432  if (iptr > 0) {
433  phis += phic-phicp;
434  }
435  phicp = phic;
436  }
437 
438  caCell = caTrack->GetCell(0);
439 
440  caTrack->SetChargeSign(-(Short_t)(TMath::Sign(1.,phis)));
441 
442  // match by MC label
443  if (saveAllMatch || caTrack->GetMCindex() == muonTrack->GetMCLabel()) {
444 
445  if (saveAllMatch) {
446  if (muonTrack) delete muonTrack;
447  muonTrack = new AliMUONTrack();
448  AliMUONESDInterface::ESDToMUON(*esdTrack, *muonTrack, kFALSE);
449  if (mfwdTrack) delete mfwdTrack;
450  mfwdTrack = new AliMuonForwardTrack(*muonTrack);
451  trackParamMM = trackParamMM0;
452  }
453 
454  for (Int_t iptr = 0; iptr < nptr; iptr++) {
455 
456  muonCluster = mftCluster[iptr]->CreateMUONCluster();
457  //printf("MFTCluster: %3d %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f \n",iptr,mftCluster[iptr]->GetX(),mftCluster[iptr]->GetY(),mftCluster[iptr]->GetZ(),xTr[iptr],yTr[iptr],zTr[iptr],muonCluster->GetX(),muonCluster->GetY(),muonCluster->GetZ());
458 
459  // extrapolation to z
460  //printf("Extrap to (b): %10.4f \n",muonCluster->GetZ());
461  AliMUONTrackExtrap::ExtrapToZCov(&trackParamMM,muonCluster->GetZ());
462 
463  // add MCS (Multiple Coulomb Scattering)
464  // front/back correct ?
465  if (iptr > 0) {
466  if (planeID[iptr]%2 == 0) {
467  // back
468  AliMUONTrackExtrap::AddMCSEffect(&trackParamMM,
469  (equivalentSilicon+equivalentSiliconBeforeBack)/fRadLengthSi,-1.);
470  } else {
471  // front
472  // ... this is zero, anyway ...
473  AliMUONTrackExtrap::AddMCSEffect(&trackParamMM,
474  (equivalentSilicon+equivalentSiliconBeforeFront)/fRadLengthSi,-1.);
475  }
476  }
477 
478  //printf("1b (%2d): %10.4f %10.4f %10.4f %10.4f %10.4f %10.4f %f\n",iptr,trackParamMM.GetNonBendingCoor(), trackParamMM.GetBendingCoor(),trackParamMM.GetZ(),muonCluster->GetX(),muonCluster->GetY(),muonCluster->GetZ(),trackParamMM.GetTrackChi2());
479  addChi2TrackAtCluster = RunKalmanFilter(trackParamMM,*muonCluster);
480  trackParamMM.SetTrackChi2(trackParamMM.GetTrackChi2()+addChi2TrackAtCluster);
481 
482  mfwdTrack->AddTrackParamAtMFTCluster(trackParamMM,*muonCluster,iptr);
483  mfwdTrack->SetGlobalChi2(trackParamMM.GetTrackChi2());
484  mfwdTrack->SetTrackMCId(caTrack->GetMCindex());
485  //printf("2b: %10.4f %10.4f %10.4f %f\n",trackParamMM.GetNonBendingCoor(), trackParamMM.GetBendingCoor(),trackParamMM.GetZ(),trackParamMM.GetTrackChi2());
486  delete muonCluster;
487 
488  } // end MFT cluster loop
489 
490  if (saveAllMatch) {
491  if (mfwdTrack->GetNormalizedChi2() < chi2cut) {
492  //printf("Muon forward track %2d:%2d end chi2: %f , %f , %d \n",iTrack,iTrackMFT,mfwdTrack->GetGlobalChi2(),mfwdTrack->GetGlobalChi2()/mfwdTrack->GetNDF(),mfwdTrack->GetNDF());
493  new ((*mfwdTracks)[iTrackMatchB++]) AliMuonForwardTrack(*mfwdTrack);
494  } else {
495  //printf("... not matched (b) ... %2d:%2d end chi2: %f , %f , %d \n",iTrack,iTrackMFT,mfwdTrack->GetGlobalChi2(),mfwdTrack->GetGlobalChi2()/mfwdTrack->GetNDF(),mfwdTrack->GetNDF());
496  }
497  }
498 
499  } // end save all || match by MC label
500  } // end MFT track loop
501 
502  if (!saveAllMatch) {
503 
504  //printf("Muon forward track %d end chi2: %f , %f , %d \n",iTrack,mfwdTrack->GetGlobalChi2(),mfwdTrack->GetGlobalChi2()/mfwdTrack->GetNDF(),mfwdTrack->GetNDF());
505  if (mfwdTrack->GetNormalizedChi2() < chi2cut) {
506  new ((*mfwdTracks)[iTrackMatchB++]) AliMuonForwardTrack(*mfwdTrack);
507  }
508 
509  }
510  /*
511  for (Int_t i = 0; i < muonTrack->GetTrackParamAtCluster()->GetEntries(); i++) {
512  AliMUONTrackParam trackParamMM0(*((AliMUONTrackParam*)(muonTrack->GetTrackParamAtCluster()->At(i))));
513  printf("%d %10.4f %10.4f \n",i,trackParamMM0.P(),trackParamMM0.GetZ());
514  }
515  */
516  iTrack++;
517 
518  } // end MUON track loop
519 
520  for (Int_t iTrackMFT = 0 ; iTrackMFT < nTracksMFT; iTrackMFT++) {
521 
522  caTrack = fTrackFinder->GetTrack(iTrackMFT);
523  new ((*mftTracks)[iTrackMFT]) AliMFTCATrack(*caTrack);
524 
525  }
526 
527  outputTreeMFTTracks->Fill();
528  outputTreeMFTTracks->Write();
529  outputTreeMuonForwardTracks->Fill();
530  outputTreeMuonForwardTracks->Write();
531  outputTreeMFTCells->Fill();
532  outputTreeMFTCells->Write();
533  outputTreeEvent->Fill();
534  outputTreeEvent->Write();
535 
536  outputFileMFTTracks->Close();
537 
538  mftTracks->Delete();
539  delete mftTracks;
540 
541  mftCells->Delete();
542  delete mftCells;
543 
544  mfwdTracks->Delete();
545  delete mfwdTracks;
546 
547  fTrackFinder->Clear("");
548 
549  return 0;
550 
551 }
552 
553 //=========================================================================================================================================
554 
555 Double_t AliMFTTracker::RunKalmanFilter(AliMUONTrackParam &trackParamAtCluster, AliMUONVCluster &cluster)
556 {
560  AliDebug(1,"Enter RunKalmanFilter");
561 
562  // Get actual track parameters (p)
563  TMatrixD param(trackParamAtCluster.GetParameters());
564 
565  // Get new cluster parameters (m)
566  TMatrixD clusterParam(5,1);
567  clusterParam.Zero();
568  clusterParam(0,0) = cluster.GetX();
569  clusterParam(2,0) = cluster.GetY();
570 
571  // Compute the actual parameter weight (W)
572  TMatrixD paramWeight(trackParamAtCluster.GetCovariances());
573  if (paramWeight.Determinant() != 0) {
574  paramWeight.Invert();
575  } else {
576  AliWarning(" Determinant = 0");
577  return 2.*AliMUONTrack::MaxChi2();
578  }
579 
580  // Compute the new cluster weight (U)
581  TMatrixD clusterWeight(5,5);
582  clusterWeight.Zero();
583  clusterWeight(0,0) = 1. / cluster.GetErrX2();
584  clusterWeight(2,2) = 1. / cluster.GetErrY2();
585 
586  // Compute the new parameters covariance matrix ( (W+U)^-1 )
587  TMatrixD newParamCov(paramWeight,TMatrixD::kPlus,clusterWeight);
588  if (newParamCov.Determinant() != 0) {
589  newParamCov.Invert();
590  } else {
591  AliWarning(" Determinant = 0");
592  return 2.*AliMUONTrack::MaxChi2();
593  }
594 
595  // Save the new parameters covariance matrix
596  trackParamAtCluster.SetCovariances(newParamCov);
597 
598  // Compute the new parameters (p' = ((W+U)^-1)U(m-p) + p)
599  TMatrixD tmp(clusterParam,TMatrixD::kMinus,param);
600  TMatrixD tmp2(clusterWeight,TMatrixD::kMult,tmp); // U(m-p)
601  TMatrixD newParam(newParamCov,TMatrixD::kMult,tmp2); // ((W+U)^-1)U(m-p)
602  newParam += param; // ((W+U)^-1)U(m-p) + p
603 
604  // Save the new parameters
605  trackParamAtCluster.SetParameters(newParam);
606 
607  // Compute the additional chi2 (= ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m))
608  tmp = newParam; // p'
609  tmp -= param; // (p'-p)
610  TMatrixD tmp3(paramWeight,TMatrixD::kMult,tmp); // W(p'-p)
611  TMatrixD addChi2Track(tmp,TMatrixD::kTransposeMult,tmp3); // ((p'-p)^-1)W(p'-p)
612  tmp = newParam; // p'
613  tmp -= clusterParam; // (p'-m)
614  TMatrixD tmp4(clusterWeight,TMatrixD::kMult,tmp); // U(p'-m)
615  addChi2Track += TMatrixD(tmp,TMatrixD::kTransposeMult,tmp4); // ((p'-p)^-1)W(p'-p) + ((p'-m)^-1)U(p'-m)
616 
617  return addChi2Track(0,0);
618 
619 }
620 
621 //=========================================================================================================================================
622 
624  AliCodeTimerAuto("",0);
625 
627  AliMFTSegmentation * seg = mftGeo->GetSegmentation();
628 
629  AliMFTHalfSegmentation *halfSeg[2];
630  for (int i=0; i<2; i++) halfSeg[i] = seg->GetHalf(i);
631 
632  AliMFTHalfDiskSegmentation *halfDiskSeg[2];
633 
634  for (Int_t iPlane=0; iPlane<AliMFTConstants::kNDisks; iPlane++) {
635  fMFTClusterArrayFront[iPlane]->Delete();
636  fMFTClusterArrayBack[iPlane] ->Delete();
637  for (int i=0; i<2; i++) halfDiskSeg[i] = halfSeg[i]->GetHalfDisk(iPlane);
638 
639  for (Int_t iCluster=0; iCluster<fMFTClusterArray[iPlane]->GetEntries(); iCluster++) {
640  AliMFTCluster *cluster = (AliMFTCluster*) fMFTClusterArray[iPlane]->At(iCluster);
641  if (mftGeo->GetLadderID(cluster->GetDetElemID())<(halfDiskSeg[mftGeo->GetHalfMFTID(cluster->GetDetElemID())]->GetNLadders())/2) {
642  new ((*fMFTClusterArrayFront[iPlane])[fMFTClusterArrayFront[iPlane]->GetEntries()]) AliMFTCluster(*cluster);
643  }
644  else {
645  new ((*fMFTClusterArrayBack[iPlane])[fMFTClusterArrayBack[iPlane]->GetEntries()]) AliMFTCluster(*cluster);
646  }
647  }
648  }
649 
650 }
651 
652 //======================================================================================================================================
653 
655 
656  AliRunLoader *runLoader = AliRunLoader::Open("galice.root");
657  if (!runLoader) {
658  AliError("no run loader found in file galice.root");
659  return;
660  }
661 
662  runLoader->CdGAFile();
663  runLoader->LoadgAlice();
664  runLoader->LoadHeader();
665  runLoader->GetEvent(gAlice->GetEvNumber());
666 
667  TArrayF vtx(3);
668  runLoader->GetHeader()->GenEventHeader()->PrimaryVertex(vtx);
669  AliInfo(Form("Primary vertex from MC found in (%f, %f, %f)\n",vtx[0], vtx[1], vtx[2]));
670 
671  fXVertexMC = vtx[0];
672  fYVertexMC = vtx[1];
673  fZVertexMC = vtx[2];
674 
675  fXExtrapVertex = gRandom->Gaus(vtx[0], AliMFTConstants::fPrimaryVertexResX);
676  fYExtrapVertex = gRandom->Gaus(vtx[1], AliMFTConstants::fPrimaryVertexResY);
677  fZExtrapVertex = gRandom->Gaus(vtx[2], AliMFTConstants::fPrimaryVertexResZ);
680  AliInfo(Form("Set ESD vertex from MC (%f +/- %f, %f +/- %f, %f)",
682 
683 }
684 
685 //======================================================================================================================================
686 
688 
689  AliInfo("Adding clusters from underlying event");
690 
691  if (!fMFT) return;
692 
693  TGrid::Connect("alien://");
694 
695  TFile* fileWithClustersToAdd = TFile::Open(fMFT->GetFileNameForUnderlyingEvent());
696  if (!fileWithClustersToAdd) return;
697  if (!(fileWithClustersToAdd->IsOpen())) return;
698  if (!(fileWithClustersToAdd->cd(Form("Event%d",fMFT->GetUnderlyingEventID())))) return;
699 
700  TClonesArray *recPointsPerPlaneToAdd[AliMFTConstants::fNMaxPlanes] = {0};
701  TTree *treeIn = 0;
702 
703  for (Int_t iPlane=0; iPlane<AliMFTConstants::fNMaxPlanes; iPlane++) recPointsPerPlaneToAdd[iPlane] = new TClonesArray("AliMFTCluster");
704 
705  treeIn = (TTree*) gDirectory->Get("TreeR");
706 
707  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
708  if (!(treeIn->GetBranch(Form("Plane_%02d",iPlane)))) {
709  for (Int_t jPlane=0; jPlane<AliMFTConstants::fNMaxPlanes; jPlane++) delete recPointsPerPlaneToAdd[jPlane];
710  return;
711  }
712  else treeIn->SetBranchAddress(Form("Plane_%02d",iPlane), &(recPointsPerPlaneToAdd[iPlane]));
713  }
714 
715  treeIn -> GetEntry(0);
716 
717  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
718  printf("plane %d -> before = %d ",iPlane,fMFTClusterArray[iPlane]->GetEntries());
719  Int_t nClusters = recPointsPerPlaneToAdd[iPlane]->GetEntries();
720  for (Int_t iCluster=0; iCluster<nClusters; iCluster++) {
721  AliMFTCluster *newCluster = (AliMFTCluster*) recPointsPerPlaneToAdd[iPlane]->At(iCluster);
722  for (Int_t iTrack=0; iTrack<newCluster->GetNMCTracks(); iTrack++) newCluster->SetMCLabel(iTrack, newCluster->GetMCLabel(iTrack)+AliMFTConstants::fLabelOffsetMC);
723  new ((*fMFTClusterArray[iPlane])[fMFTClusterArray[iPlane]->GetEntries()]) AliMFTCluster(*newCluster);
724  }
725  printf("after = %d\n",fMFTClusterArray[iPlane]->GetEntries());
726  }
727 
728  for (Int_t jPlane=0; jPlane<AliMFTConstants::fNMaxPlanes; jPlane++) delete recPointsPerPlaneToAdd[jPlane];
729 
730 }
731 
732 //======================================================================================================================================
733 
735 
736  AliInfo("Adding clusters from pile-up event(s)");
737 
738  if (!fMFT) return;
739 
740  TGrid::Connect("alien://");
741 
742  TFile* fileWithClustersToAdd = TFile::Open(fMFT->GetFileNameForPileUpEvents());
743  if (!fileWithClustersToAdd) return;
744  if (!(fileWithClustersToAdd->IsOpen())) return;
745 
746  TClonesArray *recPointsPerPlaneToAdd[AliMFTConstants::fNMaxPlanes] = {0};
747  TTree *treeIn = 0;
748 
749  for (Int_t iPileUp=0; iPileUp<AliMFTConstants::fNMaxPileUpEvents; iPileUp++) {
750 
751  if (!(fileWithClustersToAdd->cd(Form("Event%d",fMFT->GetPileUpEventID(iPileUp))))) continue;
752 
753  for (Int_t iPlane=0; iPlane<AliMFTConstants::fNMaxPlanes; iPlane++) recPointsPerPlaneToAdd[iPlane] = new TClonesArray("AliMFTCluster");
754 
755  treeIn = (TTree*) gDirectory->Get("TreeR");
756 
757  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
758  if (!(treeIn->GetBranch(Form("Plane_%02d",iPlane)))) {
759  for (Int_t jPlane=0; jPlane<AliMFTConstants::fNMaxPlanes; jPlane++) delete recPointsPerPlaneToAdd[jPlane];
760  return;
761  }
762  else treeIn->SetBranchAddress(Form("Plane_%02d",iPlane), &(recPointsPerPlaneToAdd[iPlane]));
763  }
764 
765  treeIn -> GetEntry(0);
766 
767  for (Int_t iPlane=0; iPlane<fNPlanesMFT; iPlane++) {
768  AliInfo(Form("plane %d -> before = %d ",iPlane,fMFTClusterArray[iPlane]->GetEntries()));
769  Int_t nClusters = recPointsPerPlaneToAdd[iPlane]->GetEntries();
770  for (Int_t iCluster=0; iCluster<nClusters; iCluster++) {
771  AliMFTCluster *newCluster = (AliMFTCluster*) recPointsPerPlaneToAdd[iPlane]->At(iCluster);
772  for (Int_t iTrack=0; iTrack<newCluster->GetNMCTracks(); iTrack++) newCluster->SetMCLabel(iTrack, newCluster->GetMCLabel(iTrack)+AliMFTConstants::fLabelOffsetMC);
773  new ((*fMFTClusterArray[iPlane])[fMFTClusterArray[iPlane]->GetEntries()]) AliMFTCluster(*newCluster);
774  }
775  AliInfo(Form("after = %d\n",fMFTClusterArray[iPlane]->GetEntries()));
776  }
777 
778  for (Int_t jPlane=0; jPlane<AliMFTConstants::fNMaxPlanes; jPlane++) delete recPointsPerPlaneToAdd[jPlane];
779 
780  }
781 
782 }
783 
784 //======================================================================================================================================
785 //___________________________________________________________________________
787 
788  if (!track) return 0;
789  if (!track->GetCATrack()) return 0;
790 
791  AliMFTCATrack * caTrack = track->GetCATrack();
792  Int_t nCells = caTrack->GetNcells();
793  AliDebug(1,Form("NCell = %d ",nCells));
794 
795  Double_t xTrErrDet = 0.0025/TMath::Sqrt(12.);
796  Double_t yTrErrDet = 0.0025/TMath::Sqrt(12.);
797  Double_t xTrErrMS = 0.00055; // estimated at p = 5.5 GeV/c
798  Double_t yTrErrMS = 0.00055; // estimated at p = 5.5 GeV/c
799 
800  Int_t nDet=0;
801  const Int_t nMaxCell = 10;
802 
803  if (nCells>nMaxCell) AliError(Form("Number of Cell = %d; Bigger than allowed value = %d", nCells,nMaxCell));
804 
805  Double_t xcl[nMaxCell];
806  Double_t ycl[nMaxCell];
807  Double_t zcl[nMaxCell];
808  Double_t xerr[nMaxCell];
809  Double_t yerr[nMaxCell];
810 // Double_t &a; Double_t &ae; Double_t &b; Double_t &be;
811 // Int_t skip;
812 
813  AliMFTCACell *caCell = NULL;
814  for (int iCell=0; iCell<nCells; iCell++) {
815  caCell = caTrack->GetCell(iCell);
816  if(iCell==0){
817  xcl[nDet] = caCell->GetHit1()[0];
818  ycl[nDet] = caCell->GetHit1()[1];
819  zcl[nDet] = caCell->GetHit1()[2];
820  xerr[nDet] = TMath::Sqrt(xTrErrDet*xTrErrDet+xTrErrMS*xTrErrMS);
821  yerr[nDet] = TMath::Sqrt(yTrErrDet*yTrErrDet+yTrErrMS*yTrErrMS);
822  nDet++;
823  }
824  xcl[nDet] = caCell->GetHit2()[0];
825  ycl[nDet] = caCell->GetHit2()[1];
826  zcl[nDet] = caCell->GetHit2()[2];
827  xerr[nDet] = TMath::Sqrt(xTrErrDet*xTrErrDet+xTrErrMS*xTrErrMS);
828  yerr[nDet] = TMath::Sqrt(yTrErrDet*yTrErrDet+yTrErrMS*yTrErrMS);
829  nDet++;
830 
831  }
832 
833 
834 
835 
836  // y=a*x+b
837 //
838 // const Int_t nMaxh = 100;
839 // Double_t xCl[nMaxh], yCl[nMaxh], yErr[nMaxh];
840 // Int_t idet = 0;
841 // for (Int_t i = 0; i < nDet; i++) {
842 // if (i == skip) continue;
843 // xCl[idet] = xcl[i];
844 // yCl[idet] = ycl[i];
845 // yErr[idet] = yerr[i];
846 // idet++;
847 // }
848 //
849 // Double_t S1, SXY, SX, SY, SXX, SsXY, SsXX, SsYY, Xm, Ym, s, delta, difx;
850 //
851 // S1 = SXY = SX = SY = SXX = 0.0;
852 // SsXX = SsYY = SsXY = Xm = Ym = 0.;
853 // difx = 0.;
854 // for (Int_t i = 0; i < idet; i++) {
855 // S1 += 1.0/(yErr[i]*yErr[i]);
856 // SXY += xCl[i]*yCl[i]/(yErr[i]*yErr[i]);
857 // SX += xCl[i]/(yErr[i]*yErr[i]);
858 // SY += yCl[i]/(yErr[i]*yErr[i]);
859 // SXX += xCl[i]*xCl[i]/(yErr[i]*yErr[i]);
860 // if (i > 0) difx += TMath::Abs(xCl[i]-xCl[i-1]);
861 // Xm += xCl[i];
862 // Ym += yCl[i];
863 // SsXX += xCl[i]*xCl[i];
864 // SsYY += yCl[i]*yCl[i];
865 // SsXY += xCl[i]*yCl[i];
866 // }
867 // delta = SXX*S1 - SX*SX;
868 // if (delta == 0.) {
869 // return kFALSE;
870 // }
871 // a = (SXY*S1 - SX*SY)/delta;
872 // b = (SY*SXX - SX*SXY)/delta;
873 //
874 // Ym /= (Double_t)idet;
875 // Xm /= (Double_t)idet;
876 // SsYY -= (Double_t)idet*(Ym*Ym);
877 // SsXX -= (Double_t)idet*(Xm*Xm);
878 // SsXY -= (Double_t)idet*(Ym*Xm);
879 // Double_t eps = 1.E-24;
880 // if ((idet > 2) && (TMath::Abs(difx) > eps) && ((SsYY-(SsXY*SsXY)/SsXX) > 0.)) {
881 // s = TMath::Sqrt((SsYY-(SsXY*SsXY)/SsXX)/(idet-2));
882 // be = s*TMath::Sqrt(1./(Double_t)idet+(Xm*Xm)/SsXX);
883 // ae = s/TMath::Sqrt(SsXX);
884 // } else {
885 // be = 0.;
886 // ae = 0.;
887 // }
888 //
889  return kTRUE;
890 
891 }
892 
893 
static const Double_t fYVertexTolerance
Double_t fXExtrapVertex
best final candidate (if any)
Class for the description of the structure a Half-Disk.
Int_t LoadgAlice()
TClonesArray * fMFTClusterArrayFront[fNMaxPlanes]
array of clusters for the planes of the MFT
Definition: AliMFTTracker.h:90
printf("Chi2/npoints = %f\n", TMath::Sqrt(chi2/npoints))
Double_t fYExtrapVertexError
static void ESDToMUON(const AliESDMuonTrack &esdTrack, AliMUONTrack &track, Bool_t refit=kTRUE)
TFile * Open(const char *filename, Long64_t &nevents)
static void ExtrapToVertex(AliMUONTrackParam *trackParam, Double_t xVtx, Double_t yVtx, Double_t zVtx, Double_t errXVtx, Double_t errYVtx)
void AddTrackParamAtMFTCluster(AliMUONTrackParam &trackParam, AliMUONVCluster &cluster, const Int_t mftid)
overload of the AliMUONTrack function
AliMFT * fMFT
pointer to the ESD event
Definition: AliMFTTracker.h:76
static const Double_t fPrimaryVertexResY
Double_t fZExtrapVertex
virtual void PrimaryVertex(TArrayF &o) const
virtual void Clear(Option_t *)
const Int_t GetNtracks()
Class to describe the MUON tracks in the Event Summary Data class.
Double_t GetVertX()
Definition: AliMFTCATrack.h:39
virtual Double_t GetY() const
Definition: AliVertex.h:39
TClonesArray * fCandidateTracks
array of back clusters for the planes of the MFT
Definition: AliMFTTracker.h:93
Class Doing MFT Track reconstruction.
Double_t GetVertZ()
Definition: AliMFTCATrack.h:41
void SetZVertRange(Double_t *zvr, Double_t zvd)
static const Double_t fRadLengthSi
Definition: AliMFTTracker.h:71
AliMFTHalfSegmentation * GetHalf(Int_t iHalf) const
Returns pointer to the segmentation of the half-MFT.
const TMatrixD & GetParameters() const
return track parameters
Int_t GetLadderID(UInt_t uniqueID) const
Returns Ladder ID based on Unique ID provided.
Definition: AliMFT.h:42
const Char_t * GetFileNameForUnderlyingEvent()
Definition: AliMFT.h:111
void SetChargeSign(Short_t sign)
Definition: AliMFTCATrack.h:51
AliMFTSegmentation * fSegmentation
Definition: AliMFTTracker.h:77
Short_t GetUnderlyingEventID()
Definition: AliMFT.h:113
Int_t * GetLayers()
Definition: AliMFTCACell.h:29
Int_t GetDetElemID()
Definition: AliMFTCluster.h:70
static const Double_t fPrimaryVertexResX
Double_t fXVertexMC
Double_t * GetHit1()
Definition: AliMFTCACell.h:25
static const Int_t fNMaxPlanes
Int_t LoadClusters(TTree *cf)
Track parameters in ALICE dimuon spectrometer.
Double_t GetNormalizedChi2() const
virtual Double_t GetErrX2() const =0
Return resolution**2 (cm**2) on coordinate X.
Double_t GetVertY()
Definition: AliMFTCATrack.h:40
AliTPCfastTrack * track
Double_t RunKalmanFilter(AliMUONTrackParam &trackParam, AliMUONVCluster &cluster)
void SeparateFrontBackClusters()
Int_t GetEvNumber() const
Definition: AliRun.cxx:379
TClonesArray * fMFTClusterArrayBack[fNMaxPlanes]
array of front clusters for the planes of the MFT
Definition: AliMFTTracker.h:91
Double_t GetPhi()
Definition: AliMFTCATrack.h:43
virtual ~AliMFTTracker()
#define AliWarning(message)
Definition: AliLog.h:541
AliMFTSegmentation * GetSegmentation() const
Returns pointer to the segmentation.
void SetMCLabel(Int_t track, Int_t labelMC)
Definition: AliMFTCluster.h:64
static AliRunLoader * Open(const char *filename="galice.root", const char *eventfoldername=AliConfig::GetDefaultEventFolderName(), Option_t *option="READ")
virtual Double_t GetZ() const
Return coordinate Z (cm)
void AddClustersFromPileUpEvents()
Description of an ALICE Standalone MFT track.
Definition: AliMFTTrack.h:24
AliMFTCATrack * GetTrack(Int_t nt)
Int_t GetNMCTracks() const
Definition: AliMFTCluster.h:62
AliMUONRawCluster * CreateMUONCluster()
Double_t * GetHit2()
Definition: AliMFTCACell.h:26
abstract base class for clusters
static Bool_t ExtrapToZCov(AliMUONTrackParam *trackParam, Double_t zEnd, Bool_t updatePropagator=kFALSE)
void Clear()
Add comment.
TClonesArray * fMFTTracks
array of candidate global tracks
Definition: AliMFTTracker.h:94
void LoadClusters(TClonesArray *clusterArrayFront[AliMFTConstants::fNMaxPlanes], TClonesArray *clusterArrayBack[AliMFTConstants::fNMaxPlanes])
static const Int_t fLabelOffsetMC
AliHeader * GetHeader() const
#define AliInfo(message)
Definition: AliLog.h:484
MUON raw cluster.
static AliMFTGeometry * Instance()
Retuns MFT Geometry singleton object.
void SetCellGID(Int_t index, Int_t gid)
Definition: AliMFTCATrack.h:53
Segmentation class for each half of the ALICE Muon Forward Tracker.
#define AliCodeTimerAuto(message, counter)
Definition: AliCodeTimer.h:137
Double_t fYExtrapVertex
AliMFTCACell * GetCell(Int_t ic) const
Definition: AliMFTCATrack.h:28
void EventReconstruct(TClonesArray *fMFTTracks)
static void AddMCSEffect(AliMUONTrackParam *param, Double_t dZ, Double_t x0)
Short_t Charge() const
virtual Double_t GetZ() const
Definition: AliVertex.h:40
Bool_t fBransonCorrection
Int_t LoadHeader()
Int_t GetMCLabel() const
return the corresponding MC track number
Definition: AliMUONTrack.h:135
AliRun * gAlice
Definition: AliRun.cxx:62
TTree * treeIn
Int_t GetMCindex()
Definition: AliMFTCATrack.h:50
Double_t fMinResearchRadiusAtPlane[fNMaxPlanes]
Bool_t LinearFit(AliMFTTrack *track)
Int_t GetNcells() const
Definition: AliMFTCATrack.h:26
Double_t fZVertexMC
void SetTrackMCId(Int_t id)
Set the MC label of the attached MFT track.
Double_t GetTrackChi2() const
return the chi2 of the track when the associated cluster was attached
void SetNPlanesMFT(Int_t nPlanesMFT)
Definition: AliMFTTracker.h:47
virtual Double_t GetErrY2() const =0
Return resolution**2 (cm**2) on coordinate Y.
void Init(Char_t *parfile)
#define AliFatal(message)
Definition: AliLog.h:640
virtual Double_t GetX() const
Definition: AliVertex.h:38
void AddClustersFromUnderlyingEvent()
static const Double_t fPrimaryVertexResZ
void SetParameters(const TMatrixD &parameters)
set track parameters
Int_t GetEvent(Int_t evno)
virtual Double_t GetY() const =0
Return coordinate Y (cm)
TClonesArray * fMFTClusterArray[fNMaxPlanes]
Definition: AliMFTTracker.h:89
#define AliDebug(logLevel, message)
Definition: AliLog.h:300
virtual AliGenEventHeader * GenEventHeader() const
Definition: AliHeader.cxx:244
Class for the virtual segmentation of the ALICE Muon Forward Tracker.
static const Double_t fXVertexTolerance
static const Int_t fNMaxPileUpEvents
static void ExtrapToVertexWithoutBranson(AliMUONTrackParam *trackParam, Double_t zVtx)
virtual Int_t GetNContributors() const
Definition: AliVertex.h:42
static const Double_t fRadLengthSi
expressed in cm
Double_t fXExtrapVertexError
void SetTrackChi2(Double_t chi2)
set the chi2 of the track when the associated cluster was attached
const Char_t * GetFileNameForPileUpEvents()
Definition: AliMFT.h:112
virtual Double_t GetX() const =0
Return coordinate X (cm)
AliDetector * GetDetector(const char *name) const
Definition: AliRun.cxx:200
Reconstructed track in ALICE dimuon spectrometer.
Definition: AliMUONTrack.h:24
#define AliError(message)
Definition: AliLog.h:591
Double_t fYVertexMC
AliMFTTrackFinder * fTrackFinder
Definition: AliMFTTracker.h:78
Int_t GetHalfMFTID(UInt_t uniqueID) const
Returns Half-MFT ID based on Unique ID provided.
void SetCovariances(const TMatrixD &covariances)
static const Int_t kNDisks
Number of Disk.
Int_t Clusters2Tracks(AliESDEvent *event)
AliMFTCATrack * GetCATrack() const
return pointer to track found by Track Finder (includes clusters)
Definition: AliMFTTrack.h:50
Class for the creation of the "standalone MFT tracks".
Definition: AliMFTTracker.h:34
Int_t GetMCLabel(Int_t track) const
Definition: AliMFTCluster.h:63
const TMatrixD & GetCovariances() const
Short_t GetPileUpEventID(Short_t i)
Definition: AliMFT.h:114
Class Handling both Virutal Segmentation and Real Volumes.
Int_t * GetMFTClsId()
Definition: AliMFTCACell.h:30
void GetVertexFromMC()
static Double_t MaxChi2()
return the maximum chi2 above which the track can be considered as abnormal (due to extrapolation fai...
Definition: AliMUONTrack.h:144
ALICE muon forward track, combining the information of the Muon Spectrometer and the Muon Forward Tra...
Double_t GetTheta()
Definition: AliMFTCATrack.h:42
TObjArray * GetTrackParamAtCluster() const
void SetGlobalChi2(Double_t chi2)
set the minimum value of the function minimized by the fit
Definition: AliMUONTrack.h:71