[u/mrichter/AliRoot.git] / PWGLF / RESONANCES / macros / lego_train / AddRsnDaughterCutsKStarNsigma.C

#ifndef __CINT__
#include <Rtypes.h>
#endif
Int_t AddRsnDaughterCutsKStarNsigma(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);
   Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
   Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);

   // === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
   Int_t numberOfCuts = 2;

   //---------------------------------------------
   //  Define single cutsP
   //---------------------------------------------

   Printf("AddRsnDaughterCutsKStarNsigma 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 etaRange=0.8;

   //defaults
   Double_t trackPtMin=0.15;
   Double_t trackPtMax=1.e20;
   Int_t NclTPC=70;
   Char_t DCAxyFormula[100]="0.0182+0.035/pt^1.01";
   Bool_t useTrackPtCut=kFALSE;

   Bool_t useTPC_Pi=kFALSE;
   Bool_t useTOF_Pi=kFALSE;
   Bool_t useTPC_K=kFALSE;
   Bool_t useTOF_K=kFALSE;

   if (opt.Contains("qualityonly")) {
      useTPC_Pi=kFALSE;
      useTOF_Pi=kFALSE;
      useTPC_K=kFALSE;
      useTOF_K=kFALSE;
   } else if (!opt.Contains("nsig")) {
      useTPC_Pi=kTRUE;
      useTOF_Pi=kTRUE;
      useTPC_K=kTRUE;
      useTOF_K=kTRUE;
   }

   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("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;
   }

   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 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;
      if (opt.Contains("NclTPC100")) NclTPC=100;
      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;
   }

   // KAON SETTINGS =======================================
   TString scheme="";
   TString cutname = "K_Kstar";
   if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
   AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);

   AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
   if (useCommonQualityCut>=0) {
      qualityCutK->SetAODTestFilterBit(useCommonQualityCut);
      if(useDCAxy) {qualityCutK->SetCheckOnlyFilterBit(kFALSE); qualityCutK->SetDCARPtFormula(DCAxyFormula);}
   } else {
      qualityCutK->SetDefaults2010();
      if(useDCAxy) qualityCutK->SetDCARPtFormula(DCAxyFormula);
   }
   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 (useTrackPtCut) {
      Printf("Adding K Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
      AliRsnValueDaughter *valTrackPtK = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kPt);

      AliRsnCutValue *cutTrackPtK = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type2),opt.Data()),trackPtMin,trackPtMax);
      cutTrackPtK->SetTargetType(AliRsnTarget::kDaughter);
      cutTrackPtK->SetValueObj(valTrackPtK);
      cutsK->AddCut(cutTrackPtK);
      if (!scheme.IsNull()) scheme += "&";
      scheme += cutTrackPtK->GetName();
   }

   if (useNclTPC) {
      Printf("Adding NclTPC >= %i",NclTPC);
      AliRsnValueDaughter *valNclTPCK = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
      AliRsnCutValue *cutNclTPCK = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type2),opt.Data()),NclTPC,1000.);
      cutNclTPCK->SetTargetType(AliRsnTarget::kDaughter);
      cutNclTPCK->SetValueObj(valNclTPCK);
      cutsK->AddCut(cutNclTPCK);
      if (!scheme.IsNull()) scheme += "&";
      scheme += cutNclTPCK->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 *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);

   AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi");
   if (useCommonQualityCut>=0) {
      qualityCutPi->SetAODTestFilterBit(useCommonQualityCut);
      if(useDCAxy) {qualityCutPi->SetCheckOnlyFilterBit(kFALSE); qualityCutPi->SetDCARPtFormula(DCAxyFormula);}
   } else {
      qualityCutPi->SetDefaults2010();
      if(useDCAxy) qualityCutPi->SetDCARPtFormula(DCAxyFormula);
   }
   cutsP->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);
      cutsP->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);
      cutsP->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);
      cutsP->AddCut(cutEtaP);
      if (!scheme.IsNull()) scheme += "&";
      scheme += cutEtaP->GetName();
   }

   if (useTrackPtCut) {
      Printf("Adding Pi Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
      AliRsnValueDaughter *valTrackPtP = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);

      AliRsnCutValue *cutTrackPtP = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax);
      cutTrackPtP->SetTargetType(AliRsnTarget::kDaughter);
      cutTrackPtP->SetValueObj(valTrackPtP);
      cutsP->AddCut(cutTrackPtP);
      if (!scheme.IsNull()) scheme += "&";
      scheme += cutTrackPtP->GetName();
   }

   if (useNclTPC) {
      Printf("Adding NclTPC Pi >= %i",NclTPC);
      AliRsnValueDaughter *valNclTPCP = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
      AliRsnCutValue *cutNclTPCP = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),NclTPC,1000.);
      cutNclTPCP->SetTargetType(AliRsnTarget::kDaughter);
      cutNclTPCP->SetValueObj(valNclTPCP);
      cutsP->AddCut(cutNclTPCP);
      if (!scheme.IsNull()) scheme += "&";
      scheme += cutNclTPCP->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();
   }

   Printf ("CUT Scheme for PION is '%s'",scheme.Data());
   cutsP->SetCutScheme(scheme.Data());

   // END PROTON =======================================


   if (opt.Contains("mon")) {
      AddMonitorOutput(cutsP->GetMonitorOutput(),opt);
      AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
   }
   if (isRsnMini) {
      AliRsnMiniAnalysisTask *taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask *>(task);
      if (taskRsnMini) {
         taskRsnMini->AddTrackCuts(cutsK);
         taskRsnMini->AddTrackCuts(cutsP);

      }
   } else {
      AliRsnDaughterSelector *sel = rsnIH->GetSelector();
      //       sel->SetLabelCheck(kFALSE);
      sel->Add(cutsP, kTRUE);
      sel->Add(cutsK, kTRUE);
   }
   return numberOfCuts;

}
Commit	Line	Data
221dc8d3	1	#ifndef __CINT__
	2	#include <Rtypes.h>
	3	#endif
	4	Int_t AddRsnDaughterCutsKStarNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,AliRsnInputHandler rsnIH=0,AliAnalysisTaskSE task=0)
	5	{
	6
	7	if (!rsnIH) return 0;
	8
	9	Bool_t valid;
	10	Int_t isRsnMini = AliRsnTrainManager::GetGlobalInt("IsRsnMini",valid);
	11	Int_t collisionType = AliRsnTrainManager::GetGlobalInt("IsCollisionType",valid);
	12	Int_t useCommonQualityCut = AliRsnTrainManager::GetGlobalInt("RsnCommonQualityCut",valid);
	13
	14	// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
	15	Int_t numberOfCuts = 2;
	16
	17	//---------------------------------------------
	18	// Define single cutsP
	19	//---------------------------------------------
	20
	21	Printf("AddRsnDaughterCutsKStarNsigma Option : %s",opt.Data());
	22
	23
	24	// default values
	25	Double_t nSigmaTPC_Pi=3.0;
	26	Double_t nSigmaTPC_K=3.0;
	27	Double_t nSigmaTOF_Pi=3.0;
	28	Double_t nSigmaTOF_K=3.0;
	29	Double_t etaRange=0.8;
	30
680e4375	31	//defaults
	32	Double_t trackPtMin=0.15;
	33	Double_t trackPtMax=1.e20;
	34	Int_t NclTPC=70;
	35	Char_t DCAxyFormula[100]="0.0182+0.035/pt^1.01";
	36	Bool_t useTrackPtCut=kFALSE;
	37
221dc8d3	38	Bool_t useTPC_Pi=kFALSE;
	39	Bool_t useTOF_Pi=kFALSE;
	40	Bool_t useTPC_K=kFALSE;
	41	Bool_t useTOF_K=kFALSE;
	42
	43	if (opt.Contains("qualityonly")) {
	44	useTPC_Pi=kFALSE;
	45	useTOF_Pi=kFALSE;
	46	useTPC_K=kFALSE;
	47	useTOF_K=kFALSE;
	48	} else if (!opt.Contains("nsig")) {
	49	useTPC_Pi=kTRUE;
	50	useTOF_Pi=kTRUE;
	51	useTPC_K=kTRUE;
	52	useTOF_K=kTRUE;
	53	}
	54
	55	if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
	56	if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
	57	if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
	58	if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
	59
	60	if (opt.Contains("PiTPCnsig10")) nSigmaTPC_Pi = 1.0;
	61	if (opt.Contains("PiTPCnsig15")) nSigmaTPC_Pi = 1.5;
	62	if (opt.Contains("PiTPCnsig20")) nSigmaTPC_Pi = 2.0;
	63	if (opt.Contains("PiTPCnsig25")) nSigmaTPC_Pi = 2.5;
	64	if (opt.Contains("PiTPCnsig30")) nSigmaTPC_Pi = 3.0;
	65
	66	if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
	67	if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
	68	if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
	69	if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
	70	if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
	71
	72	if (opt.Contains("PiTOFnsig10")) nSigmaTOF_Pi = 1.0;
	73	if (opt.Contains("PiTOFnsig15")) nSigmaTOF_Pi = 1.5;
	74	if (opt.Contains("PiTOFnsig20")) nSigmaTOF_Pi = 2.0;
	75	if (opt.Contains("PiTOFnsig25")) nSigmaTOF_Pi = 2.5;
	76	if (opt.Contains("PiTOFnsig30")) nSigmaTOF_Pi = 3.0;
	77
	78	if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
	79	if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
	80	if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
	81	if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
	82	if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
	83
	84
	85	Bool_t usePDG=kFALSE;
	86	if (opt.Contains("pdg")) {
	87	Printf("Using PDG");
	88	usePDG = kTRUE;
	89	}
	90
	91	Bool_t useEta = kFALSE;
	92	if (opt.Contains("eta")) {
	93	Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
	94	useEta = kTRUE;
	95	}
	96
680e4375	97	if (opt.Contains("trackPt")) {
	98	useTrackPtCut = kTRUE;
	99	if (opt.Contains("trackPtMin015")) trackPtMin = 0.15;
	100	if (opt.Contains("trackPtMin02")) trackPtMin = 0.2;
	101	if (opt.Contains("trackPtMin05")) trackPtMin = 0.5;
	102	if (opt.Contains("trackPtMin06")) trackPtMin = 0.6;
	103
	104	if (opt.Contains("trackPtMax18")) trackPtMax = 1.8;
	105	if (opt.Contains("trackPtMax20")) trackPtMax = 2.0;
	106	if (opt.Contains("trackPtMax25")) trackPtMax = 2.5;
	107	}
	108
	109	Bool_t useNclTPC = kFALSE;
	110	if (opt.Contains("NclTPC")) {
	111	if (opt.Contains("NclTPC70")) NclTPC=70;
	112	if (opt.Contains("NclTPC75")) NclTPC=75;
	113	if (opt.Contains("NclTPC80")) NclTPC=80;
	114	if (opt.Contains("NclTPC85")) NclTPC=85;
	115	if (opt.Contains("NclTPC90")) NclTPC=90;
	116	if (opt.Contains("NclTPC100")) NclTPC=100;
	117	useNclTPC = kTRUE;
	118	}
	119
	120	Bool_t useDCAxy = kFALSE;
	121	if (opt.Contains("DCAxy")) {
	122	if (opt.Contains("DCAxyFormula7s")) sprintf(DCAxyFormula,"0.0182+0.035/pt^1.01");
	123	if (opt.Contains("DCAxyFormula6s")) sprintf(DCAxyFormula,"0.0156+0.03/pt^1.01");
	124	if (opt.Contains("DCAxyFormula5s")) sprintf(DCAxyFormula,"0.013+0.025/pt^1.01");
	125	useDCAxy = kTRUE;
	126	}
	127
221dc8d3	128	// KAON SETTINGS =======================================
	129	TString scheme="";
	130	TString cutname = "K_Kstar";
	131	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
	132	AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
	133
	134	AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
	135	if (useCommonQualityCut>=0) {
	136	qualityCutK->SetAODTestFilterBit(useCommonQualityCut);
680e4375	137	if(useDCAxy) {qualityCutK->SetCheckOnlyFilterBit(kFALSE); qualityCutK->SetDCARPtFormula(DCAxyFormula);}
221dc8d3	138	} else {
221dc8d3	139	qualityCutK->SetDefaults2010();
680e4375	140	if(useDCAxy) qualityCutK->SetDCARPtFormula(DCAxyFormula);
221dc8d3	141	}
	142	cutsK->AddCut(qualityCutK);
	143	if (!scheme.IsNull()) scheme += "&";
	144	scheme += qualityCutK->GetName();
	145
	146	if (useTPC_K) {
	147	AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	148	cutKTPC->SinglePIDRange(nSigmaTPC_K);
	149	cutsK->AddCut(cutKTPC);
	150	if (!scheme.IsNull()) scheme += "&";
	151	scheme += cutKTPC->GetName();
	152	}
	153
	154	if (useTOF_K) {
	155	AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
	156	cutKTOF->SinglePIDRange(nSigmaTOF_K);
	157	cutsK->AddCut(cutKTOF);
	158	if (!scheme.IsNull()) scheme += "&";
	159	scheme += cutKTOF->GetName();
	160	}
	161	if (useEta) {
	162	AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
	163	AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
	164	cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
	165	cutEtaK->SetValueObj(valEtaK);
	166	cutsK->AddCut(cutEtaK);
	167	if (!scheme.IsNull()) scheme += "&";
	168	scheme += cutEtaK->GetName();
	169	}
680e4375	170
	171	if (useTrackPtCut) {
	172	Printf("Adding K Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
	173	AliRsnValueDaughter *valTrackPtK = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kPt);
	174
	175	AliRsnCutValue *cutTrackPtK = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type2),opt.Data()),trackPtMin,trackPtMax);
	176	cutTrackPtK->SetTargetType(AliRsnTarget::kDaughter);
	177	cutTrackPtK->SetValueObj(valTrackPtK);
	178	cutsK->AddCut(cutTrackPtK);
	179	if (!scheme.IsNull()) scheme += "&";
	180	scheme += cutTrackPtK->GetName();
	181	}
	182
	183	if (useNclTPC) {
	184	Printf("Adding NclTPC >= %i",NclTPC);
	185	AliRsnValueDaughter *valNclTPCK = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
	186	AliRsnCutValue *cutNclTPCK = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type2),opt.Data()),NclTPC,1000.);
	187	cutNclTPCK->SetTargetType(AliRsnTarget::kDaughter);
	188	cutNclTPCK->SetValueObj(valNclTPCK);
	189	cutsK->AddCut(cutNclTPCK);
	190	if (!scheme.IsNull()) scheme += "&";
	191	scheme += cutNclTPCK->GetName();
	192	}
	193
