Int_t AddRsnDaughterCutsBPID(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid;
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
// gets selector
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
//---------------------------------------------
// Define single cuts
//---------------------------------------------
AliRsnCutPID *cut1 = new AliRsnCutPID(Form("cut%sBPID%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kFALSE);
AliRsnCutSet *cuts1 = new AliRsnCutSet(Form("%sBPID%s",AliPID::ParticleName(type1),opt.Data()), AliRsnTarget::kDaughter);
cuts1->AddCut(cut1);
cuts1->SetCutScheme(cut1->GetName());
sel->Add(cuts1, kTRUE);
AliRsnCutSet *cuts2 = 0;
if (type1 != type2) {
AliRsnCutPID *cut2 = new AliRsnCutPID(Form("cut%sBPID%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kFALSE);
cuts2 = new AliRsnCutSet(Form("%sBPID%s",AliPID::ParticleName(type2),opt.Data()), AliRsnTarget::kDaughter);
cuts2->AddCut(cut2);
cuts2->SetCutScheme(cut2->GetName());
sel->Add(cuts2, kTRUE);
numberOfCuts++;
}
if (opt.Contains("mon")) {
AddMonitorOutput(cuts1->GetMonitorOutput(),opt);
if (type1 != type2) {
AddMonitorOutput(cuts2->GetMonitorOutput(),opt);
}
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cuts1);
if (type1 != type2) taskRsnMini->AddTrackCuts(cuts2);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
sel->Add(cuts1, kTRUE);
if (type1 != type2) sel->Add(cuts2, kTRUE);
}
return numberOfCuts;
}
void AddParticleMonitor(AliAnalysisTaskSE *task, Bool_t isMC, Int_t listID1,AliRsnCutSet *commonEventCuts=0,AliRsnCutSet *cutPair=0,TString name = "")
{
Bool_t valid;
Int_t isRsnMini = AliAnalysisManager::GetGlobalInt("rsnUseMiniPackage",valid);
Int_t useMCMon = AliAnalysisManager::GetGlobalInt("rsnUseMCMonitoring",valid);
if (isRsnMini) {
// Printf("Monitoring by mini is not supported now. It will be soon !!!");
// return ;
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
AliRsnMiniMonitorTask *monTask = new AliRsnMiniMonitorTask(name.Data(),useMCMon);
AddMonitorOutputMini(monTask,listID1,name);
// AddMonitorOutputMini(monTask,listID1,name,'+');
// AddMonitorOutputMini(monTask,listID1,name,'-');
mgr->AddTask(monTask);
// connect input container according to source choice
mgr->ConnectInput(monTask, 0, mgr->GetCommonInputContainer());
// create paths for the output in the common file
TString commonPath = AliAnalysisManager::GetCommonFileName();
// create containers for output
AliAnalysisDataContainer *output = mgr->CreateContainer(Form("RsnMonMini%s", name.Data()), TList::Class(), AliAnalysisManager::kOutputContainer, commonPath.Data());
mgr->ConnectOutput(monTask, 1, output);
} else {
TList *listLoops = new TList;
// monitor definition
AliRsnDaughterDef *tracksAll = new AliRsnDaughterDef(AliRsnDaughter::kTrack /*'+' or '-'*/);
// // AliRsnDaughterDef *tracksPos = new AliRsnDaughterDef(AliRsnDaughter::kTrack,'+');
// // AliRsnDaughterDef *tracksNeg = new AliRsnDaughterDef(AliRsnDaughter::kTrack,'-');
//
AliRsnLoopDaughter *lm =0;
// // loop object
listLoops->Add(new AliRsnLoopDaughter(Form("ALL_%s", name.Data()), listID1, tracksAll));
//
// // listLoops->Add(new AliRsnLoopDaughter(Form("%s_pos", name.Data()), listID1, tracksPos));
// // listLoops->Add(new AliRsnLoopDaughter(Form("%s_neg", name.Data()), listID1, tracksNeg));
//
TIter next(listLoops);
while ((lm = (AliRsnLoopDaughter *)next.Next())) {
// if (commonEventCuts) lm->SetEventCuts(commonEventCuts);
AddMonitorOutput(0,"mc_loop",lm);
((AliRsnAnalysisTask *)task)->AddLoop(lm);
}
}
}
void AddMonitorLoop(AliRsnAnalysisTask *task, Bool_t isMC, Int_t listID1, const char *suffix = "")
{
// monitor definition
AliRsnDaughterDef *tracks = new AliRsnDaughterDef(AliRsnDaughter::kTrack /*'+' or '-'*/);
// loop object
AliRsnLoopDaughter *loopMon1 = new AliRsnLoopDaughter(Form("%s_mon1", suffix), listID1, tracks);
// AliRsnLoopDaughter *loopMon2 = new AliRsnLoopDaughter(Form("%s_mon2", suffix), listID2, tracks);
// add cuts on events
AliRsnCutSet *eventCuts = EventCuts();
loopMon1->SetEventCuts(eventCuts);
// loopMon2->SetEventCuts(eventCuts);
// add monitors
AddMonitorOutput(loopMon1);
// AddMonitorOutput(loopMon2);
// add loop to task
task->Add(loopMon1);
// task->Add(loopMon2);
}
Int_t AddRsnDaughterCutsRhoNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
Bool_t usePPCut = kFALSE;
if (isPP && (opt.Contains("usePP"))) usePPCut = kTRUE;
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
//---------------------------------------------
// Define single cuts
//---------------------------------------------
Printf("AddRsnDaughterCutsRho Option : %s",opt.Data());
Double_t nSigmaTPC=3.0;
Double_t nSigmaTOF=3.0;
Double_t etaRange=0.8;
Bool_t useTPC_Pi=kFALSE;
Bool_t useTOF_Pi=kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_Pi=kFALSE;
useTOF_Pi=kFALSE;
} else if (!opt.Contains("nsig")) {
useTPC_Pi=kTRUE;
useTOF_Pi=kTRUE;
}
if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
if (opt.Contains("PiTPCnsig10")) nSigmaTPC = 1.0;
if (opt.Contains("PiTPCnsig15")) nSigmaTPC = 1.5;
if (opt.Contains("PiTPCnsig20")) nSigmaTPC = 2.0;
if (opt.Contains("PiTPCnsig25")) nSigmaTPC = 2.5;
if (opt.Contains("PiTPCnsig30")) nSigmaTPC = 3.0;
if (opt.Contains("PiTOFnsig10")) nSigmaTOF = 1.0;
if (opt.Contains("PiTOFnsig15")) nSigmaTOF = 1.5;
if (opt.Contains("PiTOFnsig20")) nSigmaTOF = 2.0;
if (opt.Contains("PiTOFnsig25")) nSigmaTOF = 2.5;
if (opt.Contains("PiTOFnsig30")) nSigmaTOF = 3.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
//---------------------------------------------
// Combine cuts
//---------------------------------------------
TString cutname = "Pi_Rho";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
TString scheme="";
AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQuatityPi");
qualityCut->SetDefaults2010();
cuts->AddCut(qualityCut);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCut->GetName();
if (useTPC_Pi) {
AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
cutPiTPC->SinglePIDRange(nSigmaTPC);
cuts->AddCut(cutPiTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTPC->GetName();
}
if (useTOF_Pi) {
AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
cutPiTOF->SinglePIDRange(nSigmaTOF);
cuts->AddCut(cutPiTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTOF->GetName();
}
if (useEta) {
Printf("Adding ETA ...");
AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEta->SetTargetType(AliRsnTarget::kDaughter);
cutEta->SetValueObj(valEta);
cuts->AddCut(cutEta);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEta->GetName();
}
if (usePDG) {
Printf("Adding PDG ...");
AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cuts->AddCut(cutPDG);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDG->GetName();
}
Printf ("CUT Scheme is '%s'",scheme.Data());
cuts->SetCutScheme(scheme.Data());
if (opt.Contains("mon")) {
AddMonitorOutput(cuts->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cuts);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cuts, kTRUE);
}
return numberOfCuts;
}
Int_t AddRsnDaughterCutsKStarTOFanalysis(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid;
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 2;
//---------------------------------------------
// Define single cutsP
//---------------------------------------------
Printf("AddRsnDaughterCutsKStarTOFanalysis Option : %s",opt.Data());
// default values
Double_t nSigmaTPC_Pi=3.0;
Double_t nSigmaTPC_K=3.0;
Double_t nSigmaTOF_Pi=3.0;
Double_t nSigmaTOF_K=3.0;
Double_t nSigmaTPCveto_Pi=5.0;
Double_t nSigmaTPCveto_K=5.0;
Double_t etaRange=0.8;
Bool_t useTPC_Pi=kFALSE;
Bool_t useTOF_Pi=kFALSE;
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t useTPCveto_Pi = kFALSE;
Bool_t useTPCveto_K = kFALSE;
Bool_t useCombined_Pi = kFALSE;
Bool_t useCombined_K = kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_Pi=kFALSE;
useTOF_Pi=kFALSE;
useTPC_K=kFALSE;
useTOF_K=kFALSE;
useTPCveto_Pi = kFALSE;
useTPCveto_K = kFALSE;
useCombined_Pi = kFALSE;
useCombined_K = kFALSE;
} else {
if (opt.Contains("combined")) {
useCombined_Pi = kTRUE;
useCombined_K = kTRUE;
} else {
if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if(opt.Contains("TPCveto")) {
useTPCveto_Pi = kTRUE;
useTPCveto_K = kTRUE;
nSigmaTPCveto_Pi = 5.0;
nSigmaTPCveto_K = 5.0;
}
}
}
if (opt.Contains("PiTPCnsig10")) nSigmaTPC_Pi = 1.0;
if (opt.Contains("PiTPCnsig15")) nSigmaTPC_Pi = 1.5;
if (opt.Contains("PiTPCnsig20")) nSigmaTPC_Pi = 2.0;
if (opt.Contains("PiTPCnsig25")) nSigmaTPC_Pi = 2.5;
if (opt.Contains("PiTPCnsig30")) nSigmaTPC_Pi = 3.0;
if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
if (opt.Contains("PiTOFnsig10")) nSigmaTOF_Pi = 1.0;
if (opt.Contains("PiTOFnsig15")) nSigmaTOF_Pi = 1.5;
if (opt.Contains("PiTOFnsig20")) nSigmaTOF_Pi = 2.0;
if (opt.Contains("PiTOFnsig25")) nSigmaTOF_Pi = 2.5;
if (opt.Contains("PiTOFnsig30")) nSigmaTOF_Pi = 3.0;
if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
// KAON SETTINGS =======================================
TString scheme="";
TString cutname = "K_Kstar";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsK;
if (useCombined_K) {
cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kKaon, nSigmaTOF_K, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsK->GetCutScheme();
} else {
if (useTPCveto_K) {
cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kKaon, nSigmaTOF_K, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsK->GetCutScheme();
} else {
cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
qualityCutK->SetDefaults2010();
cutsK->AddCut(qualityCutK);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutK->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC_K);
cutsK->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF_K);
cutsK->AddCut(cutKTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}
}
}
if (useEta) {
AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
cutEtaK->SetValueObj(valEtaK);
cutsK->AddCut(cutEtaK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaK->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
cutsK->AddCut(cutPDGK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGK->GetName();
}
Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
cutsK->SetCutScheme(scheme.Data());
// END KAON =======================================
// Pion SETTINGS ===========================================
scheme="";
cutname = "Pi_Kstar";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsPi;
if (useCombined_Pi) {
cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kPion, nSigmaTOF_Pi, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsPi->GetCutScheme();
} else {
if (useTPCveto_Pi) {
cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kPion, nSigmaTOF_Pi, 5);
if (!scheme.IsNull()) scheme += "&";
scheme += cutsPi->GetCutScheme();
} else {
cutsPi = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi");
qualityCutPi->SetDefaults2010();
cutsPi->AddCut(qualityCutPi);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutPi->GetName();
if (useTPC_Pi) {
AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
cutPiTPC->SinglePIDRange(nSigmaTPC_Pi);
cutsPi->AddCut(cutPiTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTPC->GetName();
}
if (useTOF_Pi) {
AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
cutPiTOF->SinglePIDRange(nSigmaTOF_Pi);
cutsPi->AddCut(cutPiTOF);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPiTOF->GetName();
}
}
}
if (useEta) {
AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
cutEtaP->SetValueObj(valEtaP);
cutsPi->AddCut(cutEtaP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaP->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cutsPi->AddCut(cutPDGP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGP->GetName();
}
Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
cutsPi->SetCutScheme(scheme.Data());
// END PION =======================================
if (opt.Contains("mon")) {
AddMonitorOutput(cutsPi->GetMonitorOutput(),opt);
AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cutsK);
taskRsnMini->AddTrackCuts(cutsPi);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cutsPi, kTRUE);
sel->Add(cutsK, kTRUE);
}
return numberOfCuts;
}
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;
}
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;
}
Int_t AddRsnDaughterCutsLambdaNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
// Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);
TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid);
Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid);
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 2;
//---------------------------------------------
// Define single cutsP
//---------------------------------------------
Printf("AddRsnDaughterCutsLambda Option : %s",opt.Data());
Double_t nSigmaTPC_P=3.0;
Double_t nSigmaTPC_K=3.0;
Double_t nSigmaTOF_P=3.0;
Double_t nSigmaTOF_K=3.0;
Double_t etaRange=0.8;
Double_t PtMin_P=0.15;
Double_t PtMax_P=1.e10;
Double_t PtMin_K=0.15;
Double_t PtMax_K=1.e10;
Double_t PMax_P=1.1;
Double_t PMax_K=0.6;
Bool_t useTPC_P=kFALSE;
Bool_t useTOF_P=kFALSE;
Bool_t rejectUnmatchedTOF_P=kTRUE;
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t rejectUnmatchedTOF_K=kTRUE;
if (opt.Contains("qualityonly")) {
useTPC_P=kFALSE;
useTOF_P=kFALSE;
useTPC_K=kFALSE;
useTOF_K=kFALSE;
} else if (!opt.Contains("nsig")) {
useTPC_P=kTRUE;
useTOF_P=kTRUE;
useTPC_K=kTRUE;
useTOF_K=kTRUE;
}
if (opt.Contains("PTPCnsig")) useTPC_P=kTRUE;
if (opt.Contains("PTPCnsig10")) nSigmaTPC_P = 1.0;
if (opt.Contains("PTPCnsig15")) nSigmaTPC_P = 1.5;
if (opt.Contains("PTPCnsig20")) nSigmaTPC_P = 2.0;
if (opt.Contains("PTPCnsig25")) nSigmaTPC_P = 2.5;
if (opt.Contains("PTPCnsig30")) nSigmaTPC_P = 3.0;
if (opt.Contains("PTPCnsig40")) nSigmaTPC_P = 4.0;
if (opt.Contains("PTPCnsig50")) nSigmaTPC_P = 5.0;
if (opt.Contains("PTPCnsig1000")) nSigmaTPC_P = 100.0;
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
if (opt.Contains("KTPCnsig40")) nSigmaTPC_K = 4.0;
if (opt.Contains("KTPCnsig50")) nSigmaTPC_K = 5.0;
if (opt.Contains("KTPCnsig1000")) nSigmaTPC_K = 100.0;
if (opt.Contains("PTOFnsig")) useTOF_P=kTRUE;
if (opt.Contains("PTOFacceptUnmatched")) rejectUnmatchedTOF_P=kFALSE;
if (opt.Contains("PTOFnsig10")) nSigmaTOF_P = 1.0;
if (opt.Contains("PTOFnsig15")) nSigmaTOF_P = 1.5;
if (opt.Contains("PTOFnsig20")) nSigmaTOF_P = 2.0;
if (opt.Contains("PTOFnsig25")) nSigmaTOF_P = 2.5;
if (opt.Contains("PTOFnsig30")) nSigmaTOF_P = 3.0;
if (opt.Contains("PTOFnsig40")) nSigmaTOF_P = 4.0;
if (opt.Contains("PTOFnsig50")) nSigmaTOF_P = 5.0;
if (opt.Contains("PTOFnsig1000")) nSigmaTOF_P = 100.0;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE;
if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
if (opt.Contains("KTOFnsig40")) nSigmaTOF_K = 4.0;
if (opt.Contains("KTOFnsig50")) nSigmaTOF_K = 5.0;
if (opt.Contains("KTOFnsig1000")) nSigmaTOF_K = 100.0;
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))) etaRange=0.1*j;
Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
useEta = kTRUE;
}
Bool_t usePPt=kFALSE;
if(opt.Contains("PPt")){
Printf("Using Proton pT range (%.2f,%.2f)",PtMin_P,PtMax_P);
usePPt=kTRUE;
}
Bool_t useKPt=kFALSE;
if(opt.Contains("KPt")){
Printf("Using Kaon pT range (%.2f,%.2f)",PtMin_K,PtMax_K);
useKPt=kTRUE;
}
Bool_t usePMax_P=kFALSE;
if(opt.Contains("PPMax")){
for(int j=1;j<=9;j++) if(opt.Contains(Form("PPMax0%i",j))) PMax_P=0.1*j;
for(int j=10;j<=30;j++) if(opt.Contains(Form("PPMax%i",j))) PMax_P=0.1*j;
Printf("Using Proton momentum range (0,%.2f)",PMax_P);
usePMax_P=kTRUE;
}
Bool_t usePMax_K=kFALSE;
if(opt.Contains("KPMax")){
for(int j=1;j<=9;j++) if(opt.Contains(Form("KPMax0%i",j))) PMax_K=0.1*j;
for(int j=10;j<=30;j++) if(opt.Contains(Form("KPMax%i",j))) PMax_K=0.1*j;
Printf("Using Kaon momentum range (0,%.2f)",PMax_K);
usePMax_K=kTRUE;
}
// PROTON SETTINGS ===========================================
TString scheme="";
TString cutname = "p_Lambda";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutP = new AliRsnCutTrackQuality("cutQualityP");
if (useCommonQualityCut>=0) {
qualityCutP->SetAODTestFilterBit(useCommonQualityCut);
} else {
qualityCutP->SetDefaults2010();
}
cutsP->AddCut(qualityCutP);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutP->GetName();
if (useTPC_P) {
AliRsnCutPIDNSigma *cutPTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCP",AliPID::kProton,AliRsnCutPIDNSigma::kTPC);
cutPTPC->SinglePIDRange(nSigmaTPC_P);
cutsP->AddCut(cutPTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPTPC->GetName();
}
if (useTOF_P) {
AliRsnCutPIDNSigma *cutPTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFP",AliPID::kProton,AliRsnCutPIDNSigma::kTOF);
cutPTOF->SinglePIDRange(nSigmaTOF_P);
cutsP->AddCut(cutPTOF);
if(rejectUnmatchedTOF_P){
if (!scheme.IsNull()) scheme += "&";
scheme += cutPTOF->GetName();
}else{
AliRsnCutTOFMatch *cutPTOFMatch = new AliRsnCutTOFMatch("cutPTOFMatch");
cutsP->AddCut(cutPTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutPTOF->GetName(),cutPTOFMatch->GetName());
}
}
if (useEta) {
AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
cutEtaP->SetValueObj(valEtaP);
cutsP->AddCut(cutEtaP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaP->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cutsP->AddCut(cutPDGP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGP->GetName();
}
if(usePPt){
AliRsnValueDaughter *valPtP = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutPtP = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type1),opt.Data()),PtMin_P,PtMax_P);
cutPtP->SetTargetType(AliRsnTarget::kDaughter);
cutPtP->SetValueObj(valPtP);
cutsP->AddCut(cutPtP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPtP->GetName();
}
if(usePMax_P){
AliRsnValueDaughter *valPP = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kP);
AliRsnCutValue *cutPP = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type1),opt.Data()),0.,PMax_P);
cutPP->SetTargetType(AliRsnTarget::kDaughter);
cutPP->SetValueObj(valPP);
cutsP->AddCut(cutPP);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPP->GetName();
}
Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
cutsP->SetCutScheme(scheme.Data());
// END PROTON =======================================
// KAON SETTINGS =======================================
scheme="";
cutname = "K_Lambda";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQualityK");
if (useCommonQualityCut>=0) {
qualityCutK->SetAODTestFilterBit(useCommonQualityCut);
} else {
qualityCutK->SetDefaults2010();
}
cutsK->AddCut(qualityCutK);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCutK->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC_K);
cutsK->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF_K);
cutsK->AddCut(cutKTOF);
if(rejectUnmatchedTOF_K){
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}else{
AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch");
cutsK->AddCut(cutKTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName());
}
}
if (useEta) {
AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
cutEtaK->SetValueObj(valEtaK);
cutsK->AddCut(cutEtaK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEtaK->GetName();
}
if (usePDG) {
AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
cutsK->AddCut(cutPDGK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDGK->GetName();
}
if(useKPt){
AliRsnValueDaughter *valPtK = new AliRsnValueDaughter(Form("val%sPt%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutPtK = new AliRsnCutValue(Form("cut%sPt%s",AliPID::ParticleName(type2),opt.Data()),PtMin_K,PtMax_K);
cutPtK->SetTargetType(AliRsnTarget::kDaughter);
cutPtK->SetValueObj(valPtK);
cutsK->AddCut(cutPtK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPtK->GetName();
}
if(usePMax_K){
AliRsnValueDaughter *valPK = new AliRsnValueDaughter(Form("val%sP%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kP);
AliRsnCutValue *cutPK = new AliRsnCutValue(Form("cut%sP%s",AliPID::ParticleName(type2),opt.Data()),0.,PMax_K);
cutPK->SetTargetType(AliRsnTarget::kDaughter);
cutPK->SetValueObj(valPK);
cutsK->AddCut(cutPK);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPK->GetName();
}
Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
cutsK->SetCutScheme(scheme.Data());
// END KAON =======================================
if (opt.Contains("mon")) {
AddMonitorOutput(cutsP->GetMonitorOutput(),opt);
AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cutsP);
taskRsnMini->AddTrackCuts(cutsK);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cutsP, kTRUE);
sel->Add(cutsK, kTRUE);
}
return numberOfCuts;
}
/***************************************************************************
[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;
}
void SetRsnOutput(AliRsnMiniAnalysisTask *task, AliRsnCutSet *cutsPair,
ERsnCollisionType collisionType, Bool_t isMC,
ERsnQualityCutType qualityCutType,
ERsnDaughterCutType daughterCutType,
Double_t nSigmaKaon ,TString polarizationOpt) {
Int_t aodFilterBit = -1; // ESD
Bool_t useCrossedRows = kTRUE;
Bool_t trueOnly = kFALSE;
Bool_t useMixLS = kFALSE;
TString suffix = "";
AliRsnCutSetDaughterParticle::ERsnDaughterCutSet cutSetIDDaughter = AliRsnCutSetDaughterParticle::kNoCuts;
if (daughterCutType == ERsnDaughterCutType::kFastTPCpidNsigma)
cutSetIDDaughter = AliRsnCutSetDaughterParticle::kFastTPCpidNsigma;
AliRsnCutSetDaughterParticle *cutSetKaon = 0;
cutSetKaon = new AliRsnCutSetDaughterParticle(
TString::Format("cutK%i_%2.1fsigma", cutSetIDDaughter, nSigmaKaon).Data(),
cutSetIDDaughter, AliPID::kKaon, nSigmaKaon, -1.0, aodFilterBit,
useCrossedRows);
AliRsnCutTrackQuality *qualityCut = cutSetKaon->GetQualityCut();
if (qualityCutType == ERsnQualityCutType::k2010)
qualityCut->SetDefaults2010(useCrossedRows);
else
qualityCut->SetDefaults2011(useCrossedRows);
Int_t iCutK = task->AddTrackCuts(cutSetKaon);
TString monitorOpt = "";
Bool_t enableMonitor = kTRUE;
if (enableMonitor) {
Printf("======== Cut monitoring enabled");
gROOT->LoadMacro(
"$ALICE_PHYSICS/PWGLF/RESONANCES/macros/mini/AddMonitorOutput.C");
AddMonitorOutput(isMC, cutSetKaon->GetMonitorOutput(), monitorOpt.Data());
}
// -- Values ------------------------------------------------------------------------------------
/* invariant mass */ Int_t imID = task->CreateValue(AliRsnMiniValue::kInvMass,kFALSE);
/* IM difference */ Int_t diffID = task->CreateValue(AliRsnMiniValue::kInvMassDiff,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);
/* cos(theta) J */ Int_t ctjID = task->CreateValue(AliRsnMiniValue::kCosThetaJackson,kFALSE);
/* cos(theta) J (MC)*/ Int_t ctjmID = task->CreateValue(AliRsnMiniValue::kCosThetaJackson,kTRUE);
/* cos(theta) T */ Int_t cttID = task->CreateValue(AliRsnMiniValue::kCosThetaTransversity,kFALSE);
/* cos(theta) T (MC)*/ Int_t cttmID = task->CreateValue(AliRsnMiniValue::kCosThetaTransversity,kTRUE);
/* cos(theta) E */ Int_t cteID = task->CreateValue(AliRsnMiniValue::kCosThetaToEventPlane,kFALSE);
/* cos(theta) E (MC)*/ Int_t ctemID = task->CreateValue(AliRsnMiniValue::kCosThetaToEventPlane,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 [11]={!trueOnly,!trueOnly,!trueOnly,!trueOnly, isMC,isMC,isMC,isMC,isMC, useMixLS,useMixLS};
// Int_t useIM [11]={ 1 , 1 , 1 , 1 , 1 , 1 , 2 , 2 ,0 , 1 , 1 };
// TString name [11]={"Unlike","Mixing","LikePP","LikeMM","Trues" ,"TruesFine","TruesMM","TruesFineMM","Res" ,"MixingPP","MixingMM"};
// TString comp [11]={"PAIR" , "MIX" ,"PAIR" ,"PAIR" , "TRUE" , "TRUE" ,"TRUE" ,"TRUE" ,"TRUE" ,"MIX" ,"MIX" };
// TString output [11]={"SPARSE","SPARSE","SPARSE","SPARSE","SPARSE","SPARSE" ,"SPARSE" ,"SPARSE" ,"SPARSE","SPARSE" ,"SPARSE" };
// Int_t pdgCode[11]={333 , 333 ,333 ,333 , 333 , 333 ,333 ,333 ,333 , 333 ,333 };
// Char_t charge1[11]={'+' , '+' ,'+' ,'-' , '+' , '+' ,'+' , '+' ,'+' ,'+' ,'-' };
// Char_t charge2[11]={'-' , '-' ,'+' ,'-' , '-' , '-' ,'-' , '-' ,'-' ,'+' ,'-' };
const Int_t n = 7;
Bool_t use [n]={ 1, 1, 1, 1, isMC, isMC, isMC};
Int_t useIM [n]={ 1, 1, 1, 1, 1, 1, 0};
TString name [n]={ "Unlike", "Mixing", "LikePP", "LikeMM", "Trues", "Mother", "Res"};
TString comp [n]={ "PAIR" , "MIX", "PAIR" , "PAIR" , "TRUE", "MOTHER", "TRUE"};
TString output [n]={ "SPARSE", "SPARSE", "SPARSE", "SPARSE","SPARSE", "SPARSE", "SPARSE"};
Int_t pdgCode[n]={ 333, 333, 333, 333, 333, 333, 333};
Char_t charge1[n]={ '+', '+', '+', '-', '+', '+', '+'};
Char_t charge2[n]={ '-', '-', '+', '-', '-', '-', '-'};
for(Int_t i=0;i<n-1;i++){
if(!use[i]) continue;
AliRsnMiniOutput* out=task->CreateOutput(TString::Format("phi_%s%s",name[i].Data(),suffix.Data()).Data(),output[i].Data(),comp[i].Data());
out->SetDaughter(0, AliRsnDaughter::kKaon);
out->SetDaughter(1, AliRsnDaughter::kKaon);
if (comp[i].CompareTo("MOTHER")) {
out->SetCutID(0, iCutK);
out->SetCutID(1, iCutK);
out->SetCharge(0, charge1[i]);
out->SetCharge(1, charge2[i]);
}
// out->SetMotherPDG(pdgCode[i]);
out->SetMotherPDG(333);
out->SetMotherMass(1.019461);
out->SetPairCuts(cutsPair);
//axis X: invmass (or resolution)
if(useIM[i]==1) out->AddAxis(imID,215,0.985,1.2);
else out->AddAxis(diffID,200,-0.02,0.02);
//axis Y: transverse momentum of pair as default
out->AddAxis(ptID,200,0.,20.);//default use mother pt
// axis Z: centrality-multiplicity
if(collisionType!=kPP) out->AddAxis(centID,100,0.,100.);
else out->AddAxis(centID,160,0,160);
if (!isMC) {
if (polarizationOpt.Contains("J")) out->AddAxis(ctjID,20,-1.,1);
if (polarizationOpt.Contains("T")) out->AddAxis(cttID,20,-1.,1);
if (polarizationOpt.Contains("E")) out->AddAxis(cteID,20,-1.,1);
} else {
if (polarizationOpt.Contains("J")) out->AddAxis(ctjmID,20,-1.,1);
if (polarizationOpt.Contains("T")) out->AddAxis(cttmID,20,-1.,1);
if (polarizationOpt.Contains("E")) out->AddAxis(ctemID,20,-1.,1);
}
}
}
Int_t AddRsnDaughterCutsPhiNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler *rsnIH=0,AliAnalysisTaskSE *task=0)
{
if (!rsnIH) return 0;
Bool_t valid = kTRUE;
// Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);
TString rsnQualityCut = AliRsnTrainManager::GetGlobalStr("RsnQualityCut",valid);
Int_t isMC = AliRsnTrainManager::GetGlobalInt("IsMC",valid);
Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
Int_t isMixing = AliRsnTrainManager::GetGlobalInt("IsMixing",valid);
// experts only (don't touch)
Int_t isRsnDev = AliAnalysisManager::GetGlobalInt("rsnUseRSNParDev",valid);
// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
Int_t numberOfCuts = 1;
//---------------------------------------------
// Define single cuts
//---------------------------------------------
Printf("AliRsnCutPIDNSigma Option : %s",opt.Data());
Double_t nSigmaTPC=3.0;
Double_t nSigmaTOF=3.0;
Double_t etaMin=-0.8;
Double_t etaMax=0.8;
Double_t trackPtMin=0.;
Double_t trackPtMax=1.e10;
Int_t NclTPC=70;
Char_t DCAxyFormula[100]="0.0182+0.035/pt^1.01";
Bool_t useTPC_K=kFALSE;
Bool_t useTOF_K=kFALSE;
Bool_t rejectUnmatchedTOF_K=kTRUE;
Bool_t useTrackPtCut=kFALSE;
if (opt.Contains("qualityonly")) {
useTPC_K=kFALSE;
useTOF_K=kFALSE;
}
if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
if (opt.Contains("KTOFacceptUnmatched")) rejectUnmatchedTOF_K=kFALSE;
if (opt.Contains("KTPCnsig05")) nSigmaTPC = 0.5;
if (opt.Contains("KTPCnsig08")) nSigmaTPC = 0.8;
if (opt.Contains("KTPCnsig10")) nSigmaTPC = 1.0;
if (opt.Contains("KTPCnsig15")) nSigmaTPC = 1.5;
if (opt.Contains("KTPCnsig20")) nSigmaTPC = 2.0;
if (opt.Contains("KTPCnsig25")) nSigmaTPC = 2.5;
if (opt.Contains("KTPCnsig30")) nSigmaTPC = 3.0;
if (opt.Contains("KTPCnsig40")) nSigmaTPC = 4.0;
if (opt.Contains("KTPCnsig50")) nSigmaTPC = 5.0;
if (opt.Contains("KTPCnsig1000")) nSigmaTPC = 100.0;
if (opt.Contains("KTOFnsig10")) nSigmaTOF = 1.0;
if (opt.Contains("KTOFnsig15")) nSigmaTOF = 1.5;
if (opt.Contains("KTOFnsig20")) nSigmaTOF = 2.0;
if (opt.Contains("KTOFnsig25")) nSigmaTOF = 2.5;
if (opt.Contains("KTOFnsig30")) nSigmaTOF = 3.0;
if (opt.Contains("KTOFnsig40")) nSigmaTOF = 4.0;
if (opt.Contains("KTOFnsig50")) nSigmaTOF = 5.0;
if (opt.Contains("KTOFnsig1000")) nSigmaTOF = 100.0;
if (opt.Contains("trackPt")) {
useTrackPtCut = kTRUE;
if (opt.Contains("trackPtMin015")) trackPtMin = 0.15;
if (opt.Contains("trackPtMin02")) trackPtMin = 0.2;
if (opt.Contains("trackPtMin05")) trackPtMin = 0.5;
if (opt.Contains("trackPtMin06")) trackPtMin = 0.6;
if (opt.Contains("trackPtMax18")) trackPtMax = 1.8;
if (opt.Contains("trackPtMax20")) trackPtMax = 2.0;
if (opt.Contains("trackPtMax25")) trackPtMax = 2.5;
}
Bool_t usePDG=kFALSE;
if (opt.Contains("pdg")) {
Printf("Using PDG");
usePDG = kTRUE;
}
Bool_t useEta = kFALSE;
if (opt.Contains("eta")) {
for(int j=1;j<=9;j++) if(opt.Contains(Form("eta0%i",j))){etaMin=-0.1*j; etaMax=0.1*j;}
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinMinus0%i",j))) etaMin=-0.1*j;
if(opt.Contains("etaMin00")) etaMin=0.;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMinPlus0%i",j))) etaMin=0.1*j;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxMinus0%i",j))) etaMax=-0.1*j;
if(opt.Contains("etaMax00")) etaMax=0.;
for(int j=1;j<=9;j++) if(opt.Contains(Form("etaMaxPlus0%i",j))) etaMax=0.1*j;
Printf("Using ETA range (%.2f,%.2f)",etaMin,etaMax);
useEta = kTRUE;
}
Bool_t useNclTPC = kFALSE;
if (opt.Contains("NclTPC")) {
if (opt.Contains("NclTPC70")) NclTPC=70;
if (opt.Contains("NclTPC75")) NclTPC=75;
if (opt.Contains("NclTPC80")) NclTPC=80;
if (opt.Contains("NclTPC85")) NclTPC=85;
if (opt.Contains("NclTPC90")) NclTPC=90;
useNclTPC = kTRUE;
}
Bool_t useDCAxy = kFALSE;
if (opt.Contains("DCAxy")) {
if (opt.Contains("DCAxyFormula7s")) sprintf(DCAxyFormula,"0.0182+0.035/pt^1.01");
if (opt.Contains("DCAxyFormula6s")) sprintf(DCAxyFormula,"0.0156+0.03/pt^1.01");
if (opt.Contains("DCAxyFormula5s")) sprintf(DCAxyFormula,"0.013+0.025/pt^1.01");
useDCAxy = kTRUE;
}
//---------------------------------------------
// Combine cuts
//---------------------------------------------
TString cutname = "K_Phi";
if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
AliRsnCutSet *cuts = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
TString scheme="";
AliRsnCutTrackQuality *qualityCut = new AliRsnCutTrackQuality("cutQualityK");
if (!rsnQualityCut.IsNull()) {
AliESDtrackCuts *esdTK = RsnQualityCut(rsnQualityCut.Data());
if(useDCAxy) esdTK->SetMaxDCAToVertexXYPtDep(DCAxyFormula);
qualityCut->SetESDtrackCuts(esdTK);
} else {
if (useCommonQualityCut>=0) {
qualityCut->SetAODTestFilterBit(useCommonQualityCut);
if(useDCAxy) {qualityCut->SetCheckOnlyFilterBit(kFALSE); qualityCut->SetDCARPtFormula(DCAxyFormula);}
} else {
qualityCut->SetDefaults2010();
if(useDCAxy) qualityCut->SetDCARPtFormula(DCAxyFormula);
}
}
cuts->AddCut(qualityCut);
if (!scheme.IsNull()) scheme += "&";
scheme += qualityCut->GetName();
if (useTPC_K) {
AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutPIDNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
cutKTPC->SinglePIDRange(nSigmaTPC);
cuts->AddCut(cutKTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTPC->GetName();
}
if (useTOF_K) {
AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutPIDNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
cutKTOF->SinglePIDRange(nSigmaTOF);
cuts->AddCut(cutKTOF);
if(rejectUnmatchedTOF_K){
if (!scheme.IsNull()) scheme += "&";
scheme += cutKTOF->GetName();
}else{
AliRsnCutTOFMatch *cutKTOFMatch = new AliRsnCutTOFMatch("cutKTOFMatch");
cuts->AddCut(cutKTOFMatch);
if (!scheme.IsNull()) scheme += "&";
scheme += Form("(%s|(!%s))",cutKTOF->GetName(),cutKTOFMatch->GetName());
}
}
if (useEta) {
Printf("Adding ETA ...");
AliRsnValueDaughter *valEta = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
AliRsnCutValue *cutEta = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),etaMin,etaMax);
cutEta->SetTargetType(AliRsnTarget::kDaughter);
cutEta->SetValueObj(valEta);
cuts->AddCut(cutEta);
if (!scheme.IsNull()) scheme += "&";
scheme += cutEta->GetName();
}
if (useTrackPtCut) {
Printf("Adding Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
AliRsnValueDaughter *valTrackPt = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
AliRsnCutValue *cutTrackPt = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax);
cutTrackPt->SetTargetType(AliRsnTarget::kDaughter);
cutTrackPt->SetValueObj(valTrackPt);
cuts->AddCut(cutTrackPt);
if (!scheme.IsNull()) scheme += "&";
scheme += cutTrackPt->GetName();
}
if (useNclTPC) {
Printf("Adding NclTPC >= %i",NclTPC);
AliRsnValueDaughter *valNclTPC = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
AliRsnCutValue *cutNclTPC = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),NclTPC-0.1,1000.);
cutNclTPC->SetTargetType(AliRsnTarget::kDaughter);
cutNclTPC->SetValueObj(valNclTPC);
cuts->AddCut(cutNclTPC);
if (!scheme.IsNull()) scheme += "&";
scheme += cutNclTPC->GetName();
}
if (usePDG) {
Printf("Adding PDG ...");
AliRsnCutPID *cutPDG = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
cuts->AddCut(cutPDG);
if (!scheme.IsNull()) scheme += "&";
scheme += cutPDG->GetName();
}
Printf ("CUT Scheme is '%s'",scheme.Data());
cuts->SetCutScheme(scheme.Data());
if (opt.Contains("mon")) {
AddMonitorOutput(cuts->GetMonitorOutput(),opt);
}
if (isRsnMini) {
AliRsnMiniAnalysisTask *taskRsnMini = (AliRsnMiniAnalysisTask *)task;
if (taskRsnMini) {
taskRsnMini->AddTrackCuts(cuts);
}
} else {
AliRsnDaughterSelector *sel = rsnIH->GetSelector();
// sel->SetLabelCheck(kFALSE);
sel->Add(cuts, kTRUE);
if (isRsnDev>=0 && opt.Contains("pairPID")) {
AliRsnActPostDaughterSelection *pairPID = new AliRsnActPostDaughterSelection();
pairPID->SetID(0);
const char *fn="rsnRange.txt";
if (!gSystem->AccessPathName(fn)) {
TString minStr = gSystem->GetFromPipe(TString::Format("head -n 1 %s").Data());
TString maxStr = gSystem->GetFromPipe(TString::Format("tail -n 1 %s").Data());
pairPID->SetMass(minStr.Atof(),maxStr.Atof());
} else {
// pairPID->SetMass(1.01,1.03);
pairPID->SetMass(1.015,1.025);
pairPID->SetMass(1.019,1.021);
pairPID->SetMass(1.0195,1.0205);
pairPID->SetMass(1.1000,1.1005);
// pairPID->SetMass(1.1005,1.1010);
}
sel->AddAction(pairPID);
}
}
return numberOfCuts;
}
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;
}
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;
}
