[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


#include "AliConversionTrackCuts.h"
//#include "AliAODTrack.h"
#include "AliAODEvent.h"
#include <TFormula.h>
#include <iostream>
#include "TH2F.h"
#include "AliESDtrackCuts.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(-1),
  fDCAXYmax(-1),
  fOwnedTracks(),
  fInitialized(kFALSE),
  fhPhi(NULL),
  fhPt(NULL),
  fhPhiPt(NULL),
  fhdcaxyPt(NULL),
  fhdcazPt(NULL),
  fhdca(NULL),
  fhnclpt(NULL),
  fhnclsfpt(NULL),
  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),
  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) {
    fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
    fEsdTrackCuts->SetMinNClustersTPC(70);
    
  }  else if (filterbit == 256) {
    // syst study
    fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
    fEsdTrackCuts->SetMinNClustersTPC(80);
    fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
    fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
    fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
    
  }  else if (filterbit == 512) {
    // 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

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

  FillHistograms(kPreCut, track);


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


  ///If only one track cuts then it has passed the cuts
  if( !(fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2)) {
    FillHistograms(1, track);
    return kTRUE;
  }
  ///If passing extra
  if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra1->IsSelected(track)) {
    FillHistograms(2, track);
    FillHistograms(1, track);
    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);
      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);
  // Float_t b[2];
  // Float_t bCov[3];
  // track->GetImpactParameters(b,bCov);
  // if (bCov[0]<=0 || bCov[2]<=0) {
  //   AliDebug(1, "Estimated b resolution lower or equal zero!");
  //   bCov[0]=0; bCov[2]=0;
  // }
  
  // Float_t dcaToVertexXY = b[0];
  // Float_t dcaToVertexZ = b[1];
  // FillDCAHist(dcaToVertexZ, dcaToVertexXY, track);
  // return kTRUE;
}

Bool_t AliConversionTrackCuts::AcceptTrack(AliAODTrack * track) {
  //Check aod track
  FillHistograms(kPreCut, track);
  if(!track->TestFilterBit(fFilterBit)) {
    return kFALSE;
  }


  ///Do dca xy cut!
  FillHistograms(1, track);
  return kTRUE;


  // if (track->GetTPCNcls() < fTPCminNClusters) return kFALSE;
  // FillHistograms(kCutNcls, track);

  // if (track->Chi2perNDF() > fTPCmaxChi2) return kFALSE;
  // FillHistograms(kCutNDF, track);

  // AliAODVertex *vertex = track->GetProdVertex();
  // if (vertex && fRejectKinkDaughters) {
  //   if (vertex->GetType() == AliAODVertex::kKink) {
  //     return kFALSE;
  //   }
  // }
  // FillHistograms(kCutKinc, track);
  
  // if(TMath::Abs(track->ZAtDCA()) > fDCAZmax) {
  //   return kFALSE;
  // }
  // FillHistograms(kCutDCAZ, track);

  // Float_t xatdca = track->XAtDCA();
  // Float_t yatdca = track->YAtDCA();
  // Float_t xy = xatdca*xatdca + yatdca*yatdca;
  // if(xy > fDCAXYmax) {
  //   return kFALSE;
  // }

  // FillHistograms(kCutDCAXY, track);


  // fhnclpt->Fill(track->Pt(), track->GetTPCNcls());
  // if(track->GetTPCNclsF() > 0) fhnclsfpt->Fill(track->Pt(), ((Double_t) track->GetTPCNcls())/track->GetTPCNclsF());
  // FillDCAHist(track->ZAtDCA(), TMath::Sqrt(track->XAtDCA()*track->XAtDCA() + track->YAtDCA()*track->YAtDCA()), track);


}


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

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

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

  fhPhi = new TH2F("phi", "phi", 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);
  

  // 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("dcaxypt", "dcaxypt", 20, 0, 20, 50, 0, 5);
  // fHistograms->Add(fhdcaxyPt);

  // fhdcazPt = new TH2F("dcazpt", "dcazpt", 20, 0, 20, 50, 0, 5);
  // fHistograms->Add(fhdcazPt);

  // fhdca = new TH2F("dca", "dca", 60, -3, 3, 60, -3, 3);
  // 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);
  
  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);
}


