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

#ifndef __CINT__
#include <Rtypes.h>
#endif
Int_t AddRsnDaughterCutsKStarTOFanalysis(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 = 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;

}
Commit	Line	Data
b8e377df	1	#ifndef __CINT__
	2	#include <Rtypes.h>
	3	#endif
	4	Int_t AddRsnDaughterCutsKStarTOFanalysis(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler rsnIH=0,AliAnalysisTaskSE task=0)
	5	{
	6
	7	if (!rsnIH) return 0;
	8
	9	Bool_t valid = kTRUE;
	10	Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
	11
	12	Bool_t usePPCut = kFALSE;
	13
	14	if (isPP && (opt.Contains("usePP"))) usePPCut = kTRUE;
	15
	16
	17	// === USER HAS TO SET CORRECT NUMBER OF CUTS SETS =====
	18	Int_t numberOfCuts = 2;
	19
	20	//---------------------------------------------
	21	// Define single cutsP
	22	//---------------------------------------------
	23	Printf("AddRsnDaughterCutsKStarTOFanalysis Option : %s",opt.Data());
	24
	25
	26	// default values
	27	Double_t nSigmaTPC_Pi=3.0;
	28	Double_t nSigmaTPC_K=3.0;
	29	Double_t nSigmaTOF_Pi=3.0;
	30	Double_t nSigmaTOF_K=3.0;
	31	Double_t nSigmaTPCveto_Pi=5.0;
	32	Double_t nSigmaTPCveto_K=5.0;
	33	Double_t etaRange=0.8;
	34
	35	Bool_t useTPC_Pi=kFALSE;
	36	Bool_t useTOF_Pi=kFALSE;
	37	Bool_t useTPC_K=kFALSE;
	38	Bool_t useTOF_K=kFALSE;
	39	Bool_t useTPCveto_Pi = kFALSE;
	40	Bool_t useTPCveto_K = kFALSE;
	41	Bool_t useCombined_Pi = kFALSE;
	42	Bool_t useCombined_K = kFALSE;
	43
	44	if (opt.Contains("qualityonly")) {
	45	useTPC_Pi=kFALSE;
	46	useTOF_Pi=kFALSE;
	47	useTPC_K=kFALSE;
	48	useTOF_K=kFALSE;
	49	useTPCveto_Pi = kFALSE;
	50	useTPCveto_K = kFALSE;
	51	useCombined_Pi = kFALSE;
	52	useCombined_K = kFALSE;
	53	} else {
	54	if (opt.Contains("combined")) {
	55	useCombined_Pi = kTRUE;
	56	useCombined_K = kTRUE;
	57	} else {
	58	if (opt.Contains("PiTPCnsig")) useTPC_Pi=kTRUE;
	59	if (opt.Contains("PiTOFnsig")) useTOF_Pi=kTRUE;
	60	if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
	61	if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
	62	if(opt.Contains("TPCveto")) {
	63	useTPCveto_Pi = kTRUE;
	64	useTPCveto_K = kTRUE;
65	nSigmaTPCveto_Pi = 5.0;
66	nSigmaTPCveto_K = 5.0;
67	}
68	}
69	}
70
71	if (opt.Contains("PiTPCnsig10")) nSigmaTPC_Pi = 1.0;
72	if (opt.Contains("PiTPCnsig15")) nSigmaTPC_Pi = 1.5;
73	if (opt.Contains("PiTPCnsig20")) nSigmaTPC_Pi = 2.0;
74	if (opt.Contains("PiTPCnsig25")) nSigmaTPC_Pi = 2.5;
75	if (opt.Contains("PiTPCnsig30")) nSigmaTPC_Pi = 3.0;
76
77	if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
78	if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
79	if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
80	if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
81	if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
82
83	if (opt.Contains("PiTOFnsig10")) nSigmaTOF_Pi = 1.0;
84	if (opt.Contains("PiTOFnsig15")) nSigmaTOF_Pi = 1.5;
85	if (opt.Contains("PiTOFnsig20")) nSigmaTOF_Pi = 2.0;
86	if (opt.Contains("PiTOFnsig25")) nSigmaTOF_Pi = 2.5;
87	if (opt.Contains("PiTOFnsig30")) nSigmaTOF_Pi = 3.0;
88
89	if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
90	if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
91	if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
92	if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
93	if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
94
95
96	Bool_t usePDG=kFALSE;
97	if (opt.Contains("pdg")) {
98	Printf("Using PDG");
99	usePDG = kTRUE;
100	}
101
102	Bool_t useEta = kFALSE;
103	if (opt.Contains("eta")) {
104	Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
105	useEta = kTRUE;
106	}
107
108	// KAON SETTINGS =======================================
109	TString scheme="";
110	TString cutname = "K_Kstar";
111	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
112	AliRsnCutSet *cutsK;
113
114	if (useCombined_K) {
115	cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kKaon, nSigmaTOF_K, 5);
116	if (!scheme.IsNull()) scheme += "&";
117	scheme += cutsK->GetCutScheme();
118	} else {
119	if (useTPCveto_K) {
120	cutsK = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kKaon, nSigmaTOF_K, 5);
121	if (!scheme.IsNull()) scheme += "&";
122	scheme += cutsK->GetCutScheme();
123	} else {
124	cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
125
126	AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
127	qualityCutK->SetDefaults2010();
128	cutsK->AddCut(qualityCutK);
129	if (!scheme.IsNull()) scheme += "&";
130	scheme += qualityCutK->GetName();
131
132	if (useTPC_K) {
133	AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
134	cutKTPC->SinglePIDRange(nSigmaTPC_K);
135	cutsK->AddCut(cutKTPC);
136	if (!scheme.IsNull()) scheme += "&";
137	scheme += cutKTPC->GetName();
138	}
139
140	if (useTOF_K) {
141	AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
142	cutKTOF->SinglePIDRange(nSigmaTOF_K);
143	cutsK->AddCut(cutKTOF);
144	if (!scheme.IsNull()) scheme += "&";
145	scheme += cutKTOF->GetName();
146	}
147	}
148	}
149
150	if (useEta) {
151	AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
152	AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
153	cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
154	cutEtaK->SetValueObj(valEtaK);
155	cutsK->AddCut(cutEtaK);
156	if (!scheme.IsNull()) scheme += "&";
157	scheme += cutEtaK->GetName();
158	}
159	if (usePDG) {
160	AliRsnCutPID *cutPDGK = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type2),opt.Data()),type2,0.0,kTRUE);
161	cutsK->AddCut(cutPDGK);
162	if (!scheme.IsNull()) scheme += "&";
163	scheme += cutPDGK->GetName();
164	}
165
166	Printf ("CUT Scheme for KAON is '%s'",scheme.Data());
167	cutsK->SetCutScheme(scheme.Data());
168
169	// END KAON =======================================
170
171	// Pion SETTINGS ===========================================
172
173	scheme="";
174	cutname = "Pi_Kstar";
175	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
176	AliRsnCutSet *cutsPi;
177
178	if (useCombined_Pi) {
179	cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTPCTOFpidKstarPP2010, AliPID::kPion, nSigmaTOF_Pi, 5);
180	if (!scheme.IsNull()) scheme += "&";
181	scheme += cutsPi->GetCutScheme();
182	} else {
183	if (useTPCveto_Pi) {
184	cutsPi = new AliRsnCutSetDaughterParticle(cutname.Data(), AliRsnCutSetDaughterParticle::kTOFpidKstarPbPb2010, AliPID::kPion, nSigmaTOF_Pi, 5);
185	if (!scheme.IsNull()) scheme += "&";
186	scheme += cutsPi->GetCutScheme();
187	} else {
188	cutsPi = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
189
190	AliRsnCutTrackQuality *qualityCutPi = new AliRsnCutTrackQuality("cutQuatityPi");
191	qualityCutPi->SetDefaults2010();
192	cutsPi->AddCut(qualityCutPi);
193	if (!scheme.IsNull()) scheme += "&";
194	scheme += qualityCutPi->GetName();
195	if (useTPC_Pi) {
196	AliRsnCutPIDNSigma *cutPiTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCPi",AliPID::kPion,AliRsnCutPIDNSigma::kTPC);
197	cutPiTPC->SinglePIDRange(nSigmaTPC_Pi);
198	cutsPi->AddCut(cutPiTPC);
199	if (!scheme.IsNull()) scheme += "&";
200	scheme += cutPiTPC->GetName();
201	}
202	if (useTOF_Pi) {
203	AliRsnCutPIDNSigma *cutPiTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFPi",AliPID::kPion,AliRsnCutPIDNSigma::kTOF);
204	cutPiTOF->SinglePIDRange(nSigmaTOF_Pi);
205	cutsPi->AddCut(cutPiTOF);
206	if (!scheme.IsNull()) scheme += "&";
207	scheme += cutPiTOF->GetName();
208	}
209	}
210	}
211
212	if (useEta) {
213	AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
214	AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
215	cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
216	cutEtaP->SetValueObj(valEtaP);
217	cutsPi->AddCut(cutEtaP);
218	if (!scheme.IsNull()) scheme += "&";
219	scheme += cutEtaP->GetName();
220	}
221	if (usePDG) {
222	AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
223	cutsPi->AddCut(cutPDGP);
224	if (!scheme.IsNull()) scheme += "&";
225	scheme += cutPDGP->GetName();
226	}
227
228	Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
229	cutsPi->SetCutScheme(scheme.Data());
230
231	// END PION =======================================
232
233	if (opt.Contains("mon")) {
234	AddMonitorOutput(cutsPi->GetMonitorOutput(),opt);
235	AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
236	}
237	if (isRsnMini) {
238	AliRsnMiniAnalysisTask taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask >(task);
239	if (taskRsnMini) {
240	taskRsnMini->AddTrackCuts(cutsK);
241	taskRsnMini->AddTrackCuts(cutsPi);
242
243	}
244	} else {
245	AliRsnDaughterSelector *sel = rsnIH->GetSelector();
246	// sel->SetLabelCheck(kFALSE);
247	sel->Add(cutsPi, kTRUE);
248	sel->Add(cutsK, kTRUE);
249	}
250	return numberOfCuts;
251
252	}