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

AliAnalysisTaskHFE* ConfigHFECalSys_PbPb(Bool_t useMC, int TPCclust, int Nits, int ITSstat, double nSigMim, double Mimeop, double Maxeop, int PIDorder){
  //
  // HFE standard task configuration
  //

  cout << "==== Summary of cuts  ===== " << endl;
  cout << "TPC ; " << TPCclust << endl;
  cout << "ITS ; " << Nits << endl;
  cout << "PID ; " << nSigMim << " ; " << Mimeop << " ; " << Maxeop << endl;

  AliHFEcuts *hfecuts = new AliHFEcuts("hfeCuts","HFE Standard Cuts for EMCal");
  hfecuts->CreateStandardCuts();
  //hfecuts->SetMinNClustersTPC(120);
  hfecuts->SetMinNClustersTPC(TPCclust);
  hfecuts->SetMinRatioTPCclusters(0.6);
  hfecuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);

  //hfecuts->SetMinNClustersITS(3);
  hfecuts->SetMinNClustersITS(Nits);
  hfecuts->SetCutITSpixel(AliHFEextraCuts::kAny);
  if(ITSstat==1)hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
  hfecuts->SetCheckITSLayerStatus(kFALSE);

  //hfecuts->UnsetVertexRequirement();
  hfecuts->SetMaxImpactParam(3.,3.);
  hfecuts->SetPtRange(2.0,60.0);

  hfecuts->SetVertexRange(10.);
  //hfecuts->SetMaxChi2perClusterITS(36);
  //hfecuts->SetSigmaToVertex(10);
  //hfecuts->SetTOFPIDStep(kTRUE);
  //hfecuts->SetTOFMISMATCHStep(kTRUE);
  //hfecuts->SetTPCPIDCleanUpStep(kTRUE);
  hfecuts->SetQAOn();
  //hfecuts->SetMinNTrackletsTRD(5);

  AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisStandardEMCal");
  task->SetHFECuts(hfecuts);
  task->SetPbPbAnalysis(kTRUE);
  //task->SetRemovePileUp(kTRUE);
  task->GetPIDQAManager()->SetHighResolutionHistos();

  // Define Variables
  AliHFEvarManager *vm = task->GetVarManager();
  //vm->AddVariable("pt");
  //vm->AddVariable("eta");
  
  const Double_t ptbinning[50] = {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., 
                                  9., 10., 11., 12., 13., 
                                  14., 15., 16., 17., 18.,
                                  20., 22., 24., 26., 28.,
                                  30., 32., 34., 36., 38.,
				  40., 45., 50., 55., 60.,
			          65., 70., 80., 90., 100}; 

  const 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}; 

  vm->AddVariable("pt", 49, ptbinning);
  vm->AddVariable("eta", 16, etabinning);
  vm->AddVariable("phi");
  vm->AddVariable("charge");
  vm->AddVariable("source");
  vm->AddVariable("centrality");
  /*
  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);

  if(PIDorder == 0)
     {
      pid->AddDetector("EMCAL", 1);
      pid->AddDetector("TPC", 0);
     }
  else if
    {
     pid->AddDetector("EMCAL", 0);
     pid->AddDetector("TPC", 1);
   }

//  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]=0.16;  // cut tuned for 0-10%
      //params_centr_5_10[0]=0.16; // cut tuned for 0-10%
      //params_centr_10_20[0]=0.29;
      //params_centr_20_30[0]=0.38;
      //params_centr_per[0]=0.44;
      /*
      params_centr_0_5[0]=-1.5;  // cut tuned for 0-10%
      params_centr_5_10[0]=-1.5; // cut tuned for 0-10%
      params_centr_10_20[0]=-1.5;
      params_centr_20_30[0]=-1.5;
      params_centr_per[0]=-1.5;
      */
      params_centr_0_5[0] = nSigMim;  // cut tuned for 0-10%
      params_centr_5_10[0] = nSigMim; // cut tuned for 0-10%
      params_centr_10_20[0] = nSigMim;
      params_centr_20_30[0] = nSigMim;
      params_centr_per[0] = nSigMim;


      char *cutmodel;
      cutmodel="pol0";


      for(Int_t a=0;a<11;a++)
      {
	  if(a>3)  pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_per,3.0);
	  if(a==0) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_0_5,3.0);    //  0-5%
	  if(a==1) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_5_10,3.0);    //  5-10%
	  if(a==2) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_10_20,3.0);    //  10-20%
	  if(a==3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_20_30,3.0);    //  20-30%
      }


  }


  // V0 tagged tracks
  AliHFEcuts *v0trackCuts = new AliHFEcuts("V0trackCuts", "Track Cuts for tagged track Analysis");
  v0trackCuts->CreateStandardCuts();
  //v0trackCuts->SetMinNClustersTPC(120);
  v0trackCuts->SetMinNClustersTPC(TPCclust);
  v0trackCuts->SetMinRatioTPCclusters(0.6);
  v0trackCuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
  v0trackCuts->SetMinNClustersITS(1);
  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();
  
  task->SwitchOnPlugin(AliAnalysisTaskHFE::kTaggedTrackAnalysis);
  task->SetTaggedTrackCuts(v0trackCuts);
  task->SetCleanTaggedTrack(kFALSE);
  
  // change E/p cuts
  AliHFEpidEMCAL *emcpid = pid->AliHFEpid::GetDetPID(AliHFEpid::kEMCALpid);
  emcpid->SetEoPMax(Maxeop);
  emcpid->SetEoPMim(Mimeop);

  // 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 standard Task:\n");
  task->Print();
  pid->PrintStatus();
  printf("*************************************\n"); 
  return task;
}
Commit	Line	Data
e8ae876b	1	AliAnalysisTaskHFE* ConfigHFECalSys_PbPb(Bool_t useMC, int TPCclust, int Nits, int ITSstat, double nSigMim, double Mimeop, double Maxeop, int PIDorder){
6f880c3b	2	//
	3	// HFE standard task configuration
	4	//
	5
	6	cout << "==== Summary of cuts ===== " << endl;
	7	cout << "TPC ; " << TPCclust << endl;
	8	cout << "ITS ; " << Nits << endl;
	9	cout << "PID ; " << nSigMim << " ; " << Mimeop << " ; " << Maxeop << endl;
	10
	11	AliHFEcuts *hfecuts = new AliHFEcuts("hfeCuts","HFE Standard Cuts for EMCal");
	12	hfecuts->CreateStandardCuts();
	13	//hfecuts->SetMinNClustersTPC(120);
	14	hfecuts->SetMinNClustersTPC(TPCclust);
	15	hfecuts->SetMinRatioTPCclusters(0.6);
	16	hfecuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
	17
	18	//hfecuts->SetMinNClustersITS(3);
	19	hfecuts->SetMinNClustersITS(Nits);
	20	hfecuts->SetCutITSpixel(AliHFEextraCuts::kAny);
e8ae876b	21	if(ITSstat==1)hfecuts->SetCutITSpixel(AliHFEextraCuts::kFirst);
6f880c3b	22	hfecuts->SetCheckITSLayerStatus(kFALSE);
	23
	24	//hfecuts->UnsetVertexRequirement();
	25	hfecuts->SetMaxImpactParam(3.,3.);
a689c6fb	26	hfecuts->SetPtRange(2.0,60.0);
6f880c3b	27
	28	hfecuts->SetVertexRange(10.);
	29	//hfecuts->SetMaxChi2perClusterITS(36);
	30	//hfecuts->SetSigmaToVertex(10);
	31	//hfecuts->SetTOFPIDStep(kTRUE);
	32	//hfecuts->SetTOFMISMATCHStep(kTRUE);
	33	//hfecuts->SetTPCPIDCleanUpStep(kTRUE);
	34	hfecuts->SetQAOn();
	35	//hfecuts->SetMinNTrackletsTRD(5);
	36
	37	AliAnalysisTaskHFE *task = new AliAnalysisTaskHFE("HFEanalysisStandardEMCal");
	38	task->SetHFECuts(hfecuts);
	39	task->SetPbPbAnalysis(kTRUE);
	40	//task->SetRemovePileUp(kTRUE);
	41	task->GetPIDQAManager()->SetHighResolutionHistos();
	42
	43	// Define Variables
	44	AliHFEvarManager *vm = task->GetVarManager();
	45	//vm->AddVariable("pt");
	46	//vm->AddVariable("eta");
	47
	48	const Double_t ptbinning[50] = {1., 1.1, 1.2, 1.3, 1.4,
	49	1.5, 1.75, 2., 2.25, 2.5,
	50	2.75, 3., 3.5, 4., 4.5,
	51	5., 5.5, 6., 7., 8.,
	52	9., 10., 11., 12., 13.,
	53	14., 15., 16., 17., 18.,
	54	20., 22., 24., 26., 28.,
	55	30., 32., 34., 36., 38.,
	56	40., 45., 50., 55., 60.,
	57	65., 70., 80., 90., 100};
	58
	59	const 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};
	60
	61	vm->AddVariable("pt", 49, ptbinning);
	62	vm->AddVariable("eta", 16, etabinning);
	63	vm->AddVariable("phi");
	64	vm->AddVariable("charge");
	65	vm->AddVariable("source");
	66	vm->AddVariable("centrality");
	67	/*
	68	if(!useMC){
	69
	70	for(Int_t a=0;a<12;a++)
	71	{
	72	TF1 *hBackground = new TF1("hadronicBackgroundFunction","TMath::Exp([0]/x + [1])", 0., 20.);
	73	hBackground->SetParameter(0, -43.87);
	74	hBackground->SetParameter(1, 2.85);
	75	task->SetBackGroundFactorsFunction(hBackground,a);
	76	}
	77
	78
	79	}
	80	*/
	81	// Define PID
	82	AliHFEpid *pid = task->GetPID();
	83	if(useMC) pid->SetHasMCData(kTRUE);
	84
	85	if(PIDorder == 0)
	86	{
	87	pid->AddDetector("EMCAL", 1);
	88	pid->AddDetector("TPC", 0);
	89	}
	90	else if
