[u/mrichter/AliRoot.git] / PWGGA / GammaConv / AliConversionTrackCuts.cxx

/**************************************************************************
 * This file is property of and copyright by the ALICE HLT Project        *
 * ALICE Experiment at CERN, All rights reserved.                         *
 *                                                                        *
 * Primary Author: Svein Lindal <slindal@fys.uio.no>                      *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/// @file   AliConversionTrackCuts.cxx
/// @author Svein Lindal
/// @brief  Base class for analysation of conversion particle - track correlations - track cuts


#include "AliConversionTrackCuts.h"
//#include "AliAODTrack.h"
#include "AliAODEvent.h"
#include <TFormula.h>
#include <iostream>
#include "TH2F.h"
#include "AliESDtrackCuts.h"
#include "THn.h"

using namespace std;
ClassImp(AliConversionTrackCuts)


const char* AliConversionTrackCuts::fgkCutNames[AliConversionTrackCuts::kNCuts] = {
  "nClusTPC", 
  "FoundFindable", 
  "Chi2PerNDF", 
  "Kink", 
  "DCA_Z", 
  "DCA_XY", 
  "TPCRefit"
  "kAccTracks"
};


//________________________________________________________________________
AliConversionTrackCuts::AliConversionTrackCuts() : 
  AliAnalysisCuts(),
  fEsdTrackCuts(NULL),
  fEsdTrackCutsExtra1(NULL),
  fEsdTrackCutsExtra2(NULL),
  fEvent(NULL),
  fFilterBit(2048),
  fDCAZmax(3.2*3.2),
  fDCAXYmax(2.4*2.4),
  fOwnedTracks(),
  fInitialized(kFALSE),
  fhPhi(NULL),
  //  fhPt(NULL),
  //fhPhiPt(NULL),
  fhdcaxyPt(NULL),
  fhdcazPt(NULL),
  fhdca(NULL),
  fhnclpt(NULL),
  fhnclsfpt(NULL),
  fhEtaPhi(NULL),
  fhTrackEff(NULL),
  fkCreateTrackEff(kFALSE),
  fHistograms(NULL) 
{
  //Constructor
  fOwnedTracks.SetOwner(kTRUE);
}
//________________________________________________________________________
AliConversionTrackCuts::AliConversionTrackCuts(TString name, TString title = "title") : 
  AliAnalysisCuts(name, title),
  fEsdTrackCuts(NULL),
  fEsdTrackCutsExtra1(NULL),
  fEsdTrackCutsExtra2(NULL),
  fEvent(NULL),
  fFilterBit(2048),
  fDCAZmax(-1),
  fDCAXYmax(-1),
  fOwnedTracks(),
  fInitialized(kFALSE),
  fhPhi(NULL),  
  //fhPt(NULL),
  //fhPhiPt(NULL),
  fhdcaxyPt(NULL),
  fhdcazPt(NULL),
  fhdca(NULL),
  fhnclpt(NULL),
  fhnclsfpt(NULL),
  fhEtaPhi(NULL),
  fhTrackEff(NULL),
  fkCreateTrackEff(kFALSE),
  fHistograms(NULL)
{
  //Constructor
  fOwnedTracks.SetOwner(kTRUE);
}


//________________________________________________________________________________
 AliConversionTrackCuts::~AliConversionTrackCuts() {
   ///destructor
   // if(fHistograms)
   // 	 delete fHistograms;
   // fHistograms = NULL;

   if(fEsdTrackCuts)
     delete fEsdTrackCuts;
   fEsdTrackCuts = NULL;
   
   if(fEsdTrackCutsExtra1)
     delete fEsdTrackCutsExtra1;
   fEsdTrackCutsExtra1 = NULL;
   
   if(fEsdTrackCutsExtra2)
     delete fEsdTrackCutsExtra2;
   fEsdTrackCutsExtra2 = NULL;

   fOwnedTracks.Delete();
}

//______________________________________________________________________________
void AliConversionTrackCuts::DefineESDCuts() {
  // Reproduces the cuts of the corresponding bit in the ESD->AOD filtering
  // (see $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C)
  ///Copied from alianalyseleadingue
  const Int_t filterbit = fFilterBit;

  if (filterbit == 128) {
    if(!fEsdTrackCuts) {
      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
      fEsdTrackCuts->SetMinNClustersTPC(70);
    }
  }  else if (filterbit == 256) {
    if(!fEsdTrackCuts) {
      // syst study
      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
      fEsdTrackCuts->SetMinNClustersTPC(80);
      fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
      fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
      fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
    }
  }  else if (filterbit == 512) {
    if(!fEsdTrackCuts) {
      // syst study
      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
      fEsdTrackCuts->SetMinNClustersTPC(60);
      fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
      fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
      fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
    }
  } else if (filterbit == 1024) {
    if(!fEsdTrackCuts) {
      fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
      fEsdTrackCuts->SetMinNClustersTPC(-1);
      fEsdTrackCuts->SetMinNCrossedRowsTPC(70);
      fEsdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
    }
  } else if (filterbit == 2048)  {
    // mimic hybrid tracks 
    // correspond to esdTrackCutsHTG, but WITHOUT spd constraint. this is checked with the next object
    if(!fEsdTrackCuts) {
      fEsdTrackCuts = new AliESDtrackCuts();
      TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
      fEsdTrackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
      fEsdTrackCuts->SetMaxChi2PerClusterTPC(4);
      fEsdTrackCuts->SetRequireTPCStandAlone(kTRUE);
      fEsdTrackCuts->SetAcceptKinkDaughters(kFALSE);
      fEsdTrackCuts->SetRequireTPCRefit(kTRUE);
      fEsdTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
      
      fEsdTrackCuts->SetMaxDCAToVertexXY(2.4);
      fEsdTrackCuts->SetMaxDCAToVertexZ(3.2);
      fEsdTrackCuts->SetDCAToVertex2D(kTRUE);
	
      fEsdTrackCuts->SetMaxChi2PerClusterITS(36);
      fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
	
      fEsdTrackCuts->SetRequireSigmaToVertex(kFALSE);
	
      fEsdTrackCuts->SetEtaRange(-0.9, 0.9);
      fEsdTrackCuts->SetPtRange(0.1, 1000000.0);
	
      fEsdTrackCuts->SetRequireITSRefit(kFALSE); //not here, n
    }
    // Add SPD requirement 
    fEsdTrackCutsExtra1 = new AliESDtrackCuts("SPD", "Require 1 cluster in SPD");
    fEsdTrackCutsExtra1->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
    fEsdTrackCutsExtra1->SetRequireITSRefit(kTRUE);
    // A track passing fEsdTrackCuts and fEsdTrackCutsExtra1 corresponds to esdTrackCutsHTG
    
    fEsdTrackCutsExtra2 = new AliESDtrackCuts("No_SPD", "Reject tracks with cluster in SPD");
    fEsdTrackCutsExtra2->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kNone);
    // A track passing fEsdTrackCuts and fEsdTrackCutsExtra2 corresponds to esdTrackCutsHTGC and needs to be constrained
    
    
  }
}


//______________________________________________________________________________
Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
  //Check esd track
  FillHistograms(kPreCut, track);


  if( fFilterBit == 256) {

    ///Standalone tpc tracks constrained
    const AliExternalTrackParam * param = track->GetConstrainedParam();
    if(param) {
      AliESDtrack* esdTrack = new AliESDtrack(*track);
      esdTrack->CopyFromVTrack(param);
      track = esdTrack;
      fOwnedTracks.Add(track);

      if( !fEsdTrackCuts->IsSelected(track)) return kFALSE;

      FillHistograms(1, track);

      Double_t dca[2];
      GetDCA(track, dca);
      
      FillDCAHist(dca[1], dca[0], track);
      if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
      return kTRUE;
    } else {
      return kFALSE;
    }

    return kFALSE;
  }


  if(!fInitialized) {
    DefineESDCuts();
    // if(fDCAXYmax > 0) {
    //   if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexXY(fDCAXYmax);
    // }
    // if(fDCAZmax > 0) {
    //   if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexZ(fDCAZmax);
    // }
  
    fInitialized = kTRUE;
  }


  Double_t dca[2];
  GetDCA(track, dca);

  
  ///If only one track cuts then it has passed the cuts
  if( !(fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2)) {
    FillHistograms(1, track);
    FillDCAHist(dca[1], dca[0], track);
    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
    return kTRUE;
  }

  ///If passing extra
  if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra1->IsSelected(track)) {
    FillHistograms(1, track);
    FillHistograms(2, track);

    FillDCAHist(dca[1], dca[0], track);
    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
    
    return kTRUE;
  } 

  ///If passing extra2
  if (fEsdTrackCutsExtra2 && fEsdTrackCutsExtra2->IsSelected(track)) {
    const AliExternalTrackParam * param = track->GetConstrainedParam();
    if(param) {
      AliESDtrack* esdTrack = new AliESDtrack(*track);
      esdTrack->CopyFromVTrack(param);
      track = esdTrack;
      fOwnedTracks.Add(track);

      FillHistograms(3, track);
      FillHistograms(1, track);

      FillDCAHist(dca[1], dca[0], track);
      if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());

      return kTRUE;
    } else {
      return kFALSE;
    }
  } else {
    return kFALSE;
  }

  cout << "error error, should not be herer!"<<endl;
  return kFALSE;

  // FillHistograms(kPreCut + 1, track);
  // return kTRUE;

  // fhnclpt->Fill(track->Pt(), track->GetTPCNcls());
  // if(track->GetTPCNclsF() > 0) fhnclsfpt->Fill(track->Pt(), ((Double_t) track->GetTPCNcls())/track->GetTPCNclsF());
  // FillHistograms(kPreCut + 1, track);

  // ///Get impact parameters
  // Double_t extCov[15];
  // track->GetExternalCovariance(extCov);
  // return kTRUE;
}

Bool_t AliConversionTrackCuts::AcceptTrack(AliAODTrack * track) {
  //Check aod track
  
  FillHistograms(kPreCut, track);
  
  if (fFilterBit == 768) {
    if(!track->IsHybridGlobalConstrainedGlobal()) return kFALSE;
      
    if (!(track->GetStatus() & AliVTrack::kITSrefit)) {
      return kFALSE;
    }
      
    //The cluster sharing cut can be done with:
    Double_t frac = Double_t(track->GetTPCnclsS()) / Double_t(track->GetTPCncls());
    if (frac > 0.4) return kFALSE;
      
    ///Do dca xy cut!
    FillHistograms(1, track);
      
    ///DCA
    Double_t dca[2] = { -999, -999};
    //Bool_t dcaok = 
    GetDCA(track, dca);
    FillDCAHist(dca[1], dca[0], track);
      
      
    if(track->IsGlobalConstrained()) {
      FillHistograms(3, track);
    } else {
      FillHistograms(2, track);
    }
      
    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
      
    return kTRUE;
    
    ////////////////////////////////
    //// Standalone
    ////////////////////////////////
  } else  if(fFilterBit == 256) {
    if(!track->IsTPCConstrained()) return kFALSE;


    ///DCA
    Double_t dca[2] = { -999, -999};
    GetDCA(track, dca);

    if( (dca[0]*dca[0]/fDCAXYmax + dca[1]*dca[1]/fDCAZmax) > 1 ) {
      FillHistograms(3, track);
      return kFALSE;
    }

    if(track->GetTPCncls() < 70) {
      FillHistograms(4, track);
      return kFALSE;
    }

    AliAODVertex * vtx = track->GetProdVertex();
    if (vtx->GetType() == AliAODVertex::kKink ) {
      FillHistograms(5, track);
      return kFALSE;
    }

    if(track->Chi2perNDF() > 36) {
      FillHistograms(6, track);
      return kFALSE;
    }
    if(track->Chi2perNDF() > 26) {
      FillHistograms(7, track);
      return kFALSE;
    }
    if(track->Chi2perNDF() > 16) {
      FillHistograms(8, track);
      return kFALSE;
    }
    if(track->Chi2perNDF() > 4) {
      FillHistograms(9, track);
      return kFALSE;
    }


    FillDCAHist(dca[1], dca[0], track);

    FillHistograms(2, track);
    if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
    return kTRUE;

  }
  return kFALSE;
}


///______________________________________________________________________________
Bool_t AliConversionTrackCuts::GetDCA(const AliESDtrack *track, Double_t dcaxyz[2]) {
  ///Get track dca esd trck
  Float_t dca[2];
  Float_t bCov[3];
  track->GetImpactParameters(dca,bCov);
  if (bCov[0]<=0 || bCov[2]<=0) {
    AliDebug(1, "Estimated b resolution lower or equal zero!");
    bCov[0]=0; bCov[2]=0;
    return kFALSE;
  }

  dcaxyz[0] = dca[0];
  dcaxyz[1] = dca[1];
  
  return kTRUE;
}

///_____________________________________________________________________________
Bool_t AliConversionTrackCuts::GetDCA(const AliAODTrack *track, Double_t dca[2]) {
  ///Get track dca aod trck
  if(track->TestBit(AliAODTrack::kIsDCA)){
    dca[0]=track->DCA();
    dca[1]=track->ZAtDCA();
    return kTRUE;
  }
  
  Bool_t ok=kFALSE;
  if(fEvent) {
    Double_t covdca[3];
    //AliAODTrack copy(*track);
    AliExternalTrackParam etp; etp.CopyFromVTrack(track);
    
    Float_t xstart = etp.GetX();
    if(xstart>3.) {
      dca[0]=-999.;
      dca[1]=-999.;
    //printf("This method can be used only for propagation inside the beam pipe \n");
    return kFALSE;
    }


    AliAODVertex *vtx =(AliAODVertex*)(fEvent->GetPrimaryVertex());
    Double_t fBzkG = fEvent->GetMagneticField(); // z componenent of field in kG
    ok = etp.PropagateToDCA(vtx,fBzkG,kVeryBig,dca,covdca);
    //ok = copy.PropagateToDCA(vtx,fBzkG,kVeryBig,dca,covdca);
  }
  if(!ok){
    dca[0]=-999.;
    dca[1]=-999.;
  }
  return ok;
}


TList * AliConversionTrackCuts::CreateHistograms() {
  //Create the histograms

  if(!fHistograms) fHistograms = new TList();

  fHistograms->SetOwner(kTRUE);
  fHistograms->SetName("trackCuts");

  fhPhi = new TH2F(Form("phi_%s", GetName()), Form("phi_%s", GetTitle()), 5, -0.5, 4.5, 32, 0, TMath::TwoPi());
  // TAxis * xax = fhPhi->GetXaxis();
  // for(Int_t i = 0; i < kNCuts; i++){
  // 	xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
  // }
  fHistograms->Add(fhPhi);
  

  fhEtaPhi = new TH2F(Form("etaphi_%s",GetName()), Form("etaphi_%s", GetTitle()), 36, -0.9, 0.9, 32, 0, TMath::TwoPi());
  fHistograms->Add(fhEtaPhi);

  // fhPt = new TH2F("pt", "pt", kNCuts+2, kPreCut -0.5, kNCuts + 0.5, 
  // 				  20, 0., 20.);
  // xax = fhPt->GetXaxis();
  // for(Int_t i = 0; i < kNCuts; i++){
  // 	xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
  // }
  // fHistograms->Add(fhPt);

  //  fhPhiPt = new TH2F("phipt", "phipt", 100, 0, 100, 64, 0, TMath::TwoPi());
  //fHistograms->Add(fhPhiPt);

  fhdcaxyPt = new TH2F(Form("dcaxypt_%s", GetName()),  Form("dcaxypt_%s", GetTitle()), 20, 0, 20, 50, -2.5, 2.5);
  fHistograms->Add(fhdcaxyPt);

  fhdcazPt = new TH2F(Form("dcazpt_%s", GetName()),  Form("dcazpt_%s", GetTitle()), 20, 0, 20, 70, -3.5, 3.5);
  fHistograms->Add(fhdcazPt);

  fhdca = new TH2F(Form("dca_%s", GetName()),  Form("dca_%s", GetTitle()), 70, -3.5, 3.5, 50, -2.5, 2.5);
  fhdca->SetXTitle("dca z");
  fhdca->SetYTitle("dca xy");

  
  fHistograms->Add(fhdca);

  // fhnclpt = new TH2F("nclstpcvspt", "nclstpcvspt", 20, 0, 20, 50, 0, 100);
  // fHistograms->Add(fhnclpt);

  // fhnclsfpt = new TH2F("nclsfpt", "nclsfpt", 20, 0, 20, 60, 0, 1.2);
  // fHistograms->Add(fhnclsfpt);

  
  if (fkCreateTrackEff) {
    const Double_t ptbins[23] = {0.5,  0.6, 0.7,  0.8, 0.9,  1.0, 1.2, 1.4,  1.6, 1.8, 
			  2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.25, 
			  4.5, 4.75, 5.0};
    
    const Int_t bins[4] = { 12,  22, 36, 32};
    const Double_t min[4] = { -12, 0.5, -.9,  0};
    const Double_t max[4] = {  12,   5,  .9,  2*TMath::Pi() };
    
    fhTrackEff = new THnF(Form("hTrackEff_%s", GetName()), "hTrackEff", 4, bins, min, max);
    fhTrackEff->SetBinEdges(1, ptbins);
    fHistograms->Add(fhTrackEff);
  }

  
  return fHistograms;
}

void AliConversionTrackCuts::FillHistograms(Int_t cutIndex, AliVTrack * track) {

  //Fill histograms
  if(fhPhi) fhPhi->Fill(cutIndex, track->Phi());
  //  if(fhPt) fhPt->Fill(cutIndex, track->Pt());
  //if(passed) fhPhiPt->Fill(track->Pt(), track->Phi());

}

void AliConversionTrackCuts::FillDCAHist(Float_t dcaz, Float_t dcaxy, AliVTrack * track) {
  if(fhdcaxyPt) fhdcaxyPt->Fill(track->Pt(), dcaxy);
  if(fhdcazPt) fhdcazPt->Fill(track->Pt(), dcaz);
  if(fhdca) fhdca->Fill(dcaz, dcaxy);
  
  if(fhTrackEff) {
    Double_t val[4];
    val[0] = fEvent->GetPrimaryVertex()->GetZ();
    val[1] =  track->Pt();
    val[2] =  track->Eta();
    val[3] =  track->Phi();
    
    fhTrackEff->Fill(val);
  }
}


//_________________________________________________________________________________________________
void AliConversionTrackCuts::Print(const Option_t *) const
{
//
// Print information on this cut
//

  // printf("Cut name                : %s \n", GetName());
  // printf("Kink daughters are      : %s \n", (fRejectKinkDaughters ? "rejected" : "accepted"));
  // printf("TPC requirements        : clusters/findable %f, min. cluster = %d, max chi2 = %f, %s require refit\n", fTPCClusOverFindable, fTPCminNClusters, fTPCmaxChi2, (fRequireTPCRefit) ? "" : "Don't");
  // printf("ITS requirements        : min. cluster = %d (all), %d (SPD), max chi2 = %f \n", fITSminNClusters, fSPDminNClusters, fITSmaxChi2);
  // printf("DCA z cut               : fixed to %f cm \n", fDCAZmax);
  // printf("DCA xy cut              : fixed to %f cm \n", fDCAXYmax)
    ;
}
 
//_________________________________________________________________________________________________

Bool_t AliConversionTrackCuts::IsSelected(TObject * object ) {
  AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(object);
  if (aodtrack) {
    return AcceptTrack(aodtrack);
  } else {
    AliESDtrack * track = dynamic_cast<AliESDtrack*>(object);
    if (track)
      return AcceptTrack(track);
  }

return kFALSE;
}
Commit	Line	Data
4267afec	1	/**************************************************************************
	2	* This file is property of and copyright by the ALICE HLT Project *
	3	* ALICE Experiment at CERN, All rights reserved. *
	4	* *
	5	* Primary Author: Svein Lindal <slindal@fys.uio.no> *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/// @file AliConversionTrackCuts.cxx
	17	/// @author Svein Lindal
a8515f2e	18	/// @brief Base class for analysation of conversion particle - track correlations - track cuts
4267afec	19
	20
	21	#include "AliConversionTrackCuts.h"
92efd725	22	//#include "AliAODTrack.h"
4267afec	23	#include "AliAODEvent.h"
	24	#include <TFormula.h>
	25	#include <iostream>
	26	#include "TH2F.h"
439cf020	27	#include "AliESDtrackCuts.h"
839f7ade	28	#include "THn.h"
4267afec	29
	30	using namespace std;
	31	ClassImp(AliConversionTrackCuts)
	32
	33
	34	const char* AliConversionTrackCuts::fgkCutNames[AliConversionTrackCuts::kNCuts] = {
	35	"nClusTPC",
	36	"FoundFindable",
	37	"Chi2PerNDF",
	38	"Kink",
	39	"DCA_Z",
	40	"DCA_XY",
	41	"TPCRefit"
	42	"kAccTracks"
	43	};
	44
	45
	46
	47	//________________________________________________________________________
	48	AliConversionTrackCuts::AliConversionTrackCuts() :
439cf020	49	AliAnalysisCuts(),
99d49b30	50	fEsdTrackCuts(NULL),
	51	fEsdTrackCutsExtra1(NULL),
	52	fEsdTrackCutsExtra2(NULL),
	53	fEvent(NULL),
	54	fFilterBit(2048),
a8515f2e	55	fDCAZmax(3.2*3.2),
a8515f2e	56	fDCAXYmax(2.4*2.4),
99d49b30	57	fOwnedTracks(),
99d49b30	58	fInitialized(kFALSE),
4267afec	59	fhPhi(NULL),
266ffce4 SL	60	// fhPt(NULL),
266ffce4 SL	61	//fhPhiPt(NULL),
4267afec	62	fhdcaxyPt(NULL),
a280ac15	63	fhdcazPt(NULL),
439cf020	64	fhdca(NULL),
a280ac15	65	fhnclpt(NULL),
a280ac15	66	fhnclsfpt(NULL),
266ffce4	67	fhEtaPhi(NULL),
839f7ade	68	fhTrackEff(NULL),
839f7ade	69	fkCreateTrackEff(kFALSE),
99d49b30	70	fHistograms(NULL)
99d49b30	71	{
4267afec	72	//Constructor
99d49b30	73	fOwnedTracks.SetOwner(kTRUE);
4267afec	74	}
	75	//________________________________________________________________________
	76	AliConversionTrackCuts::AliConversionTrackCuts(TString name, TString title = "title") :
	77	AliAnalysisCuts(name, title),
99d49b30	78	fEsdTrackCuts(NULL),
	79	fEsdTrackCutsExtra1(NULL),
	80	fEsdTrackCutsExtra2(NULL),
	81	fEvent(NULL),
	82	fFilterBit(2048),
	83	fDCAZmax(-1),
	84	fDCAXYmax(-1),
	85	fOwnedTracks(),
	86	fInitialized(kFALSE),
4267afec	87	fhPhi(NULL),
266ffce4 SL	88	//fhPt(NULL),
266ffce4 SL	89	//fhPhiPt(NULL),
4267afec	90	fhdcaxyPt(NULL),
a280ac15	91	fhdcazPt(NULL),
439cf020	92	fhdca(NULL),
a280ac15	93	fhnclpt(NULL),
a280ac15	94	fhnclsfpt(NULL),
266ffce4	95	fhEtaPhi(NULL),
839f7ade	96	fhTrackEff(NULL),
839f7ade	97	fkCreateTrackEff(kFALSE),
4267afec	98	fHistograms(NULL)
	99	{
	100	//Constructor
99d49b30	101	fOwnedTracks.SetOwner(kTRUE);
849102f9	102	}
4267afec	103
	104
	105	//________________________________________________________________________________
	106	AliConversionTrackCuts::~AliConversionTrackCuts() {
	107	///destructor
	108	// if(fHistograms)
	109	// delete fHistograms;
	110	// fHistograms = NULL;
	111
99d49b30	112	if(fEsdTrackCuts)
	113	delete fEsdTrackCuts;
	114	fEsdTrackCuts = NULL;
	115
	116	if(fEsdTrackCutsExtra1)
	117	delete fEsdTrackCutsExtra1;
	118	fEsdTrackCutsExtra1 = NULL;
	119
	120	if(fEsdTrackCutsExtra2)
	121	delete fEsdTrackCutsExtra2;
	122	fEsdTrackCutsExtra2 = NULL;
	123
	124	fOwnedTracks.Delete();
	125	}
	126
	127	//______________________________________________________________________________
	128	void AliConversionTrackCuts::DefineESDCuts() {
	129	// Reproduces the cuts of the corresponding bit in the ESD->AOD filtering
	130	// (see $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C)
	131	///Copied from alianalyseleadingue
	132	const Int_t filterbit = fFilterBit;
	133
	134	if (filterbit == 128) {
a8515f2e	135	if(!fEsdTrackCuts) {
	136	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	137	fEsdTrackCuts->SetMinNClustersTPC(70);
	138	}
99d49b30	139	} else if (filterbit == 256) {
a8515f2e	140	if(!fEsdTrackCuts) {
	141	// syst study
	142	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	143	fEsdTrackCuts->SetMinNClustersTPC(80);
	144	fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
	145	fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
	146	fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
	147	}
99d49b30	148	} else if (filterbit == 512) {
a8515f2e	149	if(!fEsdTrackCuts) {
	150	// syst study
	151	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	152	fEsdTrackCuts->SetMinNClustersTPC(60);
	153	fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
	154	fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
	155	fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
	156	}
99d49b30	157	} else if (filterbit == 1024) {
	158	if(!fEsdTrackCuts) {
	159	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	160	fEsdTrackCuts->SetMinNClustersTPC(-1);
	161	fEsdTrackCuts->SetMinNCrossedRowsTPC(70);
	162	fEsdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
	163	}
	164	} else if (filterbit == 2048) {
	165	// mimic hybrid tracks
	166	// correspond to esdTrackCutsHTG, but WITHOUT spd constraint. this is checked with the next object
	167	if(!fEsdTrackCuts) {
	168	fEsdTrackCuts = new AliESDtrackCuts();
	169	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
	170	fEsdTrackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
	171	fEsdTrackCuts->SetMaxChi2PerClusterTPC(4);
	172	fEsdTrackCuts->SetRequireTPCStandAlone(kTRUE);
	173	fEsdTrackCuts->SetAcceptKinkDaughters(kFALSE);
	174	fEsdTrackCuts->SetRequireTPCRefit(kTRUE);
	175	fEsdTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
	176
	177	fEsdTrackCuts->SetMaxDCAToVertexXY(2.4);
	178	fEsdTrackCuts->SetMaxDCAToVertexZ(3.2);
	179	fEsdTrackCuts->SetDCAToVertex2D(kTRUE);
	180
	181	fEsdTrackCuts->SetMaxChi2PerClusterITS(36);
	182	fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
	183
	184	fEsdTrackCuts->SetRequireSigmaToVertex(kFALSE);
	185
	186	fEsdTrackCuts->SetEtaRange(-0.9, 0.9);
	187	fEsdTrackCuts->SetPtRange(0.1, 1000000.0);
	188
	189	fEsdTrackCuts->SetRequireITSRefit(kFALSE); //not here, n
	190	}
	191	// Add SPD requirement
	192	fEsdTrackCutsExtra1 = new AliESDtrackCuts("SPD", "Require 1 cluster in SPD");
	193	fEsdTrackCutsExtra1->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
	194	fEsdTrackCutsExtra1->SetRequireITSRefit(kTRUE);
	195	// A track passing fEsdTrackCuts and fEsdTrackCutsExtra1 corresponds to esdTrackCutsHTG
	196
	197	fEsdTrackCutsExtra2 = new AliESDtrackCuts("No_SPD", "Reject tracks with cluster in SPD");
	198	fEsdTrackCutsExtra2->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kNone);
	199	// A track passing fEsdTrackCuts and fEsdTrackCutsExtra2 corresponds to esdTrackCutsHTGC and needs to be constrained
	200
	201
	202	}
4267afec	203	}
4267afec	204
a8515f2e	205
99d49b30	206	//______________________________________________________________________________
	207	Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
	208	//Check esd track
a8515f2e	209	FillHistograms(kPreCut, track);
	210
	211
	212	if( fFilterBit == 256) {
	213
	214	///Standalone tpc tracks constrained
	215	const AliExternalTrackParam * param = track->GetConstrainedParam();
	216	if(param) {
	217	AliESDtrack* esdTrack = new AliESDtrack(*track);
	218	esdTrack->CopyFromVTrack(param);
	219	track = esdTrack;
	220	fOwnedTracks.Add(track);
	221
	222	if( !fEsdTrackCuts->IsSelected(track)) return kFALSE;
	223
	224	FillHistograms(1, track);
	225
	226	Double_t dca[2];
	227	GetDCA(track, dca);
	228
	229	FillDCAHist(dca[1], dca[0], track);
	230	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
a8515f2e	231	return kTRUE;
	232	} else {
	233	return kFALSE;
	234	}
	235
	236	return kFALSE;
	237	}
	238
99d49b30	239
	240	if(!fInitialized) {
	241	DefineESDCuts();
a8515f2e	242	// if(fDCAXYmax > 0) {
	243	// if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexXY(fDCAXYmax);
	244	// }
	245	// if(fDCAZmax > 0) {
	246	// if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexZ(fDCAZmax);
	247	// }
99d49b30	248
	249	fInitialized = kTRUE;
	250	}
	251
99d49b30	252
a8515f2e	253	Double_t dca[2];
a8515f2e	254	GetDCA(track, dca);
99d49b30	255
99d49b30	256
99d49b30	257	///If only one track cuts then it has passed the cuts
	258	if( !(fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2)) {
	259	FillHistograms(1, track);
a8515f2e	260	FillDCAHist(dca[1], dca[0], track);
a8515f2e	261	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
99d49b30	262	return kTRUE;
99d49b30	263	}
a8515f2e	264
99d49b30	265	///If passing extra
99d49b30	266	if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra1->IsSelected(track)) {
99d49b30	267	FillHistograms(1, track);
a8515f2e	268	FillHistograms(2, track);
	269
	270	FillDCAHist(dca[1], dca[0], track);
	271	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
	272
99d49b30	273	return kTRUE;
	274	}
	275
	276	///If passing extra2
	277	if (fEsdTrackCutsExtra2 && fEsdTrackCutsExtra2->IsSelected(track)) {
	278	const AliExternalTrackParam * param = track->GetConstrainedParam();
	279	if(param) {
34a878c4	280	AliESDtrack* esdTrack = new AliESDtrack(*track);
99d49b30	281	esdTrack->CopyFromVTrack(param);
	282	track = esdTrack;
	283	fOwnedTracks.Add(track);
	284
	285	FillHistograms(3, track);
	286	FillHistograms(1, track);
a8515f2e	287
	288	FillDCAHist(dca[1], dca[0], track);
	289	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
	290
99d49b30	291	return kTRUE;
	292	} else {
	293	return kFALSE;
	294	}
	295	} else {
	296	return kFALSE;
	297	}
	298
	299	cout << "error error, should not be herer!"<<endl;
	300	return kFALSE;
	301
	302	// FillHistograms(kPreCut + 1, track);
	303	// return kTRUE;
	304
	305	// fhnclpt->Fill(track->Pt(), track->GetTPCNcls());
	306	// if(track->GetTPCNclsF() > 0) fhnclsfpt->Fill(track->Pt(), ((Double_t) track->GetTPCNcls())/track->GetTPCNclsF());
	307	// FillHistograms(kPreCut + 1, track);
	308
	309	// ///Get impact parameters
	310	// Double_t extCov[15];
	311	// track->GetExternalCovariance(extCov);
99d49b30	312	// return kTRUE;
	313	}
	314
	315	Bool_t AliConversionTrackCuts::AcceptTrack(AliAODTrack * track) {
	316	//Check aod track
a8515f2e	317
99d49b30	318	FillHistograms(kPreCut, track);
a8515f2e	319
	320	if (fFilterBit == 768) {
	321	if(!track->IsHybridGlobalConstrainedGlobal()) return kFALSE;
	322
	323	if (!(track->GetStatus() & AliVTrack::kITSrefit)) {
	324	return kFALSE;
	325	}
	326
	327	//The cluster sharing cut can be done with:
	328	Double_t frac = Double_t(track->GetTPCnclsS()) / Double_t(track->GetTPCncls());
	329	if (frac > 0.4) return kFALSE;
	330
	331	///Do dca xy cut!
	332	FillHistograms(1, track);
	333
	334	///DCA
	335	Double_t dca[2] = { -999, -999};
	336	//Bool_t dcaok =
	337	GetDCA(track, dca);
	338	FillDCAHist(dca[1], dca[0], track);
	339
	340
	341	if(track->IsGlobalConstrained()) {
	342	FillHistograms(3, track);
	343	} else {
	344	FillHistograms(2, track);
	345	}
	346
	347	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
	348
	349	return kTRUE;
	350
	351	////////////////////////////////
	352	//// Standalone
	353	////////////////////////////////
	354	} else if(fFilterBit == 256) {
	355	if(!track->IsTPCConstrained()) return kFALSE;
99d49b30	356
99d49b30	357
34a878c4	358
a8515f2e	359	///DCA
	360	Double_t dca[2] = { -999, -999};
	361	GetDCA(track, dca);
34a878c4	362
a8515f2e	363	if( (dca[0]dca[0]/fDCAXYmax + dca[1]dca[1]/fDCAZmax) > 1 ) {
	364	FillHistograms(3, track);
	365	return kFALSE;
	366	}
99d49b30	367
a8515f2e	368	if(track->GetTPCncls() < 70) {
	369	FillHistograms(4, track);
	370	return kFALSE;
	371	}
99d49b30	372
a8515f2e	373	AliAODVertex * vtx = track->GetProdVertex();
	374	if (vtx->GetType() == AliAODVertex::kKink ) {
	375	FillHistograms(5, track);
	376	return kFALSE;
	377	}
99d49b30	378
a8515f2e	379	if(track->Chi2perNDF() > 36) {
	380	FillHistograms(6, track);
	381	return kFALSE;
	382	}
	383	if(track->Chi2perNDF() > 26) {
	384	FillHistograms(7, track);
	385	return kFALSE;
	386	}
	387	if(track->Chi2perNDF() > 16) {
	388	FillHistograms(8, track);
	389	return kFALSE;
	390	}
	391	if(track->Chi2perNDF() > 4) {
	392	FillHistograms(9, track);
	393	return kFALSE;
	394	}
	395
	396
	397
	398	FillDCAHist(dca[1], dca[0], track);
99d49b30	399
266ffce4	400	FillHistograms(2, track);
a8515f2e	401	if(fhEtaPhi) fhEtaPhi->Fill(track->Eta(), track->Phi());
	402	return kTRUE;
	403
266ffce4	404	}
a8515f2e	405	return kFALSE;
	406	}
	407
99d49b30	408
a8515f2e	409	///______________________________________________________________________________
	410	Bool_t AliConversionTrackCuts::GetDCA(const AliESDtrack *track, Double_t dcaxyz[2]) {
	411	///Get track dca esd trck
	412	Float_t dca[2];
	413	Float_t bCov[3];
	414	track->GetImpactParameters(dca,bCov);
	415	if (bCov[0]<=0 \|\| bCov[2]<=0) {
	416	AliDebug(1, "Estimated b resolution lower or equal zero!");
	417	bCov[0]=0; bCov[2]=0;
	418	return kFALSE;
	419	}
	420
	421	dcaxyz[0] = dca[0];
	422	dcaxyz[1] = dca[1];
	423
266ffce4	424	return kTRUE;
99d49b30	425	}
99d49b30	426
a8515f2e	427	///_____________________________________________________________________________
266ffce4	428	Bool_t AliConversionTrackCuts::GetDCA(const AliAODTrack *track, Double_t dca[2]) {
a8515f2e	429	///Get track dca aod trck
266ffce4 SL	430	if(track->TestBit(AliAODTrack::kIsDCA)){
	431	dca[0]=track->DCA();
	432	dca[1]=track->ZAtDCA();
	433	return kTRUE;
	434	}
	435
	436	Bool_t ok=kFALSE;
	437	if(fEvent) {
	438	Double_t covdca[3];
	439	//AliAODTrack copy(*track);
	440	AliExternalTrackParam etp; etp.CopyFromVTrack(track);
	441
	442	Float_t xstart = etp.GetX();
	443	if(xstart>3.) {
	444	dca[0]=-999.;
a8515f2e	445	dca[1]=-999.;
266ffce4 SL	446	//printf("This method can be used only for propagation inside the beam pipe \n");
	447	return kFALSE;
	448	}
99d49b30	449
99d49b30	450
266ffce4 SL	451	AliAODVertex vtx =(AliAODVertex)(fEvent->GetPrimaryVertex());
	452	Double_t fBzkG = fEvent->GetMagneticField(); // z componenent of field in kG
	453	ok = etp.PropagateToDCA(vtx,fBzkG,kVeryBig,dca,covdca);
	454	//ok = copy.PropagateToDCA(vtx,fBzkG,kVeryBig,dca,covdca);
	455	}
	456	if(!ok){
	457	dca[0]=-999.;
	458	dca[1]=-999.;
	459	}
	460	return ok;
	461	}
99d49b30	462
	463
	464
4267afec	465	TList * AliConversionTrackCuts::CreateHistograms() {
4267afec	466	//Create the histograms
439cf020	467
4267afec	468	if(!fHistograms) fHistograms = new TList();
	469
	470	fHistograms->SetOwner(kTRUE);
	471	fHistograms->SetName("trackCuts");
	472
5f175fb0	473	fhPhi = new TH2F(Form("phi_%s", GetName()), Form("phi_%s", GetTitle()), 5, -0.5, 4.5, 32, 0, TMath::TwoPi());
99d49b30	474	// TAxis * xax = fhPhi->GetXaxis();
	475	// for(Int_t i = 0; i < kNCuts; i++){
	476	// xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
	477	// }
4267afec	478	fHistograms->Add(fhPhi);
	479
	480
5f175fb0	481	fhEtaPhi = new TH2F(Form("etaphi_%s",GetName()), Form("etaphi_%s", GetTitle()), 36, -0.9, 0.9, 32, 0, TMath::TwoPi());
266ffce4	482	fHistograms->Add(fhEtaPhi);
4267afec	483
99d49b30	484	// fhPt = new TH2F("pt", "pt", kNCuts+2, kPreCut -0.5, kNCuts + 0.5,
	485	// 20, 0., 20.);
	486	// xax = fhPt->GetXaxis();
	487	// for(Int_t i = 0; i < kNCuts; i++){
	488	// xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
	489	// }
	490	// fHistograms->Add(fhPt);
4267afec	491
439cf020	492	// fhPhiPt = new TH2F("phipt", "phipt", 100, 0, 100, 64, 0, TMath::TwoPi());
439cf020	493	//fHistograms->Add(fhPhiPt);
4267afec	494
5f175fb0	495	fhdcaxyPt = new TH2F(Form("dcaxypt_%s", GetName()), Form("dcaxypt_%s", GetTitle()), 20, 0, 20, 50, -2.5, 2.5);
266ffce4	496	fHistograms->Add(fhdcaxyPt);
4267afec	497
5f175fb0	498	fhdcazPt = new TH2F(Form("dcazpt_%s", GetName()), Form("dcazpt_%s", GetTitle()), 20, 0, 20, 70, -3.5, 3.5);
266ffce4	499	fHistograms->Add(fhdcazPt);
4267afec	500
5f175fb0	501	fhdca = new TH2F(Form("dca_%s", GetName()), Form("dca_%s", GetTitle()), 70, -3.5, 3.5, 50, -2.5, 2.5);
266ffce4 SL	502	fhdca->SetXTitle("dca z");
	503	fhdca->SetYTitle("dca xy");
	504
	505
	506	fHistograms->Add(fhdca);
439cf020	507
99d49b30	508	// fhnclpt = new TH2F("nclstpcvspt", "nclstpcvspt", 20, 0, 20, 50, 0, 100);
99d49b30	509	// fHistograms->Add(fhnclpt);
4267afec	510
99d49b30	511	// fhnclsfpt = new TH2F("nclsfpt", "nclsfpt", 20, 0, 20, 60, 0, 1.2);
99d49b30	512	// fHistograms->Add(fhnclsfpt);
839f7ade	513
	514
	515
	516	if (fkCreateTrackEff) {
	517	const Double_t ptbins[23] = {0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.2, 1.4, 1.6, 1.8,
	518	2.0, 2.25, 2.5, 2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.25,
	519	4.5, 4.75, 5.0};
	520
	521	const Int_t bins[4] = { 12, 22, 36, 32};
	522	const Double_t min[4] = { -12, 0.5, -.9, 0};
	523	const Double_t max[4] = { 12, 5, .9, 2*TMath::Pi() };
	524
	525	fhTrackEff = new THnF(Form("hTrackEff_%s", GetName()), "hTrackEff", 4, bins, min, max);
	526	fhTrackEff->SetBinEdges(1, ptbins);
	527	fHistograms->Add(fhTrackEff);
	528	}
	529
4267afec	530
	531	return fHistograms;
	532	}
	533
99d49b30	534	void AliConversionTrackCuts::FillHistograms(Int_t cutIndex, AliVTrack * track) {
4267afec	535
4267afec	536	//Fill histograms
99d49b30	537	if(fhPhi) fhPhi->Fill(cutIndex, track->Phi());
99d49b30	538	// if(fhPt) fhPt->Fill(cutIndex, track->Pt());
439cf020	539	//if(passed) fhPhiPt->Fill(track->Pt(), track->Phi());
4267afec	540
	541	}
	542
439cf020	543	void AliConversionTrackCuts::FillDCAHist(Float_t dcaz, Float_t dcaxy, AliVTrack * track) {
99d49b30	544	if(fhdcaxyPt) fhdcaxyPt->Fill(track->Pt(), dcaxy);
	545	if(fhdcazPt) fhdcazPt->Fill(track->Pt(), dcaz);
	546	if(fhdca) fhdca->Fill(dcaz, dcaxy);
839f7ade	547
	548	if(fhTrackEff) {
	549	Double_t val[4];
	550	val[0] = fEvent->GetPrimaryVertex()->GetZ();
	551	val[1] = track->Pt();
	552	val[2] = track->Eta();
	553	val[3] = track->Phi();
	554
	555	fhTrackEff->Fill(val);
	556	}
439cf020	557	}
439cf020	558
4267afec	559
92efd725	560
439cf020	561
4267afec	562	//_________________________________________________________________________________________________
	563	void AliConversionTrackCuts::Print(const Option_t *) const
	564	{
	565	//
	566	// Print information on this cut
	567	//
	568
99d49b30	569	// printf("Cut name : %s \n", GetName());
	570	// printf("Kink daughters are : %s \n", (fRejectKinkDaughters ? "rejected" : "accepted"));
	571	// printf("TPC requirements : clusters/findable %f, min. cluster = %d, max chi2 = %f, %s require refit\n", fTPCClusOverFindable, fTPCminNClusters, fTPCmaxChi2, (fRequireTPCRefit) ? "" : "Don't");
	572	// printf("ITS requirements : min. cluster = %d (all), %d (SPD), max chi2 = %f \n", fITSminNClusters, fSPDminNClusters, fITSmaxChi2);
	573	// printf("DCA z cut : fixed to %f cm \n", fDCAZmax);
	574	// printf("DCA xy cut : fixed to %f cm \n", fDCAXYmax)
	575	;
4267afec	576	}
439cf020	577
439cf020	578	//_________________________________________________________________________________________________
4267afec	579
439cf020	580	Bool_t AliConversionTrackCuts::IsSelected(TObject * object ) {
	581	AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(object);
	582	if (aodtrack) {
	583	return AcceptTrack(aodtrack);
	584	} else {
	585	AliESDtrack * track = dynamic_cast<AliESDtrack*>(object);
	586	if (track)
	587	return AcceptTrack(track);
	588	}
4267afec	589
439cf020	590	return kFALSE;
439cf020	591	}
4267afec	592
	593
	594
	595