//------------------------------------------------------
void DefineCutsTagger(AliHFJetsTaggingVertex *tg){
// define cuts for tagger:
// 1) AliRDHFJetsCuts: event selections, basic jet cuts (pT jet, accpetance, emcal, pT leading-track)
// 2) AliRDHFJetsCutsVertex: cuts to reconstruct vertices
// (nprong, pT jet, eta, R, pTmin tracks, electron ID, displacement and other cut variables)
AliRDHFJetsCutsVertex *cuts2=new AliRDHFJetsCutsVertex("jetCuts");
// jets
cuts2->SetJetRadius(0.4);
cuts2->SetMaxEtaJet(0.5);//0.9-R
cuts2->SetMinPtJet(10);
cuts2->SetMaxPtJet(200);
// tracks
AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts","default");
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMinNClustersTPC(70);
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
esdTrackCuts->SetRequireITSRefit(kTRUE);
//esdTrackCuts->SetMinNClustersITS(4);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
esdTrackCuts->SetMinDCAToVertexXY(0.);
esdTrackCuts->SetEtaRange(-0.8,0.8);
esdTrackCuts->SetPtRange(0.3,1.e10);
cuts2->AddTrackCuts(esdTrackCuts);
// vertexing
cuts2->SetNprongs(3);
cuts2->SetIsElec(kFALSE); // kTRUE to select e in jet vertex
cuts2->SetMinPtHardestTrack(1.0);//default 0.3
cuts2->SetSecVtxWithKF(kFALSE);//default with StrLinMinDist
cuts2->SetImpParCut(0.);//default 0
cuts2->SetDistPrimSec(0.);//default 0
cuts2->SetCospCut(-1);//default -1
tg->SetCuts(cuts2);
delete esdTrackCuts;
delete cuts2;
}
AliAnalysisTaskJetExtractorHF* AddTaskJetExtractorHF(
const char *trackArray = "tracks",
const char *jetArray = "jets",
const char *rhoObject = "Rho",
Double_t jetRadius = 0.3,
Double_t minJetEta = 0.6,
Double_t minJetPt = 0.15,
Double_t minTrackPt = 0.15,
Double_t minJetAreaPerc = 0.557,
const char *suffix = ""
)
{
cout << " ############ MACRO EXECUTION STARTED: AddTaskJetExtractorHF.C ############\n";
//==============================================================================
// Prepare analysis manager, containers, etc.
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskJetExtractorHF", "No analysis manager to connect to.");
return NULL;
}
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskJetExtractorHF", "This task requires an input event handler");
return NULL;
}
TString name("AliAnalysisTaskJetExtractorHF");
if (strcmp(jetArray,"")) {
name += "_";
name += jetArray;
}
if (strcmp(rhoObject,"")) {
name += "_";
name += rhoObject;
}
if (strcmp(suffix,"")) {
name += "_";
name += suffix;
}
AliAnalysisDataContainer* contHistos = mgr->CreateContainer(Form("%s_histos", name.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, Form("%s:ChargedJetsHadronCF", AliAnalysisManager::GetCommonFileName()));
//==============================================================================
// Adding and configuring tasks
AliAnalysisTaskJetExtractorHF* jetTask = new AliAnalysisTaskJetExtractorHF(name);
jetTask->SetNeedEmcalGeom(kFALSE);
jetTask->SetVzRange(-10.,10.);
AliRDHFJetsCutsVertex* cuts = new AliRDHFJetsCutsVertex("jetCuts");
// vertexing
AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts", "default");
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMinNClustersTPC(90);
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
esdTrackCuts->SetRequireITSRefit(kTRUE);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
esdTrackCuts->SetMinDCAToVertexXY(0.);
esdTrackCuts->SetEtaRange(-0.8, 0.8);
esdTrackCuts->SetPtRange(1.0, 1.e10);
cuts->AddTrackCuts(esdTrackCuts);
cuts->SetNprongs(3);
cuts->SetMinPtHardestTrack(1.0);//default 0.3
cuts->SetSecVtxWithKF(kFALSE);//default with StrLinMinDist
cuts->SetImpParCut(0.);//default 0
cuts->SetDistPrimSec(0.);//default 0
cuts->SetCospCut(-1);//default -1
jetTask->SetVertexerCuts(cuts);
AliParticleContainer *trackCont = 0;
if(!strcmp(trackArray,"mctracks") || !strcmp(trackArray, "mcparticles"))
trackCont = jetTask->AddMCParticleContainer(trackArray);
else
trackCont = jetTask->AddTrackContainer(trackArray);
trackCont->SetParticlePtCut(minTrackPt);
AliJetContainer *jetCont = jetTask->AddJetContainer(jetArray,6,jetRadius);
if (jetCont) {
jetCont->SetRhoName(rhoObject);
jetCont->SetPercAreaCut(minJetAreaPerc);
jetCont->SetJetPtCut(minJetPt);
jetCont->SetLeadingHadronType(0);
jetCont->SetPtBiasJetTrack(minTrackPt);
jetCont->SetJetEtaLimits(-minJetEta, +minJetEta);
jetCont->ConnectParticleContainer(trackCont);
jetCont->SetMaxTrackPt(1000);
}
mgr->AddTask(jetTask);
//==============================================================================
// Finalization
mgr->ConnectInput (jetTask, 0, mgr->GetCommonInputContainer() );
mgr->ConnectOutput (jetTask, 1, contHistos );
cout << " ############ MACRO EXECUTION DONE: AddTaskJetExtractorHF.C ############\n";
return jetTask;
}
AliAnalysisVertexingHF* ConfigVertexingHF() {
printf("Call to AliAnalysisVertexingHF parameters setting :\n");
vHF = new AliAnalysisVertexingHF();
//--- switch-off candidates finding (default: all on)
//vHF->SetD0toKpiOff();
vHF->SetJPSItoEleOff();
//vHF->Set3ProngOff();
vHF->SetLikeSignOn(); // like-sign pairs and triplets
// vHF->SetLikeSign3prongOff();
vHF->Set4ProngOff();
//vHF->SetDstarOff();
vHF->SetFindVertexForDstar(kFALSE);
//--- secondary vertex with KF?
//vHF->SetSecVtxWithKF();
vHF->SetCascadesOff();
vHF->SetFindVertexForCascades(kFALSE);
vHF->SetMassCutBeforeVertexing(kTRUE); // PbPb
vHF->SetV0TypeForCascadeVertex(AliRDHFCuts::kAllV0s);
//--- set cuts for single-track selection
// displaced tracks
AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts","default");
esdTrackCuts->SetRequireTPCRefit(kTRUE);
esdTrackCuts->SetMinNClustersTPC(70);
esdTrackCuts->SetRequireITSRefit(kTRUE);
//esdTrackCuts->SetMinNClustersITS(4);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
AliESDtrackCuts::kAny);
// |d0|>75 micron for pt<2GeV, no cut above 2
esdTrackCuts->SetMinDCAToVertexXYPtDep("0.0075*TMath::Max(0.,(1-TMath::Floor(TMath::Abs(pt)/2.)))");
esdTrackCuts->SetMaxDCAToVertexXY(1.);
esdTrackCuts->SetMaxDCAToVertexZ(1.);
esdTrackCuts->SetPtRange(0.6,1.e10);
esdTrackCuts->SetEtaRange(-0.8,+0.8);
AliAnalysisFilter *trkFilter = new AliAnalysisFilter("trackFilter");
trkFilter->AddCuts(esdTrackCuts);
vHF->SetTrackFilter(trkFilter);
// D* soft pion tracks
AliESDtrackCuts *esdTrackCutsSoftPi = new AliESDtrackCuts("AliESDtrackCuts","default");
esdTrackCutsSoftPi->SetMinNClustersITS(4);
esdTrackCutsSoftPi->SetMaxDCAToVertexXY(1.);
esdTrackCutsSoftPi->SetMaxDCAToVertexZ(1.);
esdTrackCutsSoftPi->SetPtRange(0.2,1.e10);
esdTrackCutsSoftPi->SetEtaRange(-0.8,+0.8);
AliAnalysisFilter *trkFilterSoftPi = new AliAnalysisFilter("trackFilterSoftPi");
trkFilterSoftPi->AddCuts(esdTrackCutsSoftPi);
vHF->SetTrackFilterSoftPi(trkFilterSoftPi);
//--- set cuts for candidates selection
Int_t nptbins=2; Float_t ptlimits[2]={0.,1000000.};
AliRDHFCutsD0toKpi *cutsD0toKpi = new AliRDHFCutsD0toKpi("CutsD0toKpi");
cutsD0toKpi->SetStandardCutsPbPb2010();
cutsD0toKpi->SetMinCentrality(-10);
cutsD0toKpi->SetMaxCentrality(110);
cutsD0toKpi->SetUseSpecialCuts(kFALSE);
cutsD0toKpi->SetMinPtCandidate(0.);
cutsD0toKpi->SetUsePID(kFALSE);
cutsD0toKpi->SetUsePhysicsSelection(kFALSE);
cutsD0toKpi->SetMaxVtxZ(1.e6);
cutsD0toKpi->SetTriggerClass("");
Float_t cutsArrayD0toKpi[11]={0.4,999999.,1.1,0.,0.,999999.,999999.,0.,0.5,-1,0.};
cutsD0toKpi->SetPtBins(nptbins,ptlimits);
cutsD0toKpi->SetCuts(11,cutsArrayD0toKpi);
cutsD0toKpi->AddTrackCuts(esdTrackCuts);
vHF->SetCutsD0toKpi(cutsD0toKpi);
AliRDHFCutsJpsitoee *cutsJpsitoee = new AliRDHFCutsJpsitoee("CutsJpsitoee");
Float_t cutsArrayJpsitoee[9]={0.350,100000.,1.1,0.,0.,100000.,100000.,100000000.,-1.1};
cutsJpsitoee->SetCuts(9,cutsArrayJpsitoee);
cutsJpsitoee->AddTrackCuts(esdTrackCuts);
vHF->SetCutsJpsitoee(cutsJpsitoee);
AliRDHFCutsDplustoKpipi *cutsDplustoKpipi = new AliRDHFCutsDplustoKpipi("CutsDplustoKpipi");
cutsDplustoKpipi->SetStandardCutsPbPb2010();
cutsDplustoKpipi->SetUsePID(kFALSE);
Float_t cutsArrayDplustoKpipi[14]={0.25,0.3,0.3,0.,0.,0.01,0.05,0.05,0.,0.88,0.,10000000000.,0.,-1.};
cutsDplustoKpipi->SetPtBins(nptbins,ptlimits);
cutsDplustoKpipi->SetCuts(14,cutsArrayDplustoKpipi);
cutsDplustoKpipi->AddTrackCuts(esdTrackCuts);
cutsDplustoKpipi->SetMinPtCandidate(2.);
vHF->SetCutsDplustoKpipi(cutsDplustoKpipi);
AliRDHFCutsDstoKKpi *cutsDstoKKpi = new AliRDHFCutsDstoKKpi("CutsDstoKKpi");
cutsDstoKKpi->SetStandardCutsPbPb2010();
cutsDstoKKpi->SetUsePID(kFALSE);
Float_t cutsArrayDstoKKpi[20]={0.35,0.3,0.3,0.,0.,0.005,0.06,0.,0.,0.9,0.,100000.,0.035,0.0001,-1.,1.,0.,0.,0.,-1.};
cutsDstoKKpi->SetPtBins(nptbins,ptlimits);
cutsDstoKKpi->SetCuts(20,cutsArrayDstoKKpi);
cutsDstoKKpi->AddTrackCuts(esdTrackCuts);
cutsDstoKKpi->SetMinPtCandidate(2.);
vHF->SetCutsDstoKKpi(cutsDstoKKpi);
AliRDHFCutsLctopKpi *cutsLctopKpi = new AliRDHFCutsLctopKpi("CutsLctopKpi");
cutsLctopKpi->SetStandardCutsPbPb2010();
cutsLctopKpi->SetUsePID(kFALSE);
Float_t cutsArrayLctopKpi[13]={0.13,0.9,1.,0.,0.,0.01,0.04,0.006,1.,0.5,0.,0.05,0.4};
cutsLctopKpi->SetPtBins(nptbins,ptlimits);
cutsLctopKpi->SetCuts(13,cutsArrayLctopKpi);
cutsLctopKpi->AddTrackCuts(esdTrackCuts);
cutsLctopKpi->SetMinPtCandidate(2.);
vHF->SetCutsLctopKpi(cutsLctopKpi);
AliRDHFCutsD0toKpipipi *cutsD0toKpipipi = new AliRDHFCutsD0toKpipipi("CutsD0toKpipipi");
Float_t cutsArrayD0toKpipipi[9]={0.2,0.04,0.00,0.01,0.02,0.8,0.,0.1,0.};
cutsD0toKpipipi->SetCuts(9,cutsArrayD0toKpipipi);
cutsD0toKpipipi->AddTrackCuts(esdTrackCuts);
vHF->SetCutsD0toKpipipi(cutsD0toKpipipi);
// D* pt dependent cuts ------------------------------------------
AliRDHFCutsDStartoKpipi *cutsDStartoKpipi = new AliRDHFCutsDStartoKpipi("CutsDStartoKpipi");
cutsDStartoKpipi->SetUsePID(kFALSE);
const Int_t nvars=16;
const Int_t nptbins=2;
Float_t* ptbins;
ptbins=new Float_t[nptbins+1];
ptbins[0]=0.;
ptbins[1]=5.;
ptbins[2]=999.;
cutsDStartoKpipi->SetPtBins(nptbins+1,ptbins);
Float_t** rdcutsvalmine;
rdcutsvalmine=new Float_t*[nvars];
for(Int_t iv=0;iv<nvars;iv++){
rdcutsvalmine[iv]=new Float_t[nptbins];
}
//0-5
rdcutsvalmine[0][0]=0.10; //D0 inv mass window
rdcutsvalmine[1][0]=0.06; // dca
rdcutsvalmine[2][0]=0.9; // thetastar
rdcutsvalmine[3][0]=0.5; // pt Pion
rdcutsvalmine[4][0]=0.5; // Pt Kaon
rdcutsvalmine[5][0]=0.1; // d0K
rdcutsvalmine[6][0]=0.1; // d0Pi
rdcutsvalmine[7][0]=0.0001; // d0xd0
rdcutsvalmine[8][0]=0.8; // costhetapoint
rdcutsvalmine[9][0]=0.15; // Dstar inv mass window
rdcutsvalmine[10][0]=0.03; // half width of (M_Kpipi-M_D0)
rdcutsvalmine[11][0]=0.1; // Pt min of Pi soft
rdcutsvalmine[12][0]=100.; // Pt max of pi soft
rdcutsvalmine[13][0]=9999.; // theta
rdcutsvalmine[14][0]=0.9; // |cosThetaPointXY|
rdcutsvalmine[15][0]=1.; // NormDecayLenghtXY
//5-999
rdcutsvalmine[0][1]=0.10; //D0 inv mass window
rdcutsvalmine[1][1]=0.06; // dca
rdcutsvalmine[2][1]=0.9; // thetastar
rdcutsvalmine[3][1]=0.5; // pt Pion
rdcutsvalmine[4][1]=0.5; // Pt Kaon
rdcutsvalmine[5][1]=0.1; // d0K
rdcutsvalmine[6][1]=0.1; // d0Pi
rdcutsvalmine[7][1]=0.0001; // d0xd0
rdcutsvalmine[8][1]=0.7; // costhetapoint
rdcutsvalmine[9][1]=0.15; // Dstar inv mass window
rdcutsvalmine[10][1]=0.03; // half width of (M_Kpipi-M_D0)
rdcutsvalmine[11][1]=0.1; // Pt min of Pi soft
rdcutsvalmine[12][1]=100.; // Pt max of pi soft
rdcutsvalmine[13][1]=9999.; // theta
rdcutsvalmine[14][1]=0.8; // |cosThetaPointXY|
rdcutsvalmine[15][1]=0.; // NormDecayLenghtXY
cutsDStartoKpipi->SetCuts(nvars,nptbins,rdcutsvalmine);
cutsDStartoKpipi->AddTrackCuts(esdTrackCuts);
cutsDStartoKpipi->AddTrackCutsSoftPi(esdTrackCutsSoftPi);
cutsDStartoKpipi->SetMinPtCandidate(2.);
vHF->SetCutsDStartoKpipi(cutsDStartoKpipi);
//--------------------------------------------------------
AliRDHFCutsLctoV0 *cutsLctoV0 = new AliRDHFCutsLctoV0("CutsLctoV0");
Float_t cutsArrayLctoV0[17]={1.0,1.0,0.05,0.05,0.0,0.0,0.0,1000.,1000.,0.99,3.,1000.,0.,0.,0.,0.,0.0};
cutsLctoV0->SetCuts(17,cutsArrayLctoV0);
cutsLctoV0->AddTrackCuts(esdTrackCuts);
vHF->SetCutsLctoV0(cutsLctoV0);
//
//--- set this if you want to reconstruct primary vertex candidate by
// candidate using other tracks in the event (for pp, broad
// interaction region)
//vHF->SetRecoPrimVtxSkippingTrks();
//--- OR set this if you want to remove the candidate daughters from
// the primary vertex, without recostructing it from scratch
//vHF->SetRmTrksFromPrimVtx();
//--- check the settings
vHF->PrintStatus();
//--- verbose
// AliLog::SetClassDebugLevel("AliAnalysisVertexingHF",2);
return vHF;
}
AliAnalysisTaskEmcalHFCJQA* AddTaskEmcalHFCJQA(
const char *ntracks = "Tracks",
const char *nclusters = "CaloClusters",
const char *njets = "Jets",
const char *nrho = "Rho",
Int_t nCentBins = 1,
Double_t jetradius = 0.4,
Double_t jetptcut = 0,
Double_t jetareacut = 0.6,
const char *type = "TPC",
Int_t leadhadtype = 0,
const char *taskname = "AliAnalysisTaskEmcalHFCJQA",
TString cutfile ="HFCJCuts.root",
UInt_t triggerMask =-1,//AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8,/*kMB kEMC7 (kEMC8) kEMCEJE kEMCEGA*/
Bool_t isMC = kFALSE,
Float_t minC = 0.,
Float_t maxC = 7.5
)
{
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr)
{
::Error("AddTaskEmcalHFCJQA", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
if (!mgr->GetInputEventHandler())
{
::Error("AddTaskEmcalHFCJQA", "This task requires an input event handler");
return NULL;
}
//-------------------------------------------------------
// Init the task and do settings
//-------------------------------------------------------
TString name(taskname);
if (strcmp(njets,"")) {
name += "_";
name += njets;
}
if (strcmp(nrho,"")) {
name += "_";
name += nrho;
}
if (strcmp(type,"")) {
name += "_";
name += type;
}
Printf("name: %s",name.Data());
AliAnalysisTaskEmcalHFCJQA* jetTask = new AliAnalysisTaskEmcalHFCJQA(name);
jetTask->SetReadMC(isMC);
jetTask->SetDebug(-1);
jetTask->SetFilterBit(AliAODTrack::kTrkGlobalNoDCA);
//Defaut parameters
AliParticleContainer *trackCont = jetTask->AddParticleContainer(ntracks);
trackCont->SetClassName("AliVTrack");
AliClusterContainer *clusterCont = jetTask->AddClusterContainer(nclusters);
TString strType(type);
AliJetContainer *jetCont = jetTask->AddJetContainer(njets,strType,jetradius);
if(jetCont) {
jetCont->SetRhoName(nrho);
jetCont->ConnectParticleContainer(trackCont);
jetCont->ConnectClusterContainer(clusterCont);
jetCont->SetZLeadingCut(0.98,0.98);
jetCont->SetPercAreaCut(0.6);
jetCont->SetJetPtCut(jetptcut);
jetCont->SetLeadingHadronType(leadhadtype);
}
//=========================CUTS=========================
AliRDHFJetsCuts *cuts;
bool kFileExists=kFALSE;
//if(!gSystem->AccessPathName(cutfile.Data(),kFileExists)){
if(gSystem->AccessPathName(cutfile.Data(),kFileExists))
{
Printf("\n==CutObject not Defined in .root File. Using Standard Cuts==\n");
// possible (!not standard!) selection for pp2012 data triggered with EMCAL
cuts=new AliRDHFJetsCuts();
hfTask = new AliAnalysisTaskEmcalHFCJQA("AliAnalysisTaskEmcalHFCJQA");
// AliRDHFJetsCutsVertex *cuts2=new AliRDHFJetsCutsVertex("jetCuts");
//cuts for jets
// cuts->SetJetRadius(0.4);
// cuts->SetMaxEtaJet(0.5);//0.9-R
// cuts->SetMinPtJet(0);
// cuts->SetMaxPtJet(200);
// cuts->ResetMaskAndEnableMBTrigger();
//cuts->SetUseAnyTrigger();
//cuts->SetTriggerMask(0);
cuts->SetTriggerMask(AliVEvent::kEMC1 | AliVEvent::kEMC7 | AliVEvent::kEMC8);
cuts->SetTriggerClass("");
AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts","default");
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMinNClustersTPC(70);
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
esdTrackCuts->SetRequireITSRefit(kTRUE);
esdTrackCuts->SetMinNClustersITS(2);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
esdTrackCuts->SetMinDCAToVertexXY(0.);
esdTrackCuts->SetEtaRange(-0.8,0.8);
esdTrackCuts->SetPtRange(1,1.e10);
if(minC>0&&minC<maxC)
{
// Pb-Pb
cuts->SetTriggerClass("");
cuts->ResetMaskAndEnableMBTrigger();
cuts->EnableCentralTrigger();
cuts->EnableSemiCentralTrigger();
cuts->SetUseCentrality(AliRDHFCuts::kCentV0M);
cuts->SetMinCentrality(minC);
cuts->SetMaxCentrality(maxC);
}
cuts->AddTrackCuts(esdTrackCuts);
//cuts for vertexing
// ::Error("AddTaskSEHFJets","No Cut Object");
}
else
{
TFile *f=TFile::Open(cutfile.Data());
//cuts= (AliRDHFCutsD0toKpi*)f->Get("EventTrackCuts");
cuts= (AliRDHFJetsCuts*)f->Get("HFCJCuts");
cout<<"\n==========================================\n Cutfile used:\n"<<cutfile.Data()<<endl;
//cuts->PrintAll();
//jetTask->SetJetCuts(cuts);
}
if(triggerMask>0) cuts->SetTriggerMask(triggerMask);
jetTask->SetJetCuts(cuts);
delete cuts;
//==========================================================
//-------------------------------------------------------
// Final settings, pass to manager and set the containers
//-------------------------------------------------------
mgr->AddTask(jetTask);
// Create containers for input/output
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer() ;
TString contname(name);
contname += "_histos";
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(contname.Data(),
TList::Class(),AliAnalysisManager::kOutputContainer,
Form("%s", AliAnalysisManager::GetCommonFileName()));
mgr->ConnectInput (jetTask, 0, cinput1 );
mgr->ConnectOutput (jetTask, 1, coutput1 );
return jetTask;
}
AliCFSingleTrackEfficiencyTask *AddSingleTrackEfficiencyTaskAnalysisQA(TString collSyst="pp",
const Bool_t readAOD = 0, // Flag to read AOD:1 or ESD:0
TString suffix="default", // suffix for the output directory
AliPID::EParticleType specie=AliPID::kPion,
Int_t pdgcode=0, //particle specie
Bool_t useMCtruthForKine=kFALSE,
Double_t maxRadiusForPrimaries=999.,
ULong64_t triggerMask=AliVEvent::kAnyINT,
TString centralityEstimator = "V0M",
Int_t fBit=0,
Bool_t TPCRefit = kTRUE,
Int_t minclustersTPC = 0,
Bool_t ITSRefit = kTRUE,
Int_t spdHits=AliESDtrackCuts::kAny,
Int_t minclustersITS = 0,
Bool_t useRecoEvSelCutsForKine=kFALSE,
Int_t configuration=AliCFSingleTrackEfficiencyTask::kFast,
Int_t usageOfBayesianPID=AliSingleTrackEffCuts::kNoBayesianPID)
{
Info("AliCFSingleTrackEfficiencyTask","SETUP CONTAINER");
//
// Setting up the container
//
// Variables
const Int_t nvar = 7; // number of variables on the grid: pt, y, phi, theta, zvtx, multiplicity, centrality
UInt_t nstep = 8; // number of container steps
const UInt_t ipt = 0;
const UInt_t ieta = 1;
const UInt_t iphi = 2;
const UInt_t itheta = 3;
const UInt_t izvtx = 4;
const UInt_t imult = 5;
const UInt_t icent = 6;
//
// Containter bining
const Int_t nbinpt=30;
// A2. Bins variation by hand for other variables
const Int_t nbin2 = configuration==AliCFSingleTrackEfficiencyTask::kSlow ? 8 : 8; //bins in eta
const Int_t nbin3 = configuration==AliCFSingleTrackEfficiencyTask::kSlow ? 9 : 18; //bins in phi
const Int_t nbin4 = configuration==AliCFSingleTrackEfficiencyTask::kSlow ? 9 : 1; //bins in theta
const Int_t nbin5 = configuration==AliCFSingleTrackEfficiencyTask::kSlow ? 10 : 4; //bins in zvtx
const Int_t nbinmult=8;
const Int_t nbincent=12;
//arrays for the number of bins in each dimension
Int_t iBin[nvar];
iBin[0]=nbinpt;
iBin[1]=nbin2;
iBin[2]=nbin3;
iBin[3]=nbin4;
iBin[4]=nbin5;
iBin[5]=nbinmult;
iBin[6]=nbincent;
//arrays for lower bounds :
Double_t binLimpT[nbinpt+1] = {0.00,0.10,0.15,0.20,0.25,0.30,0.35,0.40,0.50,0.60,
0.70,0.80,0.90,1.00,1.25,1.50,1.75,2.00,2.50,3.00,
3.50,4.00,5.00,6.00,7.00,8.00,10.0,12.0,16.0,20.0,30.0};
Double_t *binLim2 = new Double_t[iBin[1]+1];
Double_t *binLim3 = new Double_t[iBin[2]+1];
Double_t *binLim4 = new Double_t[iBin[3]+1];
Double_t *binLim5 = new Double_t[iBin[4]+1];
Double_t binLimmult[nbinmult+1] = {0.,5.,10.,20.,30.,40.,50.,80.,200.};
Double_t binLimcent[nbincent+1] = {0.,2.5,5.0,7.5,10.,15.,20.,30.,40.,50.,60.,80.,100.};
if(collSyst=="Pb-Pb" || collSyst=="PbPb" || collSyst=="Xe-Xe" || collSyst=="XeXe"){
binLimmult[1]=100.;
binLimmult[2]=500.;
binLimmult[3]=1000.;
binLimmult[4]=2000.;
binLimmult[5]=3000.;
binLimmult[6]=4000.;
binLimmult[7]=5000.;
binLimmult[8]=10000.;
}
// Other Variables
for(Int_t i=0; i<=nbin2; i++) binLim2[i]=(Double_t)etamin + (etamax-etamin)/nbin2*(Double_t)i ;
for(Int_t i=0; i<=nbin3; i++) binLim3[i]=(Double_t)phimin + (phimax-phimin)/nbin3*(Double_t)i ;
for(Int_t i=0; i<=nbin4; i++) binLim4[i]=(Double_t)thetamin + (thetamax-thetamin)/nbin4*(Double_t)i ;
for(Int_t i=0; i<=nbin5; i++) binLim5[i]=(Double_t)zvtxmin + (zvtxmax-zvtxmin)/nbin5*(Double_t)i ;
// Container
AliCFContainer* container = new AliCFContainer(Form("container%s",suffix.Data()),"container for tracks",nstep,nvar,iBin);
container -> SetBinLimits(ipt,binLimpT); // pt
container -> SetBinLimits(ieta,binLim2); // eta
container -> SetBinLimits(iphi,binLim3); // phi
container -> SetBinLimits(itheta,binLim4); // theta
container -> SetBinLimits(izvtx,binLim5); // Zvtx
container -> SetBinLimits(imult,binLimmult);// multiplicity
container -> SetBinLimits(icent,binLimcent);// centrality
// Variable Titles
container -> SetVarTitle(ipt,"pt");
container -> SetVarTitle(ieta, "eta");
container -> SetVarTitle(iphi,"phi");
container -> SetVarTitle(itheta, "theta");
container -> SetVarTitle(izvtx, "Zvtx");
container -> SetVarTitle(imult, "Multiplicity");
container -> SetVarTitle(icent, "Centrality");
// Step Titles
container -> SetStepTitle(0, " MC Particle with Generated Cuts");
container -> SetStepTitle(1, " MC Particle with Kine Acceptance Cuts");
container -> SetStepTitle(2, " MC Particle with Track Ref Acceptance Cuts");
container -> SetStepTitle(3, " Total Reconstructed Particle ");
container -> SetStepTitle(4, " Reco Particle With Kine Acceptance Cuts");
container -> SetStepTitle(5, " Reco Particle to MC True pt particles ");
container -> SetStepTitle(6, " Reco Particle With Quality Cuts");
container -> SetStepTitle(7, " Reco PID With Quality Cuts");
// SET TLIST FOR QA HISTOS
TList* qaList = new TList();
TObjArray* emptyList = new TObjArray(0);
//CREATE THE INTERFACE TO CORRECTION FRAMEWORK USED IN THE TASK
printf("CREATE INTERFACE AND CUTS\n");
AliCFManager* man = new AliCFManager();
man->SetNStepEvent(2);
man->SetEventContainer(container);
man->SetEventCutsList(0,emptyList);//evtmcList);
man->SetEventCutsList(1,emptyList);//evtrecoList);
man->SetParticleContainer(container);
man->SetParticleCutsList(0,emptyList);//mcGenList);
man->SetParticleCutsList(1,emptyList);//mcKineList);
man->SetParticleCutsList(2,emptyList);//mcaccList);
man->SetParticleCutsList(3,emptyList);//evtrecoPureList);
man->SetParticleCutsList(4,emptyList);//recKineList);
man->SetParticleCutsList(5,emptyList);
man->SetParticleCutsList(6,emptyList);
man->SetParticleCutsList(7,emptyList);
// Simulated particle & event cuts
AliSingleTrackEffCuts* cuts = new AliSingleTrackEffCuts();
cuts->SetPtRange(ptmin,ptmax);
cuts->SetEtaRange(etamin,etamax);
cuts->SetIsCharged(ischarged);
cuts->SetMinVtxContr(1);
cuts->SetMaxVtxZ(zvtxmax);
cuts->SetNumberOfClusters(mintrackrefsITS,mintrackrefsTPC,mintrackrefsTOF,mintrackrefsMUON);
cuts->SetTriggerMask(triggerMask);
cuts->SetIsAOD(readAOD);
cuts->SetMaxRadiusOfParticleOrigin(maxRadiusForPrimaries);
//
// Pid selection here
//
if(pdgcode>0){
cuts->SetUsePid(true);
cuts->SetParticleSpecie(specie);
cuts->SetPdgCode(pdgcode);
//
const Int_t nlims=1;
Float_t plims[nlims+1]={0.,999.}; //TPC limits in momentum [GeV/c]
Float_t sigmas[nlims]={3.};
cuts->SetUseTPCPid();
cuts->SetTPCSigmaPtBins(nlims,plims,sigmas);
cuts->SetMaximumPTPC(4.);
//
const Int_t nlims2=1;
Float_t plims2[nlims2+1]={0.,999.}; //TPC limits in momentum [GeV/c]
Float_t sigmas2[nlims2]={3.};
cuts->SetUseTOFPid();
cuts->SetTOFSigmaPtBins(nlims2,plims2,sigmas2);
cuts->SetMaximumPTOF(4.);
if(usageOfBayesianPID>0) {
cuts->SetUseCombinPID(usageOfBayesianPID);
if(usageOfBayesianPID==AliSingleTrackEffCuts::kThresholdBayesianProb)
cuts->SetPIDThreshold(thresholdPID);
}
}
//
// Track Quality cuts via ESD track cuts
//
AliESDtrackCuts* QualityCuts = new AliESDtrackCuts();
QualityCuts->SetRequireSigmaToVertex(kFALSE);
QualityCuts->SetMinNClustersTPC(minclustersTPC);
QualityCuts->SetMinNClustersITS(minclustersITS);
QualityCuts->SetRequireTPCRefit(TPCRefit);
QualityCuts->SetRequireITSRefit(ITSRefit);
QualityCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,spdHits);
QualityCuts->SetMinDCAToVertexXY(0.);
QualityCuts->SetEtaRange(etamin,etamax);
QualityCuts->SetPtRange(ptmin,ptmax);
//CREATE THE TASK
printf("CREATE CF Single track task\n");
AliCFSingleTrackEfficiencyTask *task = new AliCFSingleTrackEfficiencyTask("AliCFSingleTrackEfficiencyTask",QualityCuts,cuts);
if(readAOD && fBit>=0){
task->SetFilterBit(kTRUE);
task->SetFilterType(fBit);
}else{
task->SetFilterBit(kFALSE);
}
// task->SelectCollisionCandidates(triggerMask);//AliVEvent::kMB);
if(centralityEstimator != "") task->SetUseCentrality(kTRUE,centralityEstimator);
task->SetConfiguration(configuration);
task->SetUseGeneratedKine(useMCtruthForKine);
if(useRecoEvSelCutsForKine) task->ApplyRecoEventSelectionsToFillMCKine();
task->SetCFManager(man); //here is set the CF manager
//
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTask", "No analysis manager to connect to.");
return NULL;
}
// This task requires an ESD or AOD input handler and an AOD output handler.
// Check this using the analysis manager.
//===============================================================================
TString type = mgr->GetInputEventHandler()->GetDataType();
if (!type.Contains("ESD") && !type.Contains("AOD")) {
::Error("AddSingleTrackEfficiencyTaskPbPb", "AliCFSingleTrackEfficiency task needs the manager to have an ESD or AOD input handler.");
return NULL;
}
mgr->AddTask(task);
printf(" Create the output container\n");
//
// Create and connect containers for input/output
//
// ----- output data -----
TString outputfile = AliAnalysisManager::GetCommonFileName();
TString input1name="cchain0";
TString output2name="HistEventsProcessed", output3name="container",output4name="list",output5name="ESDtrackCuts",output6name="MCtrackCuts";
outputfile += ":PWGPP_CFSingleTrack";
// outputfile += suffix;
output2name += suffix;
output3name += suffix;
output4name += suffix;
output5name += suffix;
output6name += suffix;
// ------ input data ------
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
// ----- output data -----
// output TH1I for event counting
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(output2name, TH1I::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output Correction Framework Container (for acceptance & efficiency calculations)
AliAnalysisDataContainer *coutput2 = mgr->CreateContainer(output3name, AliCFContainer::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output QA histograms
AliAnalysisDataContainer *coutput3 = mgr->CreateContainer(output4name, TList::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output ESD track cuts for book keeping
AliAnalysisDataContainer *coutput4 = mgr->CreateContainer(output5name, AliESDtrackCuts::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
// output event and particle selection cuts for book keeping
AliAnalysisDataContainer *coutput5 = mgr->CreateContainer(output6name, AliSingleTrackEffCuts::Class(),AliAnalysisManager::kOutputContainer,outputfile.Data());
mgr->ConnectInput(task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(task,1,coutput1);
mgr->ConnectOutput(task,2,coutput2);
mgr->ConnectOutput(task,3,coutput3);
mgr->ConnectOutput(task,4,coutput4);
mgr->ConnectOutput(task,5,coutput5);
return task;
}
AliESDtrackCuts *CreateTrackCutsPWGJE(Int_t cutMode) {
//
// Macro to create track cuts for PWG Jet analysis
// User can select a specific set by indicating cutMode
// cutMode has 8 digits: first 4 digits additional cuts, last 4 digits standard cuts
// additional cuts are variations of standard cuts (used for hybrid track selection and QA)
// Numbering starts from 1000 For standard and additional cut numbers
AliESDtrackCuts *trackCuts = new AliESDtrackCuts("AliESDtrackCuts");
TString tag;
Int_t mod = 10000;
Bool_t bStdCutsDefined = kFALSE;
//_____________________________________________________________________
// STANDARD CUTS
//Get standard cuts: last 4 digits of cutMode
Int_t stdCutMode = cutMode%mod;
if(stdCutMode == 1000) {
bStdCutsDefined = kTRUE;
trackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kTRUE,1);
trackCuts->SetMinNCrossedRowsTPC(120);
trackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
trackCuts->SetMaxChi2TPCConstrainedGlobal(36);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1e10);
tag = "Global track RAA analysis QM2011 + Chi2ITS<36";
}
if(stdCutMode == 1001) {
bStdCutsDefined = kTRUE;
// TPC
trackCuts->SetMinNClustersTPC(90);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
// ITS
trackCuts->SetRequireITSRefit(kTRUE);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//reject fakes
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "Global tracks jet analysis with ITSrefit and NclsIter1=90, noSPD requirement";
}
if(stdCutMode == 1002) {
bStdCutsDefined = kTRUE;
// TPC
trackCuts->SetMinNClustersTPC(80);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
// ITS
trackCuts->SetRequireITSRefit(kTRUE);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//reject fakes
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "Global tracks jet analysis with ITSrefit and Ncls=80, noSPD requirement";
}
if(stdCutMode == 1003) {
bStdCutsDefined = kTRUE;
// tight global tracks
trackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(kFALSE,1);
trackCuts->SetMinNClustersTPC(0);
trackCuts->SetMinNCrossedRowsTPC(120);
trackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.1);// essentially switches it off
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
tag = "Global tracks ITSTPC2010 + NCrossedRows + loose ITS";
}
if(stdCutMode == 1004) {
bStdCutsDefined = kTRUE;
// TPC
trackCuts->SetMinNClustersTPC(70);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
// ITS
trackCuts->SetRequireITSRefit(kTRUE);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//reject fakes
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "Global tracks jet analysis with ITSrefit and NclsIter1=70, noSPD requirement";
}
if(stdCutMode == 1005) {
bStdCutsDefined = kTRUE;
// TPC
trackCuts->SetMinNClustersTPC(70);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
// ITS
trackCuts->SetRequireITSRefit(kTRUE);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//reject fakes
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1E+15);
tag = "Global tracks jet analysis with ITSrefit and NclsIter1=70, noSPD requirement, no upper pt cut";
}
if(stdCutMode == 1006) {
bStdCutsDefined = kTRUE;
// TPC
TFormula *f1NClustersTPCLinearPtDep = new TFormula("f1NClustersTPCLinearPtDep","70.+30./20.*x");
trackCuts->SetMinNClustersTPCPtDep(f1NClustersTPCLinearPtDep,20.);
trackCuts->SetMinNClustersTPC(70);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
// ITS
trackCuts->SetRequireITSRefit(kTRUE);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//reject fakes
trackCuts->SetMaxChi2PerClusterITS(36);
trackCuts->SetMaxChi2TPCConstrainedGlobal(36);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1E+15);
tag = "Global tracks jet analysis with ITSrefit and NclsIter1=PtDep, noSPD requirement, no upper pt cut, golden chi2";
}
if(stdCutMode == 1007) {
bStdCutsDefined = kTRUE;
trackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE,1);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//
trackCuts->SetMaxChi2TPCConstrainedGlobal(36);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1E+15);
tag = "Global tracks with AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE)";
}
if(stdCutMode == 1008) {
bStdCutsDefined = kTRUE;
trackCuts = AliESDtrackCuts::GetStandardITSTPCTrackCuts2011(kFALSE,1);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
//
trackCuts->SetMaxChi2TPCConstrainedGlobal(36);
trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
tag = "Global tracks 2011 with NCrossedRows cut";
}
if(stdCutMode == 2000) {
bStdCutsDefined = kTRUE;
// TPC
trackCuts->SetMinNClustersTPC(90);
trackCuts->SetMaxChi2PerClusterTPC(4);
trackCuts->SetRequireTPCStandAlone(kTRUE); //cut on NClustersTPC and chi2TPC Iter1
trackCuts->SetAcceptKinkDaughters(kFALSE);
trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMaxFractionSharedTPCClusters(0.4);
//accept secondaries
trackCuts->SetMaxDCAToVertexXY(2.4);
trackCuts->SetMaxDCAToVertexZ(3.2);
trackCuts->SetDCAToVertex2D(kTRUE);
trackCuts->SetRequireSigmaToVertex(kFALSE);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "Global tracks jet analysis, loose cuts, NClsIter1=90, no ITS requirements";
}
if(stdCutMode == 2001) {
bStdCutsDefined = kTRUE;
trackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
// trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMinNClustersTPC(70);
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "TPConly track cuts, loose cuts, NCls=70, no ITS requirements";
}
if(stdCutMode == 2002) {
bStdCutsDefined = kTRUE;
trackCuts = AliESDtrackCuts::GetStandardTPCOnlyTrackCuts();
// trackCuts->SetRequireTPCRefit(kTRUE);
trackCuts->SetMinNClustersTPC(0);
trackCuts->SetMinNCrossedRowsTPC(120);
trackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.1);// essentially switches it off
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 100.);
tag = "TPConly track cuts, loose cuts, NCls=70, no ITS requirements";
}
if(!bStdCutsDefined) {
printf("last 4 digits do not represent a predefined set of standard cuts. Returning 0\n");
return 0;
}
//_____________________________________________________________________
// ADDITIONAL CUTS
//Get additional cut mode: first 4 digits of cutMode
Int_t addCutMode = (int)((float)cutMode/(float)mod);
if(addCutMode == 1000) {
trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
tag += " + additonal: SPD any requirement";
}
if(addCutMode == 1001) {
trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
tag += " + additional: w/o hits in SPD";
}
if(addCutMode == 1002) {
trackCuts->SetMaxChi2PerClusterITS(1E10);
tag += " + additional: maxITSChi2=1e10";
}
if(addCutMode == 1003) {
trackCuts->SetMinNClustersTPC(0);
trackCuts->SetMinNCrossedRowsTPC(0);
trackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.);
tag += " + additional: minClusters=0 minCrossedRows=0 minCrossedRowsOverFindable=0";
}
if(addCutMode == 1004) {
trackCuts->SetRequireITSRefit(kFALSE);
tag += " + additional: ITSrefit=kFALSE";
}
if(addCutMode == 1005) {
trackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
tag += " + additional: no SPD requirement (kOff)";
}
Printf("Created track cuts for: %s", tag.Data());
return trackCuts;
}
//________________________________________________________________
AliAnalysisCuts* SetupTrackCuts(Int_t cutInstance)
{
std::cout << "SetupTrackCuts()" <<std::endl;
//AliAnalysisCuts* trackCuts=0x0;
AliESDtrackCuts *fesdTrackCuts = new AliESDtrackCuts();
//global
fesdTrackCuts->SetPtRange( 0.2 , 100. );
fesdTrackCuts->SetEtaRange( -0.8 , 0.8 );
fesdTrackCuts->SetAcceptKinkDaughters(kFALSE);
fesdTrackCuts->SetRequireSigmaToVertex(kFALSE);
fesdTrackCuts->SetDCAToVertex2D(kFALSE);
fesdTrackCuts->SetMaxDCAToVertexZ(3.);
fesdTrackCuts->SetMaxDCAToVertexXY(1.);
fesdTrackCuts->SetRequireTPCRefit(kTRUE);
fesdTrackCuts->SetRequireITSRefit(kTRUE);
if(cutInstance == 0){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 1){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(130);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 2){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(80);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 3){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(120);
fesdTrackCuts->SetMinNCrossedRowsTPC(130);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 4){
fesdTrackCuts->SetMinNClustersITS(6);
fesdTrackCuts->SetMaxChi2PerClusterITS(2.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(80);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 5){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 6){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(80);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 7){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(120);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 8){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(120);
fesdTrackCuts->SetMinNCrossedRowsTPC(80);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 9){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 10){
fesdTrackCuts->SetMinNClustersITS(5);
// fesdTrackCuts->SetMaxChi2PerClusterITS(6);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(120);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 11){
fesdTrackCuts->SetMinNClustersITS(5);
// fesdTrackCuts->SetMaxChi2PerClusterITS(100);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(120);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 12){
fesdTrackCuts->SetMinNClustersITS(6);
// fesdTrackCuts->SetMaxChi2PerClusterITS(100);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 13){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 14){
fesdTrackCuts->SetMinNClustersITS(6);
fesdTrackCuts->SetMaxChi2PerClusterITS(2.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 15){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(4.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 16){
fesdTrackCuts->SetMinNClustersITS(4);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
// fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 17){
fesdTrackCuts->SetMinNClustersITS(3);
// fesdTrackCuts->SetMaxChi2PerClusterITS(4);
// fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kBoth);
fesdTrackCuts->SetMinNClustersTPC(100);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(4);
}
if(cutInstance == 18){
fesdTrackCuts->SetMinNClustersITS(4);
// fesdTrackCuts->SetMaxChi2PerClusterITS(6);
// fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(80);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.5);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
if(cutInstance == 19){
fesdTrackCuts->SetMinNClustersITS(5);
fesdTrackCuts->SetMaxChi2PerClusterITS(3.5);
fesdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kFirst);
fesdTrackCuts->SetMinNClustersTPC(120);
fesdTrackCuts->SetMinNCrossedRowsTPC(100);
fesdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);
fesdTrackCuts->SetMaxChi2PerClusterTPC(3);
}
return fesdTrackCuts;
}
AliESDtrackCuts* MyTrackCuts(Int_t clusterCut = 1, Bool_t selPrimaries = kTRUE, TString optSyt="DefaultITSTPC2011")
{
Double_t dcaxymax = 2.0;
TString PtDcaFormula = "0.0105+0.0350/pt^1.1";//7sigma
Double_t dcazmax = 2.0;
Double_t minNcls = 50;
Double_t maxX2TPCcls = 4.0;
Double_t maxX2ITScls = 36.0;
Double_t minCrossedRows = 70.0;
Double_t minRatioClsCrRowsOverFCls = 0.8;
if(optSyt.Contains("PtDCAXY5s")) {PtDcaFormula = "0.0075+0.025/pt^1.1";}
if(optSyt.Contains("PtDCAXY6s")) {PtDcaFormula = "0.0090+0.030/pt^1.1";}
if(optSyt.Contains("PtDCAXY7s")) {PtDcaFormula = "0.0105+0.035/pt^1.1";}//Defult
if(optSyt.Contains("PtDCAXY8s")) {PtDcaFormula = "0.0120+0.040/pt^1.1";}
if(optSyt.Contains("PtDCAXY9s")) {PtDcaFormula = "0.0135+0.045/pt^1.1";}
if(optSyt.Contains("FixDCAZ1")) {dcazmax = 1.0;}
if(optSyt.Contains("FixDCAZ2")) {dcazmax = 2.0;}//Defult
if(optSyt.Contains("FixDCAZ3")) {dcazmax = 3.0;}
if(optSyt.Contains("NCrRows60")){minCrossedRows = 60;}
if(optSyt.Contains("NCrRows70")){minCrossedRows = 70;}//Defult
if(optSyt.Contains("NCrRows80")){minCrossedRows = 80;}
if(optSyt.Contains("NCrRows90")){minCrossedRows = 90;}
if(optSyt.Contains("RClsCrRowsOvFCls0.7")){minRatioClsCrRowsOverFCls = 0.7;}
if(optSyt.Contains("RClsCrRowsOvFCls0.8")){minRatioClsCrRowsOverFCls = 0.8;}//Defult
if(optSyt.Contains("RClsCrRowsOvFCls0.9")){minRatioClsCrRowsOverFCls = 0.9;}
if(optSyt.Contains("ChiSqrPerTPCCls3")) {maxX2TPCcls = 3.0;}
if(optSyt.Contains("ChiSqrPerTPCCls4")) {maxX2TPCcls = 4.0;}//Defult
if(optSyt.Contains("ChiSqrPerTPCCls5")) {maxX2TPCcls = 5.0;}
if(optSyt.Contains("ChiSqrPerITSCls30")) {maxX2ITScls = 30.0;}
if(optSyt.Contains("ChiSqrPerITSCls36")) {maxX2ITScls = 36.0;}//Defult
if(optSyt.Contains("ChiSqrPerITSCls45")) {maxX2ITScls = 45.0;}
AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts;
if(optSyt.Contains("DefaultITSTPC2011")){
::Info("Config KSTAR ", Form("Default 2011 ESD track cuts used : %s\n",optSyt.Data()));
if(clusterCut == 0) esdTrackCuts->SetMinNClustersTPC(50);
else if (clusterCut == 1) {
esdTrackCuts->SetMinNCrossedRowsTPC(70);
esdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(0.8);
}
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
// ITS
esdTrackCuts->SetRequireITSRefit(kTRUE);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
AliESDtrackCuts::kAny);
if(selPrimaries) {
// 7*(0.0015+0.0050/pt^1.1)
esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0105+0.0350/pt^1.1");
esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
}
esdTrackCuts->SetMaxDCAToVertexZ(2);
esdTrackCuts->SetDCAToVertex2D(kFALSE);
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMaxChi2PerClusterITS(36);
}
else{
::Info("Config KSTAR ", Form("User Defined ESD track cuts used for Sys : %s\n",optSyt.Data()));
if(clusterCut == 0) esdTrackCuts->SetMinNClustersTPC(minNcls);
else if (clusterCut == 1) {
esdTrackCuts->SetMinNCrossedRowsTPC(minCrossedRows);
esdTrackCuts->SetMinRatioCrossedRowsOverFindableClustersTPC(minRatioClsCrRowsOverFCls);
}
esdTrackCuts->SetMaxChi2PerClusterTPC(maxX2TPCcls);
esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
// ITS
esdTrackCuts->SetRequireITSRefit(kTRUE);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,
AliESDtrackCuts::kAny);
if(selPrimaries) {
// 7*(0.0015+0.0050/pt^1.1)
esdTrackCuts->SetMaxDCAToVertexXYPtDep(PtDcaFormula.Data());
esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
}
esdTrackCuts->SetMaxDCAToVertexZ(dcazmax);
esdTrackCuts->SetDCAToVertex2D(kFALSE);
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMaxChi2PerClusterITS(maxX2ITScls);
}
return esdTrackCuts;
}
AliPWG4HighPtQATPConly* AddTaskPWG4HighPtQATPConly(char *prodType = "LHC10e14",int cuts=2)//1: Standard Cuts 2009 2: GetStandardITSTPCTrackCuts2009
{
// Creates HighPtQATPConly analysis task and adds it to the analysis manager.
// A. Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
Error("AddTaskPWG4HighPtQATPConly", "No analysis manager to connect to.");
return NULL;
}
// B. Check the analysis type using the event handlers connected to the analysis
// manager. The availability of MC handler can also be checked here.
//==============================================================================
if (!mgr->GetInputEventHandler()) {
::Error("AddTaskPWG4HighPtQATPConly", "This task requires an input event handler");
return NULL;
}
TString type = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
const char *analysisType = "ESD";//"TPC"
// C. Create the task, add it to manager.
//===========================================================================
//CREATE THE CUTS -----------------------------------------------
//Use AliESDtrackCuts
AliESDtrackCuts *trackCuts = new AliESDtrackCuts("AliESDtrackCuts","Standard Cuts");
if(cuts==1) {
trackCuts=trackCuts->GetStandardITSTPCTrackCuts2010(kTRUE);//Primary Track Selection
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1e10);
}
else if(cuts==2) {
trackCuts=trackCuts->GetStandardITSTPCTrackCuts2009(kTRUE);//Primary Track Selection
trackCuts->SetEtaRange(-0.9,0.9);
trackCuts->SetPtRange(0.15, 1e10);
}
AliESDtrackCuts *trackCutsITS = new AliESDtrackCuts("AliESDtrackCuts","Standard Cuts with ITSrefit");
if(cuts==1) {
//Cuts SPD || SDD
// TPC
trackCutsITS->SetMinNClustersTPC(70);
trackCutsITS->SetMaxChi2PerClusterTPC(4);
trackCutsITS->SetAcceptKinkDaughters(kFALSE);
trackCutsITS->SetRequireTPCRefit(kTRUE);
// ITS
trackCutsITS->SetRequireITSRefit(kTRUE);
trackCutsITS->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kNone);
trackCutsITS->SetClusterRequirementITS(AliESDtrackCuts::kSDD, AliESDtrackCuts::kFirst);
trackCutsITS->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01");
trackCutsITS->SetMaxDCAToVertexZ(2);
trackCutsITS->SetDCAToVertex2D(kFALSE);
trackCutsITS->SetRequireSigmaToVertex(kFALSE);
trackCutsITS->SetEtaRange(-0.9,0.9);
trackCutsITS->SetPtRange(0.15, 1e10);
trackCutsITS->SetRequireITSRefit(kTRUE);
}
else if(cuts==2) {
trackCutsITS=trackCutsITS->GetStandardITSTPCTrackCuts2009(kTRUE);//Primary Track Selection
trackCutsITS->SetEtaRange(-0.9,0.9);
trackCutsITS->SetPtRange(0.15, 1e10);
}
//Create the task
AliPWG4HighPtQATPConly *taskPWG4QA = new AliPWG4HighPtQATPConly(Form("AliPWG4HighPtQATPConly%d",cuts));
taskPWG4QA->SetCuts(trackCuts);
taskPWG4QA->SetCutsITS(trackCutsITS);
taskPWG4QA->SetCutType(cuts);
if(!strcmp(prodType, "LHC10e14") || !strcmp(prodType, "PbPb")) taskPWG4QA->SetPtMax(500.);
else taskPWG4QA->SetPtMax(100.);
// E. Create ONLY the output containers for the data produced by the task.
// Get and connect other common input/output containers via the manager as below
//==============================================================================
//------ input data ------
TString outputfile = "";
outputfile = AliAnalysisManager::GetCommonFileName();
outputfile += Form(":PWG4_HighPtQATPConly%d",cuts);
AliAnalysisDataContainer *cout_hist0;
AliAnalysisDataContainer *cout_hist1;
AliAnalysisDataContainer *cout_hist2;
AliAnalysisDataContainer *cout_cuts0;
AliAnalysisDataContainer *cout_cuts1;
cout_hist0 = mgr->CreateContainer(Form("qa_histsCuts%d",cuts), TList::Class(), AliAnalysisManager::kOutputContainer,outputfile);
cout_hist1 = mgr->CreateContainer(Form("qa_histsTPCCuts%d",cuts), TList::Class(), AliAnalysisManager::kOutputContainer,outputfile);
cout_hist2 = mgr->CreateContainer(Form("qa_histsITSCuts%d",cuts), TList::Class(), AliAnalysisManager::kOutputContainer,outputfile);
cout_cuts0 = mgr->CreateContainer(Form("qa_trackCuts%d",cuts), AliESDtrackCuts::Class(), AliAnalysisManager::kParamContainer,outputfile);
cout_cuts1 = mgr->CreateContainer(Form("qa_trackCutsITS%d",cuts), AliESDtrackCuts::Class(), AliAnalysisManager::kParamContainer,outputfile);
//Add task to manager
mgr->AddTask(taskPWG4QA);
//Connect input containter to manager
mgr->ConnectInput(taskPWG4QA,0,mgr->GetCommonInputContainer());
//Connect output containers to manager
mgr->ConnectOutput(taskPWG4QA,0,cout_hist0);
mgr->ConnectOutput(taskPWG4QA,1,cout_hist1);
mgr->ConnectOutput(taskPWG4QA,2,cout_hist2);
mgr->ConnectOutput(taskPWG4QA,3,cout_cuts0);
mgr->ConnectOutput(taskPWG4QA,4,cout_cuts1);
// Return task pointer at the end
return taskPWG4QA;
}
AliEmcalEsdTrackFilterTask* AddTaskEmcalEsdTrackFilter(
const char *name = "TrackFilter",
const char *trackCuts = "Hybrid_LHC11h",
const char *taskName = "AliEmcalEsdTrackFilterTask"
)
{
enum CutsType {
kHybrid = 0,
kTpcOnly = 1
};
enum DataSet {
kLHC10bcde = 0,
kLHC10h = 0,
kLHC11a = 1,
kLHC11c = 3,
kLHC11d = 3,
kLHC11h = 3
};
CutsType cutsType = kHybrid;
DataSet dataSet = kLHC11h;
TString cutsLabel("hybrid tracks");
TString dataSetLabel("LHC11h");
TString strTrackCuts(trackCuts);
strTrackCuts.ToLower();
if (strTrackCuts.Contains("hybrid")) {
cutsType = kHybrid;
} else if (strTrackCuts.Contains("tpconly")) {
cutsType = kTpcOnly;
cutsLabel = "TPC only constrained tracks";
} else {
::Warning("AddTaskEmcalEsdTrackFilter", "Cuts type not recognized, will assume Hybrid");
}
if (strTrackCuts.Contains("lhc10h")) {
dataSet = kLHC10h;
dataSetLabel = "LHC10h";
} else if (strTrackCuts.Contains("lhc10b") || strTrackCuts.Contains("lhc10c") ||
strTrackCuts.Contains("lhc10d") || strTrackCuts.Contains("lhc10e")) {
dataSet = kLHC10bcde;
dataSetLabel = "LHC10bcde";
} else if (strTrackCuts.Contains("lhc11a") || strTrackCuts.Contains("lhc12a15a")) {
dataSet = kLHC11a;
dataSetLabel = "LHC11a";
} else if (strTrackCuts.Contains("lhc11a1a") || strTrackCuts.Contains("lhc11a1b") ||
strTrackCuts.Contains("lhc11a1c") || strTrackCuts.Contains("lhc11a1d") ||
strTrackCuts.Contains("lhc11a1e") || strTrackCuts.Contains("lhc11a1f") ||
strTrackCuts.Contains("lhc11a1g") || strTrackCuts.Contains("lhc11a1h") ||
strTrackCuts.Contains("lhc11a1i") || strTrackCuts.Contains("lhc11a1j")) {
dataSet = kLHC11a;
dataSetLabel = "LHC11a";
} else if (strTrackCuts.Contains("lhc11c")) {
dataSet = kLHC11c;
dataSetLabel = "LHC11c";
} else if (strTrackCuts.Contains("lhc11d")) {
dataSet = kLHC11d;
dataSetLabel = "LHC11d";
} else if (strTrackCuts.Contains("lhc11h") || strTrackCuts.Contains("lhc12a15e")) {
dataSet = kLHC11h;
dataSetLabel = "LHC11h";
} else if (strTrackCuts.Contains("lhc12g")) {
dataSet = kLHC11h;
dataSetLabel = "LHC12g";
} else if (strTrackCuts.Contains("lhc12")) {
dataSet = kLHC11h;
dataSetLabel = "LHC12";
} else if (strTrackCuts.Contains("lhc13b")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13b";
} else if (strTrackCuts.Contains("lhc13c")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13c";
} else if (strTrackCuts.Contains("lhc13d")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13d";
} else if (strTrackCuts.Contains("lhc13e")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13e";
} else if (strTrackCuts.Contains("lhc13f")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13f";
} else if (strTrackCuts.Contains("lhc13g")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13g";
} else if (strTrackCuts.Contains("lhc12a15f")) {
dataSet = kLHC11h;
dataSetLabel = "LHC12a15f";
} else if (strTrackCuts.Contains("lhc13b4")) {
dataSet = kLHC11h;
dataSetLabel = "LHC13b4";
} else if (strTrackCuts.Contains("lhc12a15g")) {
dataSet = kLHC11d;
dataSetLabel = "LHC12a15g";
} else if (strTrackCuts.Contains("lhc12f2a")) {
dataSet = kLHC11d;
dataSetLabel = "LHC12f2a";
} else if (strTrackCuts.Contains("lhc12a17")) {
dataSet = kLHC11h;
dataSetLabel = "LHC12a17";
} else if (strTrackCuts.Contains("lhc14a1")) {
dataSet = kLHC11h;
dataSetLabel = "LHC14a1";
} else {
::Warning("AddTaskEmcalEsdTrackFilter", "Dataset not recognized, will assume LHC11h");
}
// Get the pointer to the existing analysis manager via the static access method.
//==============================================================================
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskEmcalEsdTrackFilter", "No analysis manager to connect to.");
return NULL;
}
// Check the analysis type using the event handlers connected to the analysis manager.
//==============================================================================
AliVEventHandler *evhand = mgr->GetInputEventHandler();
if (!evhand) {
::Error("AddTaskEmcalEsdTrackFilter", "This task requires an input event handler");
return NULL;
}
if (!evhand->InheritsFrom("AliESDInputHandler")) {
::Info("AddTaskEmcalEsdTrackFilter", "This task is only needed for ESD analysis. No task added.");
return NULL;
}
//-------------------------------------------------------
// Init the task and do settings
//-------------------------------------------------------
AliEmcalEsdTrackFilterTask *eTask = new AliEmcalEsdTrackFilterTask(taskName); // default is no cut
if ((dataSet == kLHC11c && cutsType == kHybrid) ||
(dataSet == kLHC11d && cutsType == kHybrid) ||
(dataSet == kLHC11h && cutsType == kHybrid)) {
/* hybrid track cuts*/
AliESDtrackCuts *cutsp = AliEmcalESDTrackCutsGenerator::CreateTrackCutsPWGJE(10001008); //1000 adds SPD any requirement
eTask->SetTrackCuts(cutsp);
AliESDtrackCuts *hybsp = AliEmcalESDTrackCutsGenerator::CreateTrackCutsPWGJE(10041008); //1004 removes ITSrefit requirement from standard set
hybsp->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
eTask->SetHybridTrackCuts(hybsp);
eTask->SetIncludeNoITS(kFALSE);
} else if ((dataSet == kLHC10h && cutsType == kHybrid) ||
(dataSet == kLHC11a && cutsType == kHybrid)) {
/* hybrid track cuts*/
AliESDtrackCuts *cutsp = AliEmcalESDTrackCutsGenerator::CreateTrackCutsPWGJE(10001006); //1000 adds SPD any requirement
eTask->SetTrackCuts(cutsp);
AliESDtrackCuts *hybsp = AliEmcalESDTrackCutsGenerator::CreateTrackCutsPWGJE(10041006); //1004 removes ITSrefit requirement from standard set
hybsp->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kOff);
eTask->SetHybridTrackCuts(hybsp);
eTask->SetIncludeNoITS(kTRUE);
}
else if (dataSet == kLHC11h && cutsType == kTpcOnly) {
/* TPC-only constrained track cuts*/
AliESDtrackCuts *cutsp = AliEmcalESDTrackCutsGenerator::CreateTrackCutsPWGJE(2001); //TPC-only loose track cuts
eTask->SetTrackCuts(cutsp);
eTask->SetHybridTrackCuts(0);
}
else {
::Error("AddTaskEmcalEsdTrackFilter","Track cuts type / period not recognized! Undefined beahviour will follow!");
}
eTask->SetTracksName(name);
std::cout << " *** Track selector task configured to select " << cutsLabel << " in dataset "<< dataSetLabel << " *** " << std::endl;
//-------------------------------------------------------
// Final settings, pass to manager and set the containers
//-------------------------------------------------------
mgr->AddTask(eTask);
// Create containers for input/output
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
mgr->ConnectInput(eTask, 0, cinput1);
return eTask;
}
AliAnalysisTaskSEHFJetsOrig* AddTaskSEHFJetsOrig(TString fileout="standard",Bool_t readmc=kTRUE,TString cutfile="HFJetVertexCuts.root",TString containerprefix="c", Float_t minC=0., Float_t maxC=7.5)
{
//
// Configuration macro for the task to analyze the fraction of prompt charm
// using the D0 impact parameter
// [email protected]
//
//==========================================================================
Int_t last=0;
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskSEHFJetsOrig", "No analysis manager to connect to.");
return NULL;
}
TString str,containername;
if(fileout=="standard"){
fileout=AliAnalysisManager::GetCommonFileName();
fileout+=":PWG3_HFCJ_";
fileout+="HFjetVertex";
if(containerprefix!="c")fileout+=containerprefix;
str="HFjetVertex";
}
else {
str=fileout;
str.ReplaceAll(".root","");
}
str.Prepend("_");
AliAnalysisTaskSEHFJetsOrig *hfTask;
if(!gSystem->AccessPathName(cutfile.Data(),kFileExists)){
TFile *f=TFile::Open(cutfile.Data());
AliRDHFJetsCuts.cxx *cuts= (AliRDHFCutsD0toKpi*)f->Get("HFJetsCutsVertex");
cuts->PrintAll();
hfTask = new AliAnalysisTaskSEHFJetsOrig("AliAnalysisTaskSEHFJetsOrig");
AliHFJetVertexTagging *tagger=new AliHFJetVertexTagging();
hfTask->SetTagger(tagger);
hfTask->SetCuts(cuts);
}
else {
AliRDHFJetsCuts *cuts=new AliRDHFJetsCuts();
hfTask = new AliAnalysisTaskSEHFJetsOrig("AliAnalysisTaskSEHFJetsOrig");
hfTask->SetCuts(cuts);
AliHFJetVertexTagging *tagger=new AliHFJetVertexTagging();
AliRDHFJetsCutsVertex *cuts2=new AliRDHFJetsCutsVertex("jetCuts");
//cuts for jets
cuts->SetJetRadius(0.4);
cuts->SetMaxEtaJet(0.5);//0.9-R
cuts->SetMinPtJet(5);
cuts->SetMaxPtJet(200);
cuts2->SetJetRadius(0.4);
cuts2->SetMaxEtaJet(0.5);//0.9-R
cuts2->SetMinPtJet(5);
cuts2->SetMaxPtJet(200);
AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts","default");
esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
esdTrackCuts->SetMinNClustersTPC(70);
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetRequireTPCRefit(kTRUE);
esdTrackCuts->SetRequireITSRefit(kTRUE);
//esdTrackCuts->SetMinNClustersITS(4);
esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
esdTrackCuts->SetMinDCAToVertexXY(0.);
esdTrackCuts->SetEtaRange(-0.8,0.8);
esdTrackCuts->SetPtRange(0.3,1.e10);
cuts2->AddTrackCuts(esdTrackCuts);
//cuts for vertexing
cuts2->SetNprongs(3);
cuts2->SetIsElec(kFALSE); // kTRUE to select e in jet vertex
// cuts2->SetMinPtHardestTrack(1.5);//default 0.3
// cuts2->SetSecVtxWithKF(kFALSE);//default with StrLinMinDist
// cuts2->SetImpParCut(0.01);//default 0
// cuts2->SetDistPrimSec(0.1);//default 0
// cuts2->SetCospCut(0.7);//default -1
// cuts2->SetMinPtHardestTrack(1.3);//default 0.3
// cuts2->SetSecVtxWithKF(kFALSE);//default with StrLinMinDist
// cuts2->SetImpParCut(0.01);//default 0
// cuts2->SetDistPrimSec(0.05);//default 0
// cuts2->SetCospCut(0.7);//default -1
cuts2->SetMinPtHardestTrack(1.0);//default 0.3
cuts2->SetSecVtxWithKF(kFALSE);//default with StrLinMinDist
cuts2->SetImpParCut(0.);//default 0
cuts2->SetDistPrimSec(0.);//default 0
cuts2->SetCospCut(-1);//default -1
tagger->SetCuts(cuts2);
hfTask->SetCuts(cuts);
hfTask->SetTagger(tagger);
// ::Error("AddTaskSEHFJets","No Cut Object");
}
cuts->SetMinCentrality(minC);
cuts->SetMaxCentrality(maxC);
hfTask->SetReadMC(readmc);
mgr->AddTask(hfTask);
// Create containers for input/output
AliAnalysisDataContainer *cinput = mgr->GetCommonInputContainer();
//mgr->CreateContainer("cinput",TChain::Class(),AliAnalysisManager::kInputContainer);
mgr->ConnectInput(hfTask,0,cinput);
//Now container for general properties histograms
containername="outputNentries";
containername.Prepend(containerprefix.Data());
containername.Append(str.Data());
AliAnalysisDataContainer *coutputNentries = mgr->CreateContainer(containername.Data(),TH1F::Class(), AliAnalysisManager::kOutputContainer, fileout.Data());
mgr->ConnectOutput(hfTask,1,coutputNentries);
containername="RecoJetsProp";
containername.Prepend(containerprefix.Data());
containername.Append(str.Data());
AliAnalysisDataContainer *cSparseVtxProp = mgr->CreateContainer(containername.Data(),THnSparse::Class(), AliAnalysisManager::kOutputContainer, fileout.Data());
mgr->ConnectOutput(hfTask,2,cSparseVtxProp);
containername="SparseVerticesProp";
containername.Prepend(containerprefix.Data());
containername.Append(str.Data());
AliAnalysisDataContainer *cSparseVtxProp = mgr->CreateContainer(containername.Data(),THnSparse::Class(), AliAnalysisManager::kOutputContainer, fileout.Data());
mgr->ConnectOutput(hfTask,3,cSparseVtxProp);
containername="SparseJetVerticesProp";
containername.Prepend(containerprefix.Data());
containername.Append(str.Data());
AliAnalysisDataContainer *cSparseVtxProp = mgr->CreateContainer(containername.Data(),THnSparse::Class(), AliAnalysisManager::kOutputContainer, fileout.Data());
mgr->ConnectOutput(hfTask,4,cSparseVtxProp);
containername="SparsebTaggedJets";
containername.Prepend(containerprefix.Data());
containername.Append(str.Data());
AliAnalysisDataContainer *cSparsebJets = mgr->CreateContainer(containername.Data(),THnSparse::Class(), AliAnalysisManager::kOutputContainer, fileout.Data());
mgr->ConnectOutput(hfTask,5,cSparsebJets);
return hfTask;
}