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;
}
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;
}
void AnalysisTrainMuonCAF(char* fileout = "AliAOD.root", char *datasetname = "myDataSet", Int_t nev=1234567890)
{
// Macro to produce a generic AOD starting from an ESD file.
// The AOD is filled with two tasks:
// 1- with the first one (AliAnalysisTaskESDfilter),
// all the branches of the AOD are filled apart from the muons.
// 2- with the second task (AliAnalysisTaskESDMuonFilter)
// muons tracks are added to the tracks branch
// This macro works on the CAF
// R. Arnaldi 4/5/08
gSystem->Load("libTree");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
gSystem->Load("libPhysics");
// Reset user processes if CAF if not responding anymore
// TProof::Reset("lxb6046");
// Connect to proof
TProof::Open("lxb6046"); // may be username@lxb6046 if user not the same as on local
// Clear packages if changing ROOT version on CAF or local
// gProof->ClearPackages();
// Enable proof debugging if needed
// gProof->SetLogLevel(5);
// Common packages
gProof->UploadPackage("STEERBase.par");
gProof->EnablePackage("STEERBase");
gProof->UploadPackage("ESD.par");
gProof->EnablePackage("ESD");
gProof->UploadPackage("AOD.par");
gProof->EnablePackage("AOD");
gProof->UploadPackage("ANALYSIS.par");
gProof->EnablePackage("ANALYSIS");
gProof->UploadPackage("ANALYSISalice.par");
gProof->EnablePackage("ANALYSISalice");
// Analysis-specific
// --- Enable the PWG3base Package
gProof->UploadPackage("PWG3muon.par");
gProof->EnablePackage("PWG3muon");
// Chain from files staged on CAF
// gROOT->LoadMacro("CreateESDChain.C");
// TChain* chain = CreateESDChain("ESD1503X_v1.txt",3);
// TChain* chain = CreateESDChain("ESD82XX_30Kshort.txt", 10);
// Chain from datasets
gROOT->LoadMacro("CreateChainFromDataSet.C");
ds = gProof->GetDataSet(datasetname)->GetStagedSubset();
chain = CreateChainFromDataSet(ds, "esdTree");
// Make the analysis manager
AliAnalysisManager *mgr = new AliAnalysisManager("Analysis Train", "Analysis train");
// ESD input handler
AliESDInputHandler *esdHandler = new AliESDInputHandler();
esdHandler->SetInactiveBranches("FMD CaloCluster");
// AOD output handler
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName(fileout);
//aodHandler->SetOutputFileName("AOD.root");
mgr->SetInputEventHandler(esdHandler);
mgr->SetOutputEventHandler(aodHandler);
// Set of cuts plugged into the ESD filter
//
// standard
AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose");
esdTrackCutsL->SetMinNClustersTPC(50);
esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5);
esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
esdTrackCutsL->SetRequireTPCRefit(kTRUE);
esdTrackCutsL->SetMinNsigmaToVertex(3);
esdTrackCutsL->SetRequireSigmaToVertex(kTRUE);
esdTrackCutsL->SetAcceptKingDaughters(kFALSE);
//
// hard cuts
AliESDtrackCuts* esdTrackCutsH = new AliESDtrackCuts("AliESDtrackCuts", "Hard");
esdTrackCutsH->SetMinNClustersTPC(100);
esdTrackCutsH->SetMaxChi2PerClusterTPC(2.0);
esdTrackCutsH->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
esdTrackCutsH->SetRequireTPCRefit(kTRUE);
esdTrackCutsH->SetMinNsigmaToVertex(2);
esdTrackCutsH->SetRequireSigmaToVertex(kTRUE);
esdTrackCutsH->SetAcceptKingDaughters(kFALSE);
esdTrackCutsH->SetPRange(0.,2.);
//
// muon cuts
AliESDMuonTrackCuts* esdMuonTrackCuts = new AliESDMuonTrackCuts("AliESDMuonTrackCuts", "test");
esdMuonTrackCuts->SetPRange(0.,20.);
//esdMuonTrackCuts->SetPtRange(0.,0.5); // example of kinematic cuts that can be applied
// track filter (to reject tracks not surviving the cuts - refers to all particles apart from muons)
AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
trackFilter->AddCuts(esdTrackCutsH);
// muon track filter (to reject muon tracks not surviving the cuts)
AliAnalysisFilter* trackMuonFilter = new AliAnalysisFilter("trackMuonFilter");
trackMuonFilter->AddCuts(esdMuonTrackCuts);
// ESD filter task putting standard info to output generic AOD
AliAnalysisTaskESDfilter *esdfilter = new AliAnalysisTaskESDfilter("ESD Filter");
//esdfilter->SetTrackFilter(trackFilter);
esdfilter->SetDebugLevel(10);
mgr->AddTask(esdfilter);
// ESD filter task putting muon info to output generic AOD
AliAnalysisTaskESDMuonFilter *esdmuonfilter = new AliAnalysisTaskESDMuonFilter("ESD Muon Filter");
esdmuonfilter->SetTrackFilter(trackMuonFilter);
mgr->AddTask(esdmuonfilter);
// Containers for input/output
AliAnalysisDataContainer *cin_esd = mgr->GetCommonInputContainer();
// Output AOD container.
AliAnalysisDataContainer *cout_aod = mgr->GetCommonOutputContainer();
// Connect containers to tasks slots
mgr->ConnectInput (esdfilter, 0, cin_esd );
mgr->ConnectOutput (esdfilter, 0, cout_aod );
mgr->ConnectInput (esdmuonfilter, 0, cin_esd);
mgr->ConnectOutput (esdmuonfilter, 0, cout_aod );
//
// Run the analysis
//
if (mgr->InitAnalysis()) {
mgr->PrintStatus();
mgr->StartAnalysis("proof",chain,nev);
}
}
//
// *** Configuration script for K*+-->K0Short-Pi analysis ***
//
// A configuration script for RSN package needs to define the followings:
//
// (1) decay tree of each resonance to be studied, which is needed to select
// true pairs and to assign the right mass to all candidate daughters
// (2) cuts at all levels: single daughters, tracks, events
// (3) output objects: histograms or trees
//
Bool_t ConfigKStarPlusMinus
(
AliRsnMiniAnalysisTask *task,
Int_t collSyst,
Bool_t isMC,
Float_t piPIDCut,
Float_t pPIDCut,
Int_t aodFilterBit,
Float_t trackDCAcut,
Float_t massTol,
Float_t lambdaDCA,
Float_t lambdaCosPoinAn,
Float_t lambdaDaughDCA,
Int_t NTPCcluster,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
/////////////////////////////////////////////////////
// selections for the pion from the decay of KStarPlusMinus*
/////////////////////////////////////////////////////
//
AliRsnCutDaughterSigmaStar2010PP *cutPi = new AliRsnCutDaughterSigmaStar2010PP("cutPionForKStarPlusMinus", AliPID::kPion);
cutPi->SetPIDCut(piPIDCut); // fPIDCut used in IsSelected() after the call to cutQuality
AliRsnCutTrackQuality *cutQuality = (AliRsnCutTrackQuality*) cutPi->CutQuality();
//cutQuality->SetDefaults2011();
cutQuality->SetDefaults2010(0,1); // 1st par. not default (0 -> use TPC clusters). 2nd par. default (-> standard Pt and eta range)
// SetDefaults2010 contains the following selections:
// SetPtRange(0.15, 1E+20);
// SetEtaRange(-0.8, 0.8);
// and from aliroot/master/src/ANALYSIS/ANALYSISalice/AliESDtrackCuts.cxx
// AliESDtrackCuts::GetStandardITSTPCTrackCuts2010(1,0)
// esdTrackCuts->SetMinNClustersTPC(70);
// esdTrackCuts->SetMaxChi2PerClusterTPC(4);
// esdTrackCuts->SetAcceptKinkDaughters(kFALSE);
// esdTrackCuts->SetRequireTPCRefit(kTRUE);
// esdTrackCuts->SetRequireITSRefit(kTRUE);
// esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny);
// esdTrackCuts->SetMaxDCAToVertexXYPtDep("0.0182+0.0350/pt^1.01"); // NB. With pt_min=0.15 (see above) -> DCAxy_max = 0.2560
// esdTrackCuts->SetMaxChi2TPCConstrainedGlobal(36);
// esdTrackCuts->SetMaxDCAToVertexZ(2);
// esdTrackCuts->SetDCAToVertex2D(kFALSE);
// esdTrackCuts->SetRequireSigmaToVertex(kFALSE);
// esdTrackCuts->SetMaxChi2PerClusterITS(36);
//
AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForKStarPlusMinus", AliRsnTarget::kDaughter);
cutSetPi->AddCut(cutPi);
cutSetPi->SetCutScheme(cutPi->GetName());
Int_t iCutPi = task->AddTrackCuts(cutSetPi);
//
/////////////////////////////////////////////////////////////
// selections for Lambda and for the daughters of Lambda
/////////////////////////////////////////////////////////////
//
// selections for the proton and pion daugthers of Lambda and AntiLambda
AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("qualityDaughterLambda");
esdTrackCuts->SetPtRange(0.15,1.E10);
esdTrackCuts->SetEtaRange(-0.8,0.8);
esdTrackCuts->SetRequireTPCRefit();
esdTrackCuts->SetAcceptKinkDaughters(0); //
esdTrackCuts->SetMinNClustersTPC(NTPCcluster);
esdTrackCuts->SetMaxChi2PerClusterTPC(4);
esdTrackCuts->SetMinDCAToVertexXY(0.15);
//
/////////////////////////////////////////////////
// selections for Lambda
AliRsnCutV0 *cutLambda = new AliRsnCutV0("cutLambda", kK0Short, AliPID::kPion, AliPID::kPion);
cutLambda->SetPIDCutProton(pPIDCut); // PID for the proton daughter of Lambda
cutLambda->SetPIDCutPion(piPIDCut); // PID for the pion daughter of Lambda
cutLambda->SetESDtrackCuts(esdTrackCuts); // all the other selections (defined above) for proton and pion daughters of Lambda
cutLambda->SetMaxDaughtersDCA(lambdaDaughDCA);
cutLambda->SetMaxDCAVertex(lambdaDCA);
cutLambda->SetMinCosPointingAngle(lambdaCosPoinAn);
cutLambda->SetTolerance(massTol);
cutLambda->SetMaxRapidity(0.5);
//
AliRsnCutSet *cutSetLambda = new AliRsnCutSet("setLambda", AliRsnTarget::kDaughter);
cutSetLambda->AddCut(cutLambda);
cutSetLambda->SetCutScheme(cutLambda->GetName());
Int_t iCutLambda = task->AddTrackCuts(cutSetLambda);
//
//######################################################################################################
//
// -- Values ------------------------------------------------------------------------------------
//
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
//
// -- Create all needed outputs -----------------------------------------------------------------
//
// use an array for more compact writing, which are different on mixing and charges
// [0] = unlike
// [1] = mixing
// [2] = like ++
// [3] = like --
Bool_t use [6] = {1 ,1 ,1 ,1 ,1 ,1 };
Bool_t useIM [6] = {1 ,1 ,1 ,1 ,1 ,1 };
TString name [6] = {"KStarPlusMinus","AKStarPlusMinus","KStarPlusMinusmix","AKStarPlusMinusmix","KStarPlusMinust","AKStarPlusMinust"};
TString comp [6] = {"PAIR" ,"PAIR" ,"MIX" ,"MIX" ,"TRUE" ,"TRUE" };
TString output [6] = {"HIST" ,"HIST" ,"HIST" ,"HIST" ,"HIST" ,"HIST" };
Char_t charge1 [6] = {'0' ,'0' ,'0' ,'0' ,'0' ,'0' };
Char_t charge2 [6] = {'+' ,'-' ,'+' ,'-' ,'+' ,'-' };
Int_t cutID1 [6] = { iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda ,iCutLambda };
Int_t cutID2 [6] = { iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi };
Int_t ipdg [6] = {323 ,-323 ,323 ,-323 ,323 ,-323 };
Double_t mass [6] = { 0.89166 ,0.89166 ,0.89166 ,0.89166 ,0.89166 ,0.89166 };
for (Int_t i = 0; i < 6; i++) {
if (!use[i]) continue;
if (collSyst) output[i] = "SPARSE";
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("sigmastar_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
// selection settings
out->SetCutID(0, cutID1[i]);
out->SetCutID(1, cutID2[i]);
out->SetDaughter(0, AliRsnDaughter::kKaon0);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(ipdg[i]);
out->SetMotherMass(mass[i]);
// pair cuts
out->SetPairCuts(cutsPair);
// axis X: invmass
if (useIM[i])
out->AddAxis(imID, 2000, 0, 2.0);
// out->AddAxis(imID, 700, 1.2, 4.0);
// axis Y: transverse momentum
out->AddAxis(ptID, 100, 0.0, 10.0);
//out->AddAxis(lambdaDCA, 10, 0.0, 1.0);
if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0);
}
AddMonitorOutput_PionPt(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionEta(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionDCAxy(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionDCAz(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionPIDCut(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionNTPC(cutSetPi->GetMonitorOutput());
AddMonitorOutput_PionTPCchi2(cutSetPi->GetMonitorOutput());
// AddMonitorOutput_LambdaP(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaPt(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaNegDaughPt(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaPosDaughPt(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaMass(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaDCA(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaRadius(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaDaughterDCA(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaCosPointAngle(cutSetLambda->GetMonitorOutput());
// AddMonitorOutput_LambdaProtonPID(cutSetLambda->GetMonitorOutput());
AddMonitorOutput_LambdaPionPID(cutSetLambda->GetMonitorOutput());
if (isMC) {
TString mode = "HIST";
if (collSyst) mode = "SPARSE";
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("KStarPlusMinus_TrueMC%s", suffix), mode.Data(), "MOTHER");
// selection settings
out->SetDaughter(0, AliRsnDaughter::kKaon0);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetMotherPDG(323);
out->SetMotherMass(0.89166);
// pair cuts
out->SetPairCuts(cutsPair);
// binnings
out->AddAxis(imID, 2000, 0.0, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
//out->AddAxis(lambdaDCA, 10, 0.0, 1.0);
if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0);
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("AKStarPlusMinus_TrueMC%s", suffix), mode.Data(), "MOTHER");
// selection settings
out->SetDaughter(0, AliRsnDaughter::kKaon0);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetMotherPDG(-323);
out->SetMotherMass(0.89166);
// pair cuts
out->SetPairCuts(cutsPair);
// binnings
out->AddAxis(imID, 2000, 0.0, 2.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
//out->AddAxis(lambdaDCA, 10, 0.0, 1.0);
if (collSyst) out->AddAxis(centID, 10, 0.0, 100.0);
}
return kTRUE;
}
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;
}
AliEPSelectionTask *AddTaskEventplane(Bool_t useEtaGap=kTRUE,Float_t etaGap=0.4,Bool_t posTPCAOD=kFALSE,TString containername = "EPStat")
{
// Macro to connect an event plane selection task to an existing analysis manager.
if(useEtaGap && posTPCAOD){
::Error("AddTaskEventplane", "eta-splitting of events and one side of TPC not possible at same time!");
return NULL;
}
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskEventplane", "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("AddTaskEventplane", "This task requires an input event handler");
return NULL;
}
TString inputDataType = mgr->GetInputEventHandler()->GetDataType(); // can be "ESD" or "AOD"
AliEPSelectionTask *eventplaneTask = new AliEPSelectionTask("EventplaneSelection");
eventplaneTask->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kSemiCentral | AliVEvent::kCentral);
if (inputDataType == "AOD"){
eventplaneTask->SetInput("AOD");
}
eventplaneTask->SetTrackType("TPC");
eventplaneTask->SetUsePtWeight();
eventplaneTask->SetUsePhiWeight();
eventplaneTask->SetSaveTrackContribution();
if(useEtaGap){
eventplaneTask->SetSubeventsSplitMethod(AliEPSelectionTask::kEta);
eventplaneTask->SetEtaGap(etaGap);
}
if(posTPCAOD){
eventplaneTask->SetPersonalAODtrackCuts(128,0.,0.8,0.15,20.);
eventplaneTask->SetSubeventsSplitMethod(AliEPSelectionTask::kRandom);
}
// Cuts on primary tracks
AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Standard");
esdTrackCutsL->SetMinNClustersTPC(50);
esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5);
// esdTrackCutsL->SetMaxCovDiagonalElements(2, 2, 0.5, 0.5, 2);
// esdTrackCutsL->SetRequireTPCRefit(kTRUE);
esdTrackCutsL->SetMaxDCAToVertexXY(3.0);
esdTrackCutsL->SetMaxDCAToVertexZ(3.0);
esdTrackCutsL->SetDCAToVertex2D(kTRUE);
// esdTrackCutsL->SetRequireSigmaToVertex(kFALSE);
// esdTrackCutsL->SetAcceptKinkDaughters(kFALSE);
eventplaneTask->SetPersonalESDtrackCuts(esdTrackCutsL);
mgr->AddTask(eventplaneTask);
AliAnalysisDataContainer *cinput0 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer(containername,
TList::Class(), AliAnalysisManager::kOutputContainer,
"EventStat_temp.root");
mgr->ConnectInput(eventplaneTask, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(eventplaneTask,1,coutput1);
return eventplaneTask;
}
void runAODFilterMC()
{
// PROOF example
gSystem->Load("libTree");
gSystem->Load("libPhysics");
gSystem->Load("libGeom");
gSystem->Load("libVMC");
bool bKineFilter = true;
// TProof::Mgr("alicecaf")->SetROOTVersion("v5-21-01-alice_dbg");
TProof::Open("alicecaf");
// gProof->SetParallel(1);
char *dataset = "/COMMON/COMMON/LHC08c11_10TeV_0.5T";
// char *dataset = "/PWG4/kleinb/LHC08q_jetjet100";
// gProof->ClearPackages();
gProof->UploadPackage("${ALICE_ROOT}/STEERBase.par");
gProof->EnablePackage("STEERBase");
gProof->UploadPackage("${ALICE_ROOT}/ESD.par");
gProof->EnablePackage("ESD");
gProof->UploadPackage("${ALICE_ROOT}/AOD.par");
gProof->EnablePackage("AOD");
gProof->UploadPackage("${ALICE_ROOT}/ANALYSIS.par");
gProof->EnablePackage("ANALYSIS");
gProof->UploadPackage("${ALICE_ROOT}/ANALYSISalice.par");
gProof->EnablePackage("ANALYSISalice");
//
if (gApplication) gApplication->InitializeGraphics();
// Create the chain
//
///////////////////////////////////////////////////////////////////////////////////
// Create the analysis manager
//
// Input
AliESDInputHandler* inpHandler = new AliESDInputHandler();
// Output
AliAODHandler* aodHandler = new AliAODHandler();
aodHandler->SetOutputFileName("aod_ckb2.root");
// MC Truth
AliMCEventHandler* mcHandler = new AliMCEventHandler();
AliAnalysisManager *mgr = new AliAnalysisManager("Filter Manager", "Filter Manager");
if(bKineFilter){
mgr->SetMCtruthEventHandler(mcHandler);
}
mgr->SetInputEventHandler (inpHandler);
mgr->SetOutputEventHandler (aodHandler);
aodHandler->Dump();
mgr->SetDebugLevel(10);
// Filtering of MC particles (decays conversions etc)
// this task is also needed to set the MCEventHandler
// to the AODHandler, this will not be needed when
// AODHandler goes to ANALYSISalice
AliAnalysisTaskMCParticleFilter *kinefilter = new AliAnalysisTaskMCParticleFilter("Particle Filter");
if(bKineFilter)mgr->AddTask(kinefilter);
//
AliESDtrackCuts* esdTrackCutsL = new AliESDtrackCuts("AliESDtrackCuts", "Loose");
esdTrackCutsL->SetMinNClustersTPC(50);
esdTrackCutsL->SetMaxChi2PerClusterTPC(3.5);
esdTrackCutsL->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
esdTrackCutsL->SetRequireTPCRefit(kTRUE);
esdTrackCutsL->SetDCAToVertexZ(3.0);
esdTrackCutsL->SetDCAToVertexXY(3.0);
esdTrackCutsL->SetDCAToVertex2D(kTRUE);
esdTrackCutsL->SetRequireSigmaToVertex(kFALSE);
esdTrackCutsL->SetAcceptKinkDaughters(kFALSE);
AliESDtrackCuts* esdTrackCutsITSsa = new AliESDtrackCuts("AliESDtrackCuts", "ITS stand-alone");
esdTrackCutsITSsa->SetRequireITSStandAlone(kTRUE);
AliAnalysisFilter* trackFilter = new AliAnalysisFilter("trackFilter");
trackFilter->AddCuts(esdTrackCutsL);
trackFilter->AddCuts(esdTrackCutsITSsa);
AliAnalysisTaskESDfilter *esdfilter = new AliAnalysisTaskESDfilter("ESD Filter");
esdfilter->SetTrackFilter(trackFilter);
mgr->AddTask(esdfilter);
//
// Create containers for input/output
AliAnalysisDataContainer *cinput1 = mgr->GetCommonInputContainer();
AliAnalysisDataContainer *coutput1 = mgr->GetCommonOutputContainer();
coutput1->SetSpecialOutput();
if(bKineFilter){
mgr->ConnectInput (kinefilter, 0, cinput1 );
mgr->ConnectOutput (kinefilter, 0, coutput1 );
AliAnalysisDataContainer *coutputEx = mgr->CreateContainer("cFilterList", TList::Class(),
AliAnalysisManager::kOutputContainer,"pyxsec_hists.root");
mgr->ConnectOutput (kinefilter, 1, coutputEx );
}
mgr->ConnectInput (esdfilter, 0, cinput1 );
mgr->ConnectOutput (esdfilter, 0, coutput1 );
//
// Run the analysis
//
mgr->InitAnalysis();
mgr->PrintStatus();
mgr->StartAnalysis("proof",dataset,10000);
}
//________________________________________________________________
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;
}
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;
}