//_________________________________________________________________________________________________
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
92efd725	18	/// @brief Base class for analysation of conversion particle - track correlations
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"
4267afec	28
	29	using namespace std;
	30	ClassImp(AliConversionTrackCuts)
	31
	32
	33	const char* AliConversionTrackCuts::fgkCutNames[AliConversionTrackCuts::kNCuts] = {
	34	"nClusTPC",
	35	"FoundFindable",
	36	"Chi2PerNDF",
	37	"Kink",
	38	"DCA_Z",
	39	"DCA_XY",
	40	"TPCRefit"
	41	"kAccTracks"
	42	};
	43
	44
	45
	46	//________________________________________________________________________
	47	AliConversionTrackCuts::AliConversionTrackCuts() :
439cf020	48	AliAnalysisCuts(),
99d49b30	49	fEsdTrackCuts(NULL),
	50	fEsdTrackCutsExtra1(NULL),
	51	fEsdTrackCutsExtra2(NULL),
	52	fEvent(NULL),
	53	fFilterBit(2048),
	54	fDCAZmax(-1),
	55	fDCAXYmax(-1),
	56	fOwnedTracks(),
	57	fInitialized(kFALSE),
4267afec	58	fhPhi(NULL),
	59	fhPt(NULL),
	60	fhPhiPt(NULL),
	61	fhdcaxyPt(NULL),
a280ac15	62	fhdcazPt(NULL),
439cf020	63	fhdca(NULL),
a280ac15	64	fhnclpt(NULL),
a280ac15	65	fhnclsfpt(NULL),
99d49b30	66	fHistograms(NULL)
99d49b30	67	{
4267afec	68	//Constructor
99d49b30	69	fOwnedTracks.SetOwner(kTRUE);
4267afec	70	}
	71	//________________________________________________________________________
	72	AliConversionTrackCuts::AliConversionTrackCuts(TString name, TString title = "title") :
	73	AliAnalysisCuts(name, title),
99d49b30	74	fEsdTrackCuts(NULL),
	75	fEsdTrackCutsExtra1(NULL),
	76	fEsdTrackCutsExtra2(NULL),
	77	fEvent(NULL),
	78	fFilterBit(2048),
	79	fDCAZmax(-1),
	80	fDCAXYmax(-1),
	81	fOwnedTracks(),
	82	fInitialized(kFALSE),
4267afec	83	fhPhi(NULL),
	84	fhPt(NULL),
	85	fhPhiPt(NULL),
	86	fhdcaxyPt(NULL),