221dc8d3	194	if (usePDG) {
	195	AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
	196	cutsK->AddCut(cutPDGK);
	197	if (!scheme.IsNull()) scheme += "&";
	198	scheme += cutPDGK->GetName();
	199	}
	200
	201	Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
	202	cutsK->SetCutScheme(scheme.Data());
	203
	204	// END KAON =======================================
	205
	206	// Pion SETTINGS ===========================================
	207
	208	scheme="";
	209	cutname = "Pi_Kstar";
	210	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
	211	AliRsnCutSet *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
	212
	213	AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi");
	214	if (useCommonQualityCut>=0) {
	215	qualityCutPi->SetAODTestFilterBit(useCommonQualityCut);
680e4375	216	if(useDCAxy) {qualityCutPi->SetCheckOnlyFilterBit(kFALSE); qualityCutPi->SetDCARPtFormula(DCAxyFormula);}
221dc8d3	217	} else {
221dc8d3	218	qualityCutPi->SetDefaults2010();
680e4375	219	if(useDCAxy) qualityCutPi->SetDCARPtFormula(DCAxyFormula);
221dc8d3	220	}
	221	cutsP->AddCut(qualityCutPi);
	222	if (!scheme.IsNull()) scheme += "&";
	223	scheme += qualityCutPi->GetName();
	224	if (useTPC_Pi) {
	225	AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
	226	cutPiTPC->SinglePIDRange(nSigmaTPC_Pi);
	227	cutsP->AddCut(cutPiTPC);
	228	if (!scheme.IsNull()) scheme += "&";
	229	scheme += cutPiTPC->GetName();
	230	}
	231	if (useTOF_Pi) {
	232	AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
	233	cutPiTOF->SinglePIDRange(nSigmaTOF_Pi);
	234	cutsP->AddCut(cutPiTOF);
	235	if (!scheme.IsNull()) scheme += "&";
	236	scheme += cutPiTOF->GetName();
	237	}
	238	if (useEta) {
	239	AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
	240	AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
	241	cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
	242	cutEtaP->SetValueObj(valEtaP);
	243	cutsP->AddCut(cutEtaP);
	244	if (!scheme.IsNull()) scheme += "&";
	245	scheme += cutEtaP->GetName();
	246	}
