AliRsnCutSet* PairCuts(AliRsnPairDef *support)
{
// for pairs we define a rapidity windows, defined through a cut
// --> NOTE: it needs a support AliRsnPairDef from which it takes the mass
AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY);
AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, kFALSE);
valRapidity->SetSupportObject(support);
cutRapidity->SetValueObj(valRapidity);
// cut set
AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
pairCuts->AddCut(cutRapidity);
pairCuts->SetCutScheme(cutRapidity->GetName());
}
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;
}
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;
}
Bool_t AddRsnEventComputations(Bool_t isMC, const char *options = "", const char *taskName = "RSNtask")
{
// ==================================================================================================================
// == PRELIMINARY OPERATIONS ========================================================================================
// ==================================================================================================================
// retrieve task from manager, using its name
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
AliRsnAnalysisTask *task = (AliRsnAnalysisTask*)mgr->GetTask(taskName);
if (!task) {
Error("RsnConfigMonitor", "Task not found");
return kFALSE;
}
TString opt(options);
opt.ToUpper();
opt.ReplaceAll(" ", "");
Bool_t central = opt.Contains("CENT");
Bool_t peripheral = opt.Contains("PERI");
// ==================================================================================================================
// == EVENT CUTS ====================================================================================================
// ==================================================================================================================
// event cuts are added directly to a cutSet in the task
// we create all and then add thos which are needed
// primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
// we switch on the check for pileup
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
cutVertex->SetCheckPileUp(kTRUE);
// centrality:
// - 2nd argument --> one of the centrality evaluation methods
// - 3rd, 4th argument --> centrality ranges in percentile (0-10 for central, 60-70 for peripheral)
AliRsnCutValue *cutCentrality = 0x0;
if (central)
cutCentrality = new AliRsnCutValue("cutCentral", AliRsnValue::kEventCentralityV0, 0.0, 10.0);
else if (peripheral)
cutCentrality = new AliRsnCutValue("cutPeripheral", AliRsnValue::kEventCentralityV0, 60.0, 70.0);
// primary vertex is always used
task->GetEventCuts()->AddCut(cutVertex);
// set cut scheme as AND of primary vertex and centrality, if initialized
if (cutCentrality) {
task->GetEventCuts()->AddCut(cutCentrality);
task->GetEventCuts()->SetCutScheme(Form("%s & %s", cutVertex->GetName(), cutCentrality->GetName()));
} else {
task->GetEventCuts()->SetCutScheme(cutVertex->GetName());
}
::Info("AddEventStuff", "Scheme for event cuts: %s", task->GetEventCuts()->GetCutScheme().Data());
// ==================================================================================================================
// == EVENT FUNCTIONS ===============================================================================================
// ==================================================================================================================
// we want to add an AliRsnFunction to compute multiplicity distribution
// it is needed in order to know how many events we have in each multiplicity bin
// axes
AliRsnValue *axisEvMultSPD = new AliRsnValue("MultSPD", AliRsnValue::kEventMultSPD, 0.0, 150.0, 1.0);
AliRsnValue *axisEvMultMC = new AliRsnValue("MultMC" , AliRsnValue::kEventMultMC , 0.0, 150.0, 1.0);
// create function and add axis
AliRsnFunction *fcnEv = new AliRsnFunction;
if (!fcnEv->AddAxis(axisEvMultSPD)) return kFALSE;
if (isMC && !fcnEv->AddAxis(axisEvMultMC)) return kFALSE;
// add functions to pairs
task->GetInfo()->AddEventFunction(fcnEv);
return kTRUE;
}
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;
}
//
// Test config macro for RSN package.
// It configures:
// 1) a monitor for all tracks passing quality cuts
// 2) a monitor for all tracks passing quality + PID cuts
// 3) an unlike-sign invariant-mass + pt distribution for K+K- pairs
//
Bool_t RsnConfigPhiKaonTest
(
AliRsnAnalysisTask *task,
Bool_t isMC
)
{
if (!task) {
::Error("RsnConfigPhiKaonTest.C", "NULL task");
return kFALSE;
}
const char *suffix = "test";
// ----------------------------------------------------------------------------------------------
// -- DEFINITIONS -------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// daughter definition for monitor loops
// since it is intended to loop over all 'track' like objects (in the sense that we exclude V0s and cascades),
// we initialize it using the constructor that requires an AliRsnDaughter::EType and a charge, but since
// we want to loop over both charges, we set it to anything which is not '+' '-' or '0', which are tokens for
// selecting only positive, only negative or only neutral
AliRsnDaughterDef *tracks = new AliRsnDaughterDef(AliRsnDaughter::kTrack, 0);
// definition of pair decay tree for phi resonance
// here we *must* specify a particle species and a charge, in order to check the decay tree
// last arguments are the PDG code and nominal mass of the resonance, which are needed when
// one wants to select true pairs only and/or he wants to compute rapidity or Mt
AliRsnPairDef *pairDef = new AliRsnPairDef(AliRsnDaughter::kKaon, '+', AliRsnDaughter::kKaon, '-', 333, 1.019455);
// definition of loop objects:
// (a) 1 monitor for all tracks passing quality cuts
// (b) 1 monitor for all tracks passing quality+PID cuts
// (c) 1 pair filled with all tracks passing same cuts as (b)
// (d) 1 pair like (c) but for mixing
// (e) 1 pair like (c) but with true pairs only
// NOTE: (c) and (d) are instantiated with same settings, they will be made
// different after some settings done in second moment
AliRsnLoopDaughter *loopQuality = new AliRsnLoopDaughter(Form("%s_mon_quality", suffix), 0, tracks);
AliRsnLoopDaughter *loopPID = new AliRsnLoopDaughter(Form("%s_mon_pid" , suffix), 0, tracks);
AliRsnLoopPair *loopPhi = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef);
AliRsnLoopPair *loopPhiMix = new AliRsnLoopPair (Form("%s_unlike" , suffix), pairDef);
AliRsnLoopPair *loopPhiTrue = new AliRsnLoopPair (Form("%s_trues" , suffix), pairDef);
// set additional option for true pairs (slot [0])
loopPhiTrue->SetOnlyTrue(kTRUE);
loopPhiTrue->SetCheckDecay(kTRUE);
// set mixing options
loopPhi ->SetMixed(kFALSE);
loopPhiMix ->SetMixed(kTRUE);
loopPhiTrue->SetMixed(kFALSE);
// assign the ID of the entry lists to be used by each pair to get selected daughters
// in our case, the AliRsnInputHandler contains only one list for selecting kaons
Int_t idQuality, idPID;
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
AliMultiInputEventHandler *multi = dynamic_cast<AliMultiInputEventHandler*>(mgr->GetInputEventHandler());
if (!multi) {
myError("Needed a multi input handler!");
return kFALSE;
}
TObjArray *array = multi->InputEventHandlers();
AliRsnInputHandler *rsn = (AliRsnInputHandler*)array->FindObject("rsnInputHandler");
if (!rsn) {
myError("Needed an RSN event handler");
return kFALSE;
}
AliRsnDaughterSelector *sel = rsn->GetSelector();
idQuality = sel->GetID("qualityTPC", kTRUE);
idPID = sel->GetID("kaonTPC", kTRUE);
if (idQuality < 0 || idPID < 0) {
myError("List problems");
return kFALSE;
}
loopQuality->SetListID(idQuality);
loopPID ->SetListID(idPID);
loopPhi ->SetListID(0, idPID);
loopPhi ->SetListID(1, idPID);
loopPhiMix ->SetListID(0, idPID);
loopPhiMix ->SetListID(1, idPID);
loopPhiTrue->SetListID(0, idPID);
loopPhiTrue->SetListID(1, idPID);
// ----------------------------------------------------------------------------------------------
// -- EVENT CUTS --------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// primary vertex:
// - 2nd argument --> |Vz| range
// - 3rd argument --> minimum required number of contributors
// - 4th argument --> tells if TPC stand-alone vertexes must be accepted
// we switch on the check for pileup
AliRsnCutPrimaryVertex *cutVertex = new AliRsnCutPrimaryVertex("cutVertex", 10.0, 0, kFALSE);
cutVertex->SetCheckPileUp(kTRUE);
// primary vertex is always used
AliRsnCutSet *eventCuts = new AliRsnCutSet("eventCuts", AliRsnTarget::kEvent);
eventCuts->AddCut(cutVertex);
eventCuts->SetCutScheme(cutVertex->GetName());
// add the event cuts to all loops
loopQuality->SetEventCuts(eventCuts);
loopPID ->SetEventCuts(eventCuts);
loopPhi ->SetEventCuts(eventCuts);
loopPhi ->SetEventCuts(eventCuts);
loopPhiMix ->SetEventCuts(eventCuts);
loopPhiMix ->SetEventCuts(eventCuts);
loopPhiTrue->SetEventCuts(eventCuts);
loopPhiTrue->SetEventCuts(eventCuts);
// ----------------------------------------------------------------------------------------------
// -- PAIR CUTS ---------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
// for pairs we define a rapidity windows, defined through a cut
// --> NOTE: it needs a support AliRsnPairDef from which it takes the mass
AliRsnValueStd *valRapidity = new AliRsnValueStd("valY", AliRsnValueStd::kPairY);
AliRsnCutValue *cutRapidity = new AliRsnCutValue("cutY", -0.5, 0.5, isMC);
valRapidity->SetSupportObject(pairDef);
cutRapidity->SetValueObj(valRapidity);
// cut set
AliRsnCutSet *pairCuts = new AliRsnCutSet("pairCuts", AliRsnTarget::kMother);
pairCuts->AddCut(cutRapidity);
pairCuts->SetCutScheme(cutRapidity->GetName());
// add cut to pair loops only
loopPhi ->SetPairCuts(pairCuts);
loopPhi ->SetPairCuts(pairCuts);
loopPhiMix ->SetPairCuts(pairCuts);
loopPhiMix ->SetPairCuts(pairCuts);
loopPhiTrue->SetPairCuts(pairCuts);
loopPhiTrue->SetPairCuts(pairCuts);
// ----------------------------------------------------------------------------------------------
// -- COMPUTED VALUES & OUTPUTS -----------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
AliRsnValueStd *axisIM = new AliRsnValueStd("IM" , AliRsnValueStd::kPairInvMass , 0.9, 1.4, 0.001);
AliRsnValueStd *axisPt = new AliRsnValueStd("PT" , AliRsnValueStd::kPairPt , 0.0, 5.0, 0.1 );
AliRsnValueStd *axisMomTPC = new AliRsnValueStd("pTPC", AliRsnValueStd::kTrackPtpc , 0.0, 5.0, 0.01 );
AliRsnValueStd *axisSigTPC = new AliRsnValueStd("sTPC", AliRsnValueStd::kTrackTPCsignal, 0.0, 500.0, 2.0 );
// output for monitors:
// 2D histogram with TPC signal vs TPC momentum
AliRsnListOutput *outMonitor = new AliRsnListOutput("mon", AliRsnListOutput::kHistoDefault);
outMonitor->AddValue(axisMomTPC);
outMonitor->AddValue(axisSigTPC);
// output for pairs:
// 2D histogram with inv.mass vs pt
AliRsnListOutput *outPair = new AliRsnListOutput("pair", AliRsnListOutput::kHistoDefault);
outPair->AddValue(axisIM);
outPair->AddValue(axisPt);
// add outputs to loops
loopQuality->AddOutput(outMonitor);
loopPID ->AddOutput(outMonitor);
loopPhi ->AddOutput(outPair);
loopPhiMix ->AddOutput(outPair);
loopPhiTrue->AddOutput(outPair);
// ----------------------------------------------------------------------------------------------
// -- CONCLUSION --------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------------
task->Add(loopQuality);
task->Add(loopPID );
task->Add(loopPhi );
task->Add(loopPhiMix );
task->Add(loopPhiTrue);
return kTRUE;
}
