1 class AliAnalysisDataContainer;
2 class AliFlowTrackCuts;
3 class AliFlowEventCuts;
6 void AddTaskPIDFlow(Int_t triggerSelectionString=AliVEvent::kMB,
10 TString fileNameBase="output",
12 Int_t AODfilterBitRP = 272,
13 Int_t AODfilterBitPOI = 272,
15 Int_t MinTPCdedx = 10,
16 Int_t ncentrality = 6,
19 Bool_t is2011 = kFALSE,
20 AliPID::EParticleType particleType=AliPID::kPion,
21 AliFlowTrackCuts::PIDsource sourcePID=AliFlowTrackCuts::kTOFbayesian) {
23 // Define a range of the detector to exclude
24 Bool_t ExcludeRegion = kFALSE;
25 Double_t excludeEtaMin = -0.;
26 Double_t excludeEtaMax = 0.;
27 Double_t excludePhiMin = 0.;
28 Double_t excludePhiMax = 0.;
31 // Flow analysis method can be:(set to kTRUE or kFALSE)
33 Bool_t SP = kTRUE; // scalar product method (similar to eventplane method)
34 Bool_t QC = kTRUE; // cumulants using Q vectors
36 int centrMin[9] = {0,5,10,20,30,40,50,60,70};
37 int centrMax[9] = {5,10,20,30,40,50,60,70,80};
38 const int ncentr = ncentrality;
41 //---------Data selection----------
42 //kMC, kGlobal, kESD_TPConly, kESD_SPDtracklet
43 AliFlowTrackCuts::trackParameterType rptype = AliFlowTrackCuts::kTPCstandalone;
44 AliFlowTrackCuts::trackParameterType poitype = AliFlowTrackCuts::kTPCstandalone;
46 //---------Parameter mixing--------
47 //kPure - no mixing, kTrackWithMCkine, kTrackWithMCPID, kTrackWithMCpt
48 AliFlowTrackCuts::trackParameterMix rpmix = AliFlowTrackCuts::kPure;
49 AliFlowTrackCuts::trackParameterMix poimix = AliFlowTrackCuts::kPure;
51 const char* rptypestr = AliFlowTrackCuts::GetParamTypeName(rptype);
52 const char* poitypestr = AliFlowTrackCuts::GetParamTypeName(poitype);
55 //===========================================================================
57 AliFlowEventCuts* cutsEvent[ncentr];
58 AliFlowTrackCuts* cutsRP[ncentr];
59 AliFlowTrackCuts* cutsPOI[ncentr];
60 TString outputSlotName[ncentr][4];
61 TString suffixName[ncentr];
63 for(int icentr=0;icentr<ncentr;icentr++){
64 cutsEvent[icentr] = DefinecutsEvent();
65 //cutsEvent[icentr]->SetUsedDataset(is2011);
66 cutsEvent[icentr]->SetCentralityPercentileRange(centrMin[icentr],centrMax[icentr]);
67 cutsEvent[icentr]->SetCentralityPercentileMethod(AliFlowEventCuts::kV0);
68 // cutsEvent->SetRefMultMethod(AliFlowEventCuts::kVZERO);
69 //cutsEvent->SetCentralityPercentileMethod(AliFlowEventCuts::kSPD1tracklets);
70 //cutsEvent->SetNContributorsRange(2);
71 cutsEvent[icentr]->SetPrimaryVertexZrange(-10.,10.);
72 cutsEvent[icentr]->SetQA(doQA);
73 cutsEvent[icentr]->SetCutTPCmultiplicityOutliers();
77 // AliFlowTrackCuts* cutsRP2 = AliFlowTrackCuts::GetStandardVZEROOnlyTrackCuts();
78 cutsRP[icentr] = DefineRPcuts();
79 cutsRP[icentr]->SetParamType(rptype);
80 cutsRP[icentr]->SetParamMix(rpmix);
81 cutsRP[icentr]->SetPtRange(0.2,5.);
82 cutsRP[icentr]->SetEtaRange(etamin,etamax);
83 cutsRP[icentr]->SetMinNClustersTPC(70);
84 // cutsRP->SetMinChi2PerClusterTPC(0.1);//
85 // cutsRP->SetMaxChi2PerClusterTPC(4.0);//
86 cutsRP[icentr]->SetMaxDCAToVertexXY(3.0);
87 cutsRP[icentr]->SetMaxDCAToVertexZ(3.0);
88 cutsRP[icentr]->SetAcceptKinkDaughters(kFALSE);
89 cutsRP[icentr]->SetMinimalTPCdedx(MinTPCdedx);
90 cutsRP[icentr]->SetAODfilterBit(AODfilterBitRP);
91 cutsRP[icentr]->SetQA(doQA);
94 cutsPOI[icentr] = DefinePOIcuts();
95 cutsPOI[icentr]->GetBayesianResponse()->ForceOldDedx(); // for 2010 data to use old TPC PID Response instead of the official one
96 cutsPOI[icentr]->SetParamType(poitype);
97 cutsPOI[icentr]->SetParamMix(poimix);
98 cutsPOI[icentr]->SetPtRange(0.2,5.);//
99 cutsPOI[icentr]->SetEtaRange(etamin,etamax);
100 //cutsPOI->SetRequireCharge(kTRUE);
101 //cutsPOI->SetPID(PdgRP);
102 cutsPOI[icentr]->SetMinNClustersTPC(70);
103 // cutsPOI->SetMinChi2PerClusterTPC(0.1); //
104 // cutsPOI->SetMaxChi2PerClusterTPC(4.0); //
105 // cutsPOI->SetRequireITSRefit(kTRUE);
106 // cutsPOI->SetRequireTPCRefit(kTRUE);
107 // cutsPOI->SetMinNClustersITS(2);
108 //cutsPOI->SetMaxChi2PerClusterITS(1.e+09);
109 cutsPOI[icentr]->SetMaxDCAToVertexXY(3.0);
110 cutsPOI[icentr]->SetMaxDCAToVertexZ(3.0);
111 //cutsPOI->SetDCAToVertex2D(kTRUE);
112 //cutsPOI->SetMaxNsigmaToVertex(1.e+10);
113 //cutsPOI->SetRequireSigmaToVertex(kFALSE);
114 cutsPOI[icentr]->SetAcceptKinkDaughters(kFALSE);
115 if(isPID) cutsPOI[icentr]->SetPID(particleType, sourcePID);//particleType, sourcePID
116 if (charge!=0) cutsPOI[icentr]->SetCharge(charge);
117 //cutsPOI->SetAllowTOFmismatch(kFALSE);
118 cutsPOI[icentr]->SetRequireStrictTOFTPCagreement(kTRUE);
119 //iexample: francesco's tunig TPC Bethe Bloch for data:
120 cutsPOI[icentr]->SetMinimalTPCdedx(MinTPCdedx);
121 cutsPOI[icentr]->SetAODfilterBit(AODfilterBitPOI);
122 // cutsPOI->SetAODfilterBit(768);
123 cutsPOI[icentr]->SetQA(doQA);
124 cutsPOI[icentr]->SetPriors((centrMin[icentr]+centrMax[icentr])*0.5); // set priors and PID as a function of the centrality
126 //=====================================================================
128 suffixName[icentr] = "highharmflow";
129 suffixName[icentr] += Form("%i", centrMin[icentr]);
130 suffixName[icentr] += Form("%i", centrMax[icentr]);
132 for(int harmonic=2;harmonic<6;harmonic++){ //for v2,v3,v4 and v5
133 outputSlotName[icentr][harmonic-2] = "";
134 outputSlotName[icentr][harmonic-2]+=uniqueStr;
135 outputSlotName[icentr][harmonic-2]+=Form("v%i",harmonic);
136 outputSlotName[icentr][harmonic-2]+=cutsRP[icentr]->GetName();
137 outputSlotName[icentr][harmonic-2]+="_";
138 outputSlotName[icentr][harmonic-2]+=cutsPOI[icentr]->GetName();
139 outputSlotName[icentr][harmonic-2]+=Form("_%i-",centrMin[icentr]);
140 outputSlotName[icentr][harmonic-2]+=Form("%i_",centrMax[icentr]);
144 outputSlotName[icentr][harmonic-2]+=AliFlowTrackCuts::PIDsourceName(sourcePID);//sourcePID
145 outputSlotName[icentr][harmonic-2]+="_";
146 outputSlotName[icentr][harmonic-2]+=AliPID::ParticleName(particleType);//particleType
149 outputSlotName[icentr][harmonic-2]+="AllCharged";
151 if (charge<0) outputSlotName[icentr][harmonic-2]+="-";
152 if (charge>0) outputSlotName[icentr][harmonic-2]+="+";
156 TString fileName(fileNameBase);
157 fileName.Append(".root");
161 //====================================FLOWPACKAGE TASKS=========================//
162 AliAnalysisDataContainer *cinput1[ncentr];
163 AliAnalysisDataContainer *coutputFE[ncentr];
164 AliAnalysisDataContainer* coutputFEQA[ncentr];
165 AliAnalysisTaskFlowEvent *taskFE[ncentr];
167 AliFlowTrackCuts *QC_POI[ncentr], *SP_POI[ncentr][2], *SP_POI_gap[ncentr][2]; // POIs
169 TString outputQA[ncentr];
171 for (int icentr=0; icentr<ncentr; icentr++) {
173 // Get the pointer to the existing analysis manager via the static access method.
174 //==============================================================================
175 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
177 Error("AddTaskFlowEvent", "No analysis manager to connect to.");
181 // Check the analysis type using the event handlers connected to the analysis
182 // manager. The availability of MC handler can also be checked here.
183 //==============================================================================
184 if (!mgr->GetInputEventHandler()) {
185 ::Error("AddTaskFlowEvent", "This task requires an input event handler");
189 taskFE[icentr] = new AliAnalysisTaskFlowEvent(Form("TaskFlowEvent_%s",suffixName[icentr].Data()),"",doQA);
190 taskFE[icentr]->SelectCollisionCandidates(triggerSelectionString);
191 taskFE[icentr]->SetSubeventEtaRange(etamin, -0.5*EtaGap, 0.5*EtaGap, etamax);
192 mgr->AddTask(taskFE[icentr]);
194 // Pass cuts for RPs and POIs to the task:
195 taskFE[icentr]->SetCutsEvent(cutsEvent[icentr]);
196 taskFE[icentr]->SetCutsRP(cutsRP[icentr]);
197 taskFE[icentr]->SetCutsPOI(cutsPOI[icentr]);
198 if (cutsRP[icentr]->GetParamType()==AliFlowTrackCuts::kVZERO)
200 //TODO: since this is set in a static object all analyses in an analysis train
202 taskFE[icentr]->SetHistWeightvsPhiMin(0.);
203 taskFE[icentr]->SetHistWeightvsPhiMax(200.);
205 cinput1[icentr] = mgr->GetCommonInputContainer();
207 coutputFE[icentr] = mgr->CreateContainer(Form("FlowEventSimple_%s_%d",suffixName[icentr].Data(),icentr),AliFlowEventSimple::Class(),AliAnalysisManager::kExchangeContainer);
208 mgr->ConnectInput(taskFE[icentr],0,cinput1[icentr]);
209 mgr->ConnectOutput(taskFE[icentr],1,coutputFE[icentr]);
211 if (taskFE[icentr]->GetQAOn()) {
212 outputQA[icentr] = fileName;
213 outputQA[icentr] += ":QA";
214 coutputFEQA[icentr] = mgr->CreateContainer(Form("QA_%s",suffixName[icentr].Data()), TList::Class(),AliAnalysisManager::kOutputContainer,outputQA[icentr]);
215 mgr->ConnectOutput(taskFE[icentr],2,coutputFEQA[icentr]);
219 //POIs for SP and QC method
220 //===========================================================================
222 //half window for POIs
224 QC_POI[icentr] = new AliFlowTrackCuts(Form("Filter_%d",icentr));
225 QC_POI[icentr]->SetEtaRange( -0.8,+0.8 );
226 QC_POI[icentr]->GetBayesianResponse()->ForceOldDedx(); // for 2010 data to use old TPC PID Response instead of the official one
227 QC_POI[icentr]->SetParamType(poitype);
228 // QC_POI[icentr]->SetParamMix(poimix);
229 QC_POI[icentr]->SetPtRange(0.2,5.);//
230 QC_POI[icentr]->SetMinNClustersTPC(70);
231 // SP_POI->SetMinChi2PerClusterTPC(0.1); //
232 // SP_POI->SetMaxChi2PerClusterTPC(4.0); //
233 // SP_POI->SetRequireITSRefit(kTRUE);
234 // SP_POI->SetRequireTPCRefit(kTRUE);
235 // SP_POI->SetMinNClustersITS(2);
236 // SP_POI->SetMaxChi2PerClusterITS(1.e+09);
237 QC_POI[icentr]->SetMaxDCAToVertexXY(3.0);
238 QC_POI[icentr]->SetMaxDCAToVertexZ(3.0);
239 //SP_POI->SetDCAToVertex2D(kTRUE);
240 //SP_POI->SetMaxNsigmaToVertex(1.e+10);
241 //SP_POI->SetRequireSigmaToVertex(kFALSE);
242 QC_POI[icentr]->SetAcceptKinkDaughters(kFALSE);
243 if(isPID) QC_POI[icentr]->SetPID(particleType, sourcePID);//particleType, sourcePID
244 if (charge!=0) QC_POI[icentr]->SetCharge(charge);
245 //SP_POI->SetAllowTOFmismatch(kFALSE);
246 QC_POI[icentr]->SetRequireStrictTOFTPCagreement(kTRUE);
247 QC_POI[icentr]->SetMinimalTPCdedx(MinTPCdedx);
248 QC_POI[icentr]->SetAODfilterBit(AODfilterBitPOI);
249 QC_POI[icentr]->SetQA(doQA);
250 QC_POI[icentr]->SetPriors((centrMin[icentr]+centrMax[icentr])*0.5);
253 SP_POI[icentr][0] = new AliFlowTrackCuts(Form("Filterhf0_%d",icentr));
254 SP_POI[icentr][1] = new AliFlowTrackCuts(Form("Filterhf1_%d",icentr));
255 for(int hw=0;hw<2;hw++){
256 SP_POI[icentr][hw]->GetBayesianResponse()->ForceOldDedx(); // for 2010 data to use old TPC PID Response instead of the official one
257 SP_POI[icentr][hw]->SetParamType(poitype);
258 // SP_POI[icentr][hw]->SetParamMix(poimix);
259 SP_POI[icentr][hw]->SetPtRange(0.2,5.);//
260 SP_POI[icentr][hw]->SetMinNClustersTPC(70);
261 // SP_POI->SetMinChi2PerClusterTPC(0.1); //
262 // SP_POI->SetMaxChi2PerClusterTPC(4.0); //
263 // SP_POI->SetRequireITSRefit(kTRUE);
264 // SP_POI->SetRequireTPCRefit(kTRUE);
265 // SP_POI->SetMinNClustersITS(2);
266 // SP_POI->SetMaxChi2PerClusterITS(1.e+09);
267 SP_POI[icentr][hw]->SetMaxDCAToVertexXY(3.0);
268 SP_POI[icentr][hw]->SetMaxDCAToVertexZ(3.0);
269 //SP_POI->SetDCAToVertex2D(kTRUE);
270 //SP_POI->SetMaxNsigmaToVertex(1.e+10);
271 //SP_POI->SetRequireSigmaToVertex(kFALSE);
272 SP_POI[icentr][hw]->SetAcceptKinkDaughters(kFALSE);
273 if(isPID) SP_POI[icentr][hw]->SetPID(particleType, sourcePID);//particleType, sourcePID
274 if (charge!=0) SP_POI[icentr][hw]->SetCharge(charge);
275 //SP_POI->SetAllowTOFmismatch(kFALSE);
276 SP_POI[icentr][hw]->SetRequireStrictTOFTPCagreement(kTRUE);
277 SP_POI[icentr][hw]->SetMinimalTPCdedx(MinTPCdedx);
278 SP_POI[icentr][hw]->SetAODfilterBit(AODfilterBitPOI);
279 SP_POI[icentr][hw]->SetQA(doQA);
280 SP_POI[icentr][hw]->SetPriors((centrMin[icentr]+centrMax[icentr])*0.5);
284 SP_POI_gap[icentr][0] = new AliFlowTrackCuts(Form("Filterhf0_%d",icentr));
285 SP_POI_gap[icentr][1] = new AliFlowTrackCuts(Form("Filterhf1_%d",icentr));
286 for(int hw=0;hw<2;hw++){
287 SP_POI_gap[icentr][hw]->GetBayesianResponse()->ForceOldDedx(); // for 2010 data to use old TPC PID Response instead of the official one
288 SP_POI_gap[icentr][hw]->SetParamType(poitype);
289 // SP_POI[icentr][hw]->SetParamMix(poimix);
290 SP_POI_gap[icentr][hw]->SetPtRange(0.2,5.);//
291 SP_POI_gap[icentr][hw]->SetMinNClustersTPC(70);
292 // SP_POI_gap->SetMinChi2PerClusterTPC(0.1); //
293 // SP_POI_gap->SetMaxChi2PerClusterTPC(4.0); //
294 // SP_POI_gap->SetRequireITSRefit(kTRUE);
295 // SP_POI_gap->SetRequireTPCRefit(kTRUE);
296 // SP_POI_gap->SetMinNClustersITS(2);
297 // SP_POI_gap->SetMaxChi2PerClusterITS(1.e+09);
298 SP_POI_gap[icentr][hw]->SetMaxDCAToVertexXY(3.0);
299 SP_POI_gap[icentr][hw]->SetMaxDCAToVertexZ(3.0);
300 //SP_POI_gap->SetDCAToVertex2D(kTRUE);
301 //SP_POI_gap->SetMaxNsigmaToVertex(1.e+10);
302 //SP_POI_gap->SetRequireSigmaToVertex(kFALSE);
303 SP_POI_gap[icentr][hw]->SetAcceptKinkDaughters(kFALSE);
304 if(isPID) SP_POI_gap[icentr][hw]->SetPID(particleType, sourcePID);//particleType, sourcePID
305 if (charge!=0) SP_POI_gap[icentr][hw]->SetCharge(charge);
306 //SP_POI_gap->SetAllowTOFmismatch(kFALSE);
307 SP_POI_gap[icentr][hw]->SetRequireStrictTOFTPCagreement(kTRUE);
308 SP_POI_gap[icentr][hw]->SetMinimalTPCdedx(MinTPCdedx);
309 SP_POI_gap[icentr][hw]->SetAODfilterBit(AODfilterBitPOI);
310 SP_POI_gap[icentr][hw]->SetQA(doQA);
311 SP_POI_gap[icentr][hw]->SetPriors((centrMin[icentr]+centrMax[icentr])*0.5);
317 for(int i=0;i<4;i++){
320 AddQCmethod( "QC", fileName, rptypestr, outputSlotName[icentr][i], triggerSelectionString, coutputFE[icentr], NULL, QC_POI[icentr], harm, icentr); // QC TPC
324 AddSPmethod( "SP", fileName, rptypestr, outputSlotName[icentr][i], triggerSelectionString, coutputFE[icentr], NULL, SP_POI[icentr][0], "Qa", harm, icentr, etamin, etamax,0); // SP Qa
325 AddSPmethod( "SP", fileName, rptypestr, outputSlotName[icentr][i], triggerSelectionString, coutputFE[icentr], NULL, SP_POI[icentr][1], "Qb", harm, icentr, etamin, etamax,0); // SP Qb
327 if(SPSUB && EtaGap!=0){
328 AddSPmethod( "SP", fileName, rptypestr, outputSlotName[icentr][i], triggerSelectionString, coutputFE[icentr], NULL, SP_POI_gap[icentr][0], "Qa", harm, icentr, etamin, etamax, EtaGap); // SP Qa
329 AddSPmethod( "SP", fileName, rptypestr, outputSlotName[icentr][i], triggerSelectionString, coutputFE[icentr], NULL, SP_POI_gap[icentr][1], "Qb", harm, icentr, etamin, etamax, EtaGap); // SP Qb
338 //===========================================================================
340 void AddQCmethod(char *name="",TString fileName="", TString rptypestr="", TString outputSlotName="", Int_t triggerSelectionString=0,AliAnalysisDataContainer* coutputFE,AliFlowTrackCuts* cutsRP, AliFlowTrackCuts* cutsPOI,Int_t harm=2, Int_t icentr=0) {
342 AliAnalysisDataContainer *coutputQC;
343 AliAnalysisTaskQCumulants *taskQC;
345 int centrMin[9] = {0,5,10,20,30,40,50,60,70};
346 int centrMax[9] = {5,10,20,30,40,50,60,70,80};
347 TString folder = "FlowPID_QC_";
348 TString myFolder = Form("%sv%d_%d%d",folder.Data(),harm,centrMin[icentr],centrMax[icentr]);
349 TString myNameQC = Form("%sv%d%s",name,harm,outputSlotName.Data());
350 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
351 AliAnalysisDataContainer *flowEvent = mgr->CreateContainer( Form("TPConly_%s",myFolder.Data()),
352 AliFlowEventSimple::Class(),
353 AliAnalysisManager::kExchangeContainer );
355 AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myNameQC.Data()),
356 AliFlowEventSimple::Class(),
357 AliAnalysisManager::kExchangeContainer );
358 AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myNameQC.Data()),cutsRP, cutsPOI);
359 mgr->AddTask(tskFilter);
360 mgr->ConnectInput( tskFilter,0,coutputFE);
361 mgr->ConnectOutput(tskFilter,1,flowEvent2);
363 taskQC = new AliAnalysisTaskQCumulants(Form("TaskQCumulants_%s",outputSlotName.Data()));
364 taskQC->SelectCollisionCandidates(triggerSelectionString);
365 taskQC->SetCalculateCumulantsVsM(kFALSE);
366 taskQC->SetnBinsMult(10000);
367 taskQC->SetMinMult(0.);
368 taskQC->SetMaxMult(10000.);
369 taskQC->SetHarmonic(harm);
370 taskQC->SetApplyCorrectionForNUA(kFALSE);
371 taskQC->SetFillMultipleControlHistograms(kFALSE);
373 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
375 TString outputQC = fileName;
376 outputQC += ":outputQCanalysis";
377 outputQC+= rptypestr;
379 coutputQC = mgr->CreateContainer(Form("QC_%s",outputSlotName.Data()),
380 TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
381 mgr->AddTask(taskQC);
382 mgr->ConnectInput(taskQC,0,flowEvent2);
383 mgr->ConnectOutput(taskQC,1,coutputQC);
387 void AddSPmethod(char *name="", TString fileName="", TString rptypestr="", TString outputSlotName="", Int_t triggerSelectionString=0,AliAnalysisDataContainer* coutputFE, AliFlowTrackCuts* cutsRP,AliFlowTrackCuts* cutsPOI, char* Qvector, Int_t harm=2, Int_t icentr=0, Double_t etamin=-0.8, Double_t etamax=0.8, Double_t gap=0.0) {
389 AliAnalysisDataContainer *coutputSP;
390 AliAnalysisTaskScalarProduct *taskSP;
392 int centrMin[9] = {0,5,10,20,30,40,50,60,70};
393 int centrMax[9] = {5,10,20,30,40,50,60,70,80};
396 cutsPOI->SetEtaRange( +0.5*gap, +0.8 );
399 cutsPOI->SetEtaRange( -0.8,-0.5*gap );
402 TString folder = "FlowPID_SP_";
403 TString myFolder = Form("%sv%i_%s_%i-%i_%.f",folder.Data(),harm,Qvector,centrMin[icentr],centrMax[icentr],gap*10);
404 TString myNameSP = Form("%s_v%d_%s_%s_%.f",name,harm,Qvector,outputSlotName.Data(),gap*10);
405 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
407 AliAnalysisDataContainer *flowEvent = mgr->CreateContainer( Form("TPConly_%s",myFolder.Data()),
408 AliFlowEventSimple::Class(),
409 AliAnalysisManager::kExchangeContainer );
411 AliAnalysisDataContainer *flowEvent2 = mgr->CreateContainer( Form("Filter_%s", myNameSP.Data()),
412 AliFlowEventSimple::Class(),
413 AliAnalysisManager::kExchangeContainer );
415 AliAnalysisTaskFilterFE *tskFilter = new AliAnalysisTaskFilterFE( Form("TaskFilter_%s",myNameSP.Data()),
417 tskFilter->SetSubeventEtaRange(etamin, -.5*gap, +.5*gap, etamax);
418 mgr->AddTask(tskFilter);
419 mgr->ConnectInput( tskFilter,0,coutputFE);
420 mgr->ConnectOutput(tskFilter,1,flowEvent2);
423 taskSP = new AliAnalysisTaskScalarProduct(Form("TaskScalarProduct_%s",outputSlotName.Data()),kFALSE);
424 taskSP->SetHarmonic(harm);
425 taskSP->SelectCollisionCandidates(triggerSelectionString);
426 taskSP->SetRelDiffMsub(1.0);
427 taskSP->SetTotalQvector(Qvector);
428 taskSP->SetApplyCorrectionForNUA(kTRUE);
430 AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
433 TString outputSP = fileName;
434 outputSP += ":outputSPanalysis";
435 outputSP+= rptypestr;
436 coutputSP = mgr->CreateContainer(Form("SP_%s_%s_%.f",outputSlotName.Data(),Qvector,gap*10),
437 TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
438 mgr->AddTask(taskSP);
439 mgr->ConnectInput(taskSP,0,flowEvent2);
440 mgr->ConnectOutput(taskSP,1,coutputSP);
442 AliFlowEventCuts* DefinecutsEvent(){
443 AliFlowEventCuts* cutsEvent = new AliFlowEventCuts("eventcuts");
446 AliFlowTrackCuts* DefineRPcuts(){
447 AliFlowTrackCuts* cutsRP = new AliFlowTrackCuts("TPConlyRP");
450 AliFlowTrackCuts* DefinePOIcuts(){
451 AliFlowTrackCuts* cutsPOI = new AliFlowTrackCuts("TPConlyPOI");