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