[u/mrichter/AliRoot.git] / PWGHF / hfe / macros / configs / PbPb / ConfigHFETRDpbpb.C

AliAnalysisTaskHFE* ConfigHFETRDpbpb(Bool_t useMC=kFALSE, Bool_t beauty=kFALSE, UChar_t Sample=10,
				     UChar_t TPCcl=70, UChar_t TPCclPID = 80,
				     Double_t TPCclRatio = 0.6, Double_t TPCclshared = 1.1,
				     UChar_t ITScl=3,  Double_t ITSchi2perclusters=99999999.,
				     Double_t dcaxy=1000.0, Double_t dcaz=2000.0,
				     Double_t TPCs=0., Double_t TPCu=3.09,
				     Double_t TOFs=3.,Double_t IpSig=3., TString appendix,
				     UChar_t TRDtl = 5,UChar_t TRDeff = 2,Bool_t TRDonFlyCut = kFALSE, Bool_t TRDexactTracklets = kFALSE){
  //
  // HFE standard task configuration
  //
    Bool_t kAnalyseTaggedTracks = kTRUE;

    Float_t eeff[6] = {0.7, 0.75, 0.8, 0.85, 0.9, 0.95};
    Int_t eeffint[6] = {70, 75, 80, 85, 90, 95};
    if(TRDeff >= 6 || TRDtl < 4 || TRDtl > 6) return NULL;

  AliHFEcuts *hfecuts = new AliHFEcuts(appendix,"HFE cuts pbpb TOF TPC TRD");
  hfecuts->CreateStandardCuts();

  hfecuts->SetMinNClustersTPC(TPCcl);
  hfecuts->SetMinNClustersTPCPID(TPCclPID);
  hfecuts->SetMinRatioTPCclusters(TPCclRatio);
  hfecuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
  hfecuts->SetFractionOfSharedTPCClusters(TPCclshared);

  hfecuts->SetMinNClustersITS(ITScl);
  hfecuts->SetMaxChi2perClusterITS(ITSchi2perclusters);
  hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
  hfecuts->SetCheckITSLayerStatus(kFALSE);

  hfecuts->SetIPcutParam(0,0,0,IpSig,kTRUE);
  if(useMC && beauty) hfecuts->SetProductionVertex(0,100,0,100);

  hfecuts->SetMaxImpactParam(dcaxy,dcaz);

  hfecuts->SetMinNTrackletsTRD(TRDtl, TRDexactTracklets);   // number of trd tracklets


  // event cuts
  hfecuts->SetUseMixedVertex(kTRUE);
  hfecuts->SetVertexRange(10.);

  // others
  hfecuts->SetTOFPIDStep(kTRUE);
  //hfecuts->SetMaxChi2perClusterITS(36);
  //hfecuts->SetTOFMISMATCHStep(kTRUE);
  //hfecuts->SetTPCPIDCleanUpStep(kTRUE);
  hfecuts->SetQAOn();

  AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE(appendix);
  task->SetHFECuts(hfecuts);
  task->SetPbPbAnalysis(kTRUE);
  task->SetRemovePileUp(kTRUE);
  task->GetPIDQAManager()->SetHighResolutionHistos();
  
  // Define Variables
  Double_t ptbinning[36] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2, 
			    1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3., 3.5, 4., 4.5, 5., 
			    5.5, 6., 7., 8., 10., 12., 14., 16., 18., 20.};
  Double_t etabinning[17] = {-0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0., 0.1, 0.2, 
			     0.3, 0.4, 0.5, 0.6, 0.7, 0.8};
  AliHFEvarManager *vm = task->GetVarManager();
  //vm->AddVariable("pt");
  //vm->AddVariable("eta");
  vm->AddVariable("pt", 35, ptbinning);
  vm->AddVariable("eta", 16, etabinning);
  vm->AddVariable("phi");
  vm->AddVariable("charge");
  vm->AddVariable("source");
  vm->AddVariable("centrality");

  // no background function for TRD PbPb analysis at the moment
  /*
  if(!useMC){
    
    for(Int_t a=0;a<12;a++)
      {
	TF1 *hBackground = new TF1("hadronicBackgroundFunction","TMath::Exp([0]/x + [1])", 0., 20.);
	hBackground->SetParameter(0, -43.87);
	hBackground->SetParameter(1, 2.85);
	task->SetBackGroundFactorsFunction(hBackground,a);
      }
  }
  */


  // Define PID
  AliHFEpid *pid = task->GetPID();
  if(useMC) pid->SetHasMCData(kTRUE);
  pid->AddDetector("TOF", 0);
 // pid->AddDetector("TRD", 2); // adjust order
 // pid->AddDetector("TPC", 1);
  pid->AddDetector("TRD", 1); // adjust order
  pid->AddDetector("TPC", 2);

  //pid->ConfigureTPCrejection();
  
  if(!useMC){
    
    Double_t params_centr_0_5[1];
    Double_t params_centr_5_10[1];
    Double_t params_centr_10_20[1];
    Double_t params_centr_20_30[1];
    Double_t params_centr_per[1];
    params_centr_0_5[0]=TPCs;   // 0.16; // cut tuned for 0-10%
    params_centr_5_10[0]=TPCs;  // 0.16; // cut tuned for 0-10%
    params_centr_10_20[0]=TPCs; // 0.29;
    params_centr_20_30[0]=TPCs; // 0.38;
    params_centr_per[0]=TPCs;   // 0.44;
    char *cutmodel;
    cutmodel="pol0";
    
    
    for(Int_t a=0;a<11;a++)
      {
	if(a>3)  pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_per,TPCu);
	if(a==0) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_0_5,TPCu);    //  0-5%
	if(a==1) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_5_10,TPCu);    //  5-10%
	if(a==2) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_10_20,TPCu);    //  10-20%
	if(a==3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_20_30,TPCu);    //  20-30%
      }
  }
  pid->ConfigureTOF(TOFs);


  // adjust
  AliHFEpidTRD *trdpid = pid->GetDetPID(AliHFEpid::kTRDpid);
  trdpid->SetRenormalizeElPi();
  trdpid->SetElectronEfficiency(eeff[TRDeff]);   // efficiency
  trdpid->SetNTracklets(TRDtl);      // ntracklets threshold
  //trdpid->SetCutNTracklets(TRDtl, TRDexactTracklets);
  AliOADBContainer *cont = new AliOADBContainer("TRDthresholds");
  cont->InitFromFile(Form("%s/util/hfe/TRD.OADBThresholds.root", gSystem->Getenv("TRAIN_ROOT")),"TRDthresholds");
  trdpid->SetOADBThresholds(cont);
  if(TRDonFlyCut) trdpid->SelectCutOnTheFly(kTRUE);


  if(kAnalyseTaggedTracks)
  {
      // V0 tagged tracks
      AliHFEcuts *v0trackCuts = new AliHFEcuts("V0trackCuts", "Track Cuts for tagged track Analysis");
      v0trackCuts->CreateStandardCuts();

      v0trackCuts->SetMinNClustersTPC(TPCcl);
      v0trackCuts->SetMinNClustersTPCPID(TPCclPID);
      v0trackCuts->SetFractionOfSharedTPCClusters(TPCclshared);
      v0trackCuts->SetMinRatioTPCclusters(TPCclRatio);
      v0trackCuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
      v0trackCuts->SetMinNClustersITS(1);
      v0trackCuts->SetMaxChi2perClusterITS(ITSchi2perclusters);
      v0trackCuts->SetCutITSpixel(AliHFEextraCuts::kAny);
      v0trackCuts->SetCheckITSLayerStatus(kFALSE);
      v0trackCuts->UnsetVertexRequirement();
      //v0trackCuts->SetMaxChi2perClusterITS(36);
      //hfecuts->SetSigmaToVertex(10);
      v0trackCuts->SetTOFPIDStep(kTRUE);
      //v0trackCuts->SetTOFMISMATCHStep(kTRUE);
      //v0trackCuts->SetTPCPIDCleanUpStep(kTRUE);
      v0trackCuts->SetQAOn();
      v0trackCuts->SetMinNTrackletsTRD(TRDtl); // condition for TRD tracklets

      task->SwitchOnPlugin(AliAnalysisTaskHFE::kTaggedTrackAnalysis);
      task->SetTaggedTrackCuts(v0trackCuts);
      task->SetCleanTaggedTrack(kFALSE);
  }
  
  // QA
  task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
  //task->SetFillSignalOnly(kFALSE);    // for DE pluging for MC
  task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
  //task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
  //task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
  task->SwitchOnPlugin(AliAnalysisTaskHFE::kDEstep);

  printf("*************************************\n");
  printf("Configuring task PbPb \n"); 
  //if(isLHC10) printf("Configuring TPC1 Task 2010 :\n");
  //if(isLHC11) printf("Configuring TPC1 Task 2011 :\n");
  task->Print();
  pid->PrintStatus();
  printf("*************************************\n"); 
  return task;
}
Commit	Line	Data
d84c68e9	1	AliAnalysisTaskHFE* ConfigHFETRDpbpb(Bool_t useMC=kFALSE, Bool_t beauty=kFALSE, UChar_t Sample=10,
	2	UChar_t TPCcl=70, UChar_t TPCclPID = 80,
	3	Double_t TPCclRatio = 0.6, Double_t TPCclshared = 1.1,
	4	UChar_t ITScl=3, Double_t ITSchi2perclusters=99999999.,
	5	Double_t dcaxy=1000.0, Double_t dcaz=2000.0,
	6	Double_t TPCs=0., Double_t TPCu=3.09,
	7	Double_t TOFs=3.,Double_t IpSig=3., TString appendix,
	8	UChar_t TRDtl = 5,UChar_t TRDeff = 2,Bool_t TRDonFlyCut = kFALSE, Bool_t TRDexactTracklets = kFALSE){
	9	//
	10	// HFE standard task configuration
	11	//
	12	Bool_t kAnalyseTaggedTracks = kTRUE;
	13
	14	Float_t eeff[6] = {0.7, 0.75, 0.8, 0.85, 0.9, 0.95};
	15	Int_t eeffint[6] = {70, 75, 80, 85, 90, 95};
	16	if(TRDeff >= 6 \|\| TRDtl < 4 \|\| TRDtl > 6) return NULL;
	17
	18	AliHFEcuts *hfecuts = new AliHFEcuts(appendix,"HFE cuts pbpb TOF TPC TRD");
	19	hfecuts->CreateStandardCuts();
	20
	21	hfecuts->SetMinNClustersTPC(TPCcl);
	22	hfecuts->SetMinNClustersTPCPID(TPCclPID);
	23	hfecuts->SetMinRatioTPCclusters(TPCclRatio);
	24	hfecuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
	25	hfecuts->SetFractionOfSharedTPCClusters(TPCclshared);
	26
	27	hfecuts->SetMinNClustersITS(ITScl);
	28	hfecuts->SetMaxChi2perClusterITS(ITSchi2perclusters);
	29	hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
	30	hfecuts->SetCheckITSLayerStatus(kFALSE);
	31
	32	hfecuts->SetIPcutParam(0,0,0,IpSig,kTRUE);
	33	if(useMC && beauty) hfecuts->SetProductionVertex(0,100,0,100);
	34
	35	hfecuts->SetMaxImpactParam(dcaxy,dcaz);
	36
	37	hfecuts->SetMinNTrackletsTRD(TRDtl, TRDexactTracklets); // number of trd tracklets
	38
	39
	40	// event cuts
	41	hfecuts->SetUseMixedVertex(kTRUE);
	42	hfecuts->SetVertexRange(10.);
	43
	44	// others
	45	hfecuts->SetTOFPIDStep(kTRUE);
	46	//hfecuts->SetMaxChi2perClusterITS(36);
	47	//hfecuts->SetTOFMISMATCHStep(kTRUE);
	48	//hfecuts->SetTPCPIDCleanUpStep(kTRUE);
	49	hfecuts->SetQAOn();
	50
	51	AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE(appendix);
	52	task->SetHFECuts(hfecuts);
	53	task->SetPbPbAnalysis(kTRUE);
	54	task->SetRemovePileUp(kTRUE);
	55	task->GetPIDQAManager()->SetHighResolutionHistos();
	56
	57	// Define Variables
	58	Double_t ptbinning[36] = {0., 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1., 1.1, 1.2,
	59	1.3, 1.4, 1.5, 1.75, 2., 2.25, 2.5, 2.75, 3., 3.5, 4., 4.5, 5.,
	60	5.5, 6., 7., 8., 10., 12., 14., 16., 18., 20.};
	61	Double_t etabinning[17] = {-0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0., 0.1, 0.2,
	62	0.3, 0.4, 0.5, 0.6, 0.7, 0.8};
	63	AliHFEvarManager *vm = task->GetVarManager();
	64	//vm->AddVariable("pt");
65	//vm->AddVariable("eta");
66	vm->AddVariable("pt", 35, ptbinning);
67	vm->AddVariable("eta", 16, etabinning);
68	vm->AddVariable("phi");
69	vm->AddVariable("charge");
70	vm->AddVariable("source");
71	vm->AddVariable("centrality");
72
73	// no background function for TRD PbPb analysis at the moment
74	/*
75	if(!useMC){
76
77	for(Int_t a=0;a<12;a++)
78	{
79	TF1 *hBackground = new TF1("hadronicBackgroundFunction","TMath::Exp([0]/x + [1])", 0., 20.);
80	hBackground->SetParameter(0, -43.87);
81	hBackground->SetParameter(1, 2.85);
82	task->SetBackGroundFactorsFunction(hBackground,a);
83	}
84	}
85	*/
86
87
88	// Define PID
89	AliHFEpid *pid = task->GetPID();
90	if(useMC) pid->SetHasMCData(kTRUE);
91	pid->AddDetector("TOF", 0);
92	// pid->AddDetector("TRD", 2); // adjust order
93	// pid->AddDetector("TPC", 1);
94	pid->AddDetector("TRD", 1); // adjust order
95	pid->AddDetector("TPC", 2);
96
97	//pid->ConfigureTPCrejection();
98
99	if(!useMC){
100
101	Double_t params_centr_0_5[1];
102	Double_t params_centr_5_10[1];
103	Double_t params_centr_10_20[1];
104	Double_t params_centr_20_30[1];
105	Double_t params_centr_per[1];
106	params_centr_0_5[0]=TPCs; // 0.16; // cut tuned for 0-10%
107	params_centr_5_10[0]=TPCs; // 0.16; // cut tuned for 0-10%
108	params_centr_10_20[0]=TPCs; // 0.29;
109	params_centr_20_30[0]=TPCs; // 0.38;
110	params_centr_per[0]=TPCs; // 0.44;
111	char *cutmodel;
112	cutmodel="pol0";
113
114
115	for(Int_t a=0;a<11;a++)
116	{
117	if(a>3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_per,TPCu);
118	if(a==0) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_0_5,TPCu); // 0-5%
119	if(a==1) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_5_10,TPCu); // 5-10%
120	if(a==2) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_10_20,TPCu); // 10-20%
121	if(a==3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_20_30,TPCu); // 20-30%
122	}
123	}
124	pid->ConfigureTOF(TOFs);
125
126
127	// adjust
128	AliHFEpidTRD *trdpid = pid->GetDetPID(AliHFEpid::kTRDpid);
129	trdpid->SetRenormalizeElPi();
130	trdpid->SetElectronEfficiency(eeff[TRDeff]); // efficiency
131	trdpid->SetNTracklets(TRDtl); // ntracklets threshold
132	//trdpid->SetCutNTracklets(TRDtl, TRDexactTracklets);
133	AliOADBContainer *cont = new AliOADBContainer("TRDthresholds");
134	cont->InitFromFile(Form("%s/util/hfe/TRD.OADBThresholds.root", gSystem->Getenv("TRAIN_ROOT")),"TRDthresholds");
135	trdpid->SetOADBThresholds(cont);
136	if(TRDonFlyCut) trdpid->SelectCutOnTheFly(kTRUE);
137
138
139	if(kAnalyseTaggedTracks)
140	{
141	// V0 tagged tracks
142	AliHFEcuts *v0trackCuts = new AliHFEcuts("V0trackCuts", "Track Cuts for tagged track Analysis");
143	v0trackCuts->CreateStandardCuts();
144
145	v0trackCuts->SetMinNClustersTPC(TPCcl);
146	v0trackCuts->SetMinNClustersTPCPID(TPCclPID);
147	v0trackCuts->SetFractionOfSharedTPCClusters(TPCclshared);
148	v0trackCuts->SetMinRatioTPCclusters(TPCclRatio);
149	v0trackCuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
150	v0trackCuts->SetMinNClustersITS(1);
151	v0trackCuts->SetMaxChi2perClusterITS(ITSchi2perclusters);
152	v0trackCuts->SetCutITSpixel(AliHFEextraCuts::kAny);
153	v0trackCuts->SetCheckITSLayerStatus(kFALSE);
154	v0trackCuts->UnsetVertexRequirement();
155	//v0trackCuts->SetMaxChi2perClusterITS(36);
156	//hfecuts->SetSigmaToVertex(10);
157	v0trackCuts->SetTOFPIDStep(kTRUE);
158	//v0trackCuts->SetTOFMISMATCHStep(kTRUE);
159	//v0trackCuts->SetTPCPIDCleanUpStep(kTRUE);
160	v0trackCuts->SetQAOn();
161	v0trackCuts->SetMinNTrackletsTRD(TRDtl); // condition for TRD tracklets
162
163	task->SwitchOnPlugin(AliAnalysisTaskHFE::kTaggedTrackAnalysis);
164	task->SetTaggedTrackCuts(v0trackCuts);
165	task->SetCleanTaggedTrack(kFALSE);
166	}
167
168	// QA
169	task->SetQAOn(AliAnalysisTaskHFE::kPIDqa);
170	//task->SetFillSignalOnly(kFALSE); // for DE pluging for MC
171	task->SetQAOn(AliAnalysisTaskHFE::kMCqa);
172	//task->SwitchOnPlugin(AliAnalysisTaskHFE::kIsElecBackGround);
173	//task->SwitchOnPlugin(AliAnalysisTaskHFE::kSecVtx);
174	task->SwitchOnPlugin(AliAnalysisTaskHFE::kDEstep);
175
176	printf("*************************************\n");
177	printf("Configuring task PbPb \n");
178	//if(isLHC10) printf("Configuring TPC1 Task 2010 :\n");
179	//if(isLHC11) printf("Configuring TPC1 Task 2011 :\n");
180	task->Print();
181	pid->PrintStatus();
182	printf("*************************************\n");
183	return task;
184	}