void SetEventCuts(AliRsnMiniAnalysisTask *task, Bool_t isMC,
ERsnCollisionType collisionType, Double_t vzCut,
Bool_t rejectPileUp) {
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors to vtx
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = 0;
cutVertex = new AliRsnCutPrimaryVertex("cutEVertex", vzCut, 0, kFALSE);
AliRsnCutEventUtils *cutEventUtils = 0;
cutEventUtils = new AliRsnCutEventUtils("cutEUtils", kTRUE, rejectPileUp);
if ((collisionType == kPP) && (!isMC) && cutVertex) {
cutVertex->SetCheckPileUp(rejectPileUp); // set the check for pileup
::Info("AddTaskRsnPhiSpinPol",
Form(":::::::::::::::::: Pile-up rejection mode: %s",
(rejectPileUp) ? "ON" : "OFF"));
}
// define and fill cut set for event cut
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutEventUtils);
eventCuts->AddCut(cutVertex);
TString cutScheme =
TString::Format("%s&%s", cutEventUtils->GetName(), cutVertex->GetName());
eventCuts->SetCutScheme(cutScheme.Data());
task->SetEventCuts(eventCuts);
}
AliRsnCutSet *SetPairCuts(AliRsnMiniAnalysisTask *task, Double_t minY, Double_t maxY) {
// -- PAIR CUTS (common to all resonances)
// ------------------------------------------------------
AliRsnCutMiniPair *cutY =
new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(minY, maxY);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
return cutsPair;
}
AliRsnCutSet* PairCuts(AliRsnPairDef *support)
{
// for pairs we define a rapidity windows, defined through a cut
// --> NOTE: it needs a support AliRsnPairDef from which it takes the mass
AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY);
AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, kFALSE);
valRapidity->SetSupportObject(support);
cutRapidity->SetValueObj(valRapidity);
// cut set
AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
pairCuts->AddCut(cutRapidity);
pairCuts->SetCutScheme(cutRapidity->GetName());
}
AliRsnCutSet* EventCuts()
{
// primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
// we switch on the check for pileup
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
cutVertex->SetCheckPileUp(kTRUE);
// primary vertex is always used
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
return eventCuts;
}
AliRsnMiniAnalysisTask * AddTaskRsnQA(
Bool_t isMC = kFALSE,
Bool_t useGeoCutsPbPb2015 = kFALSE,
TString multEstimator = "AliMultSelection_V0M",
UInt_t triggerMask = AliVEvent::kINT7,
TString outNameSuffix = "phi",
Int_t evtCutSetID = 0, //0 for data, 1 for MC, 2 for data with pile-up rejection
Int_t pairCutSetID = 0, //selects on pair rapidity: 0 for symmetric system, 1 for p-Pb 5 TeV, 2 for p-Pb 8 TeV
Int_t aodFilterBit = 5, //filter bit 5 corresponds to StdITSTPCtrackCuts2011 with TPC crossed rows
Bool_t enableMonitor = kTRUE,
TString monitorOpt = "NoSIGN")
{
//-------------------------------------------
// event cuts
//-------------------------------------------
if (evtCutSetID == eventCutSet::kPileUpCut)
rejectPileUp = kTRUE;
else
rejectPileUp = kFALSE;
//-------------------------------------------
//pair cuts
//-------------------------------------------
Double_t minYlab = -0.5;
Double_t maxYlab = 0.5;
if (pairCutSetID==pairYCutSet::kYpPb5TeV) {
//-0.5 < y_cm < 0.0
minYlab = -0.465; maxYlab = 0.035;
}
// if (pairCutSetID==pairYCutSet::kYpPb8TeV) {
// //to be calculated
// minYlab = -0.9; maxYlab = 0.9;
// }
// if (pairCutSetID==pairYCutSet::kYPbp5TeV) {
// //to be calculated
// minYlab = -0.9; maxYlab = 0.9;
// }
// if (pairCutSetID==pairYCutSet::kYPbp5TeV) {
// //to be calculated
// minYlab = -0.765; maxYlab = -0.165;
// }
if (pairCutSetID==pairYCutSet::kYcentralTight) {
//|y_cm| < 0.3
minYlab = -0.3; maxYlab = 0.3;
}
//-------------------------------------------
//mixing settings
//-------------------------------------------
Int_t nmix = 5;
Float_t maxDiffVzMix = 1.0;
Float_t maxDiffMultMix = 5.0;
//
// -- INITIALIZATION ----------------------------------------------------------------------------
// retrieve analysis manager
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskRsnQA", "No analysis manager to connect to.");
return NULL;
}
// create the task and configure
TString taskName = Form("taskRsnQA");
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), kTRUE);
//Set trigger selection
task->UseESDTriggerMask(triggerMask);
//task->SelectCollisionCandidate(triggerMask);
/*
//Set multiplicity/centrality estimator
//if (isPP)
task->UseMultiplicity("AliMultSelection_V0M");
//else
//task->UseCentrality("V0M");
*/
if (multEstimator.IsNull()){
::Error("AddTaskRsnQA", "No multiplicity selection estimator set.");
return NULL;
}
if (multEstimator.Contains("AliMultSelection"))
task->UseMultiplicity(multEstimator.Data());
else
task->UseCentrality(multEstimator.Data());
//Set event mixing options
task->UseContinuousMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(maxDiffVzMix);
task->SetMaxDiffMult(maxDiffMultMix);
::Info("AddTaskRsnQA", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f", nmix, maxDiffVzMix, maxDiffMultMix));
//Add task
mgr->AddTask(task);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE); //cut on z_vtx < 10 cm //
AliRsnCutEventUtils* cutEventUtils=new AliRsnCutEventUtils("cutEventUtils", kTRUE, rejectPileUp);
cutEventUtils->SetCheckAcceptedMultSelection();
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutEventUtils);
// eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(Form("%s", cutEventUtils->GetName()));
task->SetEventCuts(eventCuts);
//
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
//vertex
Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE);
//multiplicity or centrality
Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT");
outVtx->AddAxis(vtxID, 220, -11.0, 11.0);
AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT");
outMult->AddAxis(multID, 101, 0.0, 101.0); //also in pp, p-Pb the percentile is returned
TH2F* hvz = new TH2F("hVzVsCent",Form("Vertex position vs centrality"), 101, 0., 101., 220, -11.0, 11.0);
hvz->GetXaxis()->SetTitle("multiplicity %");
hvz->GetYaxis()->SetTitle("z_{vtx} (cm)");
task->SetEventQAHist("vz", hvz);
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(minYlab, maxYlab);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIG ANALYSIS --------------------------------------------------------------------------
//
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/qa/ConfigRsnQA.C");
if (!ConfigRsnQA(task, isMC, cutsPair, aodFilterBit, enableMonitor, "NoSIGN", useGeoCutsPbPb2015) ) return 0x0;
// -- CONTAINERS --------------------------------------------------------------------------------
TString outputFileName = AliAnalysisManager::GetCommonFileName();
Printf("AddTaskRsnQA - Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnQA_%s", outNameSuffix.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
AliRsnMiniAnalysisTask * AddTaskDeltaPP7TeV
(
Bool_t isMC,
Bool_t isPP,
const char *path,
Int_t nmix
)
{
//
// -- INITIALIZATION ----------------------------------------------------------------------------
//
// retrieve analysis manager
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
// create the task and connect with physics selection
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask("RSN", isMC);
if (isAOD049 && !isMC && !isPP){
task->SetUseCentralityPatch(kTRUE);
}
mgr->AddTask(task);
// settings
if (isPP)
task->UseMultiplicity("QUALITY");
else
task->UseCentrality("V0M");
// set mixing
task->UseContinuousMix();
//task->UseBinnedMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(1.0);
task->SetMaxDiffMult(5.0);
task->SetMaxDiffAngle(1E20);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
// set the check for pileup
if (isPP) cutVertex->SetCheckPileUp(kTRUE);
// define and fill cut set
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
// set cuts in task
task->SetEventCuts(eventCuts);
//
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
// initialize value computation for multiplicity/centrality
// second argument tells if the value must be taken from MC
// (when this can be done)
// after creating the value, the task returns its ID
Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
// create event-related output
AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT");
// set axes, by passing value ID and defining the binning
if (isPP)
outMult->AddAxis(multID, 300, 0.0, 300.0);
else
outMult->AddAxis(multID, 100, 0.0, 100.0);
//
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
//
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(-0.5, 0.5);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIGS -----------------------------------------------------------------------------------
//
if (useDelta) {
gROOT->LoadMacro("${ALICE_PHYSICS}/PWGLF/RESONANCES/macros/mini/ConfigDeltaPP7TeV.C");
ConfigDeltaPP7TeV(task, isMC, "", cutsPair);
if (isMC) {
gROOT->LoadMacro("${ALICE_PHYSICS}/PWGLF/RESONANCES/macros/mini/ConfigDeltaPP7TeV_MC.C");
ConfigDeltaPP7TeV_MC(task, isPP, "", cutsPair);
}
}
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
const char *file = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *output = mgr->CreateContainer("RsnOut", TList::Class(), AliAnalysisManager::kOutputContainer, file);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
AliRsnMiniAnalysisTask * AddTaskKStarPP5TeV
(
Bool_t isMC = kFALSE,
Bool_t isPP = kTRUE,
Int_t Strcut = 2011,
TString outNameSuffix = "tofveto3stpc2s",
Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate=AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,
Float_t nsigmaPi = 2.0,
Float_t nsigmaK = 2.0,
Bool_t enableMonitor = kTRUE,
Int_t nmix = 5,
Float_t maxDiffVzMix = 1.0,
Float_t maxDiffMultMix = 5.0
)
{
UInt_t triggerMask = AliVEvent::kINT7;
Bool_t rejectPileUp = kTRUE;
Double_t vtxZcut = 10.0;//cm, default cut on vtx z
if(!isPP || isMC) rejectPileUp = kFALSE;
//
// -- INITIALIZATION ----------------------------------------------------------------------------
// retrieve analysis manager
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddTaskKStarPP5TeV", "No analysis manager to connect to.");
return NULL;
}
// create the task and configure
TString taskName = Form("KStar%s%s", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"));
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
//task->SelectCollisionCandidates(AliVEvent::kMB);
task->UseESDTriggerMask(triggerMask);
if (isPP)
task->UseMultiplicity("QUALITY");
else
task->UseCentrality("V0M");
// set event mixing options
task->UseContinuousMix();
//task->UseBinnedMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(maxDiffVzMix);
task->SetMaxDiffMult(maxDiffMultMix);
task->UseMC(isMC);
::Info("AddTaskKStarPP5TeV", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n", nmix, maxDiffVzMix, maxDiffMultMix));
mgr->AddTask(task);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
if (isPP && (!isMC)) cutVertex->SetCheckPileUp(rejectPileUp); // set the check for pileup
cutVertex->SetCheckZResolutionSPD();
cutVertex->SetCheckDispersionSPD();
cutVertex->SetCheckZDifferenceSPDTrack();
AliRsnCutEventUtils* cutEventUtils=new AliRsnCutEventUtils("cutEventUtils",kTRUE,rejectPileUp);
cutEventUtils->SetCheckIncompleteDAQ();
cutEventUtils->SetCheckSPDClusterVsTrackletBG();
// define and fill cut set for event cut
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutEventUtils);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(Form("%s&%s",cutEventUtils->GetName(),cutVertex->GetName()));
// set cuts in task
task->SetEventCuts(eventCuts);
//
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
//vertex
Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE);
AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT");
outVtx->AddAxis(vtxID, 400, -20.0, 20.0);
//multiplicity or centrality
Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT");
if (isPP)
outMult->AddAxis(multID, 400, 0.0, 400.0);
else
outMult->AddAxis(multID, 100, 0.0, 100.0);
//
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
//
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(-0.5, 0.5);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIG ANALYSIS --------------------------------------------------------------------------
//
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigKStarPP5TeV.C");
if (!ConfigKStarPP5TeV(task, isMC, isPP, "", cutsPair, Strcut, customQualityCutsID,cutKaCandidate,nsigmaPi,nsigmaK, enableMonitor)) return 0x0;
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
TString outputFileName = AliAnalysisManager::GetCommonFileName();
// outputFileName += ":Rsn";
Printf("AddTaskKStarPP5TeV - Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
Int_t AddRsnDaughterCutsLambdaNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
// Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);
TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid);
Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid);
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 2;
//---------------------------------------------
// Define single cutsP
//---------------------------------------------
Printf("AddRsnDaughterCutsLambda Option : %s",opt.Data());
Double_t nSigmaTPC_P=3.0;
Double_t nSigmaTPC_K=3.0;
Double_t nSigmaTOF_P=3.0;
Double_t nSigmaTOF_K=3.0;
Double_t etaRange=0.8;
Double_t PtMin_P=0.15;
Double_t PtMax_P=1.e10;
Double_t PtMin_K=0.15;
Double_t PtMax_K=1.e10;
Double_t PMax_P=1.1;
Double_t PMax_K=0.6;
Bool_t useTPC_P=kFALSE;
Bool_t useTOF_P=kFALSE;
Bool_t rejectUnmatchedTOF_P=kTRUE;
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t rejectUnmatchedTOF_K=kTRUE;
if (opt.Contains("qualityonly")) {
useTPC_P=kFALSE;
useTOF_P=kFALSE;
useTPC_K=kFALSE;
useTOF_K=kFALSE;
} else if (!opt.Contains("nsig")) {
useTPC_P=kTRUE;
useTOF_P=kTRUE;
useTPC_K=kTRUE;
useTOF_K=kTRUE;
}
if (opt.Contains("PTPCnsig")) useTPC_P=kTRUE;
if (opt.Contains("PTPCnsig10")) nSigmaTPC_P = 1.0;
if (opt.Contains("PTPCnsig15")) nSigmaTPC_P = 1.5;
if (opt.Contains("PTPCnsig20")) nSigmaTPC_P = 2.0;
if (opt.Contains("PTPCnsig25")) nSigmaTPC_P = 2.5;
if (opt.Contains("PTPCnsig30")) nSigmaTPC_P = 3.0;
if (opt.Contains("PTPCnsig40")) nSigmaTPC_P = 4.0;
if (opt.Contains("PTPCnsig50")) nSigmaTPC_P = 5.0;
if (opt.Contains("PTPCnsig1000")) nSigmaTPC_P = 100.0;
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
if (opt.Contains("KTPCnsig40")) nSigmaTPC_K = 4.0;
if (opt.Contains("KTPCnsig50")) nSigmaTPC_K = 5.0;
if (opt.Contains("KTPCnsig1000")) nSigmaTPC_K = 100.0;
if (opt.Contains("PTOFnsig")) useTOF_P=kTRUE;
if (opt.Contains("PTOFacceptUnmatched")) rejectUnmatchedTOF_P=kFALSE;
if (opt.Contains("PTOFnsig10")) nSigmaTOF_P = 1.0;
if (opt.Contains("PTOFnsig15")) nSigmaTOF_P = 1.5;
if (opt.Contains("PTOFnsig20")) nSigmaTOF_P = 2.0;
if (opt.Contains("PTOFnsig25")) nSigmaTOF_P = 2.5;
if (opt.Contains("PTOFnsig30")) nSigmaTOF_P = 3.0;
if (opt.Contains("PTOFnsig40")) nSigmaTOF_P = 4.0;
if (opt.Contains("PTOFnsig50")) nSigmaTOF_P = 5.0;
if (opt.Contains("PTOFnsig1000")) nSigmaTOF_P = 100.0;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE;
if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
if (opt.Contains("KTOFnsig40")) nSigmaTOF_K = 4.0;
if (opt.Contains("KTOFnsig50")) nSigmaTOF_K = 5.0;
if (opt.Contains("KTOFnsig1000")) nSigmaTOF_K = 100.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))) etaRange=0.1*j;
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
Bool_t usePPt=kFALSE;
if(opt.Contains("PPt")){
Printf("Using Proton pT range (%.2f,%.2f)",PtMin_P,PtMax_P);
usePPt=kTRUE;
}
Bool_t useKPt=kFALSE;
if(opt.Contains("KPt")){
Printf("Using Kaon pT range (%.2f,%.2f)",PtMin_K,PtMax_K);
useKPt=kTRUE;
}
Bool_t usePMax_P=kFALSE;
if(opt.Contains("PPMax")){
for(int j=1;j<=9;j++) if(opt.Contains(Form("PPMax0%i",j))) PMax_P=0.1*j;
for(int j=10;j<=30;j++) if(opt.Contains(Form("PPMax%i",j))) PMax_P=0.1*j;
Printf("Using Proton momentum range (0,%.2f)",PMax_P);
usePMax_P=kTRUE;
}
Bool_t usePMax_K=kFALSE;
if(opt.Contains("KPMax")){
for(int j=1;j<=9;j++) if(opt.Contains(Form("KPMax0%i",j))) PMax_K=0.1*j;
for(int j=10;j<=30;j++) if(opt.Contains(Form("KPMax%i",j))) PMax_K=0.1*j;
Printf("Using Kaon momentum range (0,%.2f)",PMax_K);
usePMax_K=kTRUE;
}
// PROTON SETTINGS ===========================================
TString scheme="";
TString cutname = "p_Lambda";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutP = new AliRsnCutTrackQuality("cutQualityP");
if (useCommonQualityCut>=0) {
qualityCutP->SetAODTestFilterBit(useCommonQualityCut);
} else {
qualityCutP->SetDefaults2010();
}
cutsP->AddCut(qualityCutP);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutP->GetName();
if (useTPC_P) {
AliRsnCutPIDNSigma *cutPTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCP",AliPID::kProton,AliRsnCutPIDNSigma::kTPC);
cutPTPC->SinglePIDRange(nSigmaTPC_P);
cutsP->AddCut(cutPTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPTPC->GetName();
}
if (useTOF_P) {
AliRsnCutPIDNSigma *cutPTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFP",AliPID::kProton,AliRsnCutPIDNSigma::kTOF);
cutPTOF->SinglePIDRange(nSigmaTOF_P);
cutsP->AddCut(cutPTOF);
if(rejectUnmatchedTOF_P){
if (!scheme.IsNull()) scheme += "&";
scheme += cutPTOF->GetName();
}else{
AliRsnCutTOFMatch *cutPTOFMatch = new AliRsnCutTOFMatch("cutPTOFMatch");
cutsP->AddCut(cutPTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutPTOF->GetName(),cutPTOFMatch->GetName());
}
}
if (useEta) {
AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
cutEtaP->SetValueObj(valEtaP);
cutsP->AddCut(cutEtaP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaP->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cutsP->AddCut(cutPDGP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGP->GetName();
}
if(usePPt){
AliRsnValueDaughter *valPtP = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutPtP = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type1),opt.Data()),PtMin_P,PtMax_P);
cutPtP->SetTargetType(AliRsnTarget::kDaughter);
cutPtP->SetValueObj(valPtP);
cutsP->AddCut(cutPtP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPtP->GetName();
}
if(usePMax_P){
AliRsnValueDaughter *valPP = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kP);
AliRsnCutValue *cutPP = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type1),opt.Data()),0.,PMax_P);
cutPP->SetTargetType(AliRsnTarget::kDaughter);
cutPP->SetValueObj(valPP);
cutsP->AddCut(cutPP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPP->GetName();
}
Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
cutsP->SetCutScheme(scheme.Data());
// END PROTON =======================================
// KAON SETTINGS =======================================
scheme="";
cutname = "K_Lambda";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQualityK");
if (useCommonQualityCut>=0) {
qualityCutK->SetAODTestFilterBit(useCommonQualityCut);
} else {
qualityCutK->SetDefaults2010();
}
cutsK->AddCut(qualityCutK);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutK->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC_K);
cutsK->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF_K);
cutsK->AddCut(cutKTOF);
if(rejectUnmatchedTOF_K){
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}else{
AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch");
cutsK->AddCut(cutKTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName());
}
}
if (useEta) {
AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
cutEtaK->SetValueObj(valEtaK);
cutsK->AddCut(cutEtaK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaK->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
cutsK->AddCut(cutPDGK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGK->GetName();
}
if(useKPt){
AliRsnValueDaughter *valPtK = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutPtK = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type2),opt.Data()),PtMin_K,PtMax_K);
cutPtK->SetTargetType(AliRsnTarget::kDaughter);
cutPtK->SetValueObj(valPtK);
cutsK->AddCut(cutPtK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPtK->GetName();
}
if(usePMax_K){
AliRsnValueDaughter *valPK = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kP);
AliRsnCutValue *cutPK = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type2),opt.Data()),0.,PMax_K);
cutPK->SetTargetType(AliRsnTarget::kDaughter);
cutPK->SetValueObj(valPK);
cutsK->AddCut(cutPK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPK->GetName();
}
Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
cutsK->SetCutScheme(scheme.Data());
// END KAON =======================================
if (opt.Contains("mon")) {
AddMonitorOutput(cutsP->GetMonitorOutput(),opt);
AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cutsP);
taskRsnMini->AddTrackCuts(cutsK);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cutsP, kTRUE);
sel->Add(cutsK, kTRUE);
}
return numberOfCuts;
}
AliRsnMiniAnalysisTask * AddAnalysisTaskSigmaStarPbPb
(
Bool_t isMC,
Bool_t isPP,
Float_t cutV = 10.0,
Int_t aodFilterBit = 5,
Int_t piPIDCut = 3.0,
Int_t pPIDCut = 3.0,
Float_t trackDCAcut = 7.0,
Float_t massTol = 0.01,
Float_t lambdaDCA = 0.3,
Float_t lambdaCosPoinAn = 0.99,
Float_t lambdaDaughDCA = 0.5,
Int_t NTPCcluster = 70,
Int_t nmix = 5,
Float_t maxDiffVzMix = 1.0,
Float_t maxDiffMultMix = 10.0,
Float_t maxDiffAngleMixDeg = 20.0,
Int_t aodN = 68,
TString outNameSuffix = "Sigma1385"
)
{
//
// -- INITIALIZATION ----------------------------------------------------------------------------
// retrieve analysis manager
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddAnalysisTaskSigmaStarPbPb", "No analysis manager to connect to.");
return NULL;
}
// create the task and configure
TString taskName = Form("SigmaStar%s%s_%.1f_%d_%.1f_%.1f_%.2f_%.2f_%.1f_%.2f_%.1f", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA);
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
if (!isMC && !isPP){
Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no"));
task->SetUseCentralityPatch(aodN==49);
}
if (isPP)
task->UseMultiplicity("QUALITY");
else
task->UseCentrality("V0M");
// set event mixing options
task->UseContinuousMix();
//task->UseBinnedMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(maxDiffVzMix);
task->SetMaxDiffMult(maxDiffMultMix);
if (!isPP) task->SetMaxDiffAngle(maxDiffAngleMixDeg*TMath::DegToRad()); //set angle diff in rad
::Info("AddAnalysisTaskSigmaStarPbPb", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n max diff EP angle = %5.3f deg", nmix, maxDiffVzMix, maxDiffMultMix, (isPP ? 0.0 : maxDiffAngleMixDeg)));
mgr->AddTask(task);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", cutV, 0, kFALSE);
if (isPP) cutVertex->SetCheckPileUp(kTRUE); // set the check for pileup
// define and fill cut set for event cut
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
// set cuts in task
task->SetEventCuts(eventCuts);
//
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
//vertex
Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE);
AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT");
outVtx->AddAxis(vtxID, 400, -20.0, 20.0);
//multiplicity or centrality
Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT");
if (isPP)
outMult->AddAxis(multID, 400, 0.0, 400.0);
else
outMult->AddAxis(multID, 100, 0.0, 100.0);
//event plane (only for PbPb)
Int_t planeID = task->CreateValue(AliRsnMiniValue::kPlaneAngle, kFALSE);
AliRsnMiniOutput *outPlane = 0x0; //task->CreateOutput("eventPlane", "HIST", "EVENT");
if (!isPP){
outPlane = task->CreateOutput("eventPlane", "HIST", "EVENT");
outPlane->AddAxis(planeID, 180, 0.0, TMath::Pi());
}
//
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
//
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(-0.5, 0.5);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIG ANALYSIS --------------------------------------------------------------------------
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigSigmaStarPbPb.C");
if (isMC) {
Printf("========================== MC analysis - PID cuts not used");
} else
Printf("========================== DATA analysis - PID cuts used");
if (!ConfigSigmaStarPbPb(task, isPP, isMC, piPIDCut, pPIDCut, aodFilterBit, piDCAcut, massTol, lambdaDCA, lambdaCosPoinAn, lambdaDaughDCA, NTPCcluster, "", cutsPair)) return 0x0;
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
TString outputFileName = AliAnalysisManager::GetCommonFileName();
// outputFileName += ":Rsn";
Printf("AddAnalysisTaskSigmaStarPbPb - Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s_%.1f_%d_%.1f_%.1f_%.2f_%.2f_%.1f_%.2f_%.1f",outNameSuffix.Data(),cutV,NTPCcluster,piPIDCut,pPIDCut,trackDCAcut,massTol,lambdaDCA,lambdaCosPoinAn,lambdaDaughDCA),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
Bool_t AddAnalysisTaskRsn
(
Bool_t isMC,
Bool_t useCentrality,
Bool_t checkPileUp,
const char *path = "$(HOME)/code/resonances/alice-rsn-package/PWG2resonances/RESONANCES/macros/test/pulvir"
)
{
//
// -- INITIALIZATION ----------------------------------------------------------------------------
//
// retrieve analysis manager
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
// create the task and connect with physics selection
AliRsnAnalysisTask *task = new AliRsnAnalysisTask("RSN");
task->SelectCollisionCandidates();
mgr->AddTask(task);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
// set the check for pileup
::Info("AddAnalysisTaskRsn", "Check of pile-up from SPD is %s", (checkPileUp ? "active" : "disabled"));
cutVertex->SetCheckPileUp(checkPileUp);
// define and fill cut set
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
//
// -- CONFIGS -----------------------------------------------------------------------------------
//
// add configs and count how many are added
// will return kFALSE if none is added
Int_t added = 0;
if (useTest) {
// NOTE: this is a test and will had its own definition of event cuts
// ----> will not use those defined above
gROOT->LoadMacro(Form("%s/RsnConfigTest.C", path));
if (!RsnConfigTest(task, isMC)) return kFALSE;
added++;
}
if (useEvent) {
gROOT->LoadMacro(Form("%s/RsnConfigEvent.C", path));
if (!RsnConfigEvent(task, isMC, useCentrality, eventCuts)) return kFALSE;
added++;
}
if (useKaonMonitor) {
gROOT->LoadMacro(Form("%s/RsnConfigMonitorTPC.C", path));
if (!RsnConfigMonitorTPC(task, isMC, useCentrality, eventCuts)) return kFALSE;
added++;
}
if (usePhiTPC) {
gROOT->LoadMacro(Form("%s/RsnConfigPhiTPC.C", path));
if (!RsnConfigPhiTPC(task, isMC, useCentrality, eventCuts)) return kFALSE;
added++;
}
if (useKStarTPC) {
gROOT->LoadMacro(Form("%s/RsnConfigKStarTPC.C", path));
if (!RsnConfigKStarTPC(task, isMC, useCentrality, eventCuts)) return kFALSE;
added++;
}
::Info("AddAnalysisTaskRsn.C", "Added %d configs", added);
if (!added) {
::Error("AddAnalysisTaskRsn.C", "Cannot process an empty task!");
return kFALSE;
}
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
const char *file = AliAnalysisManager::GetCommonFileName();
AliAnalysisDataContainer *output = mgr->CreateContainer("RsnOut", TList::Class(), AliAnalysisManager::kOutputContainer, file);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return kTRUE;
}
Int_t AddRsnDaughterCutsKStarTOFanalysis(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid;
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 2;
//---------------------------------------------
// Define single cutsP
//---------------------------------------------
Printf("AddRsnDaughterCutsKStarTOFanalysis Option : %s",opt.Data());
// default values
Double_t nSigmaTPC_Pi=3.0;
Double_t nSigmaTPC_K=3.0;
Double_t nSigmaTOF_Pi=3.0;
Double_t nSigmaTOF_K=3.0;
Double_t nSigmaTPCveto_Pi=5.0;
Double_t nSigmaTPCveto_K=5.0;
Double_t etaRange=0.8;
Bool_t useTPC_Pi=kFALSE;
Bool_t useTOF_Pi=kFALSE;
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t useTPCveto_Pi = kFALSE;
Bool_t useTPCveto_K = kFALSE;
Bool_t useCombined_Pi = kFALSE;
Bool_t useCombined_K = kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_Pi=kFALSE;
useTOF_Pi=kFALSE;
useTPC_K=kFALSE;
useTOF_K=kFALSE;
useTPCveto_Pi = kFALSE;
useTPCveto_K = kFALSE;
useCombined_Pi = kFALSE;
useCombined_K = kFALSE;
} else {
if (opt.Contains("combined")) {
useCombined_Pi = kTRUE;
useCombined_K = kTRUE;
} else {
if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if(opt.Contains("TPCveto")) {
useTPCveto_Pi = kTRUE;
useTPCveto_K = kTRUE;
nSigmaTPCveto_Pi = 5.0;
nSigmaTPCveto_K = 5.0;
}
}
}
if (opt.Contains("PiTPCnsig10")) nSigmaTPC_Pi = 1.0;
if (opt.Contains("PiTPCnsig15")) nSigmaTPC_Pi = 1.5;
if (opt.Contains("PiTPCnsig20")) nSigmaTPC_Pi = 2.0;
if (opt.Contains("PiTPCnsig25")) nSigmaTPC_Pi = 2.5;
if (opt.Contains("PiTPCnsig30")) nSigmaTPC_Pi = 3.0;
if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
if (opt.Contains("PiTOFnsig10")) nSigmaTOF_Pi = 1.0;
if (opt.Contains("PiTOFnsig15")) nSigmaTOF_Pi = 1.5;
if (opt.Contains("PiTOFnsig20")) nSigmaTOF_Pi = 2.0;
if (opt.Contains("PiTOFnsig25")) nSigmaTOF_Pi = 2.5;
if (opt.Contains("PiTOFnsig30")) nSigmaTOF_Pi = 3.0;
if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
// KAON SETTINGS =======================================
TString scheme="";
TString cutname = "K_Kstar";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsK;
if (useCombined_K) {
cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kKaon, nSigmaTOF_K, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsK->GetCutScheme();
} else {
if (useTPCveto_K) {
cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kKaon, nSigmaTOF_K, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsK->GetCutScheme();
} else {
cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
qualityCutK->SetDefaults2010();
cutsK->AddCut(qualityCutK);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutK->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC_K);
cutsK->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF_K);
cutsK->AddCut(cutKTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}
}
}
if (useEta) {
AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
cutEtaK->SetValueObj(valEtaK);
cutsK->AddCut(cutEtaK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaK->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
cutsK->AddCut(cutPDGK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGK->GetName();
}
Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
cutsK->SetCutScheme(scheme.Data());
// END KAON =======================================
// Pion SETTINGS ===========================================
scheme="";
cutname = "Pi_Kstar";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsPi;
if (useCombined_Pi) {
cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kPion, nSigmaTOF_Pi, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsPi->GetCutScheme();
} else {
if (useTPCveto_Pi) {
cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kPion, nSigmaTOF_Pi, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsPi->GetCutScheme();
} else {
cutsPi = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi");
qualityCutPi->SetDefaults2010();
cutsPi->AddCut(qualityCutPi);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutPi->GetName();
if (useTPC_Pi) {
AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
cutPiTPC->SinglePIDRange(nSigmaTPC_Pi);
cutsPi->AddCut(cutPiTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTPC->GetName();
}
if (useTOF_Pi) {
AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
cutPiTOF->SinglePIDRange(nSigmaTOF_Pi);
cutsPi->AddCut(cutPiTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTOF->GetName();
}
}
}
if (useEta) {
AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
cutEtaP->SetValueObj(valEtaP);
cutsPi->AddCut(cutEtaP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaP->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cutsPi->AddCut(cutPDGP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGP->GetName();
}
Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
cutsPi->SetCutScheme(scheme.Data());
// END PION =======================================
if (opt.Contains("mon")) {
AddMonitorOutput(cutsPi->GetMonitorOutput(),opt);
AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cutsK);
taskRsnMini->AddTrackCuts(cutsPi);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cutsPi, kTRUE);
sel->Add(cutsK, kTRUE);
}
return numberOfCuts;
}
AliRsnMiniAnalysisTask * AddAnalysisTaskTPCKStar
(
Bool_t isMC,
Bool_t isPP,
Int_t aodFilterBit = 5,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma,
Float_t nsigmaPi = 2.0,
Float_t nsigmaKa = 2.0,
Bool_t enableMonitor = kTRUE,
Bool_t IsMcTrueOnly = kFALSE,
UInt_t triggerMask = AliVEvent::kMB,
Int_t PbPb2011CentFlat = 0,
Int_t nmix = 0,
Float_t maxDiffVzMix = 1.0,
Float_t maxDiffMultMix = 10.0,
Float_t maxDiffAngleMixDeg = 20.0,
Int_t aodN = 0,
TString outNameSuffix = ""
)
{
//
// -- INITIALIZATION ----------------------------------------------------------------------------
// retrieve analysis manager
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddAnalysisTaskTPCKStar", "No analysis manager to connect to.");
return NULL;
}
// create the task and configure
TString taskName = Form("TPCKStar%s%s_%i%i_%s", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"), (Int_t)cutPiCandidate,(Int_t)cutKaCandidate, outNameSuffix.Data() );
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
if (!isMC && !isPP){
Printf(Form("========== SETTING USE CENTRALITY PATCH AOD049 : %s", (aodN==49)? "yes" : "no"));
task->SetUseCentralityPatch(aodN==49);
}
//centrality flatening patch LHC11h
if(PbPb2011CentFlat)
task->SetUseCentralityPatchPbPb2011(PbPb2011CentFlat);
//task->SelectCollisionCandidates(AliVEvent::kMB | AliVEvent::kCentral | AliVEvent::kSemiCentral);
task->SelectCollisionCandidates(triggerMask);
if (isPP)
task->UseMultiplicity("QUALITY");
else
task->UseCentrality("V0M");
// set event mixing options
task->UseContinuousMix();
//task->UseBinnedMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(maxDiffVzMix);
task->SetMaxDiffMult(maxDiffMultMix);
if (!isPP) task->SetMaxDiffAngle(maxDiffAngleMixDeg*TMath::DegToRad()); //set angle diff in rad
::Info("AddAnalysisTaskTPCKStar", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f \n max diff EP angle = %5.3f deg", nmix, maxDiffVzMix, maxDiffMultMix, (isPP ? 0.0 : maxDiffAngleMixDeg)));
mgr->AddTask(task);
//
// -- EVENT CUTS (same for all configs) ---------------------------------------------------------
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
if (isPP) cutVertex->SetCheckPileUp(kTRUE); // set the check for pileup
// define and fill cut set for event cut
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
// set cuts in task
task->SetEventCuts(eventCuts);
//
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
//vertex
Int_t vtxID = task->CreateValue(AliRsnMiniValue::kVz, kFALSE);
AliRsnMiniOutput *outVtx = task->CreateOutput("eventVtx", "HIST", "EVENT");
outVtx->AddAxis(vtxID, 400, -20.0, 20.0);
//multiplicity or centrality
Int_t multID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
AliRsnMiniOutput *outMult = task->CreateOutput("eventMult", "HIST", "EVENT");
if (isPP)
outMult->AddAxis(multID, 400, 0.0, 400.0);
else
outMult->AddAxis(multID, 100, 0.0, 100.0);
//event plane (only for PbPb)
Int_t planeID = task->CreateValue(AliRsnMiniValue::kPlaneAngle, kFALSE);
AliRsnMiniOutput *outPlane = task->CreateOutput("eventPlane", "HIST", "EVENT");
if (!isPP)
outPlane->AddAxis(planeID, 180, 0.0, TMath::Pi());
//
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
//
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(-0.5, 0.5);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIG ANALYSIS --------------------------------------------------------------------------
if(!isMC){
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStar.C");
if (!ConfigTPCanalysisKStar(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, aodN)) return 0x0;
}
else {
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigTPCanalysisKStarMC.C");
if (!ConfigTPCanalysisKStarMC(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, 313, aodN)) return 0x0; //K*
if (!ConfigTPCanalysisKStarMC(task, isMC, isPP, "", cutsPair, aodFilterBit, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, -313, aodN)) return 0x0; //anti-K*
}
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
TString outputFileName = AliAnalysisManager::GetCommonFileName();
// outputFileName += ":Rsn";
Printf("AddAnalysisTaskTPCKStar - Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
Int_t AddRsnDaughterCutsPhiNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
// Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);
TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid);
Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid);
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid);
// experts only (don't touch)
Int_t isRsnDev = AliAnalysisManager::GetGlobalInt("rsnUseRSNParDev",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
//---------------------------------------------
// Define single cuts
//---------------------------------------------
Printf("AliRsnCutPIDNSigma Option : %s",opt.Data());
Double_t nSigmaTPC=3.0;
Double_t nSigmaTOF=3.0;
Double_t etaMin=-0.8;
Double_t etaMax=0.8;
Double_t trackPtMin=0.;
Double_t trackPtMax=1.e10;
Int_t NclTPC=70;
Char_t DCAxyFormula[100]="0.0182+0.035/pt^1.01";
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t rejectUnmatchedTOF_K=kTRUE;
Bool_t useTrackPtCut=kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_K=kFALSE;
useTOF_K=kFALSE;
}
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE;
if (opt.Contains("KTPCnsig05")) nSigmaTPC = 0.5;
if (opt.Contains("KTPCnsig08")) nSigmaTPC = 0.8;
if (opt.Contains("KTPCnsig10")) nSigmaTPC = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC = 3.0;
if (opt.Contains("KTPCnsig40")) nSigmaTPC = 4.0;
if (opt.Contains("KTPCnsig50")) nSigmaTPC = 5.0;
if (opt.Contains("KTPCnsig1000")) nSigmaTPC = 100.0;
if (opt.Contains("KTOFnsig10")) nSigmaTOF = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF = 3.0;
if (opt.Contains("KTOFnsig40")) nSigmaTOF = 4.0;
if (opt.Contains("KTOFnsig50")) nSigmaTOF = 5.0;
if (opt.Contains("KTOFnsig1000")) nSigmaTOF = 100.0;
if (opt.Contains("trackPt")) {
useTrackPtCut = kTRUE;
if (opt.Contains("trackPtMin015")) trackPtMin = 0.15;
if (opt.Contains("trackPtMin02")) trackPtMin = 0.2;
if (opt.Contains("trackPtMin05")) trackPtMin = 0.5;
if (opt.Contains("trackPtMin06")) trackPtMin = 0.6;
if (opt.Contains("trackPtMax18")) trackPtMax = 1.8;
if (opt.Contains("trackPtMax20")) trackPtMax = 2.0;
if (opt.Contains("trackPtMax25")) trackPtMax = 2.5;
}
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))){etaMin=-0.1*j; etaMax=0.1*j;}
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinMinus0%i",j))) etaMin=-0.1*j;
if(opt.Contains("etaMin00")) etaMin=0.;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinPlus0%i",j))) etaMin=0.1*j;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxMinus0%i",j))) etaMax=-0.1*j;
if(opt.Contains("etaMax00")) etaMax=0.;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxPlus0%i",j))) etaMax=0.1*j;
Printf("Using ETA range (%.2f,%.2f)",etaMin,etaMax);
useEta = kTRUE;
}
Bool_t useNclTPC = kFALSE;
if (opt.Contains("NclTPC")) {
if (opt.Contains("NclTPC70")) NclTPC=70;
if (opt.Contains("NclTPC75")) NclTPC=75;
if (opt.Contains("NclTPC80")) NclTPC=80;
if (opt.Contains("NclTPC85")) NclTPC=85;
if (opt.Contains("NclTPC90")) NclTPC=90;
useNclTPC = kTRUE;
}
Bool_t useDCAxy = kFALSE;
if (opt.Contains("DCAxy")) {
if (opt.Contains("DCAxyFormula7s")) sprintf(DCAxyFormula,"0.0182+0.035/pt^1.01");
if (opt.Contains("DCAxyFormula6s")) sprintf(DCAxyFormula,"0.0156+0.03/pt^1.01");
if (opt.Contains("DCAxyFormula5s")) sprintf(DCAxyFormula,"0.013+0.025/pt^1.01");
useDCAxy = kTRUE;
}
//---------------------------------------------
// Combine cuts
//---------------------------------------------
TString cutname = "K_Phi";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
TString scheme="";
AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQualityK");
if (!rsnQualityCut.IsNull()) {
AliESDtrackCuts *esdTK = RsnQualityCut(rsnQualityCut.Data());
if(useDCAxy) esdTK->SetMaxDCAToVertexXYPtDep(DCAxyFormula);
qualityCut->SetESDtrackCuts(esdTK);
} else {
if (useCommonQualityCut>=0) {
qualityCut->SetAODTestFilterBit(useCommonQualityCut);
if(useDCAxy) {qualityCut->SetCheckOnlyFilterBit(kFALSE); qualityCut->SetDCARPtFormula(DCAxyFormula);}
} else {
qualityCut->SetDefaults2010();
if(useDCAxy) qualityCut->SetDCARPtFormula(DCAxyFormula);
}
}
cuts->AddCut(qualityCut);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCut->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC);
cuts->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF);
cuts->AddCut(cutKTOF);
if(rejectUnmatchedTOF_K){
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}else{
AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch");
cuts->AddCut(cutKTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName());
}
}
if (useEta) {
Printf("Adding ETA ...");
AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),etaMin,etaMax);
cutEta->SetTargetType(AliRsnTarget::kDaughter);
cutEta->SetValueObj(valEta);
cuts->AddCut(cutEta);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEta->GetName();
}
if (useTrackPtCut) {
Printf("Adding Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
AliRsnValueDaughter *valTrackPt = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutTrackPt = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax);
cutTrackPt->SetTargetType(AliRsnTarget::kDaughter);
cutTrackPt->SetValueObj(valTrackPt);
cuts->AddCut(cutTrackPt);
if (!scheme.IsNull()) scheme += "&";
scheme += cutTrackPt->GetName();
}
if (useNclTPC) {
Printf("Adding NclTPC >= %i",NclTPC);
AliRsnValueDaughter *valNclTPC = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
AliRsnCutValue *cutNclTPC = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),NclTPC-0.1,1000.);
cutNclTPC->SetTargetType(AliRsnTarget::kDaughter);
cutNclTPC->SetValueObj(valNclTPC);
cuts->AddCut(cutNclTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutNclTPC->GetName();
}
if (usePDG) {
Printf("Adding PDG ...");
AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cuts->AddCut(cutPDG);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDG->GetName();
}
Printf ("CUT Scheme is '%s'",scheme.Data());
cuts->SetCutScheme(scheme.Data());
if (opt.Contains("mon")) {
AddMonitorOutput(cuts->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cuts);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cuts, kTRUE);
if (isRsnDev>=0 && opt.Contains("pairPID")) {
AliRsnActPostDaughterSelection *pairPID = new AliRsnActPostDaughterSelection();
pairPID->SetID(0);
const char *fn="rsnRange.txt";
if (!gSystem->AccessPathName(fn)) {
TString minStr = gSystem->GetFromPipe(TString::Format("head -n 1 %s").Data());
TString maxStr = gSystem->GetFromPipe(TString::Format("tail -n 1 %s").Data());
pairPID->SetMass(minStr.Atof(),maxStr.Atof());
} else {
// pairPID->SetMass(1.01,1.03);
pairPID->SetMass(1.015,1.025);
pairPID->SetMass(1.019,1.021);
pairPID->SetMass(1.0195,1.0205);
pairPID->SetMass(1.1000,1.1005);
// pairPID->SetMass(1.1005,1.1010);
}
sel->AddAction(pairPID);
}
}
return numberOfCuts;
}
//
// *** Configuration script for phi->KK analysis with 2010 runs ***
//
// 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 ConfigKStar
(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
//
// -- Define track cuts -------------------------------------------------------------------------
//
// integrated pion cut
AliRsnCutDaughterKStar2010PP *cutPi = new AliRsnCutDaughterKStar2010PP("cutPionForKStar", AliPID::kPion);
// cut set
AliRsnCutSet *cutSetPi = new AliRsnCutSet("setPionForKStar", AliRsnTarget::kDaughter);
cutSetPi->AddCut(cutPi);
cutSetPi->SetCutScheme(cutPi->GetName());
// add to task
Int_t iCutPi = task->AddTrackCuts(cutSetPi);
// integrated kaon cut
AliRsnCutDaughterKStar2010PP *cutK = new AliRsnCutDaughterKStar2010PP("cutKaonForKStar", AliPID::kKaon);
// cut set
AliRsnCutSet *cutSetK = new AliRsnCutSet("setKaonForKStar", AliRsnTarget::kDaughter);
cutSetK->AddCut(cutK);
cutSetK->SetCutScheme(cutK->GetName());
// add to task
Int_t iCutK = task->AddTrackCuts(cutSetK);
//
// -- Values ------------------------------------------------------------------------------------
//
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
/* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
/* 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 [10] = { 1 , 1 , 1 , 1 , 1 , 1 , isMC , isMC , isMC , isMC };
Bool_t useIM [10] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 };
TString name [10] = {"Unlike1", "Unlike2", "Mixing1", "Mixing2", "LikePP", "LikeMM", "Trues1", "Trues2", "Res1" , "Res2" };
TString comp [10] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" };
TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" };
Char_t charge1 [10] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
Char_t charge2 [10] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' };
Int_t cutID1 [10] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
Int_t cutID2 [10] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi };
for (Int_t i = 0; i < 10; i++) {
if (!use[i]) continue;
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%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::kKaon);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(313);
out->SetMotherMass(0.896);
// pair cuts
out->SetPairCuts(cutsPair);
// axis X: invmass (or resolution)
if (useIM[i])
out->AddAxis(imID, 90, 0.6, 1.5);
else
out->AddAxis(resID, 200, -0.02, 0.02);
// axis Y: transverse momentum
out->AddAxis(ptID, 100, 0.0, 10.0);
}
return kTRUE;
}
AliRsnMiniAnalysisTask * AddTaskKsPP5TeV_PID
(
Bool_t isMC = kFALSE,
Bool_t isPP = kTRUE,
TString outNameSuffix = "tpc2stof3sveto",
Int_t evtCutSetID = 0,
Int_t pairCutSetID = 0,
Int_t mixingConfigID = 0,
Int_t aodFilterBit = 5,
Int_t customQualityCutsID = -1,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,
Float_t nsigmaPi = 2.0,
Float_t nsigmaKa = 2.0,
Bool_t enableMonitor = kTRUE,
Bool_t IsMcTrueOnly = kFALSE,
TString monitorOpt = "NoSIGN",
Bool_t useMixLS = 0,
Bool_t checkReflex = 0,
AliRsnMiniValue::EType yaxisvar = AliRsnMiniValue::kPt
)
{
//-------------------------------------------
// event cuts
//-------------------------------------------
UInt_t triggerMask = AliVEvent::kINT7;//A Khuntia
// if(isMC && (evtCutSetID==eventCutSet::kNoEvtSel || evtCutSetID==eventCutSet::kSpecial3)) triggerMask=AliVEvent::kAny;
Bool_t rejectPileUp = kTRUE; //
Double_t vtxZcut = 10.0; //cm, default cut on vtx z
Int_t MultBins=aodFilterBit/100;
if (evtCutSetID==eventCutSet::kDefaultVtx12){vtxZcut = 12.0;} //cm
if (evtCutSetID==eventCutSet::kDefaultVtx8){vtxZcut = 8.0;} //cm
if (evtCutSetID==eventCutSet::kDefaultVtx5){vtxZcut = 5.0;}//cm
if (evtCutSetID==eventCutSet::kNoPileUpCut){rejectPileUp=kFALSE;}//cm
if(evtCutSetID==eventCutSet::kSpecial2) vtxZcut=1.e6;//off
if(!isPP || isMC || MultBins) rejectPileUp=kFALSE;
//-------------------------------------------
//pair cuts
//-------------------------------------------
Double_t minYlab = -0.5;
Double_t maxYlab = 0.5;
if (pairCutSetID==pairYCutSet::kCentral) { //|y_cm|<0.3
minYlab = -0.3; maxYlab = 0.3;
}
//-------------------------------------------
//mixing settings
//-------------------------------------------
Int_t nmix = 0;
Float_t maxDiffVzMix = 1.0;
Float_t maxDiffMultMix = 10.0;
if (mixingConfigID == eventMixConfig::kMixDefault) { nmix = 10;}
if (mixingConfigID == eventMixConfig::k5Evts) {nmix = 5;}
if (mixingConfigID == eventMixConfig::k5Cent) {maxDiffMultMix = 5;}
if(mixingConfigID==eventMixConfig::k5Evts5Cent){nmix=5; maxDiffMultMix=5;}
//
// -- INITIALIZATION ----------------------------------------------------------------------------
// retrieve analysis manager
//
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
if (!mgr) {
::Error("AddAnalysisTaskTOFKStar", "No analysis manager to connect to.");
return NULL;
}
// create the task and configure
TString taskName = Form("TOFKStar%s%s_%i%i", (isPP? "pp" : "PbPb"), (isMC ? "MC" : "Data"), (Int_t)cutPiCandidate,(Int_t)cutKaCandidate );
AliRsnMiniAnalysisTask *task = new AliRsnMiniAnalysisTask(taskName.Data(), isMC);
//task->UseESDTriggerMask(triggerMask); //ESD
//task->SelectCollisionCandidates(triggerMask); //AOD
if(evtCutSetID!=eventCutSet::kNoEvtSel && evtCutSetID!=eventCutSet::kSpecial3) task->SelectCollisionCandidates(triggerMask); //AOD
if(isPP){
if(MultBins==1) task->UseMultiplicity("AliMultSelection_V0M");
else if(MultBins==2) task->UseMultiplicity("AliMultSelection_RefMult08");
else task->UseMultiplicity("QUALITY");
}else task->UseCentrality("V0M");
// set event mixing options
task->UseContinuousMix();
//task->UseBinnedMix();
task->SetNMix(nmix);
task->SetMaxDiffVz(maxDiffVzMix);
task->SetMaxDiffMult(maxDiffMultMix);
::Info("AddTaskKsPP5TeV_PID", Form("Event mixing configuration: \n events to mix = %i \n max diff. vtxZ = cm %5.3f \n max diff multi = %5.3f", nmix, maxDiffVzMix, maxDiffMultMix));
mgr->AddTask(task);
//
// cut on primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors to vtx
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
AliRsnCutPrimaryVertex* cutVertex=0;
if(evtCutSetID!=eventCutSet::kSpecial1 && evtCutSetID!=eventCutSet::kNoEvtSel && (!MultBins || fabs(vtxZcut-10.)>1.e-10)){
cutVertex=new AliRsnCutPrimaryVertex("cutVertex",vtxZcut,0,kFALSE);
if(!MultBins && evtCutSetID!=eventCutSet::kSpecial3){
cutVertex->SetCheckZResolutionSPD();
cutVertex->SetCheckDispersionSPD();
cutVertex->SetCheckZDifferenceSPDTrack();
}
if (evtCutSetID==eventCutSet::kSpecial3) cutVertex->SetCheckGeneratedVertexZ();
}
///////----------AKhuntia----------//////
AliRsnCutEventUtils* cutEventUtils=0;
if(evtCutSetID!=eventCutSet::kNoEvtSel && evtCutSetID!=eventCutSet::kSpecial3){
cutEventUtils=new AliRsnCutEventUtils("cutEventUtils",kTRUE,rejectPileUp);
if(!MultBins){
cutEventUtils->SetCheckIncompleteDAQ();
cutEventUtils->SetCheckSPDClusterVsTrackletBG();
}else{
//cutEventUtils->SetCheckInelGt0SPDtracklets();
cutEventUtils->SetRemovePileUppA2013(kFALSE);
cutEventUtils->SetCheckAcceptedMultSelection();
}
}
if(isPP && (!isMC) && cutVertex){
cutVertex->SetCheckPileUp(rejectPileUp);// set the check for pileup
::Info("AddTaskKsPP5TeV_PID", Form(":::::::::::::::::: Pile-up rejection mode: %s", (rejectPileUp)?"ON":"OFF"));
}
//------------------------------------
// define and fill cut set for event cut
AliRsnCutSet* eventCuts=0;
if(cutEventUtils || cutVertex){
eventCuts=new AliRsnCutSet("eventCuts",AliRsnTarget::kEvent);
if(cutEventUtils && cutVertex){
eventCuts->AddCut(cutEventUtils);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(Form("%s&%s",cutEventUtils->GetName(),cutVertex->GetName()));
}else if(cutEventUtils && !cutVertex){
eventCuts->AddCut(cutEventUtils);
eventCuts->SetCutScheme(Form("%s",cutEventUtils->GetName()));
}else if(!cutEventUtils && cutVertex){
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(Form("%s",cutVertex->GetName()));
}
task->SetEventCuts(eventCuts);
}
// -- EVENT-ONLY COMPUTATIONS -------------------------------------------------------------------
//
//vertex
Int_t vtxID=task->CreateValue(AliRsnMiniValue::kVz,kFALSE);
AliRsnMiniOutput* outVtx=task->CreateOutput("eventVtx","HIST","EVENT");
outVtx->AddAxis(vtxID,240,-12.0,12.0);
//multiplicity or centrality
Int_t multID=task->CreateValue(AliRsnMiniValue::kMult,kFALSE);
AliRsnMiniOutput* outMult=task->CreateOutput("eventMult","HIST","EVENT");
if(isPP && !MultBins) outMult->AddAxis(multID,400,0.5,400.5);
else outMult->AddAxis(multID,110,0.,110.);
TH2F* hvz=new TH2F("hVzVsCent","",110,0.,110., 240,-12.0,12.0);
task->SetEventQAHist("vz",hvz);//plugs this histogram into the fHAEventVz data member
TH2F* hmc=new TH2F("MultiVsCent","", 110,0.,110., 400,0.5,400.5);
hmc->GetYaxis()->SetTitle("QUALITY");
task->SetEventQAHist("multicent",hmc);//plugs this histogram into the fHAEventMultiCent data member
//
// -- PAIR CUTS (common to all resonances) ------------------------------------------------------
//
AliRsnCutMiniPair *cutY = new AliRsnCutMiniPair("cutRapidity", AliRsnCutMiniPair::kRapidityRange);
cutY->SetRangeD(minYlab, maxYlab);
AliRsnCutSet *cutsPair = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
cutsPair->AddCut(cutY);
cutsPair->SetCutScheme(cutY->GetName());
//
// -- CONFIG ANALYSIS --------------------------------------------------------------------------
//
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/ConfigKsPP5TeV_PID.C");
//gROOT->LoadMacro("ConfigKStarPP8TeV_PID.C");
if (!ConfigKsPP5TeV_PID(task, isMC, isPP, "", cutsPair, aodFilterBit, customQualityCutsID, cutPiCandidate, cutKaCandidate, nsigmaPi, nsigmaKa, enableMonitor, isMC&IsMcTrueOnly, monitorOpt.Data(), useMixLS, isMC&checkReflex, yaxisvar)) return 0x0;
//
// -- CONTAINERS --------------------------------------------------------------------------------
//
TString outputFileName = AliAnalysisManager::GetCommonFileName();
// outputFileName += ":Rsn";
Printf("AddAnalysisTaskTOFKStar - Set OutputFileName : \n %s\n", outputFileName.Data() );
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnOut_%s",outNameSuffix.Data()),
TList::Class(),
AliAnalysisManager::kOutputContainer,
outputFileName);
mgr->ConnectInput(task, 0, mgr->GetCommonInputContainer());
mgr->ConnectOutput(task, 1, output);
return task;
}
//
// Test config macro for RSN package.
// It configures:
// 1) a monitor for all tracks passing quality cuts
// 2) a monitor for all tracks passing quality + PID cuts
// 3) an unlike-sign invariant-mass + pt distribution for K+K- pairs
//
Bool_t RsnConfigPhiKaonTest
(
AliRsnAnalysisTask *task,
Bool_t isMC
)
{
if (!task) {
::Error("RsnConfigPhiKaonTest.C", "NULL task");
return kFALSE;
}
const char *suffix = "test";
// ----------------------------------------------------------------------------------------------
// -- DEFINITIONS -------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// daughter definition for monitor loops
// since it is intended to loop over all 'track' like objects (in the sense that we exclude V0s and cascades),
// we initialize it using the constructor that requires an AliRsnDaughter::EType and a charge, but since
// we want to loop over both charges, we set it to anything which is not '+' '-' or '0', which are tokens for
// selecting only positive, only negative or only neutral
AliRsnDaughterDef *tracks = new AliRsnDaughterDef(AliRsnDaughter::kTrack, 0);
// definition of pair decay tree for phi resonance
// here we *must* specify a particle species and a charge, in order to check the decay tree
// last arguments are the PDG code and nominal mass of the resonance, which are needed when
// one wants to select true pairs only and/or he wants to compute rapidity or Mt
AliRsnPairDef *pairDef = new AliRsnPairDef(AliRsnDaughter::kKaon, '+', AliRsnDaughter::kKaon, '-', 333, 1.019455);
// definition of loop objects:
// (a) 1 monitor for all tracks passing quality cuts
// (b) 1 monitor for all tracks passing quality+PID cuts
// (c) 1 pair filled with all tracks passing same cuts as (b)
// (d) 1 pair like (c) but for mixing
// (e) 1 pair like (c) but with true pairs only
// NOTE: (c) and (d) are instantiated with same settings, they will be made
// different after some settings done in second moment
AliRsnLoopDaughter *loopQuality = new AliRsnLoopDaughter(Form("%s_mon_quality", suffix), 0, tracks);
AliRsnLoopDaughter *loopPID = new AliRsnLoopDaughter(Form("%s_mon_pid" , suffix), 0, tracks);
AliRsnLoopPair *loopPhi = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef);
AliRsnLoopPair *loopPhiMix = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef);
AliRsnLoopPair *loopPhiTrue = new AliRsnLoopPair (Form("%s_trues" , suffix), pairDef);
// set additional option for true pairs (slot [0])
loopPhiTrue->SetOnlyTrue(kTRUE);
loopPhiTrue->SetCheckDecay(kTRUE);
// set mixing options
loopPhi ->SetMixed(kFALSE);
loopPhiMix ->SetMixed(kTRUE);
loopPhiTrue->SetMixed(kFALSE);
// assign the ID of the entry lists to be used by each pair to get selected daughters
// in our case, the AliRsnInputHandler contains only one list for selecting kaons
Int_t idQuality, idPID;
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
AliMultiInputEventHandler *multi = dynamic_cast<AliMultiInputEventHandler*>(mgr->GetInputEventHandler());
if (!multi) {
myError("Needed a multi input handler!");
return kFALSE;
}
TObjArray *array = multi->InputEventHandlers();
AliRsnInputHandler *rsn = (AliRsnInputHandler*)array->FindObject("rsnInputHandler");
if (!rsn) {
myError("Needed an RSN event handler");
return kFALSE;
}
AliRsnDaughterSelector *sel = rsn->GetSelector();
idQuality = sel->GetID("qualityTPC", kTRUE);
idPID = sel->GetID("kaonTPC", kTRUE);
if (idQuality < 0 || idPID < 0) {
myError("List problems");
return kFALSE;
}
loopQuality->SetListID(idQuality);
loopPID ->SetListID(idPID);
loopPhi ->SetListID(0, idPID);
loopPhi ->SetListID(1, idPID);
loopPhiMix ->SetListID(0, idPID);
loopPhiMix ->SetListID(1, idPID);
loopPhiTrue->SetListID(0, idPID);
loopPhiTrue->SetListID(1, idPID);
// ----------------------------------------------------------------------------------------------
// -- EVENT CUTS --------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
// we switch on the check for pileup
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
cutVertex->SetCheckPileUp(kTRUE);
// primary vertex is always used
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
// add the event cuts to all loops
loopQuality->SetEventCuts(eventCuts);
loopPID ->SetEventCuts(eventCuts);
loopPhi ->SetEventCuts(eventCuts);
loopPhi ->SetEventCuts(eventCuts);
loopPhiMix ->SetEventCuts(eventCuts);
loopPhiMix ->SetEventCuts(eventCuts);
loopPhiTrue->SetEventCuts(eventCuts);
loopPhiTrue->SetEventCuts(eventCuts);
// ----------------------------------------------------------------------------------------------
// -- PAIR CUTS ---------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// for pairs we define a rapidity windows, defined through a cut
// --> NOTE: it needs a support AliRsnPairDef from which it takes the mass
AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY);
AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, isMC);
valRapidity->SetSupportObject(pairDef);
cutRapidity->SetValueObj(valRapidity);
// cut set
AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
pairCuts->AddCut(cutRapidity);
pairCuts->SetCutScheme(cutRapidity->GetName());
// add cut to pair loops only
loopPhi ->SetPairCuts(pairCuts);
loopPhi ->SetPairCuts(pairCuts);
loopPhiMix ->SetPairCuts(pairCuts);
loopPhiMix ->SetPairCuts(pairCuts);
loopPhiTrue->SetPairCuts(pairCuts);
loopPhiTrue->SetPairCuts(pairCuts);
// ----------------------------------------------------------------------------------------------
// -- COMPUTED VALUES & OUTPUTS -----------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
AliRsnValueStd *axisIM = new AliRsnValueStd("IM" , AliRsnValueStd::kPairInvMass , 0.9, 1.4, 0.001);
AliRsnValueStd *axisPt = new AliRsnValueStd("PT" , AliRsnValueStd::kPairPt , 0.0, 5.0, 0.1 );
AliRsnValueStd *axisMomTPC = new AliRsnValueStd("pTPC", AliRsnValueStd::kTrackPtpc , 0.0, 5.0, 0.01 );
AliRsnValueStd *axisSigTPC = new AliRsnValueStd("sTPC", AliRsnValueStd::kTrackTPCsignal, 0.0, 500.0, 2.0 );
// output for monitors:
// 2D histogram with TPC signal vs TPC momentum
AliRsnListOutput *outMonitor = new AliRsnListOutput("mon", AliRsnListOutput::kHistoDefault);
outMonitor->AddValue(axisMomTPC);
outMonitor->AddValue(axisSigTPC);
// output for pairs:
// 2D histogram with inv.mass vs pt
AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault);
outPair->AddValue(axisIM);
outPair->AddValue(axisPt);
// add outputs to loops
loopQuality->AddOutput(outMonitor);
loopPID ->AddOutput(outMonitor);
loopPhi ->AddOutput(outPair);
loopPhiMix ->AddOutput(outPair);
loopPhiTrue->AddOutput(outPair);
// ----------------------------------------------------------------------------------------------
// -- CONCLUSION --------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
task->Add(loopQuality);
task->Add(loopPID );
task->Add(loopPhi );
task->Add(loopPhiMix );
task->Add(loopPhiTrue);
return kTRUE;
}
//
// *** Configuration script for phi->KK analysis with 2010 runs ***
//
// 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 ConfigPhiPbPbTPC
(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isESD,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
//
// -- Define track cuts -------------------------------------------------------------------------
//
// BB parameterization depends on data sample (MC, data)
Double_t bbPar[5];
if (isMC) {
bbPar[0] = 2.15898 / 50.0;
bbPar[1] = 1.75295E1;
bbPar[2] = 3.40030E-9;
bbPar[3] = 1.96178;
bbPar[4] = 3.91720;
} else {
bbPar[0] = 1.41543 / 50.0;
bbPar[1] = 2.63394E1;
bbPar[2] = 5.0411E-11;
bbPar[3] = 2.12543;
bbPar[4] = 4.88663;
}
// standard kaon cut
AliRsnCutKaonForPhi2010 *cut = new AliRsnCutKaonForPhi2010(Form("cut%s", suffix), 3.0, 3.0, 0.8);
// setup (set manually the TPC PID)
cut->SetMode(AliRsnCutKaonForPhi2010::kOnlyTPC);
cut->InitMyPID(isMC, isESD);
cut->MyPID()->GetTPCResponse().SetBetheBlochParameters(bbPar[0], bbPar[1], bbPar[2], bbPar[3], bbPar[4]);
// cut set
AliRsnCutSet *cutSet = new AliRsnCutSet(Form("set%s", suffix), AliRsnTarget::kDaughter);
cutSet->AddCut(cut);
cutSet->SetCutScheme(cut->GetName());
// add to task
Int_t icut = task->AddTrackCuts(cutSet);
::Info("Config", "Cut ID = %d", icut);
//
// -- Values ------------------------------------------------------------------------------------
//
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
/* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
/* 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 , 0 , 0 , 0 , isMC , isMC };
Bool_t useIM [6] = { 1 , 1 , 1 , 1 , 1 , 0 };
TString name [6] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues" , "Res" };
TString comp [6] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" };
TString output [6] = {"SPARSE", "SPARSE", "SPARSE", "SPARSE", "SPARSE", "SPARSE" };
Char_t charge1 [6] = {'+' , '+' , '+' , '-' , '+' , '+' };
Char_t charge2 [6] = {'-' , '-' , '+' , '-' , '-' , '-' };
Int_t cutID [6] = { icut , icut , icut , icut , icut , icut };
for (Int_t i = 0; i < 6; i++) {
if (!use[i]) continue;
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("phi_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
// selection settings
out->SetCutID(0, cutID[i]);
out->SetCutID(1, cutID[i]);
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kKaon);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(333);
out->SetMotherMass(1.019455);
// pair cuts
out->SetPairCuts(cutsPair);
// axis X: invmass (or resolution)
if (useIM)
out->AddAxis(imID, 500, 0.9, 1.4);
else
out->AddAxis(resID, 200, -0.02, 0.02);
// axis Y: transverse momentum
out->AddAxis(ptID, 100, 0.0, 10.0);
// axis Z: centrality
out->AddAxis(centID, 100, 0.0, 100.0);
}
return kTRUE;
}
//
// *** 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;
}
Int_t AddRsnDaughterCutsRhoNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
Bool_t usePPCut = kFALSE;
if (isPP && (opt.Contains("usePP"))) usePPCut = kTRUE;
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
//---------------------------------------------
// Define single cuts
//---------------------------------------------
Printf("AddRsnDaughterCutsRho Option : %s",opt.Data());
Double_t nSigmaTPC=3.0;
Double_t nSigmaTOF=3.0;
Double_t etaRange=0.8;
Bool_t useTPC_Pi=kFALSE;
Bool_t useTOF_Pi=kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_Pi=kFALSE;
useTOF_Pi=kFALSE;
} else if (!opt.Contains("nsig")) {
useTPC_Pi=kTRUE;
useTOF_Pi=kTRUE;
}
if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
if (opt.Contains("PiTPCnsig10")) nSigmaTPC = 1.0;
if (opt.Contains("PiTPCnsig15")) nSigmaTPC = 1.5;
if (opt.Contains("PiTPCnsig20")) nSigmaTPC = 2.0;
if (opt.Contains("PiTPCnsig25")) nSigmaTPC = 2.5;
if (opt.Contains("PiTPCnsig30")) nSigmaTPC = 3.0;
if (opt.Contains("PiTOFnsig10")) nSigmaTOF = 1.0;
if (opt.Contains("PiTOFnsig15")) nSigmaTOF = 1.5;
if (opt.Contains("PiTOFnsig20")) nSigmaTOF = 2.0;
if (opt.Contains("PiTOFnsig25")) nSigmaTOF = 2.5;
if (opt.Contains("PiTOFnsig30")) nSigmaTOF = 3.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
//---------------------------------------------
// Combine cuts
//---------------------------------------------
TString cutname = "Pi_Rho";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
TString scheme="";
AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQuatityPi");
qualityCut->SetDefaults2010();
cuts->AddCut(qualityCut);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCut->GetName();
if (useTPC_Pi) {
AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
cutPiTPC->SinglePIDRange(nSigmaTPC);
cuts->AddCut(cutPiTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTPC->GetName();
}
if (useTOF_Pi) {
AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
cutPiTOF->SinglePIDRange(nSigmaTOF);
cuts->AddCut(cutPiTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTOF->GetName();
}
if (useEta) {
Printf("Adding ETA ...");
AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEta->SetTargetType(AliRsnTarget::kDaughter);
cutEta->SetValueObj(valEta);
cuts->AddCut(cutEta);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEta->GetName();
}
if (usePDG) {
Printf("Adding PDG ...");
AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cuts->AddCut(cutPDG);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDG->GetName();
}
Printf ("CUT Scheme is '%s'",scheme.Data());
cuts->SetCutScheme(scheme.Data());
if (opt.Contains("mon")) {
AddMonitorOutput(cuts->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cuts);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cuts, kTRUE);
}
return numberOfCuts;
}
Bool_t ConfigTPCanalysisKStarTest
(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair,
Float_t nsigmaPi = 2.0,
Float_t nsigmaKa = 2.0,
Bool_t enableMonitor = kTRUE,
Bool_t IsMcTrueOnly = kFALSE,
Int_t Pdg = 313,
TString optSys = "Default"
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
TString opt = "PbPb";
TString schemePi="";
TString schemeK="";
TString cutnameK = "K_KS";
TString cutnamePi = "Pi_KS";
if (!opt.IsNull()) cutnameK += Form("_%s",opt.Data());
if (!opt.IsNull()) cutnamePi += Form("_%s",opt.Data());
AliRsnCutSet * cutSetKaon = new AliRsnCutSet(cutnameK.Data(), AliRsnTarget::kDaughter);
AliRsnCutSet * cutSetPion = new AliRsnCutSet(cutnamePi.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *fQualityTrackCut = new AliRsnCutTrackQuality("AliRsnCutTrackQuality");
//Analysis Track cuts are implemented here
AliESDtrackCuts * esdTrackCuts = MyTrackCuts(1, kTRUE,optSys.Data());
fQualityTrackCut->SetESDtrackCuts(esdTrackCuts);
fQualityTrackCut->SetPtRange(0.15,30);
fQualityTrackCut->SetEtaRange(-0.8,0.8);
//PID selection
cutSetKaon->AddCut(fQualityTrackCut);
if (!schemeK.IsNull()) schemeK += "&";
schemeK += fQualityTrackCut->GetName();
cutSetPion->AddCut(fQualityTrackCut);
if (!schemePi.IsNull()) schemePi += "&";
schemePi += fQualityTrackCut->GetName();
AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
cutPiTPC->SinglePIDRange(nsigmaPi);
cutSetPion->AddCut(cutPiTPC);
if (!schemePi.IsNull()) schemePi += "&";
schemePi += cutPiTPC->GetName();
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nsigmaKa);
cutSetKaon->AddCut(cutKTPC);
if (!schemeK.IsNull()) schemeK += "&";
schemeK += cutKTPC->GetName();
Printf ("CUT Scheme for KAON is '%s'",schemeK.Data());
Printf ("CUT Scheme for PION is '%s'",schemePi.Data());
cutSetPion->SetCutScheme(schemePi.Data());
cutSetKaon->SetCutScheme(schemeK.Data());
Int_t iCutPi = task->AddTrackCuts(cutSetPion);
Int_t iCutK = task->AddTrackCuts(cutSetKaon);
if(enableMonitor){
Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled");
//gROOT->LoadMacro("$ALICE_ROOT/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetPion->GetMonitorOutput());
AddMonitorOutput(isMC, cutSetKaon->GetMonitorOutput());
}
// -- Values ------------------------------------------------------------------------------------
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
/* IM resolution */ Int_t resID = task->CreateValue(AliRsnMiniValue::kInvMassRes, kTRUE);
/* transv. momentum */ Int_t ptID = task->CreateValue(AliRsnMiniValue::kPt, kFALSE);
/* centrality */ Int_t centID = task->CreateValue(AliRsnMiniValue::kMult, kFALSE);
/* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta, kFALSE);
/* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY, 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 [10] = { !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly , !IsMcTrueOnly, !IsMcTrueOnly, isMC , isMC , isMC , isMC };
Bool_t useIM [10] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 };
TString name [10] = {"UnlikePM", "UnlikeMP", "MixingPM", "MixingMP", "LikePP", "LikeMM", "TruesPM", "TruesMP", "ResPM" , "ResMP" };
TString comp [10] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" };
//TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" };
TString output [10] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" };
Char_t charge1 [10] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
Char_t charge2 [10] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' };
Int_t cutID1 [10] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
Int_t cutID2 [10] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi };
for (Int_t i = 0; i < 10; i++) {
if (!use[i]) continue;
if(Pdg > 0) AliRsnMiniOutput *out = task->CreateOutput(Form("kstar1_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
if(Pdg < 0) AliRsnMiniOutput *out = task->CreateOutput(Form("kstar2_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
out->SetCutID(0, cutID1[i]);
out->SetCutID(1, cutID2[i]);
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(Pdg);//313
out->SetMotherMass(0.89594);
out->SetPairCuts(cutsPair);
// axis X: invmass (or resolution)
if (useIM[i])
out->AddAxis(imID, 90, 0.6, 1.5);
//else
//out->AddAxis(resID, 200, -0.02, 0.02);
// axis Y: transverse momentum
out->AddAxis(ptID, 300, 0.0, 30.0);
// axis Z: centrality-multiplicity
if (!isPP)
out->AddAxis(centID, 100, 0.0, 100.0);
else
out->AddAxis(centID, 400, 0.0, 400.0);
// axis W: pseudorapidity
// out->AddAxis(etaID, 20, -1.0, 1.0);
// axis J: rapidity
//out->AddAxis(yID, 32, -0.8, 0.8);
}
if (isMC){
// create output
if(Pdg > 0) {AliRsnMiniOutput *outm = task->CreateOutput(Form("kstar_Mother1%s", suffix), "SPARSE", "MOTHER");}
if(Pdg < 0) {AliRsnMiniOutput *outm = task->CreateOutput(Form("kstar_Mother2%s", suffix), "SPARSE", "MOTHER");}
outm->SetDaughter(0, AliRsnDaughter::kKaon);
outm->SetDaughter(1, AliRsnDaughter::kPion);
outm->SetMotherPDG(Pdg);//313
outm->SetMotherMass(0.89594);
// pair cuts
outm->SetPairCuts(cutsPair);
// binnings
outm->AddAxis(imID, 90, 0.6, 1.5);
outm->AddAxis(ptID, 300, 0.0, 30.0);
if (!isPP){
outm->AddAxis(centID, 100, 0.0, 100.0);
} else {
outm->AddAxis(centID, 400, 0.0, 400.0);
}
//outm->AddAxis(yID, 32, -0.8, 0.8);
}
return kTRUE;
}
