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