c477189d7b8be1b1e1cc4891d4bfa49e76ca2455
[u/mrichter/AliRoot.git] / HBTAN / AliHBTReaderESD.cxx
1 #include "AliHBTReaderESD.h"
2 //____________________________________________________________________
3 //////////////////////////////////////////////////////////////////////
4 //                                                                  //
5 // class AliHBTReaderESD                                            //
6 //                                                                  //
7 // reader for ALICE Event Summary Data (ESD).                       //
8 //                                                                  //
9 // Piotr.Skowronski@cern.ch                                         //
10 //                                                                  //
11 //////////////////////////////////////////////////////////////////////
12
13 #include <TPDGCode.h>
14 #include <TString.h>
15 #include <TObjString.h>
16 #include <TTree.h>
17 #include <TFile.h>
18 #include <TKey.h>
19 #include <TParticle.h>
20 #include <TH1.h>
21
22 #include <AliRun.h>
23 #include <AliRunLoader.h>
24 #include <AliStack.h>
25 #include <AliESDtrack.h>
26 #include <AliESD.h>
27
28 #include "AliHBTRun.h"
29 #include "AliHBTEvent.h"
30 #include "AliHBTParticle.h"
31 #include "AliHBTParticleCut.h"
32 #include "AliHBTTrackPoints.h"
33 #include "AliHBTClusterMap.h"
34
35 ClassImp(AliHBTReaderESD)
36
37 AliHBTReaderESD::AliHBTReaderESD(const Char_t* esdfilename, const Char_t* galfilename):
38  fESDFileName(esdfilename),
39  fGAlFileName(galfilename),
40  fFile(0x0),
41  fRunLoader(0x0),
42  fKeyIterator(0x0),
43  fReadParticles(kFALSE),
44  fCheckParticlePID(kFALSE),
45  fNTrackPoints(0),
46  fdR(0.0),
47  fClusterMap(kFALSE),
48  fNTPCClustMin(0),
49  fNTPCClustMax(150),
50  fTPCChi2PerClustMin(0.0),
51  fTPCChi2PerClustMax(10e5),
52  fChi2Min(0.0),
53  fChi2Max(10e5),
54  fC00Min(0.0),
55  fC00Max(10e5),
56  fC11Min(0.0),
57  fC11Max(10e5),
58  fC22Min(0.0),
59  fC22Max(10e5),
60  fC33Min(0.0),
61  fC33Max(10e5),
62  fC44Min(0.0),
63  fC44Max(10e5),
64  fTPCC00Min(0.0),
65  fTPCC00Max(10e5),
66  fTPCC11Min(0.0),
67  fTPCC11Max(10e5),
68  fTPCC22Min(0.0),
69  fTPCC22Max(10e5),
70  fTPCC33Min(0.0),
71  fTPCC33Max(10e5),
72  fTPCC44Min(0.0),
73  fTPCC44Max(10e5)
74
75 {
76   //cosntructor
77   if ( ((Int_t)kNSpecies) != ((Int_t)AliESDtrack::kSPECIES))
78     Fatal("AliHBTReaderESD","ESD defintions probobly changed. Ask Youra.");
79 }
80 /********************************************************************/
81   
82 AliHBTReaderESD::AliHBTReaderESD(TObjArray* dirs,const Char_t* esdfilename, const Char_t* galfilename):
83  AliHBTReader(dirs), 
84  fESDFileName(esdfilename),
85  fGAlFileName(galfilename),
86  fFile(0x0),
87  fRunLoader(0x0),
88  fKeyIterator(0x0),
89  fReadParticles(kFALSE),
90  fCheckParticlePID(kFALSE),
91  fNTrackPoints(0),
92  fdR(0.0),
93  fClusterMap(kFALSE),
94  fNTPCClustMin(0),
95  fNTPCClustMax(150),
96  fTPCChi2PerClustMin(0.0),
97  fTPCChi2PerClustMax(10e5),
98  fChi2Min(0.0),
99  fChi2Max(10e5),
100  fC00Min(0.0),
101  fC00Max(10e5),
102  fC11Min(0.0),
103  fC11Max(10e5),
104  fC22Min(0.0),
105  fC22Max(10e5),
106  fC33Min(0.0),
107  fC33Max(10e5),
108  fC44Min(0.0),
109  fC44Max(10e5),
110  fTPCC00Min(0.0),
111  fTPCC00Max(10e5),
112  fTPCC11Min(0.0),
113  fTPCC11Max(10e5),
114  fTPCC22Min(0.0),
115  fTPCC22Max(10e5),
116  fTPCC33Min(0.0),
117  fTPCC33Max(10e5),
118  fTPCC44Min(0.0),
119  fTPCC44Max(10e5)
120 {
121   //cosntructor
122   if ( ((Int_t)kNSpecies) != ((Int_t)AliESDtrack::kSPECIES))
123     Fatal("AliHBTReaderESD","ESD defintions probobly changed. Ask Youra.");
124 }
125 /********************************************************************/
126
127 AliHBTReaderESD::~AliHBTReaderESD()
128 {
129  //desctructor
130   delete fRunLoader;
131   delete fKeyIterator;
132   delete fFile;
133 }
134 /**********************************************************/
135 Int_t AliHBTReaderESD::ReadNext()
136 {
137 //reads next event from fFile
138   //fRunLoader is for reading Kine
139   
140   if (AliHBTParticle::GetDebug())
141     Info("ReadNext","Entered");
142     
143   if (fParticlesEvent == 0x0)  fParticlesEvent = new AliHBTEvent();
144   if (fTracksEvent == 0x0)  fTracksEvent = new AliHBTEvent();
145   
146   fParticlesEvent->Reset();
147   fTracksEvent->Reset();
148         
149   do  //do{}while; is OK even if 0 dirs specified. In that case we try to read from "./"
150    {
151      if (fFile == 0x0)
152       {
153        fFile = OpenFile(fCurrentDir);//rl is opened here
154        if (fFile == 0x0)
155          {
156            Error("ReadNext","Cannot get fFile for dir no. %d",fCurrentDir);
157            fCurrentDir++;
158            continue;
159          }
160        fCurrentEvent = 0;
161        fKeyIterator = new TIter(fFile->GetListOfKeys());  
162 //       fFile->Dump();
163 //       fFile->GetListOfKeys()->Print();
164       } 
165      TKey* key = (TKey*)fKeyIterator->Next();
166      if (key == 0x0)
167       {
168         if (AliHBTParticle::GetDebug() > 2 )
169           {
170             Info("ReadNext","No more keys.");
171           }
172         fCurrentDir++;
173         delete fKeyIterator;
174         fKeyIterator = 0x0;
175         delete fFile;//we have to assume there is no more ESD objects in the fFile
176         fFile = 0x0;
177         delete fRunLoader;
178         fRunLoader = 0x0;
179         continue;
180       }
181      //try to read
182      
183      
184 //     TObject* esdobj = key->ReadObj();
185 //     if (esdobj == 0x0)
186 //      {
187 //        if (AliHBTParticle::GetDebug() > 2 )
188 //          {
189 //            Info("ReadNext","Key read NULL. Key Name is %s",key->GetName());
190 //            key->Dump();
191 //          }
192 //        continue;
193 //      }
194 //     esdobj->Dump();
195 //     AliESD* esd = dynamic_cast<AliESD*>(esdobj);
196      
197      TString esdname = "ESD";
198      esdname+=fCurrentEvent;
199      AliESD* esd = dynamic_cast<AliESD*>(fFile->Get(esdname));
200      if (esd == 0x0)
201       {
202 //        if (AliHBTParticle::GetDebug() > 2 )
203 //          {
204 //            Info("ReadNext","This key is not an AliESD object %s",key->GetName());
205 //          }
206         if (AliHBTParticle::GetDebug() > 2 )
207           {
208             Info("ReadNext","Can not find AliESD object named %s",esdname.Data());
209           }
210         fCurrentDir++;
211         delete fKeyIterator;
212         fKeyIterator = 0x0;
213         delete fFile;//we have to assume there is no more ESD objects in the fFile
214         fFile = 0x0;
215         delete fRunLoader;
216         fRunLoader = 0x0;
217         continue;
218       }
219      
220      ReadESD(esd);
221       
222      fCurrentEvent++;
223      fNEventsRead++;
224      delete esd;
225      return 0;//success -> read one event
226    }while(fCurrentDir < GetNumberOfDirs());//end of loop over directories specified in fDirs Obj Array  
227    
228   return 1; //no more directories to read
229 }
230 /**********************************************************/
231
232 Int_t AliHBTReaderESD::ReadESD(AliESD* esd)
233 {
234   //****** Tentative particle type "concentrations"
235   static const Double_t concentr[5]={0.05, 0., 0.85, 0.10, 0.05};
236   
237   Double_t pidtable[kNSpecies];//array used for reading pid probabilities from ESD track
238   Double_t w[kNSpecies];
239   Double_t mom[3];//momentum
240   Double_t pos[3];//position
241   Double_t vertexpos[3];//vertex position
242   //Reads one ESD
243   if (esd == 0x0)
244    {
245      Error("ReadESD","ESD is NULL");
246      return 1;
247    }
248
249   TDatabasePDG* pdgdb = TDatabasePDG::Instance();
250   if (pdgdb == 0x0)
251    {
252      Error("ReadESD","Can not get PDG Database Instance.");
253      return 1;
254    }
255    
256   Float_t mf = esd->GetMagneticField(); 
257
258   if ( (mf == 0.0) && (fNTrackPoints > 0) )
259    {
260       Error("ReadESD","Magnetic Field is 0 and Track Points Demended. Skipping to next event.");
261       return 1;
262    }
263
264   AliStack* stack = 0x0;
265   if (fReadParticles && fRunLoader)
266    {
267      fRunLoader->GetEvent(fCurrentEvent);
268      stack = fRunLoader->Stack();
269    }
270
271   const AliESDVertex* vertex = esd->GetVertex();
272   if (vertex == 0x0)
273    {
274      Info("ReadESD","ESD returned NULL pointer to vertex - assuming (0.0,0.0,0.0)");
275      vertexpos[0] = 0.0;
276      vertexpos[1] = 0.0;
277      vertexpos[2] = 0.0;
278    }
279   else
280    {
281      vertex->GetXYZ(vertexpos);
282    }
283    
284   if (AliHBTParticle::GetDebug() > 0)
285    {
286      Info("ReadESD","Primary Vertex is (%f,%f,%f)",vertexpos[0],vertexpos[1],vertexpos[2]);
287    }
288    
289   Info("ReadESD","Reading Event %d",fCurrentEvent);
290
291   Int_t ntr = esd->GetNumberOfTracks();
292   Info("ReadESD","Found %d tracks.",ntr);
293   for (Int_t i = 0;i<ntr; i++)
294    {
295      AliESDtrack *esdtrack = esd->GetTrack(i);
296      if (esdtrack == 0x0)
297       {
298         Error("Next","Can not get track %d", i);
299         continue;
300       }
301
302      //if (esdtrack->HasVertexParameters() == kFALSE) 
303      if ((esdtrack->GetStatus() & AliESDtrack::kITSrefit) == kFALSE)
304       {
305         if (AliHBTParticle::GetDebug() > 2) 
306           Info("ReadNext","Particle skipped: Data at vertex not available.");
307         continue;
308       }
309
310      if ((esdtrack->GetStatus() & AliESDtrack::kESDpid) == kFALSE) 
311       {
312         if (AliHBTParticle::GetDebug() > 2) 
313           Info("ReadNext","Particle skipped: PID BIT is not set.");
314         continue;
315       }
316
317
318      Double_t extx;
319      Double_t extp[5];
320      esdtrack->GetConstrainedExternalParameters(extx,extp);
321      if (extp[4] == 0.0)
322       {
323         if (AliHBTParticle::GetDebug() > 2) 
324           Info("ReadNext","Track has 0 contrianed curvature -> Probobly parameters never updated. Skipping.");
325         continue;
326       } 
327      esdtrack->GetESDpid(pidtable);
328      esdtrack->GetConstrainedPxPyPz(mom);
329      esdtrack->GetConstrainedXYZ(pos);
330      pos[0] -= vertexpos[0];//we are interested only in relative position to Primary vertex at this point
331      pos[1] -= vertexpos[1];
332      pos[2] -= vertexpos[2];
333
334      Int_t charge = (extp[4] > 0)?1:-1;//if curvature=charg/Pt is positive charge is positive
335
336      //Particle from kinematics
337      AliHBTParticle* particle = 0;
338      Bool_t keeppart = kFALSE;
339      if ( fReadParticles && stack  )
340       {
341         if (esdtrack->GetLabel() < 0) continue;//this is fake -  we are not able to match any track 
342         TParticle *p = stack->Particle(esdtrack->GetLabel());
343         if (p==0x0) 
344          {
345            Error("ReadNext","Can not find track with such label.");
346            continue;
347          }
348         if(Pass(p->GetPdgCode())) 
349          {
350            if ( AliHBTParticle::GetDebug() > 5 )
351              Info("ReadNext","Simulated Particle PID (%d) did not pass the cut.",p->GetPdgCode());
352            continue; //check if we are intersted with particles of this type 
353          }
354 //           if(p->GetPdgCode()<0) charge = -1;
355         particle = new AliHBTParticle(*p,i);
356
357       }
358       
359      if(CheckTrack(esdtrack)) continue;
360       
361      //Here we apply Bayes' formula
362      Double_t rc=0.;
363      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) rc+=concentr[s]*pidtable[s];
364      if (rc==0.0) 
365       {
366         if (AliHBTParticle::GetDebug() > 2) 
367           Info("ReadNext","Particle rejected since total bayessian PID probab. is zero.");
368         continue;
369       }
370
371      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) w[s]=concentr[s]*pidtable[s]/rc;
372
373      if (AliHBTParticle::GetDebug() > 4)
374       { 
375         Info("ReadNext","###########################################################################");
376         Info("ReadNext","Momentum: %f %f %f",mom[0],mom[1],mom[2]);
377         Info("ReadNext","Position: %f %f %f",pos[0],pos[1],pos[2]);
378         TString msg("Pid list got from track:");
379         for (Int_t s = 0;s<kNSpecies;s++)
380          {
381            msg+="\n    ";
382            msg+=s;
383            msg+="(";
384            msg+=charge*GetSpeciesPdgCode((ESpecies)s);
385            msg+="): ";
386            msg+=w[s];
387            msg+=" (";
388            msg+=pidtable[s];
389            msg+=")";
390          }
391         Info("ReadNext","%s",msg.Data());
392       }//if (AliHBTParticle::GetDebug()>4)
393
394       AliHBTTrackPoints* tpts = 0x0;
395       if (fNTrackPoints > 0) 
396        {
397          tpts = new AliHBTTrackPoints(fNTrackPoints,esdtrack,mf,fdR);
398        }
399
400       AliHBTClusterMap* cmap = 0x0; 
401       if (  fClusterMap ) 
402        {
403          cmap = new AliHBTClusterMap(esdtrack);
404        }
405
406      for (Int_t s = 0; s<kNSpecies; s++)
407       {
408         Int_t pdgcode = charge*GetSpeciesPdgCode((ESpecies)s);
409         Float_t pp = w[s];
410         if (pp == 0.0) 
411          {
412            if ( AliHBTParticle::GetDebug() > 5 )
413              Info("ReadNext","Probability of being PID %d is zero. Continuing.",pdgcode);
414            continue;
415          }
416
417         if(Pass(pdgcode)) 
418          {
419            if ( AliHBTParticle::GetDebug() > 5 )
420              Info("ReadNext","PID (%d) did not pass the cut.",pdgcode);
421            continue; //check if we are intersted with particles of this type 
422          }
423
424         Double_t mass = pdgdb->GetParticle(pdgcode)->Mass();
425         Double_t tEtot = TMath::Sqrt( mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2] + mass*mass);//total energy of the track
426
427         AliHBTParticle* track = new AliHBTParticle(pdgcode, w[s],i, 
428                                                    mom[0], mom[1], mom[2], tEtot,
429                                                    pos[0], pos[1], pos[2], 0.);
430         //copy probabilitis of other species (if not zero)
431         for (Int_t k = 0; k<kNSpecies; k++)
432          {
433            if (k == s) continue;
434            if (w[k] == 0.0) continue;
435            track->SetPIDprobability(charge*GetSpeciesPdgCode( (ESpecies)k ),w[k]);
436          }
437
438         if(Pass(track))//check if meets all criteria of any of our cuts
439                        //if it does not delete it and take next good track
440          { 
441            if ( AliHBTParticle::GetDebug() > 4 )
442              Info("ReadNext","Track did not pass the cut");
443            delete track;
444            continue;
445          }
446
447         //Single Particle cuts on cluster map and track points rather do not have sense
448         if (tpts)
449          {
450            track->SetTrackPoints(tpts); 
451          }
452
453         if (cmap) 
454          { 
455            track->SetClusterMap(cmap);
456          }
457
458         fTracksEvent->AddParticle(track);
459         if (particle) fParticlesEvent->AddParticle(particle);
460         keeppart = kTRUE;
461
462         if (AliHBTParticle::GetDebug() > 4 )
463          {
464            Info("ReadNext","\n\nAdding Particle with incarnation %d",pdgcode);
465            track->Print();
466            if (particle) particle->Print();
467            Info("ReadNext","\n----------------------------------------------\n");
468          }
469       }//for (Int_t s = 0; s<kNSpecies; s++)
470
471      if (keeppart == kFALSE) 
472       {
473         delete particle;//particle was not stored in event
474         delete tpts;
475         delete cmap;
476       }
477
478    }//for (Int_t i = 0;i<ntr; i++)  -- loop over tracks
479
480   Info("ReadNext","Read %d tracks and %d particles from event %d (event %d in dir %d).",
481          fTracksEvent->GetNumberOfParticles(), fParticlesEvent->GetNumberOfParticles(),
482          fNEventsRead,fCurrentEvent,fCurrentDir);
483   fTrackCounter->Fill(fTracksEvent->GetNumberOfParticles());
484   return 0;
485 }
486
487 /**********************************************************/
488
489 void AliHBTReaderESD::Rewind()
490 {
491   //rewinds reading 
492   delete fKeyIterator;
493   delete fFile;
494   fFile = 0x0;
495   fKeyIterator = 0x0;
496   delete fRunLoader;
497   fRunLoader = 0x0;
498   fCurrentDir = 0;
499   fNEventsRead = 0;
500   if (fTrackCounter) fTrackCounter->Reset();
501 }
502 /**********************************************************/
503
504 TFile* AliHBTReaderESD::OpenFile(Int_t n)
505 {
506 //opens fFile with kine tree
507
508  const TString& dirname = GetDirName(n);
509  if (dirname == "")
510   {
511    Error("OpenFiles","Can not get directory name");
512    return 0x0;
513   }
514  TString filename = dirname +"/"+ fESDFileName;
515  TFile *ret = TFile::Open(filename.Data()); 
516
517  if ( ret == 0x0)
518   {
519     Error("OpenFiles","Can't open fFile %s",filename.Data());
520     return 0x0;
521   }
522  if (!ret->IsOpen())
523   {
524     Error("OpenFiles","Can't open fFile  %s",filename.Data());
525     return 0x0;
526   }
527  
528  if (fReadParticles )
529   {
530    fRunLoader = AliRunLoader::Open(dirname +"/"+ fGAlFileName);
531    if (fRunLoader == 0x0)
532     {
533       Error("OpenFiles","Can't get RunLoader for directory %s",dirname.Data());
534       delete ret;
535       return 0x0;
536     }
537     
538    fRunLoader->LoadHeader();
539    if (fRunLoader->LoadKinematics())
540     {
541       Error("Next","Error occured while loading kinematics.");
542       delete fRunLoader;
543       delete ret;
544       return 0x0;
545     }
546   }
547    
548  return ret;
549 }
550 /**********************************************************/
551
552 Int_t AliHBTReaderESD::GetSpeciesPdgCode(ESpecies spec)//skowron
553 {
554   //returns pdg code from the PID index
555   //ask jura about charge
556   switch (spec)
557    {
558      case kESDElectron:
559        return kPositron;
560        break;
561      case kESDMuon:
562        return kMuonPlus;
563        break;
564      case kESDPion:
565        return kPiPlus;
566        break;
567      case kESDKaon:
568        return kKPlus;
569        break;
570      case kESDProton:
571        return kProton;
572        break;
573      default:
574        ::Warning("GetSpeciesPdgCode","Specie with number %d is not defined.",(Int_t)spec);
575        break;
576    }
577   return 0;
578 }
579 /********************************************************************/
580 Bool_t AliHBTReaderESD::CheckTrack(AliESDtrack* t) const
581 {
582   //Performs check of the track
583   
584   if ( (t->GetConstrainedChi2() < fChi2Min) || (t->GetConstrainedChi2() > fChi2Max) ) return kTRUE;
585   
586   if ( (t->GetTPCclusters(0x0) < fNTPCClustMin) || (t->GetTPCclusters(0x0) > fNTPCClustMax) ) return kTRUE;
587
588   if (t->GetTPCclusters(0x0) > 0)
589    {
590      Float_t chisqpercl = t->GetTPCchi2()/((Double_t)t->GetTPCclusters(0x0));
591      if ( (chisqpercl < fTPCChi2PerClustMin) || (chisqpercl > fTPCChi2PerClustMax) ) return kTRUE;
592    }
593
594   Double_t cc[15];
595   t->GetConstrainedExternalCovariance(cc);
596
597   if ( (cc[0]  < fC00Min) || (cc[0]  > fC00Max) ) return kTRUE;
598   if ( (cc[2]  < fC11Min) || (cc[2]  > fC11Max) ) return kTRUE;
599   if ( (cc[5]  < fC22Min) || (cc[5]  > fC22Max) ) return kTRUE;
600   if ( (cc[9]  < fC33Min) || (cc[9]  > fC33Max) ) return kTRUE;
601   if ( (cc[14] < fC44Min) || (cc[14] > fC44Max) ) return kTRUE;
602
603
604   t->GetInnerExternalCovariance(cc);
605
606   if ( (cc[0]  < fTPCC00Min) || (cc[0]  > fTPCC00Max) ) return kTRUE;
607   if ( (cc[2]  < fTPCC11Min) || (cc[2]  > fTPCC11Max) ) return kTRUE;
608   if ( (cc[5]  < fTPCC22Min) || (cc[5]  > fTPCC22Max) ) return kTRUE;
609   if ( (cc[9]  < fTPCC33Min) || (cc[9]  > fTPCC33Max) ) return kTRUE;
610   if ( (cc[14] < fTPCC44Min) || (cc[14] > fTPCC44Max) ) return kTRUE;
611
612   return kFALSE;
613
614 }
615 /********************************************************************/
616
617 void AliHBTReaderESD::SetChi2Range(Float_t min, Float_t max)
618 {
619   //sets range of Chi2 per Cluster
620   fChi2Min = min;
621   fChi2Max = max;
622 }
623 /********************************************************************/
624
625 void AliHBTReaderESD::SetTPCNClustersRange(Int_t min,Int_t max)
626 {
627  //sets range of Number Of Clusters that tracks have to have
628  fNTPCClustMin = min;
629  fNTPCClustMax = max;
630 }
631 /********************************************************************/
632
633 void AliHBTReaderESD::SetTPCChi2PerCluserRange(Float_t min, Float_t max)
634 {
635   //sets range of Chi2 per Cluster
636   fTPCChi2PerClustMin = min;
637   fTPCChi2PerClustMax = max;
638 }
639 /********************************************************************/
640
641 void AliHBTReaderESD::SetC00Range(Float_t min, Float_t max)
642 {
643  //Sets range of C00 parameter of covariance matrix of the track
644  //it defines uncertainty of the momentum
645   fC00Min = min;
646   fC00Max = max;
647 }
648 /********************************************************************/
649
650 void AliHBTReaderESD::SetC11Range(Float_t min, Float_t max)
651 {
652  //Sets range of C11 parameter of covariance matrix of the track
653  //it defines uncertainty of the momentum
654   fC11Min = min;
655   fC11Max = max;
656 }
657 /********************************************************************/
658
659 void AliHBTReaderESD::SetC22Range(Float_t min, Float_t max)
660 {
661  //Sets range of C22 parameter of covariance matrix of the track
662  //it defines uncertainty of the momentum
663   fC22Min = min;
664   fC22Max = max;
665 }
666 /********************************************************************/
667
668 void AliHBTReaderESD::SetC33Range(Float_t min, Float_t max)
669 {
670  //Sets range of C33 parameter of covariance matrix of the track
671  //it defines uncertainty of the momentum
672   fC33Min = min;
673   fC33Max = max;
674 }
675 /********************************************************************/
676
677 void AliHBTReaderESD::SetC44Range(Float_t min, Float_t max)
678 {
679  //Sets range of C44 parameter of covariance matrix of the track
680  //it defines uncertainty of the momentum
681   fC44Min = min;
682   fC44Max = max;
683 }