AliRoot Core  da88d91 (da88d91)
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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 
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 
202 Int_t AliMFTTracker::Clusters2Tracks(AliESDEvent *event) {
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.
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
const Double_t GetPhi()
Definition: AliMFTCATrack.h:43
static const Double_t fPrimaryVertexResY
Double_t fZExtrapVertex
virtual void Clear(Option_t *)
const Int_t GetNtracks()
TClonesArray * fCandidateTracks
array of back clusters for the planes of the MFT
Definition: AliMFTTracker.h:93
Class Doing MFT Track reconstruction.
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 Double_t GetVertZ()
Definition: AliMFTCATrack.h:41
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)
const Int_t GetNcells() const
Definition: AliMFTCATrack.h:26
Track parameters in ALICE dimuon spectrometer.
const Double_t GetVertY()
Definition: AliMFTCATrack.h:40
Double_t GetNormalizedChi2() const
virtual Double_t GetErrX2() const =0
Return resolution**2 (cm**2) on coordinate X.
AliTPCfastTrack * track
Double_t RunKalmanFilter(AliMUONTrackParam &trackParam, AliMUONVCluster &cluster)
void SeparateFrontBackClusters()
TClonesArray * fMFTClusterArrayBack[fNMaxPlanes]
array of front clusters for the planes of the MFT
Definition: AliMFTTracker.h:91
virtual ~AliMFTTracker()
AliMFTSegmentation * GetSegmentation() const
Returns pointer to the segmentation.
void SetMCLabel(Int_t track, Int_t labelMC)
Definition: AliMFTCluster.h:64
ClassImp(TPCGenInfo)
Definition: AliTPCCmpNG.C:254
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
const Double_t GetTheta()
Definition: AliMFTCATrack.h:42
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)
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
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.
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)
Bool_t fBransonCorrection
Int_t GetMCLabel() const
return the corresponding MC track number
Definition: AliMUONTrack.h:135
const Double_t GetVertX()
Definition: AliMFTCATrack.h:39
AliRun * gAlice
Double_t fMinResearchRadiusAtPlane[fNMaxPlanes]
Bool_t LinearFit(AliMFTTrack *track)
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.
const Int_t GetMCindex()
Definition: AliMFTCATrack.h:50
void Init(Char_t *parfile)
void AddClustersFromUnderlyingEvent()
static const Double_t fPrimaryVertexResZ
void SetParameters(const TMatrixD &parameters)
set track parameters
virtual Double_t GetY() const =0
Return coordinate Y (cm)
TClonesArray * fMFTClusterArray[fNMaxPlanes]
Definition: AliMFTTracker.h:89
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)
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)
Reconstructed track in ALICE dimuon spectrometer.
Definition: AliMUONTrack.h:24
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...
return kTRUE
Definition: AliFMDv1.cxx:97
TObjArray * GetTrackParamAtCluster() const
void SetGlobalChi2(Double_t chi2)
set the minimum value of the function minimized by the fit
Definition: AliMUONTrack.h:71