void SetEventHistograms(AliRsnMiniAnalysisTask *task,ERsnCollisionType collisionType) {
// -- 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(collisionType==kPP)
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
}
//
// *** 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 ConfigPhiMC
(
AliRsnMiniAnalysisTask *task,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
//
// -- Define track cuts -------------------------------------------------------------------------
//
/*** EMPTY FOR TRUE PAIRS COMPUTATION ***/
//
// -- 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 -----------------------------------------------------------------
//
TString mode = "HIST";
if (!isPP) mode = "SPARSE";
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("phi_TrueMC%s", suffix), mode.Data(), "MOTHER");
// selection settings
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kKaon);
out->SetMotherPDG(333);
out->SetMotherMass(1.019455);
// pair cuts
out->SetPairCuts(cutsPair);
// binnings
out->AddAxis(imID, 500, 0.9, 1.4);
out->AddAxis(ptID, 100, 0.0, 10.0);
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
return kTRUE;
}
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;
}
Bool_t ConfigPhiMassStudy
(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair,
Int_t aodFilterBit = 5,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma,
Float_t nsigmaKa = 2.0,
Bool_t enableTrkSyst = kFALSE,
Char_t DCAxyFormula[100] = "0.0105+0.035/pt^1.01",
Double_t dcazmax = 3.2,
Double_t minNcls = 70,
Double_t maxX2cls = 4.0,
Double_t globalX2cls = 36.0,
Double_t minCrossedRows = 50.0,
Double_t maxClsCrossedRows = 0.8,
Bool_t enableMonitor = kTRUE,
Bool_t IsMcTrueOnly = kFALSE,
Int_t signedPdg = 333,
TString monitorOpt = "", //Flag for AddMonitorOutput.C e.g."NoSIGN"
Bool_t useCrossedRows = kFALSE,
const char* yaxisVar = "PtDaughter_PDaughter_cent", //yaxisVar = "PtDaughter_PDaughter_cent"
Bool_t useMixLS = 0
)
{
TString opt(yaxisVar);
opt.ToUpper();
Bool_t isPtDaughter = opt.Contains("PTDAUGHTER") ;
Bool_t isPDaughter = opt.Contains("PDAUGHTER") ;
Bool_t iscent = opt.Contains("CENT") ;
Bool_t iseta = opt.Contains("ETA") ;
Bool_t israpidity = opt.Contains("RAPIDITY") ;
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
// set daughter cuts
AliRsnCutSetDaughterParticle * cutSetQ;
AliRsnCutSetDaughterParticle * cutSetK;
//vary track quality cuts for systematic checks
if(enableTrkSyst){
AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("QualityCut");
trkQualityCut->SetAODTestFilterBit(aodFilterBit);//reset the filter bit cut
trkQualityCut->SetCheckOnlyFilterBit(kFALSE);//tells the cut object to check all other cuts individually,
trkQualityCut->SetDCARPtFormula(DCAxyFormula);
trkQualityCut->SetDCAZmax(dcazmax);
if(useCrossedRows) {
trkQualityCut->SetMinNCrossedRowsTPC(minCrossedRows, kTRUE);
trkQualityCut->SetMinNCrossedRowsOverFindableClsTPC(maxClsCrossedRows, kTRUE); }
else trkQualityCut->SetTPCminNClusters(minNcls);
trkQualityCut->SetTPCmaxChi2(maxX2cls);
trkQualityCut->SetITSmaxChi2(36); // In Filter bit
trkQualityCut->SetMaxChi2TPCConstrainedGlobal(globalX2cls); // In the Filterbit
trkQualityCut->SetPtRange(0.15, 20.0);
trkQualityCut->SetEtaRange(-0.8, 0.8);
trkQualityCut->Print();
if(isPP) {
cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
} else {
cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
cutSetK->SetUse2011StdQualityCuts(kTRUE);
}
}
else
{
//default cuts 2010 for pp and 2011 for p-Pb
if(isPP) {
cutSetQ = new AliRsnCutSetDaughterParticle("cutQuality", AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0, aodFilterBit, kFALSE);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutKaon_%2.1f2sigma",nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, kFALSE);
}
else {
cutSetQ = new AliRsnCutSetDaughterParticle("cutQuality", AliRsnCutSetDaughterParticle::kQualityStd2011, AliPID::kPion, -1.0, aodFilterBit, kFALSE);
cutSetQ->SetUse2011StdQualityCuts(kTRUE);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutKaon2011_%2.1f2sigma",nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, kFALSE);
cutSetK->SetUse2011StdQualityCuts(kTRUE);
}
}
Int_t iCutQ = task->AddTrackCuts(cutSetQ);
Int_t iCutK = task->AddTrackCuts(cutSetK);
if (enableMonitor){
Printf("======== Cut monitoring enabled");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data());
AddMonitorOutput(isMC, cutSetK->GetMonitorOutput(), monitorOpt.Data());
}
Int_t pdg = signedPdg;
TDatabasePDG *db = TDatabasePDG::Instance();
TParticlePDG *part = db->GetParticle(pdg);
Double_t mass = part->Mass();
// -- 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);
/* 1st daughter pt */ Int_t fdpt = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
/* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
/* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE);
/* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, kFALSE);
/* transv. momentum */ Int_t ptIDmc = task->CreateValue(AliRsnMiniValue::kPt, kTRUE);
/* 1st daughter pt */ Int_t fdptmc = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kTRUE);
/* 2nd daughter pt */ Int_t sdptmc = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kTRUE);
// -- 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 [12] = { !IsMcTrueOnly, !IsMcTrueOnly, !IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly, isMC , isMC , isMC , isMC , useMixLS , useMixLS};
Bool_t useIM [12] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 };
TString name [12] = {"UnlikePM" , "UnlikeMP" , "MixingPM" , "MixingMP" , "LikePP" , "LikeMM" ,"TruesPM","TruesMP","ResPM" ,"ResMP" ,"MixingPP","MixingMM"};
TString comp [12] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" , "TRUE" , "MIX" ,"MIX" };
TString output [12] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE","SPARSE" ,"SPARSE","SPARSE","SPARSE" ,"SPARSE"};
Char_t charge1 [12] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
Char_t charge2 [12] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' ,'+' , '-' };
Int_t cutID1 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
Int_t cutID2 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
//TString output [10] = {"HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" , "HIST" };
for (Int_t i = 0; i < 12; i++) {
if (!use[i]) continue;
AliRsnMiniOutput *out = task->CreateOutput(Form("Phi_%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::kKaon);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(pdg);
out->SetMotherMass(mass);
out->SetPairCuts(cutsPair);
// axis X: invmass (or resolution)
if (useIM[i])
out->AddAxis(imID, 800, 0.8, 1.6);
else
out->AddAxis(resID, 200, -0.02, 0.02);
// axis Y: transverse momentum of pair as default - else chosen value
out->AddAxis(ptID, 100, 0.0, 10.0); //default use mother pt
if(isPtDaughter) {
out->AddAxis(fdpt, 100, 0.0, 10.0);
out->AddAxis(sdpt, 100, 0.0, 10.0);
}
if(isPDaughter) {
out->AddAxis(fdp, 100, 0.0, 10.0);
out->AddAxis(sdp, 100, 0.0, 10.0);
}
// axis Z: centrality-multiplicity
if(iscent) {
if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
else out->AddAxis(centID, 400, 0.0, 400.0);
}
// axis W: pseudorapidity
if(iseta) out->AddAxis(etaID, 20, -1.0, 1.0);
// axis J: rapidity
if(israpidity) out->AddAxis(yID, 12, -0.6, 0.6);
}
if (isMC){
// create output
AliRsnMiniOutput *outm = task->CreateOutput(Form("Phi_Mother%s", suffix), "SPARSE", "MOTHER");
outm->SetDaughter(0, AliRsnDaughter::kKaon);
outm->SetDaughter(1, AliRsnDaughter::kKaon);
outm->SetMotherPDG(pdg);
outm->SetMotherMass(mass);
// pair cuts
outm->SetPairCuts(cutsPair);
// binnings
outm->AddAxis(imID, 800, 0.8, 1.6);
// axis Y: transverse momentum of pair as default - else chosen value
outm->AddAxis(ptID, 100, 0.0, 10.0); //default use mother pt
if(isPtDaughter) {
outm->AddAxis(fdpt, 100, 0.0, 10.0);
outm->AddAxis(sdpt, 100, 0.0, 10.0);
}
if(isPDaughter) {
outm->AddAxis(fdp, 100, 0.0, 10.0);
outm->AddAxis(sdp, 100, 0.0, 10.0);
}
if(iscent) {
if (!isPP) outm->AddAxis(centID, 100, 0.0, 100.0);
else outm->AddAxis(centID, 400, 0.0, 400.0);
}
// axis W: pseudorapidity
if(iseta) outm->AddAxis(etaID, 20, -1.0, 1.0);
// axis J: rapidity
if(israpidity) outm->AddAxis(yID, 12, -0.6, 0.6);
//create plot for generated Pt of mother vs generated Pt of daughters
AliRsnMiniOutput *outPtGen = task->CreateOutput(Form("Phi_Mother_GenPt_%s", suffix), "SPARSE", "MOTHER");
outPtGen->SetDaughter(0, AliRsnDaughter::kKaon);
outPtGen->SetDaughter(1, AliRsnDaughter::kKaon);
outPtGen->SetMotherPDG(pdg);
outPtGen->SetMotherMass(mass);
// pair cuts
outPtGen->SetPairCuts(cutsPair);
// binnings
outPtGen->AddAxis(ptIDmc, 100, 0.0, 10.0); //mother pt - generated
outPtGen->AddAxis(fdptmc, 100, 0.0, 10.0); //first daughter pt - generated
outPtGen->AddAxis(sdptmc, 100, 0.0, 10.0); //second daughter pt - generated
//create plot for reconstructed Pt of true mother vs generated Pt of daughters
AliRsnMiniOutput *outPtTrueGen = task->CreateOutput(Form("Phi_True_GenPt_%s", suffix), "SPARSE", "TRUE");
outPtTrueGen->SetDaughter(0, AliRsnDaughter::kKaon);
outPtTrueGen->SetDaughter(1, AliRsnDaughter::kKaon);
outPtTrueGen->SetCutID(0, iCutK);
outPtTrueGen->SetCutID(1, iCutK);
outPtTrueGen->SetCharge(0, '+');
outPtTrueGen->SetCharge(1, '-');
outPtTrueGen->SetMotherPDG(pdg);
outPtTrueGen->SetMotherMass(mass);
// pair cuts
outPtTrueGen->SetPairCuts(cutsPair);
// binnings
outPtTrueGen->AddAxis(ptID, 100, 0.0, 10.0); //true pt - generated
outPtTrueGen->AddAxis(fdptmc, 100, 0.0, 10.0); //first daughter pt - generated
outPtTrueGen->AddAxis(sdptmc, 100, 0.0, 10.0); //second daughter pt - generated
//create plot for reconstructed Pt of true mother vs reconstructed Pt of daughters
AliRsnMiniOutput *outPtTrueRec = task->CreateOutput(Form("Phi_True_RecPt_%s", suffix), "SPARSE", "TRUE");
outPtTrueRec->SetDaughter(0, AliRsnDaughter::kKaon);
outPtTrueRec->SetDaughter(1, AliRsnDaughter::kKaon);
outPtTrueRec->SetCutID(0, iCutK);
outPtTrueRec->SetCutID(1, iCutK);
outPtTrueRec->SetCharge(0, '+');
outPtTrueRec->SetCharge(1, '-');
outPtTrueRec->SetMotherPDG(pdg);
outPtTrueRec->SetMotherMass(mass);
// pair cuts
outPtTrueRec->SetPairCuts(cutsPair);
// binnings
outPtTrueRec->AddAxis(ptID, 100, 0.0, 10.0); //mother pt - reconstructed
outPtTrueRec->AddAxis(fdpt, 100, 0.0, 10.0); //first daughter pt - reconstructed
outPtTrueRec->AddAxis(sdpt, 100, 0.0, 10.0); //second daughter pt - reconstructed
}
return kTRUE;
}
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;
}
//
// *** 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;
}
//
// *** 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;
}
/***************************************************************************
[email protected] - last modified on 02/07/2014
*** Configuration script for K*, anti-K* analysis of 2010 pp 7TeV datasets ***
This analysis task is used to extend the pT reach of the K* spectra published in Eur.
Phys. J. C72(2012)2183.
****************************************************************************/
Bool_t ConfigKStarPP7TeV
(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair,
Int_t aodFilterBit = 5,
Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutPiCandidate = AliRsnCutSetDaughterParticle::kQualityStd2010,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate = AliRsnCutSetDaughterParticle::kQualityStd2010,
Float_t nsigmaPi = 2.0,
Float_t nsigmaKa = 2.0,
Bool_t enableMonitor = kTRUE,
Bool_t IsMcTrueOnly = kFALSE,
TString monitorOpt = "",
Bool_t useMixLS = 0,
Bool_t checkReflex = 0,
AliRsnMiniValue::EType yaxisVar = AliRsnMiniValue::kPt
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
// set daughter cuts
AliRsnCutSetDaughterParticle * cutSetQ;
AliRsnCutSetDaughterParticle * cutSetPi;
AliRsnCutSetDaughterParticle * cutSetK;
AliRsnCutTrackQuality * trkQualityCut = new AliRsnCutTrackQuality("myQualityCut");
if (SetCustomQualityCut(trkQualityCut, customQualityCutsID, aodFilterBit)) {
//Set custom quality cuts for systematic checks
cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), trkQualityCut, AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0);
cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), trkQualityCut, cutPiCandidate, AliPID::kPion, nsigmaPi);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), trkQualityCut, cutKaCandidate, AliPID::kKaon, nsigmaKa);
} else {
//use default quality cuts std 2010 with crossed rows TPC
Bool_t useCrossedRows = 1;
cutSetQ = new AliRsnCutSetDaughterParticle(Form("cutQ_bit%i",aodFilterBit), AliRsnCutSetDaughterParticle::kQualityStd2010, AliPID::kPion, -1.0, aodFilterBit, useCrossedRows);
cutSetPi = new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",cutPiCandidate, nsigmaPi), cutPiCandidate, AliPID::kPion, nsigmaPi, aodFilterBit, useCrossedRows);
cutSetK = new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutPiCandidate, nsigmaKa), cutKaCandidate, AliPID::kKaon, nsigmaKa, aodFilterBit, useCrossedRows);
}
Int_t iCutQ = task->AddTrackCuts(cutSetQ);
Int_t iCutPi = task->AddTrackCuts(cutSetPi);
Int_t iCutK = task->AddTrackCuts(cutSetK);
if (enableMonitor){
Printf("======== Cut monitoring enabled");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetQ->GetMonitorOutput(), monitorOpt.Data());
AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput(), monitorOpt.Data());
AddMonitorOutput(isMC, cutSetK->GetMonitorOutput()), monitorOpt.Data();
}
// -- 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);
/* 1st daughter pt */ Int_t fdpt = task->CreateValue(AliRsnMiniValue::kFirstDaughterPt, kFALSE);
/* 2nd daughter pt */ Int_t sdpt = task->CreateValue(AliRsnMiniValue::kSecondDaughterPt, kFALSE);
/* 1st daughter p */ Int_t fdp = task->CreateValue(AliRsnMiniValue::kFirstDaughterP, kFALSE);
/* 2nd daughter p */ Int_t sdp = task->CreateValue(AliRsnMiniValue::kSecondDaughterP, 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 [12] = {!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly,!IsMcTrueOnly ,isMC,isMC,isMC,isMC, useMixLS , useMixLS };
Bool_t useIM [12] = { 1 , 1 , 1 , 1 , 1 , 1 , 1 , 1 , 0 , 0 , 1 , 1 };
TString name [12] = {"UnlikePM", "UnlikeMP","MixingPM","MixingMP", "LikePP", "LikeMM","TruesPM","TruesMP", "ResPM" ,"ResMP" , "MixingPP", "MixingMM" };
TString comp [12] = {"PAIR" , "PAIR" , "MIX" , "MIX" , "PAIR" , "PAIR" , "TRUE" , "TRUE" , "TRUE" ,"TRUE" , "MIX" , "MIX" };
TString output [12] = {"SPARSE" , "SPARSE" , "SPARSE" , "SPARSE" , "SPARSE", "SPARSE", "SPARSE","SPARSE" , "SPARSE","SPARSE", "SPARSE" , "SPARSE" };
Int_t pdgCode [12] = {313 , 313 , 313 , 313 , 313 , 313 , 313 , -313 , 313 , -313 , 313 , 313 };
Char_t charge1 [12] = {'+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' , '+' , '-' };
Char_t charge2 [12] = {'-' , '+' , '-' , '+' , '+' , '-' , '-' , '+' , '-' , '+' , '+' , '-' };
Int_t cutID1 [12] = { iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK , iCutK };
Int_t cutID2 [12] = { iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi , iCutPi, iCutPi , iCutPi , iCutPi , iCutPi };
for (Int_t i = 0; i < 12; i++) {
if (!use[i]) continue;
AliRsnMiniOutput *out = task->CreateOutput(Form("kstar_%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(pdgCode[i]);
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 of pair as default - else chosen value
if (yaxisVar==AliRsnMiniValue::kFirstDaughterPt)
out->AddAxis(fdpt, 100, 0.0, 10.0);
else
if (yaxisVar==AliRsnMiniValue::kSecondDaughterPt)
out->AddAxis(sdpt, 100, 0.0, 10.0);
else
if (yaxisVar==AliRsnMiniValue::kFirstDaughterP)
out->AddAxis(fdp, 100, 0.0, 10.0);
else
if (yaxisVar==AliRsnMiniValue::kSecondDaughterP)
out->AddAxis(sdp, 100, 0.0, 10.0);
else
out->AddAxis(ptID, 200, 0.0, 20.0); //default use mother pt
// 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, 10, -0.5, 0.5);
}
if (isMC){
//get mothers for K* PDG = 313
AliRsnMiniOutput *outm = task->CreateOutput(Form("Ks_Mother%s", suffix), "SPARSE", "MOTHER");
outm->SetDaughter(0, AliRsnDaughter::kKaon);
outm->SetDaughter(1, AliRsnDaughter::kPion);
outm->SetMotherPDG(313);
outm->SetMotherMass(0.89594);
outm->SetPairCuts(cutsPair);
outm->AddAxis(imID, 90, 0.6, 1.5);
outm->AddAxis(ptID, 200, 0.0, 20.0);
if (!isPP){
outm->AddAxis(centID, 100, 0.0, 100.0);
} else {
outm->AddAxis(centID, 400, 0.0, 400.0);
}
//get mothers for antiK* PDG = -313
AliRsnMiniOutput *outam = task->CreateOutput(Form("antiKs_Mother%s", suffix), "SPARSE", "MOTHER");
outam->SetDaughter(0, AliRsnDaughter::kKaon);
outam->SetDaughter(1, AliRsnDaughter::kPion);
outam->SetMotherPDG(-313);
outam->SetMotherMass(0.89594);
outam->SetPairCuts(cutsPair);
outam->AddAxis(imID, 90, 0.6, 1.5);
outam->AddAxis(ptID, 200, 0.0, 20.0);
if (!isPP){
outam->AddAxis(centID, 100, 0.0, 100.0);
} else {
outam->AddAxis(centID, 400, 0.0, 400.0);
}
//get phase space of the decay from mothers
AliRsnMiniOutput *outps = task->CreateOutput(Form("Ks_phaseSpace%s", suffix), "HIST", "TRUE");
outps->SetDaughter(0, AliRsnDaughter::kKaon);
outps->SetDaughter(1, AliRsnDaughter::kPion);
outps->SetCutID(0, iCutK);
outps->SetCutID(1, iCutPi);
outps->SetMotherPDG(313);
outps->SetMotherMass(0.89594);
outps->SetPairCuts(cutsPair);
outps->AddAxis(fdpt, 50, 0.0, 5.0);
outps->AddAxis(sdpt, 50, 0.0, 5.0);
outps->AddAxis(ptID, 200, 0.0, 20.0);
AliRsnMiniOutput *outaps = task->CreateOutput(Form("antiKs_phaseSpace%s", suffix), "HIST", "TRUE");
outaps->SetDaughter(0, AliRsnDaughter::kKaon);
outaps->SetDaughter(1, AliRsnDaughter::kPion);
outaps->SetCutID(0, iCutK);
outaps->SetCutID(1, iCutPi);
outaps->SetMotherPDG(-313);
outaps->SetMotherMass(0.89594);
outaps->SetPairCuts(cutsPair);
outaps->AddAxis(fdpt, 50, 0.0, 5.0);
outaps->AddAxis(sdpt, 50, 0.0, 5.0);
outaps->AddAxis(ptID, 200, 0.0, 20.0);
//get reflections
if (checkReflex) {
AliRsnMiniOutput *outreflex = task->CreateOutput(Form("Ks_reflex%s", suffix), "SPARSE", "TRUE");
outreflex->SetDaughter(0, AliRsnDaughter::kKaon);
outreflex->SetDaughter(1, AliRsnDaughter::kPion);
outreflex->SetCutID(0, iCutPi);
outreflex->SetCutID(1, iCutK);
outreflex->SetMotherPDG(313);
outreflex->SetMotherMass(0.89594);
outreflex->SetPairCuts(cutsPair);
outreflex->AddAxis(imID, 90, 0.6, 1.5);
outreflex->AddAxis(ptID, 200, 0.0, 20.0);
if (!isPP){
outreflex->AddAxis(centID, 100, 0.0, 100.0);
} else {
outreflex->AddAxis(centID, 400, 0.0, 400.0);
}
AliRsnMiniOutput *outareflex = task->CreateOutput(Form("antiKs_reflex%s", suffix), "SPARSE", "TRUE");
outareflex->SetDaughter(0, AliRsnDaughter::kKaon);
outareflex->SetDaughter(1, AliRsnDaughter::kPion);
outareflex->SetCutID(0, iCutPi);
outareflex->SetCutID(1, iCutK);
outareflex->SetMotherPDG(-313);
outareflex->SetMotherMass(0.89594);
outareflex->SetPairCuts(cutsPair);
outareflex->AddAxis(imID, 90, 0.6, 1.5);
outareflex->AddAxis(ptID, 200, 0.0, 20.0);
if (!isPP){
outareflex->AddAxis(centID, 100, 0.0, 100.0);
} else {
outareflex->AddAxis(centID, 400, 0.0, 400.0);
}
}//end reflections
}//end MC
return kTRUE;
}
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;
}
//
// *** 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;
}
Bool_t ConfigKstarPP13TeV(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair,
Float_t nsigmaPi = 3.0,
Float_t nsigmaK = 3.0,
Bool_t enableMonitor = kTRUE,
TString optSys = "DefaultITSTPC2011"
)
{
//These are the Default values for 2011 ESD track cuts
AliPID::EParticleType type1 = AliPID::kPion;
AliPID::EParticleType type2 = AliPID::kKaon;
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
// retrieve mass from PDG database
Int_t pdg = 313;
TDatabasePDG *db = TDatabasePDG::Instance();
TParticlePDG *part = db->GetParticle(pdg);
Double_t mass = part->Mass();
// set daughter cuts
AliRsnCutSetDaughterParticle* cutSetPi;
AliRsnCutSetDaughterParticle* cutSetK;
/* AliRsnCutTrackQuality* trkQualityCut= new AliRsnCutTrackQuality("myQualityCut");
if(optSyt.Contains("DefaultITSTPC2011")){
trkQualityCut->SetDefaults2011(kTRUE,kTRUE);
Printf(Form("::::: SetCustomQualityCut:: using standard 2011 track quality cuts"));
}
else if(optSyt.Contains("DefaultTPCOnly")){
trkQualityCut->SetDefaultsTPCOnly(kTRUE);
Printf(Form("::::: SetCustomQualityCut:: using TPC-only track quality cuts"));
}
trkQualityCut->Print();*/
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);
//kTPCpidTOFveto4s
//kTPCpidTOFveto3s
//kFastTPCpidNsigma
cutSetPi=new AliRsnCutSetDaughterParticle(Form("cutPi%i_%2.1fsigma",AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,nsigmaPi),fQualityTrackCut,AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,AliPID::kPion,nsigmaPi);
cutSetK=new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s, nsigmaK),fQualityTrackCut,AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,AliPID::kKaon,nsigmaK);
Int_t iCutPi = task->AddTrackCuts(cutSetPi);
Int_t iCutK = task->AddTrackCuts(cutSetK);
if(enableMonitor){
Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetPi->GetMonitorOutput());
AddMonitorOutput(isMC, cutSetK->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 [12] = {1 ,1 ,1 ,1 ,1 ,1 ,isMC ,isMC ,isMC ,isMC ,isMC ,isMC };
Bool_t useIM [12] = {1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,1 ,0 ,0 };
TString name [12] = {"UnlikePM","UnlikeMP","MixingPM","MixingMP","LikePP","LikeMM","MCGenPM","MCGenMP","TruesPM","TruesMP","ResPM" ,"ResMP" };
TString comp [12] = {"PAIR" ,"PAIR" ,"MIX" ,"MIX" ,"PAIR" ,"PAIR" ,"MOTHER" ,"MOTHER" ,"TRUE" ,"TRUE" ,"TRUE" ,"TRUE" };
TString output [12] = {"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE","SPARSE","SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE","SPARSE"};
Char_t charge1 [12] = {'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' ,'+' ,'-' };
Char_t charge2 [12] = {'-' ,'+' ,'-' ,'+' ,'+' ,'-' ,'-' ,'+' ,'_' ,'+' ,'-' ,'+' };
Int_t cutIDPi [12] = {iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi ,iCutPi };
Int_t cutIDK [12] = {iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK };
Int_t PDGCode [12] = {313 ,313 ,313 ,313 ,313 ,313 ,313 ,-313 ,313 ,313 ,313 ,-313 };
for (Int_t i = 0; i < 12; i++) {
if (!use[i]) continue;
AliRsnMiniOutput *out = task->CreateOutput(Form("KSTAR_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetCutID(0, cutIDK[i]);
out->SetCutID(1, cutIDPi[i]);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(PDGCode[i]);
out->SetMotherMass(mass);
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, 200, 0.0, 20.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, 90, -4.5, 4.5);
}
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 ConfigDeltaPP7TeV_MC
(
AliRsnMiniAnalysisTask *task,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
//
// -- Define track cuts -------------------------------------------------------------------------
//
/*** EMPTY FOR TRUE PAIRS COMPUTATION ***/
//
// -- 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);
/* pseudorapidity */ Int_t etaID = task->CreateValue(AliRsnMiniValue::kEta , kFALSE);
/* rapidity */ Int_t yID = task->CreateValue(AliRsnMiniValue::kY , kFALSE);
//
// -- Create all needed outputs -----------------------------------------------------------------
//
TString mode = "SPARSE";
//if (!isPP) mode = "SPARSE";
//DELTA++
// create output
AliRsnMiniOutput *outpp = task->CreateOutput(Form("deltapp_TrueMCGen%s", suffix), mode.Data(), "MOTHER");
outpp->SetDaughter(0, AliRsnDaughter::kProton);
outpp->SetDaughter(1, AliRsnDaughter::kPion);
outpp->SetMotherPDG(2224);
outpp->SetMotherMass(1.232);
outpp->SetPairCuts(cutsPair);
outpp->AddAxis( imID , 100 , 1.0, 2.0 );
outpp->AddAxis( ptID , 100 , 0.0, 10.0 );
outpp->AddAxis(centID , 120 , 0.0, 120 );
outpp->AddAxis( etaID , 20 ,-1.0, 1.0 );
outpp->AddAxis( yID , 10 ,-0.5, 0.5 );
//DELTA--
AliRsnMiniOutput *outmm = task->CreateOutput(Form("deltamm_TrueMCGen%s", suffix), mode.Data(), "MOTHER");
outmm->SetDaughter(0, AliRsnDaughter::kProton);
outmm->SetDaughter(1, AliRsnDaughter::kPion);
outmm->SetMotherPDG(-2224);
outmm->SetMotherMass(1.232);
outmm->SetPairCuts(cutsPair);
outmm->AddAxis( imID , 100 , 1.0, 2.0 );
outmm->AddAxis( ptID , 100 , 0.0, 10.0 );
outmm->AddAxis( centID , 120 , 0.0, 120 );
outmm->AddAxis( etaID , 20 ,-1.0, 1.0 );
outmm->AddAxis( yID , 10 ,-0.5, 0.5 );
//DELTA0
AliRsnMiniOutput *out0pm = task->CreateOutput(Form("delta0pm_TrueMCGen%s", suffix), mode.Data(), "MOTHER");
out0pm->SetDaughter(0, AliRsnDaughter::kProton);
out0pm->SetDaughter(1, AliRsnDaughter::kPion);
out0pm->SetMotherPDG(2114);
out0pm->SetMotherMass(1.232);
out0pm->SetPairCuts(cutsPair);
out0pm->AddAxis( imID , 100 , 1.0, 2.0 );
out0pm->AddAxis( ptID , 100 , 0.0, 10.0 );
out0pm->AddAxis( centID , 120 , 0.0, 120 );
out0pm->AddAxis( etaID , 20 ,-1.0, 1.0 );
out0pm->AddAxis( yID , 10 ,-0.5, 0.5 );
//DELTA0BAR
AliRsnMiniOutput *out0mp = task->CreateOutput(Form("delta0mp_TrueMCGen%s", suffix), mode.Data(), "MOTHER");
out0mp->SetDaughter(0, AliRsnDaughter::kProton);
out0mp->SetDaughter(1, AliRsnDaughter::kPion);
out0mp->SetMotherPDG(-2114);
out0mp->SetMotherMass(1.232);
out0mp->SetPairCuts(cutsPair);
out0mp->AddAxis( imID , 100 , 1.0, 2.0 );
out0mp->AddAxis( ptID , 100 , 0.0, 10.0 );
out0mp->AddAxis( centID , 120 , 0.0, 120 );
out0mp->AddAxis( etaID , 20 ,-1.0, 1.0 );
out0mp->AddAxis( yID , 10 ,-0.5, 0.5 );
return kTRUE;
}
Bool_t ConfigPhiPP5TeV(
AliRsnMiniAnalysisTask *task,
Bool_t isMC,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair,
Int_t Strcut = 2011,
Int_t customQualityCutsID = AliRsnCutSetDaughterParticle::kDisableCustom,
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutKaCandidate=AliRsnCutSetDaughterParticle::kTPCpidTOFveto3s,
Float_t nsigmaK = 3.0,
Bool_t enableMonitor = kTRUE
)
{
//These are the Default values for 2011 ESD track cuts
AliPID::EParticleType type2 = AliPID::kKaon;
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
// retrieve mass from PDG database
Int_t pdg = 333;
TDatabasePDG *db = TDatabasePDG::Instance();
TParticlePDG *part = db->GetParticle(pdg);
Double_t mass = part->Mass();
Float_t nsigmaKTPC=fmod(nsigmaK,1000.);
Float_t nsigmaKTOF=(nsigmaK-fmod(nsigmaK,1000.))/1000.;
if(nsigmaKTOF<1.e-10) nsigmaKTOF=-1.;
// set daughter cuts
AliRsnCutSetDaughterParticle* cutSetK;
AliRsnCutTrackQuality* trkQualityCut= new AliRsnCutTrackQuality("myQualityCut");
if(!trkQualityCut) return kFALSE;
if(SetCustomQualityCut(trkQualityCut,customQualityCutsID,Strcut)){
cutSetK=new AliRsnCutSetDaughterParticle(Form("cutK%i_%2.1fsigma",cutKaCandidate, nsigmaK),trkQualityCut,cutKaCandidate,AliPID::kKaon,nsigmaKTPC,nsigmaKTOF);
}
else{
printf("Doughter Track cuts has been selected =================\n");
return kFALSE;
}
Int_t iCutK = task->AddTrackCuts(cutSetK);
if(enableMonitor){
Printf("======== Monitoring cut AliRsnCutSetDaughterParticle enabled");
gROOT->LoadMacro("$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetK->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 [7] = {1 ,1 ,1 ,1 ,isMC ,isMC ,isMC };
Bool_t useIM [7] = {1 ,1 ,1 ,1 ,1 ,1 ,0 };
TString name [7] = {"Unlike" ,"Mixing" ,"LikePP" ,"LikeMM" ,"MCGen" ,"Trues", ,"ResMP" };
TString comp [7] = {"PAIR" ,"MIX" ,"PAIR" ,"PAIR" ,"MOTHER" ,"TRUE" ,"TRUE" };
TString output [7] = {"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE"};
Char_t charge1 [7] = {'+' ,'+' ,'+' ,'-' ,'+' ,'+' ,'+' };
Char_t charge2 [7] = {'-' ,'-' ,'+' ,'-' ,'-' ,'-' ,'-' };
Int_t cutIDK [7] = {iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK ,iCutK };
Int_t PDGCode [7] = {333 ,333 ,333 ,333 ,333 ,333 ,333 };
for (Int_t i = 0; i < 7; i++) {
if (!use[i]) continue;
AliRsnMiniOutput *out = task->CreateOutput(Form("PHI_%s%s", name[i].Data(), suffix), output[i].Data(), comp[i].Data());
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kKaon);
out->SetCutID(0, cutIDK[i]);
out->SetCutID(1, cutIDK[i]);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(PDGCode[i]);
out->SetMotherMass(mass);
out->SetPairCuts(cutsPair);
// axis X: invmass (or resolution)
if (useIM[i])
out->AddAxis(imID, 250, 0.95, 1.2);
else
out->AddAxis(resID, 200, -0.02, 0.02);
// axis Y: transverse momentum
out->AddAxis(ptID, 500, 0.0, 50.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, 90, -4.5, 4.5);
}
return kTRUE;
}
Bool_t SetCustomQualityCut(AliRsnCutTrackQuality * trkQualityCut, Int_t customQualityCutsID = 0,Int_t trCut = 2011)
{
//Sets configuration for track quality object different from std quality cuts.
//Returns kTRUE if track quality cut object is successfully defined,
//returns kFALSE if an invalid set of cuts (customQualityCutsID) is chosen or if the
//object to be configured does not exist.
if ((!trkQualityCut)){
Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration.");
return kFALSE;
}
if(customQualityCutsID>=1 && customQualityCutsID<100 && customQualityCutsID!=2){
if(trCut == 2011){
trkQualityCut->SetDefaults2011(kTRUE,kTRUE);
Printf(Form("::::: SetCustomQualityCut:: using standard 2011 track quality cuts"));
}
else if(trCut == 2015){
trkQualityCut->SetDefaults2011(kTRUE,kTRUE);
trkQualityCut->GetESDtrackCuts()->SetCutGeoNcrNcl(3., 130., 1.5, 0.85, 0.7);
Printf(Form("::::: SetCustomQualityCut:: using standard 2015 track quality cuts"));
}
if(customQualityCutsID==3){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXYPtDep("0.015+0.05/pt^1.1");}//10Sig // D = 7*(0.0015+0.0050/pt^1.1)
else if(customQualityCutsID==4){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXYPtDep("0.006+0.02/pt^1.1");}//4Sig
else if(customQualityCutsID==5){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(3.);}// D = 2.
else if(customQualityCutsID==6){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(1.);}
else if(customQualityCutsID==7){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(0.2);}
else if(customQualityCutsID==8){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(5.);}// D = 4
else if(customQualityCutsID==9){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(3);}
else if(customQualityCutsID==10){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(60);}// D = 70
else if(customQualityCutsID==11){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(80);}
else if(customQualityCutsID==12){trkQualityCut->GetESDtrackCuts()->SetMinNCrossedRowsTPC(100);}
else if(customQualityCutsID==13){trkQualityCut->GetESDtrackCuts()->SetMinRatioCrossedRowsOverFindableClustersTPC(0.7);}// D = 8
else if(customQualityCutsID==14){trkQualityCut->GetESDtrackCuts()->SetMinRatioCrossedRowsOverFindableClustersTPC(0.9);}
else if(customQualityCutsID==15){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterITS(49.);}// D = 36
else if(customQualityCutsID==16){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterITS(25.);}
else if(customQualityCutsID==17){trkQualityCut->GetESDtrackCuts()->SetMaxChi2TPCConstrainedGlobal(49.);}// D = 36
else if(customQualityCutsID==18){trkQualityCut->GetESDtrackCuts()->SetMaxChi2TPCConstrainedGlobal(25.);}
else if(customQualityCutsID==19){trkQualityCut->GetESDtrackCuts()->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kOff);}
trkQualityCut->Print();
return kTRUE;
}else if(customQualityCutsID==2 || (customQualityCutsID>=100 && customQualityCutsID<200)){
trkQualityCut->SetDefaultsTPCOnly(kTRUE);
Printf(Form("::::: SetCustomQualityCut:: using TPC-only track quality cuts"));
if(customQualityCutsID==103){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXY(3.);}
else if(customQualityCutsID==104){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexXY(1.);}
else if(customQualityCutsID==105){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(4.);}
else if(customQualityCutsID==106){trkQualityCut->GetESDtrackCuts()->SetMaxDCAToVertexZ(1.);}
else if(customQualityCutsID==107){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(7.);}
else if(customQualityCutsID==108){trkQualityCut->GetESDtrackCuts()->SetMaxChi2PerClusterTPC(2.5);}
else if(customQualityCutsID==109){trkQualityCut->GetESDtrackCuts()->SetMinNClustersTPC(30);}
else if(customQualityCutsID==110){trkQualityCut->GetESDtrackCuts()->SetMinNClustersTPC(85);}
trkQualityCut->Print();
return kTRUE;
}else{
Printf("::::: SetCustomQualityCut:: use default quality cuts specified in task configuration.");
return kFALSE;
}
trkQualityCut->SetPtRange(0.15, 100000.0);
trkQualityCut->SetEtaRange(-0.8, 0.8);
Printf(Form("::::: SetCustomQualityCut:: using custom track quality cuts #%i",customQualityCutsID));
trkQualityCut->Print();
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 ConfigLStarPP_MC
(
AliRsnMiniAnalysisTask *task,
Bool_t isPP,
const char *suffix,
AliRsnCutSet *cutsPair
)
{
// manage suffix
if (strlen(suffix) > 0) suffix = Form("_%s", suffix);
//
// -- Define track cuts -------------------------------------------------------------------------
//
/*** EMPTY FOR TRUE PAIRS COMPUTATION ***/
//
// -- 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 -----------------------------------------------------------------
//
TString mode = "SPARSE";
// if (!isPP) mode = "SPARSE";
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("LStar_TrueMC1%s", suffix), mode.Data(), "MOTHER");
// selection settings
out->SetDaughter(0, AliRsnDaughter::kProton);
out->SetDaughter(1, AliRsnDaughter::kKaon);
out->SetCharge(0, '+');
out->SetCharge(1, '-');
out->SetMotherPDG(3124);
out->SetMotherMass(1.520);
// pair cuts
out->SetPairCuts(cutsPair);
// binnings
out->AddAxis(imID, 80, 1.0, 2.0);
//S.K. out->AddAxis(ptID, 100, 0.0, 10.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
//S.K. if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
out->AddAxis(centID, 10, 0.0, 100.0);
// create output
AliRsnMiniOutput *out = task->CreateOutput(Form("LStar_TrueMC2%s", suffix), mode.Data(), "MOTHER");
// selection settings
out->SetDaughter(0, AliRsnDaughter::kProton);
out->SetDaughter(1, AliRsnDaughter::kKaon);
out->SetCharge(0, '-');
out->SetCharge(1, '+');
out->SetMotherPDG(-3124);
out->SetMotherMass(1.520);
// pair cuts
out->SetPairCuts(cutsPair);
// binnings
out->AddAxis(imID, 100, 1.0, 2.0);
//S.K. out->AddAxis(ptID, 100, 0.0, 10.0);
out->AddAxis(ptID, 100, 0.0, 10.0);
//S.K. if (!isPP) out->AddAxis(centID, 100, 0.0, 100.0);
out->AddAxis(centID, 10, 0.0, 100.0);
// create output
AliRsnMiniOutput *outm = task->CreateOutput(Form("Ls_Mother"), mode.Data(), "MOTHER");
outm->SetDaughter(0, AliRsnDaughter::kProton);
outm->SetDaughter(1, AliRsnDaughter::kKaon);
outm->SetMotherPDG(3124);
outm->SetMotherMass(1.520);
// pair cuts
outm->SetPairCuts(cutsPair);
// binnings
outm->AddAxis(imID, 100, 1.0, 2.0);
outm->AddAxis(ptID, 100, 0.0, 10.0);
if (!isPP){
outm->AddAxis(centID, 100, 0.0, 100.0);
} else {
outm->AddAxis(centID, 400, 0.0, 400.0);
}
AliRsnMiniOutput *outm = task->CreateOutput(Form("Ls_AntiMother"), mode.Data(), "MOTHER");
outm->SetDaughter(0, AliRsnDaughter::kProton);
outm->SetDaughter(1, AliRsnDaughter::kKaon);
outm->SetMotherPDG(-3124);
outm->SetMotherMass(1.520);
// pair cuts
outm->SetPairCuts(cutsPair);
// binnings
outm->AddAxis(imID, 100, 1.0, 2.0);
outm->AddAxis(ptID, 100, 0.0, 10.0);
if (!isPP){
outm->AddAxis(centID, 100, 0.0, 100.0);
} else {
outm->AddAxis(centID, 400, 0.0, 400.0);
}
return kTRUE;
}
void AddPairOutputMiniRho(AliAnalysisTaskSE *task, Bool_t isMC,Bool_t isMixing, AliPID::EParticleType pType1,Int_t listID1, AliPID::EParticleType pType2,Int_t listID2, Int_t pdgMother,Double_t massMother, AliRsnCutSet *cutsPair=0,TString suffix = "") {
Bool_t valid;
Int_t isFullOutput = AliAnalysisManager::GetGlobalInt("rsnOutputFull",valid);
Int_t useMixing = AliAnalysisManager::GetGlobalInt("rsnUseMixing",valid);
Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
/* invariant mass */ Int_t imID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMass, kFALSE);
/* IM resolution */ Int_t resID = taskRsnMini->CreateValue(AliRsnMiniValue::kInvMassDiff, kTRUE);
/* transv. momentum */ Int_t ptID = taskRsnMini->CreateValue(AliRsnMiniValue::kPt, kFALSE);
/* centrality */ Int_t centID = taskRsnMini->CreateValue(AliRsnMiniValue::kMult, kFALSE);
/* eta */ Int_t etaID = taskRsnMini->CreateValue(AliRsnMiniValue::kEta, kFALSE);
// 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 [5] = { 1 , useMixing , 1 , 1 , isMC };
TString name [5] = {"Unlike", "Mixing", "LikePP", "LikeMM", "Trues"};
TString comp [5] = {"PAIR" , "MIX" , "PAIR" , "PAIR" , "TRUE" };
Char_t charge1 [5] = {'+' , '+' , '+' , '-' , '+' };
Char_t charge2 [5] = {'-' , '-' , '+' , '-' , '-' };
// common definitions
TString outputType = "HIST";
if (isFullOutput) outputType = "SPARSE";
Int_t nIM = 1000; Double_t minIM = 0.2, maxIM = 1.2;
Int_t nEta = 400; Double_t minEta = -2.0, maxEta = 2.0;
// Int_t nIM = 1000; Double_t minIM = 0.9, maxIM = 1.9;
Int_t nPt = 120; Double_t minPt = 0.0, maxPt = 12.0;
Int_t nCent = 100; Double_t minCent = 0.0, maxCent = 100.0;
Int_t nRes = 200; Double_t maxRes = 0.01;
// retrieve mass from PDG database
Int_t pdg = 113;
TDatabasePDG *db = TDatabasePDG::Instance();
TParticlePDG *part = db->GetParticle(pdg);
Printf(suffix.Data());
// create standard outputs
for (Int_t i = 0; i < 5; i++) {
if (!use[i]) continue;
// create output
AliRsnMiniOutput *out = taskRsnMini->CreateOutput(Form("%s_%s", suffix.Data(),name[i].Data() ), outputType.Data(), comp[i].Data());
// selection settings
out->SetCutID(0, listID1);
out->SetCutID(1, listID1);
out->SetDaughter(0, AliRsnDaughter::kPion);
out->SetDaughter(1, AliRsnDaughter::kPion);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
out->SetMotherPDG(pdg);
out->SetMotherMass(part->Mass());
// pair cuts
if (cutsPair) out->SetPairCuts(cutsPair);
// axis X: invmass
out->AddAxis(imID, nIM, minIM, maxIM);
if (isFullOutput) {
// axis Y: transverse momentum
out->AddAxis(ptID, nPt, minPt, maxPt);
out->AddAxis(etaID, nEta, minEta, maxEta);
// axis Z: centrality
if (!isPP) out->AddAxis(centID, nCent, minCent, maxCent);
}
}
// add output for resolution
if (isMC) {
AliRsnMiniOutput *outRes = taskRsnMini->CreateOutput(Form("rho_Res%s", suffix.Data()), outputType.Data(), "TRUE");
// selection settings
outRes->SetCutID(0, listID1);
outRes->SetCutID(1, listID1);
outRes->SetDaughter(0, AliRsnDaughter::kPion);
outRes->SetDaughter(1, AliRsnDaughter::kPion);
outRes->SetCharge(0, '+');
outRes->SetCharge(1, '-');
outRes->SetMotherPDG(pdg);
outRes->SetMotherMass(part->Mass());
// pair cuts
if (cutsPair) outRes->SetPairCuts(cutsPair);
// axis X: resolution
outRes->AddAxis(resID, nRes, -maxRes, maxRes);
if (isFullOutput) {
// axis Y: transverse momentum
outRes->AddAxis(ptID, nPt, minPt, maxPt);
outRes->AddAxis(etaID, nEta, minEta, maxEta);
// axis Z: centrality
if (!isPP) outRes->AddAxis(centID, nCent, minCent, maxCent);
}
}
//
// -- Create output for MC generated ------------------------------------------------------------
//
if (isMC) {
// create ouput
AliRsnMiniOutput *outMC = taskRsnMini->CreateOutput(Form("rho_MCGen%s", suffix.Data()), outputType.Data(), "MOTHER");
// selection settings
outMC->SetDaughter(0, AliRsnDaughter::kPion);
outMC->SetDaughter(1, AliRsnDaughter::kPion);
outMC->SetMotherPDG(pdg);
outMC->SetMotherMass(part->Mass());
// pair cuts
if (cutsPair) outMC->SetPairCuts(cutsPair);
// axis X: invmass
outMC->AddAxis(imID, nIM, minIM, maxIM);
if (isFullOutput) {
// axis Y: transverse momentum
outMC->AddAxis(ptID, nPt, minPt, maxPt);
outMC->AddAxis(etaID, nEta, minEta, maxEta);
// axis Z: centrality
if (!isPP) outMC->AddAxis(centID, nCent, minCent, maxCent);
}
}
}
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;
}