a280ac15	87	fhdcazPt(NULL),
439cf020	88	fhdca(NULL),
a280ac15	89	fhnclpt(NULL),
a280ac15	90	fhnclsfpt(NULL),
4267afec	91	fHistograms(NULL)
	92	{
	93	//Constructor
99d49b30	94	fOwnedTracks.SetOwner(kTRUE);
849102f9	95	}
4267afec	96
	97
	98	//________________________________________________________________________________
	99	AliConversionTrackCuts::~AliConversionTrackCuts() {
	100	///destructor
	101	// if(fHistograms)
	102	// delete fHistograms;
	103	// fHistograms = NULL;
	104
99d49b30	105	if(fEsdTrackCuts)
	106	delete fEsdTrackCuts;
	107	fEsdTrackCuts = NULL;
	108
	109	if(fEsdTrackCutsExtra1)
	110	delete fEsdTrackCutsExtra1;
	111	fEsdTrackCutsExtra1 = NULL;
	112
	113	if(fEsdTrackCutsExtra2)
	114	delete fEsdTrackCutsExtra2;
	115	fEsdTrackCutsExtra2 = NULL;
	116
	117	fOwnedTracks.Delete();
	118	}
	119
	120	//______________________________________________________________________________
	121	void AliConversionTrackCuts::DefineESDCuts() {
	122	// Reproduces the cuts of the corresponding bit in the ESD->AOD filtering
	123	// (see $ALICE_ROOT/ANALYSIS/macros/AddTaskESDFilter.C)
	124	///Copied from alianalyseleadingue
	125	const Int_t filterbit = fFilterBit;
	126
	127	if (filterbit == 128) {
	128	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	129	fEsdTrackCuts->SetMinNClustersTPC(70);
	130
	131	} else if (filterbit == 256) {
	132	// syst study
	133	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	134	fEsdTrackCuts->SetMinNClustersTPC(80);
	135	fEsdTrackCuts->SetMaxChi2PerClusterTPC(3);
	136	fEsdTrackCuts->SetMaxDCAToVertexZ(2.7);
	137	fEsdTrackCuts->SetMaxDCAToVertexXY(1.9);
	138
	139	} else if (filterbit == 512) {
	140	// syst study
	141	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	142	fEsdTrackCuts->SetMinNClustersTPC(60);
	143	fEsdTrackCuts->SetMaxChi2PerClusterTPC(5);
	144	fEsdTrackCuts->SetMaxDCAToVertexZ(3.7);
	145	fEsdTrackCuts->SetMaxDCAToVertexXY(2.9);
	146
	147	} else if (filterbit == 1024) {
	148	if(!fEsdTrackCuts) {
	149	fEsdTrackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
	150	fEsdTrackCuts->SetMinNClustersTPC(-1);
	151	fEsdTrackCuts->SetMinNCrossedRowsTPC(70);
	152	fEsdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
	153	}
	154	} else if (filterbit == 2048) {
	155	// mimic hybrid tracks
	156	// correspond to esdTrackCutsHTG, but WITHOUT spd constraint. this is checked with the next object
	157	if(!fEsdTrackCuts) {
	158	fEsdTrackCuts = new AliESDtrackCuts();
	159	TFormula f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.x");
	160	fEsdTrackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep, 100);
	161	fEsdTrackCuts->SetMaxChi2PerClusterTPC(4);
	162	fEsdTrackCuts->SetRequireTPCStandAlone(kTRUE);
	163	fEsdTrackCuts->SetAcceptKinkDaughters(kFALSE);
	164	fEsdTrackCuts->SetRequireTPCRefit(kTRUE);
	165	fEsdTrackCuts->SetMaxFractionSharedTPCClusters(0.4);
	166
	167	fEsdTrackCuts->SetMaxDCAToVertexXY(2.4);
	168	fEsdTrackCuts->SetMaxDCAToVertexZ(3.2);
169	fEsdTrackCuts->SetDCAToVertex2D(kTRUE);
170
171	fEsdTrackCuts->SetMaxChi2PerClusterITS(36);
172	fEsdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
173
174	fEsdTrackCuts->SetRequireSigmaToVertex(kFALSE);
175
176	fEsdTrackCuts->SetEtaRange(-0.9, 0.9);
177	fEsdTrackCuts->SetPtRange(0.1, 1000000.0);
178
179	fEsdTrackCuts->SetRequireITSRefit(kFALSE); //not here, n
180	}
181	// Add SPD requirement
182	fEsdTrackCutsExtra1 = new AliESDtrackCuts("SPD", "Require 1 cluster in SPD");
183	fEsdTrackCutsExtra1->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
184	fEsdTrackCutsExtra1->SetRequireITSRefit(kTRUE);
185	// A track passing fEsdTrackCuts and fEsdTrackCutsExtra1 corresponds to esdTrackCutsHTG
186
187	fEsdTrackCutsExtra2 = new AliESDtrackCuts("No_SPD", "Reject tracks with cluster in SPD");
188	fEsdTrackCutsExtra2->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kNone);
189	// A track passing fEsdTrackCuts and fEsdTrackCutsExtra2 corresponds to esdTrackCutsHTGC and needs to be constrained
190
191
192	}
4267afec	193	}
4267afec	194
99d49b30	195	//______________________________________________________________________________
	196	Bool_t AliConversionTrackCuts::AcceptTrack(AliESDtrack * track) {
	197	//Check esd track
	198
	199	if(!fInitialized) {
	200	DefineESDCuts();
	201	if(fDCAXYmax > 0) {
	202	if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexXY(fDCAXYmax);
	203	}
	204	if(fDCAZmax > 0) {
	205	if(fEsdTrackCuts) fEsdTrackCuts->SetMaxDCAToVertexZ(fDCAZmax);
	206	}
	207
	208	fInitialized = kTRUE;
	209	}
	210
	211	FillHistograms(kPreCut, track);
	212
	213
	214
	215	if( !fEsdTrackCuts->IsSelected(track)) return kFALSE;
	216
	217
	218	///If only one track cuts then it has passed the cuts
	219	if( !(fEsdTrackCutsExtra1 && fEsdTrackCutsExtra2)) {
	220	FillHistograms(1, track);
	221	return kTRUE;
	222	}
	223	///If passing extra
	224	if (fEsdTrackCutsExtra1 && fEsdTrackCutsExtra1->IsSelected(track)) {
	225	FillHistograms(2, track);
	226	FillHistograms(1, track);
	227	return kTRUE;
	228	}
	229
	230	///If passing extra2
	231	if (fEsdTrackCutsExtra2 && fEsdTrackCutsExtra2->IsSelected(track)) {
	232	const AliExternalTrackParam * param = track->GetConstrainedParam();
	233	if(param) {
34a878c4	234	AliESDtrack* esdTrack = new AliESDtrack(*track);
99d49b30	235	esdTrack->CopyFromVTrack(param);
	236	track = esdTrack;
	237	fOwnedTracks.Add(track);
	238
	239	FillHistograms(3, track);
	240	FillHistograms(1, track);
	241	return kTRUE;
	242	} else {
	243	return kFALSE;
	244	}
	245	} else {
	246	return kFALSE;
	247	}
	248
	249	cout << "error error, should not be herer!"<<endl;
	250	return kFALSE;
	251
	252	// FillHistograms(kPreCut + 1, track);
	253	// return kTRUE;
	254
	255	// fhnclpt->Fill(track->Pt(), track->GetTPCNcls());
	256	// if(track->GetTPCNclsF() > 0) fhnclsfpt->Fill(track->Pt(), ((Double_t) track->GetTPCNcls())/track->GetTPCNclsF());
	257	// FillHistograms(kPreCut + 1, track);
	258
	259	// ///Get impact parameters
	260	// Double_t extCov[15];
	261	// track->GetExternalCovariance(extCov);
	262	// Float_t b[2];
	263	// Float_t bCov[3];
	264	// track->GetImpactParameters(b,bCov);
	265	// if (bCov[0]<=0 \|\| bCov[2]<=0) {
	266	// AliDebug(1, "Estimated b resolution lower or equal zero!");
	267	// bCov[0]=0; bCov[2]=0;
	268	// }
	269
	270	// Float_t dcaToVertexXY = b[0];
	271	// Float_t dcaToVertexZ = b[1];
	272	// FillDCAHist(dcaToVertexZ, dcaToVertexXY, track);
	273	// return kTRUE;
	274	}
	275
	276	Bool_t AliConversionTrackCuts::AcceptTrack(AliAODTrack * track) {
	277	//Check aod track
	278	FillHistograms(kPreCut, track);
	279	if(!track->TestFilterBit(fFilterBit)) {
	280	return kFALSE;
	281	}
	282
99d49b30	283
34a878c4	284
	285
	286	///Do dca xy cut!
	287	FillHistograms(1, track);
99d49b30	288	return kTRUE;
	289
	290
	291	// if (track->GetTPCNcls() < fTPCminNClusters) return kFALSE;
	292	// FillHistograms(kCutNcls, track);
	293
	294	// if (track->Chi2perNDF() > fTPCmaxChi2) return kFALSE;
	295	// FillHistograms(kCutNDF, track);
	296
	297	// AliAODVertex *vertex = track->GetProdVertex();
	298	// if (vertex && fRejectKinkDaughters) {
	299	// if (vertex->GetType() == AliAODVertex::kKink) {
	300	// return kFALSE;
	301	// }
	302	// }
	303	// FillHistograms(kCutKinc, track);
	304
	305	// if(TMath::Abs(track->ZAtDCA()) > fDCAZmax) {
	306	// return kFALSE;
	307	// }
	308	// FillHistograms(kCutDCAZ, track);
	309
	310	// Float_t xatdca = track->XAtDCA();
	311	// Float_t yatdca = track->YAtDCA();
	312	// Float_t xy = xatdcaxatdca + yatdcayatdca;
	313	// if(xy > fDCAXYmax) {
	314	// return kFALSE;
	315	// }
	316
	317	// FillHistograms(kCutDCAXY, track);
	318
	319
	320	// fhnclpt->Fill(track->Pt(), track->GetTPCNcls());
	321	// if(track->GetTPCNclsF() > 0) fhnclsfpt->Fill(track->Pt(), ((Double_t) track->GetTPCNcls())/track->GetTPCNclsF());
	322	// FillDCAHist(track->ZAtDCA(), TMath::Sqrt(track->XAtDCA()track->XAtDCA() + track->YAtDCA()track->YAtDCA()), track);
	323
	324
	325	}
	326
	327
	328
	329
	330
	331