680e4375	247
	248	if (useTrackPtCut) {
	249	Printf("Adding Pi Pt min=%.3f max=%.3f ...",trackPtMin,trackPtMax);
	250	AliRsnValueDaughter *valTrackPtP = new AliRsnValueDaughter(Form("val%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kPt);
	251
	252	AliRsnCutValue *cutTrackPtP = new AliRsnCutValue(Form("cut%sTrackPt%s",AliPID::ParticleName(type1),opt.Data()),trackPtMin,trackPtMax);
	253	cutTrackPtP->SetTargetType(AliRsnTarget::kDaughter);
	254	cutTrackPtP->SetValueObj(valTrackPtP);
	255	cutsP->AddCut(cutTrackPtP);
	256	if (!scheme.IsNull()) scheme += "&";
	257	scheme += cutTrackPtP->GetName();
	258	}
	259
	260	if (useNclTPC) {
	261	Printf("Adding NclTPC Pi >= %i",NclTPC);
	262	AliRsnValueDaughter *valNclTPCP = new AliRsnValueDaughter(Form("val%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kNTPCclusters);
	263	AliRsnCutValue *cutNclTPCP = new AliRsnCutValue(Form("cut%sNclTPC%s",AliPID::ParticleName(type1),opt.Data()),NclTPC,1000.);
	264	cutNclTPCP->SetTargetType(AliRsnTarget::kDaughter);
	265	cutNclTPCP->SetValueObj(valNclTPCP);
	266	cutsP->AddCut(cutNclTPCP);
	267	if (!scheme.IsNull()) scheme += "&";
	268	scheme += cutNclTPCP->GetName();
	269	}
221dc8d3	270	if (usePDG) {
	271	AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
	272	cutsP->AddCut(cutPDGP);
	273	if (!scheme.IsNull()) scheme += "&";
	274	scheme += cutPDGP->GetName();
	275	}
	276
	277	Printf ("CUT Scheme for PION is '%s'",scheme.Data());
	278	cutsP->SetCutScheme(scheme.Data());
	279
	280	// END PROTON =======================================
	281
	282
	283
	284	if (opt.Contains("mon")) {
	285	AddMonitorOutput(cutsP->GetMonitorOutput(),opt);
	286	AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
	287	}
	288	if (isRsnMini) {
	289	AliRsnMiniAnalysisTask taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask >(task);
	290	if (taskRsnMini) {
	291	taskRsnMini->AddTrackCuts(cutsK);
	292	taskRsnMini->AddTrackCuts(cutsP);
	293
	294	}
	295	} else {
	296	AliRsnDaughterSelector *sel = rsnIH->GetSelector();
680e4375	297	// sel->SetLabelCheck(kFALSE);
221dc8d3	298	sel->Add(cutsP, kTRUE);
	299	sel->Add(cutsK, kTRUE);
	300	}
	301	return numberOfCuts;
	302
	303	}