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