4267afec	332	TList * AliConversionTrackCuts::CreateHistograms() {
4267afec	333	//Create the histograms
439cf020	334
4267afec	335	if(!fHistograms) fHistograms = new TList();
	336
	337	fHistograms->SetOwner(kTRUE);
	338	fHistograms->SetName("trackCuts");
	339
99d49b30	340	fhPhi = new TH2F("phi", "phi", 5, -0.5, 4.5, 32, 0, TMath::TwoPi());
	341	// TAxis * xax = fhPhi->GetXaxis();
	342	// for(Int_t i = 0; i < kNCuts; i++){
	343	// xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
	344	// }
4267afec	345	fHistograms->Add(fhPhi);
	346
	347
	348
99d49b30	349	// fhPt = new TH2F("pt", "pt", kNCuts+2, kPreCut -0.5, kNCuts + 0.5,
	350	// 20, 0., 20.);
	351	// xax = fhPt->GetXaxis();
	352	// for(Int_t i = 0; i < kNCuts; i++){
	353	// xax->SetBinLabel(xax->FindFixBin(i), fgkCutNames[i]);
	354	// }
	355	// fHistograms->Add(fhPt);
4267afec	356
439cf020	357	// fhPhiPt = new TH2F("phipt", "phipt", 100, 0, 100, 64, 0, TMath::TwoPi());
439cf020	358	//fHistograms->Add(fhPhiPt);
4267afec	359
99d49b30	360	// fhdcaxyPt = new TH2F("dcaxypt", "dcaxypt", 20, 0, 20, 50, 0, 5);
99d49b30	361	// fHistograms->Add(fhdcaxyPt);
4267afec	362
99d49b30	363	// fhdcazPt = new TH2F("dcazpt", "dcazpt", 20, 0, 20, 50, 0, 5);
99d49b30	364	// fHistograms->Add(fhdcazPt);
4267afec	365
99d49b30	366	// fhdca = new TH2F("dca", "dca", 60, -3, 3, 60, -3, 3);
99d49b30	367	// fHistograms->Add(fhdca);
439cf020	368
99d49b30	369	// fhnclpt = new TH2F("nclstpcvspt", "nclstpcvspt", 20, 0, 20, 50, 0, 100);
99d49b30	370	// fHistograms->Add(fhnclpt);
4267afec	371
99d49b30	372	// fhnclsfpt = new TH2F("nclsfpt", "nclsfpt", 20, 0, 20, 60, 0, 1.2);
99d49b30	373	// fHistograms->Add(fhnclsfpt);
4267afec	374
	375	return fHistograms;
	376	}
	377