91	{
92	pid->AddDetector("EMCAL", 0);
93	pid->AddDetector("TPC", 1);
94	}
95
96	// pid->ConfigureTPCrejection();
97
98	if(!useMC){
99
100	Double_t params_centr_0_5[1];
101	Double_t params_centr_5_10[1];
102	Double_t params_centr_10_20[1];
103	Double_t params_centr_20_30[1];
104	Double_t params_centr_per[1];
105	//params_centr_0_5[0]=0.16; // cut tuned for 0-10%
106	//params_centr_5_10[0]=0.16; // cut tuned for 0-10%
107	//params_centr_10_20[0]=0.29;
108	//params_centr_20_30[0]=0.38;
109	//params_centr_per[0]=0.44;
110	/*
111	params_centr_0_5[0]=-1.5; // cut tuned for 0-10%
112	params_centr_5_10[0]=-1.5; // cut tuned for 0-10%
113	params_centr_10_20[0]=-1.5;
114	params_centr_20_30[0]=-1.5;
115	params_centr_per[0]=-1.5;
116	*/
117	params_centr_0_5[0] = nSigMim; // cut tuned for 0-10%
118	params_centr_5_10[0] = nSigMim; // cut tuned for 0-10%
119	params_centr_10_20[0] = nSigMim;
120	params_centr_20_30[0] = nSigMim;
121	params_centr_per[0] = nSigMim;
122
123
124	char *cutmodel;
125	cutmodel="pol0";
126
127
128	for(Int_t a=0;a<11;a++)
129	{
130	if(a>3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_per,3.0);
131	if(a==0) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_0_5,3.0); // 0-5%
132	if(a==1) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_5_10,3.0); // 5-10%
133	if(a==2) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_10_20,3.0); // 10-20%
134	if(a==3) pid->ConfigureTPCcentralityCut(a,cutmodel,params_centr_20_30,3.0); // 20-30%
135	}
136
137
138	}
139
140
141	// V0 tagged tracks
142	AliHFEcuts *v0trackCuts = new AliHFEcuts("V0trackCuts", "Track Cuts for tagged track Analysis");
143	v0trackCuts->CreateStandardCuts();
144	//v0trackCuts->SetMinNClustersTPC(120);
145	v0trackCuts->SetMinNClustersTPC(TPCclust);
146	v0trackCuts->SetMinRatioTPCclusters(0.6);
147	v0trackCuts->SetTPCmodes(AliHFEextraCuts::kFound, AliHFEextraCuts::kFoundOverFindable);
148	v0trackCuts->SetMinNClustersITS(1);
149	v0trackCuts->SetCutITSpixel(AliHFEextraCuts::kAny);
150	v0trackCuts->SetCheckITSLayerStatus(kFALSE);
151	v0trackCuts->UnsetVertexRequirement();
152	//v0trackCuts->SetMaxChi2perClusterITS(36);
153	//hfecuts->SetSigmaToVertex(10);
154	v0trackCuts->SetTOFPIDStep(kTRUE);
155	// v0trackCuts->SetTOFMISMATCHStep(kTRUE);
156	//v0trackCuts->SetTPCPIDCleanUpStep(kTRUE);
157	v0trackCuts->SetQAOn();
158
159	task->SwitchOnPlugin(AliAnalysisTaskHFE::kTaggedTrackAnalysis);
160	task->SetTaggedTrackCuts(v0trackCuts);
161	task->SetCleanTaggedTrack(kFALSE);
162
163	// change E/p cuts
164	AliHFEpidEMCAL *emcpid = pid->AliHFEpid::GetDetPID(AliHFEpid::kEMCALpid);
165	emcpid->SetEoPMax(Maxeop);
166	emcpid->SetEoPMim(Mimeop);
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
177
178	printf("*************************************\n");
179	printf("Configuring standard Task:\n");
180	task->Print();
181	pid->PrintStatus();
182	printf("*************************************\n");
183	return task;
184	}