Bug correction
[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 (fCheckParticlePID)
349          {
350            if(Pass(p->GetPdgCode())) 
351             {
352               if ( AliHBTParticle::GetDebug() > 5 )
353                 Info("ReadNext","Simulated Particle PID (%d) did not pass the cut.",p->GetPdgCode());
354               continue; //check if we are intersted with particles of this type 
355             }
356          }
357 //           if(p->GetPdgCode()<0) charge = -1;
358         particle = new AliHBTParticle(*p,i);
359
360       }
361       
362      if(CheckTrack(esdtrack)) continue;
363       
364      //Here we apply Bayes' formula
365      Double_t rc=0.;
366      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) rc+=concentr[s]*pidtable[s];
367      if (rc==0.0) 
368       {
369         if (AliHBTParticle::GetDebug() > 2) 
370           Info("ReadNext","Particle rejected since total bayessian PID probab. is zero.");
371         continue;
372       }
373
374      for (Int_t s=0; s<AliESDtrack::kSPECIES; s++) w[s]=concentr[s]*pidtable[s]/rc;
375
376      if (AliHBTParticle::GetDebug() > 4)
377       { 
378         Info("ReadNext","###########################################################################");
379         Info("ReadNext","Momentum: %f %f %f",mom[0],mom[1],mom[2]);
380         Info("ReadNext","Position: %f %f %f",pos[0],pos[1],pos[2]);
381         TString msg("Pid list got from track:");
382         for (Int_t s = 0;s<kNSpecies;s++)
383          {
384            msg+="\n    ";
385            msg+=s;
386            msg+="(";
387            msg+=charge*GetSpeciesPdgCode((ESpecies)s);
388            msg+="): ";
389            msg+=w[s];
390            msg+=" (";
391            msg+=pidtable[s];
392            msg+=")";
393          }
394         Info("ReadNext","%s",msg.Data());
395       }//if (AliHBTParticle::GetDebug()>4)
396
397       AliHBTTrackPoints* tpts = 0x0;
398       if (fNTrackPoints > 0) 
399        {
400          tpts = new AliHBTTrackPoints(fNTrackPoints,esdtrack,mf,fdR);
401        }
402
403       AliHBTClusterMap* cmap = 0x0; 
404       if (  fClusterMap ) 
405        {
406          cmap = new AliHBTClusterMap(esdtrack);
407        }
408
409      for (Int_t s = 0; s<kNSpecies; s++)
410       {
411         Int_t pdgcode = charge*GetSpeciesPdgCode((ESpecies)s);
412         Float_t pp = w[s];
413         if (pp == 0.0) 
414          {
415            if ( AliHBTParticle::GetDebug() > 5 )
416              Info("ReadNext","Probability of being PID %d is zero. Continuing.",pdgcode);
417            continue;
418          }
419
420         if(Pass(pdgcode)) 
421          {
422            if ( AliHBTParticle::GetDebug() > 5 )
423              Info("ReadNext","PID (%d) did not pass the cut.",pdgcode);
424            continue; //check if we are intersted with particles of this type 
425          }
426
427         Double_t mass = pdgdb->GetParticle(pdgcode)->Mass();
428         Double_t tEtot = TMath::Sqrt( mom[0]*mom[0] + mom[1]*mom[1] + mom[2]*mom[2] + mass*mass);//total energy of the track
429
430         AliHBTParticle* track = new AliHBTParticle(pdgcode, w[s],i, 
431                                                    mom[0], mom[1], mom[2], tEtot,
432                                                    pos[0], pos[1], pos[2], 0.);
433         //copy probabilitis of other species (if not zero)
434         for (Int_t k = 0; k<kNSpecies; k++)
435          {
436            if (k == s) continue;
437            if (w[k] == 0.0) continue;
438            track->SetPIDprobability(charge*GetSpeciesPdgCode( (ESpecies)k ),w[k]);
439          }
440
441         if(Pass(track))//check if meets all criteria of any of our cuts
442                        //if it does not delete it and take next good track
443          { 
444            if ( AliHBTParticle::GetDebug() > 4 )
445              Info("ReadNext","Track did not pass the cut");
446            delete track;
447            continue;
448          }
449
450         //Single Particle cuts on cluster map and track points rather do not have sense
451         if (tpts)
452          {
453            track->SetTrackPoints(tpts); 
454          }
455
456         if (cmap) 
457          { 
458            track->SetClusterMap(cmap);
459          }
460
461         fTracksEvent->AddParticle(track);
462         if (particle) fParticlesEvent->AddParticle(particle);
463         keeppart = kTRUE;
464
465         if (AliHBTParticle::GetDebug() > 4 )
466          {
467            Info("ReadNext","\n\nAdding Particle with incarnation %d",pdgcode);
468            track->Print();
469            if (particle) particle->Print();
470            Info("ReadNext","\n----------------------------------------------\n");
471          }
472       }//for (Int_t s = 0; s<kNSpecies; s++)
473
474      if (keeppart == kFALSE) 
475       {
476         delete particle;//particle was not stored in event
477         delete tpts;
478         delete cmap;
479       }
480
481    }//for (Int_t i = 0;i<ntr; i++)  -- loop over tracks
482
483   Info("ReadNext","Read %d tracks and %d particles from event %d (event %d in dir %d).",
484          fTracksEvent->GetNumberOfParticles(), fParticlesEvent->GetNumberOfParticles(),
485          fNEventsRead,fCurrentEvent,fCurrentDir);
486   fTrackCounter->Fill(fTracksEvent->GetNumberOfParticles());
487   return 0;
488 }
489
490 /**********************************************************/
491
492 void AliHBTReaderESD::Rewind()
493 {
494   //rewinds reading 
495   delete fKeyIterator;
496   delete fFile;
497   fFile = 0x0;
498   fKeyIterator = 0x0;
499   delete fRunLoader;
500   fRunLoader = 0x0;
501   fCurrentDir = 0;
502   fNEventsRead = 0;
503   if (fTrackCounter) fTrackCounter->Reset();
504 }
505 /**********************************************************/
506
507 TFile* AliHBTReaderESD::OpenFile(Int_t n)
508 {
509 //opens fFile with kine tree
510
511  const TString& dirname = GetDirName(n);
512  if (dirname == "")
513   {
514    Error("OpenFiles","Can not get directory name");
515    return 0x0;
516   }
517  TString filename = dirname +"/"+ fESDFileName;
518  TFile *ret = TFile::Open(filename.Data()); 
519
520  if ( ret == 0x0)
521   {
522     Error("OpenFiles","Can't open fFile %s",filename.Data());
523     return 0x0;
524   }
525  if (!ret->IsOpen())
526   {
527     Error("OpenFiles","Can't open fFile  %s",filename.Data());
528     return 0x0;
529   }
530  
531  if (fReadParticles )
532   {
533    fRunLoader = AliRunLoader::Open(dirname +"/"+ fGAlFileName);
534    if (fRunLoader == 0x0)
535     {
536       Error("OpenFiles","Can't get RunLoader for directory %s",dirname.Data());
537       delete ret;
538       return 0x0;
539     }
540     
541    fRunLoader->LoadHeader();
542    if (fRunLoader->LoadKinematics())
543     {
544       Error("Next","Error occured while loading kinematics.");
545       delete fRunLoader;
546       delete ret;
547       return 0x0;
548     }
549   }
550    
551  return ret;
552 }
553 /**********************************************************/
554
555 Int_t AliHBTReaderESD::GetSpeciesPdgCode(ESpecies spec)//skowron
556 {
557   //returns pdg code from the PID index
558   //ask jura about charge
559   switch (spec)
560    {
561      case kESDElectron:
562        return kPositron;
563        break;
564      case kESDMuon:
565        return kMuonPlus;
566        break;
567      case kESDPion:
568        return kPiPlus;
569        break;
570      case kESDKaon:
571        return kKPlus;
572        break;
573      case kESDProton:
574        return kProton;
575        break;
576      default:
577        ::Warning("GetSpeciesPdgCode","Specie with number %d is not defined.",(Int_t)spec);
578        break;
579    }
580   return 0;
581 }
582 /********************************************************************/
583 Bool_t AliHBTReaderESD::CheckTrack(AliESDtrack* t) const
584 {
585   //Performs check of the track
586   
587   if ( (t->GetConstrainedChi2() < fChi2Min) || (t->GetConstrainedChi2() > fChi2Max) ) return kTRUE;
588   
589   if ( (t->GetTPCclusters(0x0) < fNTPCClustMin) || (t->GetTPCclusters(0x0) > fNTPCClustMax) ) return kTRUE;
590
591   if (t->GetTPCclusters(0x0) > 0)
592    {
593      Float_t chisqpercl = t->GetTPCchi2()/((Double_t)t->GetTPCclusters(0x0));
594      if ( (chisqpercl < fTPCChi2PerClustMin) || (chisqpercl > fTPCChi2PerClustMax) ) return kTRUE;
595    }
596
597   Double_t cc[15];
598   t->GetConstrainedExternalCovariance(cc);
599
600   if ( (cc[0]  < fC00Min) || (cc[0]  > fC00Max) ) return kTRUE;
601   if ( (cc[2]  < fC11Min) || (cc[2]  > fC11Max) ) return kTRUE;
602   if ( (cc[5]  < fC22Min) || (cc[5]  > fC22Max) ) return kTRUE;
603   if ( (cc[9]  < fC33Min) || (cc[9]  > fC33Max) ) return kTRUE;
604   if ( (cc[14] < fC44Min) || (cc[14] > fC44Max) ) return kTRUE;
605
606
607   t->GetInnerExternalCovariance(cc);
608
609   if ( (cc[0]  < fTPCC00Min) || (cc[0]  > fTPCC00Max) ) return kTRUE;
610   if ( (cc[2]  < fTPCC11Min) || (cc[2]  > fTPCC11Max) ) return kTRUE;
611   if ( (cc[5]  < fTPCC22Min) || (cc[5]  > fTPCC22Max) ) return kTRUE;
612   if ( (cc[9]  < fTPCC33Min) || (cc[9]  > fTPCC33Max) ) return kTRUE;
613   if ( (cc[14] < fTPCC44Min) || (cc[14] > fTPCC44Max) ) return kTRUE;
614
615   return kFALSE;
616
617 }
618 /********************************************************************/
619
620 void AliHBTReaderESD::SetChi2Range(Float_t min, Float_t max)
621 {
622   //sets range of Chi2 per Cluster
623   fChi2Min = min;
624   fChi2Max = max;
625 }
626 /********************************************************************/
627
628 void AliHBTReaderESD::SetTPCNClustersRange(Int_t min,Int_t max)
629 {
630  //sets range of Number Of Clusters that tracks have to have
631  fNTPCClustMin = min;
632  fNTPCClustMax = max;
633 }
634 /********************************************************************/
635
636 void AliHBTReaderESD::SetTPCChi2PerCluserRange(Float_t min, Float_t max)
637 {
638   //sets range of Chi2 per Cluster
639   fTPCChi2PerClustMin = min;
640   fTPCChi2PerClustMax = max;
641 }
642 /********************************************************************/
643
644 void AliHBTReaderESD::SetC00Range(Float_t min, Float_t max)
645 {
646  //Sets range of C00 parameter of covariance matrix of the track
647  //it defines uncertainty of the momentum
648   fC00Min = min;
649   fC00Max = max;
650 }
651 /********************************************************************/
652
653 void AliHBTReaderESD::SetC11Range(Float_t min, Float_t max)
654 {
655  //Sets range of C11 parameter of covariance matrix of the track
656  //it defines uncertainty of the momentum
657   fC11Min = min;
658   fC11Max = max;
659 }
660 /********************************************************************/
661
662 void AliHBTReaderESD::SetC22Range(Float_t min, Float_t max)
663 {
664  //Sets range of C22 parameter of covariance matrix of the track
665  //it defines uncertainty of the momentum
666   fC22Min = min;
667   fC22Max = max;
668 }
669 /********************************************************************/
670
671 void AliHBTReaderESD::SetC33Range(Float_t min, Float_t max)
672 {
673  //Sets range of C33 parameter of covariance matrix of the track
674  //it defines uncertainty of the momentum
675   fC33Min = min;
676   fC33Max = max;
677 }
678 /********************************************************************/
679
680 void AliHBTReaderESD::SetC44Range(Float_t min, Float_t max)
681 {
682  //Sets range of C44 parameter of covariance matrix of the track
683  //it defines uncertainty of the momentum
684   fC44Min = min;
685   fC44Max = max;
686 }