99d49b30	378	void AliConversionTrackCuts::FillHistograms(Int_t cutIndex, AliVTrack * track) {
4267afec	379
4267afec	380	//Fill histograms
99d49b30	381	if(fhPhi) fhPhi->Fill(cutIndex, track->Phi());
99d49b30	382	// if(fhPt) fhPt->Fill(cutIndex, track->Pt());
439cf020	383	//if(passed) fhPhiPt->Fill(track->Pt(), track->Phi());
4267afec	384
	385	}
	386
439cf020	387	void AliConversionTrackCuts::FillDCAHist(Float_t dcaz, Float_t dcaxy, AliVTrack * track) {
99d49b30	388	if(fhdcaxyPt) fhdcaxyPt->Fill(track->Pt(), dcaxy);
	389	if(fhdcazPt) fhdcazPt->Fill(track->Pt(), dcaz);
	390	if(fhdca) fhdca->Fill(dcaz, dcaxy);
439cf020	391	}
439cf020	392
4267afec	393
92efd725	394
439cf020	395
92efd725	396
4267afec	397
4267afec	398
4267afec	399
439cf020	400
4267afec	401	//_________________________________________________________________________________________________
	402	void AliConversionTrackCuts::Print(const Option_t *) const
	403	{
	404	//
	405	// Print information on this cut
	406	//
	407
99d49b30	408	// printf("Cut name : %s \n", GetName());
	409	// printf("Kink daughters are : %s \n", (fRejectKinkDaughters ? "rejected" : "accepted"));
	410	// printf("TPC requirements : clusters/findable %f, min. cluster = %d, max chi2 = %f, %s require refit\n", fTPCClusOverFindable, fTPCminNClusters, fTPCmaxChi2, (fRequireTPCRefit) ? "" : "Don't");
	411	// printf("ITS requirements : min. cluster = %d (all), %d (SPD), max chi2 = %f \n", fITSminNClusters, fSPDminNClusters, fITSmaxChi2);
	412	// printf("DCA z cut : fixed to %f cm \n", fDCAZmax);
	413	// printf("DCA xy cut : fixed to %f cm \n", fDCAXYmax)
	414	;
4267afec	415	}
439cf020	416
439cf020	417	//_________________________________________________________________________________________________
4267afec	418
439cf020	419	Bool_t AliConversionTrackCuts::IsSelected(TObject * object ) {
	420	AliAODTrack * aodtrack = dynamic_cast<AliAODTrack*>(object);
	421	if (aodtrack) {
	422	return AcceptTrack(aodtrack);
	423	} else {
	424	AliESDtrack * track = dynamic_cast<AliESDtrack*>(object);
	425	if (track)
	426	return AcceptTrack(track);
	427	}
4267afec	428
439cf020	429	return kFALSE;
439cf020	430	}
4267afec	431
	432
	433
	434