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

#ifndef __CINT__
#endif
Int_t AddRsnDaughterCutsLambdaNsigma(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);
   Int_t useCommonQualityCut = AliAnalysisManager::GetGlobalInt("rsnCommonQualityCut",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("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;

   // default values
   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;

   Bool_t useTPC_P=kFALSE;
   Bool_t useTOF_P=kFALSE;
   Bool_t useTPC_K=kFALSE;
   Bool_t useTOF_K=kFALSE;

   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("PTOFnsig")) useTOF_P=kTRUE;
   if (opt.Contains("KTPCnsig"))  useTPC_K=kTRUE;
   if (opt.Contains("KTOFnsig"))  useTOF_K=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("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("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("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;
   }

   // 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("cutQuatityP");
   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 (!scheme.IsNull()) scheme += "&";
      scheme += cutPTOF->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();
   }

   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("cutQuatityK");
   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 (!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 =======================================

   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;

}
Commit	Line	Data
4ce3e7cd	1	#ifndef __CINT__
	2	#endif
	3	Int_t AddRsnDaughterCutsLambdaNsigma(AliPID::EParticleType type1,AliPID::EParticleType type2,TString opt,Bool_t isRsnMini=kFALSE,AliRsnInputHandler rsnIH=0,AliAnalysisTaskSE task=0)
	4	{
	5
	6	if (!rsnIH) return 0;
	7
	8	Bool_t valid = kTRUE;
	9	Int_t isPP = AliAnalysisManager::GetGlobalInt("rsnIsPP",valid);
dc8dd82a	10	Int_t useCommonQualityCut = AliAnalysisManager::GetGlobalInt("rsnCommonQualityCut",valid);
4ce3e7cd	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
	24	Printf("AddRsnDaughterCutsLambda Option : %s",opt.Data());
	25
	26	Double_t nSigmaTPC_P=3.0;
	27	Double_t nSigmaTPC_K=3.0;
	28	Double_t nSigmaTOF_P=3.0;
	29	Double_t nSigmaTOF_K=3.0;
	30	Double_t etaRange=0.8;
	31
	32	// default values
	33	Double_t nSigmaTPC_P=3.0;
	34	Double_t nSigmaTPC_K=3.0;
	35	Double_t nSigmaTOF_P=3.0;
	36	Double_t nSigmaTOF_K=3.0;
	37	Double_t etaRange=0.8;
	38
	39	Bool_t useTPC_P=kFALSE;
	40	Bool_t useTOF_P=kFALSE;
	41	Bool_t useTPC_K=kFALSE;
	42	Bool_t useTOF_K=kFALSE;
	43
	44	if (opt.Contains("qualityonly")) {
	45	useTPC_P=kFALSE;
	46	useTOF_P=kFALSE;
	47	useTPC_K=kFALSE;
	48	useTOF_K=kFALSE;
	49	} else if (!opt.Contains("nsig")) {
	50	useTPC_P=kTRUE;
	51	useTOF_P=kTRUE;
	52	useTPC_K=kTRUE;
	53	useTOF_K=kTRUE;
	54	}
	55
	56	if (opt.Contains("PTPCnsig")) useTPC_P=kTRUE;
	57	if (opt.Contains("PTOFnsig")) useTOF_P=kTRUE;
	58	if (opt.Contains("KTPCnsig")) useTPC_K=kTRUE;
	59	if (opt.Contains("KTOFnsig")) useTOF_K=kTRUE;
	60
	61	if (opt.Contains("PTPCnsig10")) nSigmaTPC_P = 1.0;
	62	if (opt.Contains("PTPCnsig15")) nSigmaTPC_P = 1.5;
	63	if (opt.Contains("PTPCnsig20")) nSigmaTPC_P = 2.0;
	64	if (opt.Contains("PTPCnsig25")) nSigmaTPC_P = 2.5;
	65	if (opt.Contains("PTPCnsig30")) nSigmaTPC_P = 3.0;
	66
	67	if (opt.Contains("KTPCnsig10")) nSigmaTPC_K = 1.0;
	68	if (opt.Contains("KTPCnsig15")) nSigmaTPC_K = 1.5;
	69	if (opt.Contains("KTPCnsig20")) nSigmaTPC_K = 2.0;
	70	if (opt.Contains("KTPCnsig25")) nSigmaTPC_K = 2.5;
	71	if (opt.Contains("KTPCnsig30")) nSigmaTPC_K = 3.0;
	72
	73	if (opt.Contains("PTOFnsig10")) nSigmaTOF_P = 1.0;
	74	if (opt.Contains("PTOFnsig15")) nSigmaTOF_P = 1.5;
75	if (opt.Contains("PTOFnsig20")) nSigmaTOF_P = 2.0;
76	if (opt.Contains("PTOFnsig25")) nSigmaTOF_P = 2.5;
77	if (opt.Contains("PTOFnsig30")) nSigmaTOF_P = 3.0;
78
79	if (opt.Contains("KTOFnsig10")) nSigmaTOF_K = 1.0;
80	if (opt.Contains("KTOFnsig15")) nSigmaTOF_K = 1.5;
81	if (opt.Contains("KTOFnsig20")) nSigmaTOF_K = 2.0;
82	if (opt.Contains("KTOFnsig25")) nSigmaTOF_K = 2.5;
83	if (opt.Contains("KTOFnsig30")) nSigmaTOF_K = 3.0;
84
85
86	Bool_t usePDG=kFALSE;
87	if (opt.Contains("pdg")) {
88	Printf("Using PDG");
89	usePDG = kTRUE;
90	}
91
92	Bool_t useEta = kFALSE;
93	if (opt.Contains("eta")) {
94	Printf("Using ETA range (%.2f,%.2f)",-etaRange,etaRange);
95	useEta = kTRUE;
96	}
97
98	// PROTON SETTINGS ===========================================
99
100	TString scheme="";
101	TString cutname = "p_Lambda";
102	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
103	AliRsnCutSet *cutsP = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
104
dc8dd82a	105	AliRsnCutTrackQuality *qualityCutP = new AliRsnCutTrackQuality("cutQuatityP");
	106	if (useCommonQualityCut>=0) {
	107	qualityCutP->SetAODTestFilterBit(useCommonQualityCut);
	108	} else {
	109	qualityCutP->SetDefaults2010();
	110	}
4ce3e7cd	111	cutsP->AddCut(qualityCutP);
	112	if (!scheme.IsNull()) scheme += "&";
	113	scheme += qualityCutP->GetName();
	114
	115	if (useTPC_P) {
	116	AliRsnCutPIDNSigma *cutPTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCP",AliPID::kProton,AliRsnCutPIDNSigma::kTPC);
	117	cutPTPC->SinglePIDRange(nSigmaTPC_P);
	118	cutsP->AddCut(cutPTPC);
	119	if (!scheme.IsNull()) scheme += "&";
	120	scheme += cutPTPC->GetName();
	121	}
	122
	123	if (useTOF_P) {
	124	AliRsnCutPIDNSigma *cutPTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFP",AliPID::kProton,AliRsnCutPIDNSigma::kTOF);
	125	cutPTOF->SinglePIDRange(nSigmaTOF_P);
	126	cutsP->AddCut(cutPTOF);
	127	if (!scheme.IsNull()) scheme += "&";
	128	scheme += cutPTOF->GetName();
	129	}
	130
	131	if (useEta) {
	132	AliRsnValueDaughter *valEtaP = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type1),opt.Data()),AliRsnValueDaughter::kEta);
	133	AliRsnCutValue *cutEtaP = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type1),opt.Data()),-etaRange,etaRange);
	134	cutEtaP->SetTargetType(AliRsnTarget::kDaughter);
	135	cutEtaP->SetValueObj(valEtaP);
	136	cutsP->AddCut(cutEtaP);
	137	if (!scheme.IsNull()) scheme += "&";
	138	scheme += cutEtaP->GetName();
	139	}
	140	if (usePDG) {
	141	AliRsnCutPID *cutPDGP = new AliRsnCutPID(Form("cut%sPDG%s",AliPID::ParticleName(type1),opt.Data()),type1,0.0,kTRUE);
	142	cutsP->AddCut(cutPDGP);
	143	if (!scheme.IsNull()) scheme += "&";
	144	scheme += cutPDGP->GetName();
	145	}
	146
	147	Printf ("CUT Scheme for PROTON is '%s'",scheme.Data());
	148	cutsP->SetCutScheme(scheme.Data());
	149
	150	// END PROTON =======================================
	151
	152	// KAON SETTINGS =======================================
	153	scheme="";
	154	cutname = "K_Lambda";
	155	if (!opt.IsNull()) cutname += Form("_%s",opt.Data());
	156	AliRsnCutSet *cutsK = new AliRsnCutSet(cutname.Data(), AliRsnTarget::kDaughter);
	157
	158	AliRsnCutTrackQuality *qualityCutK = new AliRsnCutTrackQuality("cutQuatityK");
dc8dd82a	159	if (useCommonQualityCut>=0) {
	160	qualityCutK->SetAODTestFilterBit(useCommonQualityCut);
	161	} else {
	162	qualityCutK->SetDefaults2010();
	163	}
4ce3e7cd	164	cutsK->AddCut(qualityCutK);
	165	if (!scheme.IsNull()) scheme += "&";
	166	scheme += qualityCutK->GetName();
	167
	168
	169	if (useTPC_K) {
	170	AliRsnCutPIDNSigma *cutKTPC = new AliRsnCutPIDNSigma("cutNSigmaTPCK",AliPID::kKaon,AliRsnCutPIDNSigma::kTPC);
	171	cutKTPC->SinglePIDRange(nSigmaTPC_K);
	172	cutsK->AddCut(cutKTPC);
	173	if (!scheme.IsNull()) scheme += "&";
	174	scheme += cutKTPC->GetName();
	175	}
	176
	177	if (useTOF_K) {
	178	AliRsnCutPIDNSigma *cutKTOF = new AliRsnCutPIDNSigma("cutNSigmaTOFK",AliPID::kKaon,AliRsnCutPIDNSigma::kTOF);
	179	cutKTOF->SinglePIDRange(nSigmaTOF_K);
	180	cutsK->AddCut(cutKTOF);
	181	if (!scheme.IsNull()) scheme += "&";
	182	scheme += cutKTOF->GetName();
	183	}
	184
	185	if (useEta) {
	186	AliRsnValueDaughter *valEtaK = new AliRsnValueDaughter(Form("val%sETA%s",AliPID::ParticleName(type2),opt.Data()),AliRsnValueDaughter::kEta);
	187	AliRsnCutValue *cutEtaK = new AliRsnCutValue(Form("cut%sETA%s",AliPID::ParticleName(type2),opt.Data()),-etaRange,etaRange);
	188	cutEtaK->SetTargetType(AliRsnTarget::kDaughter);
	189	cutEtaK->SetValueObj(valEtaK);
	190	cutsK->AddCut(cutEtaK);
	191	if (!scheme.IsNull()) scheme += "&";
	192	scheme += cutEtaK->GetName();
	193	}
	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	if (opt.Contains("mon")) {
	207	AddMonitorOutput(cutsP->GetMonitorOutput(),opt);
	208	AddMonitorOutput(cutsK->GetMonitorOutput(),opt);
	209	}
	210	if (isRsnMini) {
	211	AliRsnMiniAnalysisTask taskRsnMini = dynamic_cast<AliRsnMiniAnalysisTask >(task);
	212	if (taskRsnMini) {
	213	taskRsnMini->AddTrackCuts(cutsP);
	214	taskRsnMini->AddTrackCuts(cutsK);
	215	}
	216	} else {
	217	AliRsnDaughterSelector *sel = rsnIH->GetSelector();
	218	// sel->SetLabelCheck(kFALSE);
	219	sel->Add(cutsP, kTRUE);
	220	sel->Add(cutsK, kTRUE);
	221	}
	222	return numberOfCuts;
	223
	224	}