]> git.uio.no Git - u/mrichter/AliRoot.git/blame - PWG2/FLOW/macros/runProofFlow.C
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
missing options in ctor
[u/mrichter/AliRoot.git] / PWG2 / FLOW / macros / runProofFlow.C
CommitLineData
a2f7afe7 1/////////////////////////////////////////////////////////////////////////////////
2//
3// HOW TO USE THIS MACRO:
4//
5// With this macro several flow analysis can be run.
6// SP = Scalar Product (for PbPb or pp)
7// LYZ1 = Lee Yang Zeroes first run (for PbPb)
8// LYZ2 = Lee Yang Zeroes second run (for PbPb)
9// LYZEP = Lee Yang Zeroes Event Plane (for PbPb)
9bed2723 10// GFC = Cumulants (for PbPb)
e6614983 11// QC = Q-cumulants (for PbPb or pp)
9bed2723 12// FQD = Fitting q-distribution (for PbPb)
a2f7afe7 13// MCEP = Flow calculated from the real MC event plane (for PbPb only)
14//
15// The LYZ analysis should be done in the following order;
16// LYZ1 -> LYZ2 -> LYZEP,
17// because LYZ2 depends on the outputfile of LYZ1 and LYZEP on the outputfile
18// of LYZ2.
19//
20// The MCEP method is a reference method.
21// It can only be run when MC information (kinematics.root & galice.root file)
22// is available in which the reaction plane is stored.
23//
24// One can run on ESD, AOD or MC.
25// Additional options are ESDMC0, ESDMC1. In these options the ESD and MC
26// information is combined. Tracks are selected in the ESD, the PID information
27// is taken from the MC (perfect PID). For ESDMC0 the track kinematics is taken
28// from the ESD and for ESDMC1 it is taken from the MC information.
29//
30///////////////////////////////////////////////////////////////////////////////////
31
32
14db9c04 33// RUN SETTINGS
21e694dd 34
14db9c04 35// Flow analysis method can be:(set to kTRUE or kFALSE)
21e694dd 36Bool_t SP = kTRUE;
8842fb2b 37Bool_t LYZ1 = kTRUE;
bc92c0cb 38Bool_t LYZ2 = kFALSE;
39Bool_t LYZEP = kFALSE;
e04e4ec5 40Bool_t GFC = kTRUE;
e6614983 41Bool_t QC = kTRUE;
9bed2723 42Bool_t FQD = kTRUE;
e04e4ec5 43Bool_t MCEP = kTRUE;
9d062fe3 44
14db9c04 45// Analysis type can be ESD, AOD, MC, ESDMC0, ESDMC1
9d062fe3 46const TString type = "ESD";
47
14db9c04 48// Boolean to fill/not fill the QA histograms
9d062fe3 49Bool_t QA = kFALSE;
50
14db9c04 51// Weights
52//Use weights for Q vector
53Bool_t usePhiWeights = kFALSE; //Phi
54Bool_t usePtWeights = kFALSE; //v'(pt)
55Bool_t useEtaWeights = kFALSE; //v'(eta)
56Bool_t useWeights = usePhiWeights||usePtWeights||useEtaWeights;
21e694dd 57
14db9c04 58
59// SETTING THE CUTS
60
61// For integrated flow
9d062fe3 62const Double_t ptmin1 = 0.0;
e04e4ec5 63const Double_t ptmax1 = 10.0;
5ccd39d8 64const Double_t ymin1 = -1.;
65const Double_t ymax1 = 1.;
9d062fe3 66const Int_t mintrackrefsTPC1 = 2;
67const Int_t mintrackrefsITS1 = 3;
68const Int_t charge1 = 1;
21e694dd 69Bool_t UsePIDIntegratedFlow = kFALSE;
9d062fe3 70const Int_t PDG1 = 211;
71const Int_t minclustersTPC1 = 50;
72const Int_t maxnsigmatovertex1 = 3;
73
14db9c04 74// For differential flow
9d062fe3 75const Double_t ptmin2 = 0.0;
e04e4ec5 76const Double_t ptmax2 = 10.0;
5ccd39d8 77const Double_t ymin2 = -1.;
78const Double_t ymax2 = 1.;
9d062fe3 79const Int_t mintrackrefsTPC2 = 2;
80const Int_t mintrackrefsITS2 = 3;
81const Int_t charge2 = 1;
21e694dd 82Bool_t UsePIDDifferentialFlow = kFALSE;
9d062fe3 83const Int_t PDG2 = 211;
84const Int_t minclustersTPC2 = 50;
85const Int_t maxnsigmatovertex2 = 3;
86
87//ESD (pp)
88//void runProofFlow(const Char_t* data="/COMMON/COMMON/LHC08c11_10TeV_0.5T", Int_t nRuns=-1, Int_t offset=0) {
9bed2723 89//void runProofFlow(const Char_t* data="/COMMON/COMMON/LHC08c18_0.9TeV_0T_Phojet", Int_t nRuns=-1, Int_t offset=0) {
90
a2f7afe7 91//ESD (therminator)
21e694dd 92//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_ESD", Int_t nRuns=-1, Int_t offset=0) {
9bed2723 93
21e694dd 94void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_c2030", Int_t nRuns=-1, Int_t offset=0) {
9bed2723 95//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_central", Int_t nRuns=-1, Int_t offset=0) {
9bed2723 96//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral", Int_t nRuns=-1, Int_t offset=0) {
97
9bed2723 98//AOD
99//void runProofFlow(const Char_t* data="/PWG2/nkolk/myDataSet", Int_t nRuns=-1, Int_t offset=0) {
e04e4ec5 100//void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_AOD", Int_t nRuns=44, Int_t offset=0) {
9d062fe3 101
bc92c0cb 102 TStopwatch timer;
103 timer.Start();
9d062fe3 104
bc92c0cb 105 if (LYZ1 && LYZ2) {cout<<"WARNING: you cannot run LYZ1 and LYZ2 at the same time! LYZ2 needs the output from LYZ1."<<endl; exit(); }
bc92c0cb 106 if (LYZ2 && LYZEP) {cout<<"WARNING: you cannot run LYZ2 and LYZEP at the same time! LYZEP needs the output from LYZ2."<<endl; exit(); }
bc92c0cb 107 if (LYZ1 && LYZEP) {cout<<"WARNING: you cannot run LYZ1 and LYZEP at the same time! LYZEP needs the output from LYZ2."<<endl; exit(); }
108
8842fb2b 109 // set to debug root versus if needed
110 // TProof::Mgr("alicecaf")->SetROOTVersion("v5-21-01-alice_dbg");
111 // TProof::Mgr("alicecaf")->SetROOTVersion("v5-21-01-alice");
5ccd39d8 112
bc92c0cb 113 printf("*** Connect to PROOF ***\n");
29b61d43 114 // TProof::Open("abilandz@alicecaf.cern.ch");
115 TProof::Open("snelling@localhost");
bc92c0cb 116
117 //gProof->UploadPackage("AF-v4-15");
118 //gProof->EnablePackage("AF-v4-15");
dc691b2f 119 gProof->UploadPackage("STEERBase.par");
120 gProof->EnablePackage("STEERBase");
121 gProof->UploadPackage("ESD.par");
122 gProof->EnablePackage("ESD");
123 gProof->UploadPackage("AOD.par");
124 gProof->EnablePackage("AOD");
125 gProof->UploadPackage("ANALYSIS.par");
126 gProof->EnablePackage("ANALYSIS");
127 gProof->UploadPackage("ANALYSISalice.par");
128 gProof->EnablePackage("ANALYSISalice");
129 gProof->UploadPackage("PWG2AOD.par");
130 gProof->EnablePackage("PWG2AOD");
21e694dd 131 gProof->ClearPackage("CORRFW.par");
dc691b2f 132 gProof->UploadPackage("CORRFW.par");
133 gProof->EnablePackage("CORRFW");
29b61d43 134 gProof->ClearPackage("PWG2flowCommon");
135 gProof->UploadPackage("PWG2flowCommon.par");
136 gProof->EnablePackage("PWG2flowCommon");
137 gProof->ClearPackage("PWG2flowTasks");
138 gProof->UploadPackage("PWG2flowTasks.par");
139 gProof->EnablePackage("PWG2flowTasks");
bc92c0cb 140
141
142 //____________________________________________//
143 //Create cuts using correction framework
144
145 //Set TList for the QA histograms
146 if (QA) {
147 if (SP){
148 TList* qaIntSP = new TList();
149 TList* qaDiffSP = new TList(); }
150 if (LYZ1) {
151 TList* qaIntLYZ1 = new TList();
152 TList* qaDiffLYZ1 = new TList(); }
153 if (LYZ2) {
154 TList* qaIntLYZ2 = new TList();
155 TList* qaDiffLYZ2 = new TList(); }
156 if (LYZEP) {
157 TList* qaIntLYZEP = new TList();
158 TList* qaDiffLYZEP = new TList(); }
159 if (GFC) {
160 TList* qaIntGFC = new TList();
161 TList* qaDiffGFC = new TList(); }
e6614983 162 if (QC) {
163 TList* qaIntQC = new TList();
164 TList* qaDiffQC = new TList(); }
9bed2723 165 if (FQD) {
166 TList* qaIntFQD = new TList();
167 TList* qaDiffFQD = new TList(); }
bc92c0cb 168 if (MCEP) {
169 TList* qaIntMCEP = new TList();
170 TList* qaDiffMCEP = new TList(); }
171 }
172
173 //############# cuts on MC
174 AliCFTrackKineCuts* mcKineCuts1 = new AliCFTrackKineCuts("mcKineCuts1","MC-level kinematic cuts");
175 mcKineCuts1->SetPtRange(ptmin1,ptmax1);
176 mcKineCuts1->SetRapidityRange(ymin1,ymax1);
177 mcKineCuts1->SetChargeMC(charge1);
178 if (QA) {
179 if (SP) { mcKineCuts1->SetQAOn(qaIntSP); }
180 if (LYZ1) { mcKineCuts1->SetQAOn(qaIntLYZ1); }
181 if (LYZ2) { mcKineCuts1->SetQAOn(qaIntLYZ2); }
182 if (LYZEP){ mcKineCuts1->SetQAOn(qaIntLYZEP); }
183 if (GFC) { mcKineCuts1->SetQAOn(qaIntGFC); }
e6614983 184 if (QC) { mcKineCuts1->SetQAOn(qaIntQC); }
9bed2723 185 if (FQD) { mcKineCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 186 if (MCEP) { mcKineCuts1->SetQAOn(qaIntMCEP); }
187 }
188
189 AliCFTrackKineCuts* mcKineCuts2 = new AliCFTrackKineCuts("mcKineCuts2","MC-level kinematic cuts");
190 mcKineCuts2->SetPtRange(ptmin2,ptmax2);
191 mcKineCuts2->SetRapidityRange(ymin2,ymax2);
192 mcKineCuts2->SetChargeMC(charge2);
193 if (QA) {
194 if (SP) { mcKineCuts2->SetQAOn(qaDiffSP); }
195 if (LYZ1) { mcKineCuts2->SetQAOn(qaDiffLYZ1); }
196 if (LYZ2) { mcKineCuts2->SetQAOn(qaDiffLYZ2); }
197 if (LYZEP){ mcKineCuts2->SetQAOn(qaDiffLYZEP); }
198 if (GFC) { mcKineCuts2->SetQAOn(qaDiffGFC); }
e6614983 199 if (QC) { mcKineCuts2->SetQAOn(qaDiffQC); }
9bed2723 200 if (FQD) { mcKineCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 201 if (MCEP) { mcKineCuts2->SetQAOn(qaDiffMCEP); }
202 }
203
5ccd39d8 204 AliCFParticleGenCuts* mcGenCuts1 = new AliCFParticleGenCuts("mcGenCuts1","MC particle generation cuts for integrated flow");
bc92c0cb 205 mcGenCuts1->SetRequireIsPrimary();
5ccd39d8 206 if (UsePIDIntegratedFlow) {mcGenCuts1->SetRequirePdgCode(PDG1);}
bc92c0cb 207 if (QA) {
208 if (SP) { mcGenCuts1->SetQAOn(qaIntSP); }
209 if (LYZ1) { mcGenCuts1->SetQAOn(qaIntLYZ1); }
210 if (LYZ2) { mcGenCuts1->SetQAOn(qaIntLYZ2); }
211 if (LYZEP){ mcGenCuts1->SetQAOn(qaIntLYZEP); }
212 if (GFC) { mcGenCuts1->SetQAOn(qaIntGFC); }
e6614983 213 if (QC) { mcGenCuts1->SetQAOn(qaIntQC); }
9bed2723 214 if (FQD) { mcGenCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 215 if (MCEP) { mcGenCuts1->SetQAOn(qaIntMCEP); }
216 }
217
5ccd39d8 218 AliCFParticleGenCuts* mcGenCuts2 = new AliCFParticleGenCuts("mcGenCuts2","MC particle generation cuts for differential flow");
bc92c0cb 219 mcGenCuts2->SetRequireIsPrimary();
5ccd39d8 220 if (UsePIDDifferentialFlow) {mcGenCuts2->SetRequirePdgCode(PDG2);}
bc92c0cb 221 if (QA) {
222 if (SP) { mcGenCuts2->SetQAOn(qaDiffSP); }
223 if (LYZ1) { mcGenCuts2->SetQAOn(qaDiffLYZ1); }
224 if (LYZ2) { mcGenCuts2->SetQAOn(qaDiffLYZ2); }
225 if (LYZEP){ mcGenCuts2->SetQAOn(qaDiffLYZEP); }
226 if (GFC) { mcGenCuts2->SetQAOn(qaDiffGFC); }
e6614983 227 if (QC) { mcGenCuts2->SetQAOn(qaDiffQC); }
9bed2723 228 if (FQD) { mcGenCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 229 if (MCEP) { mcGenCuts2->SetQAOn(qaDiffMCEP); }
230 }
231
232 //############# Acceptance Cuts
233 AliCFAcceptanceCuts *mcAccCuts1 = new AliCFAcceptanceCuts("mcAccCuts1","MC acceptance cuts");
234 mcAccCuts1->SetMinNHitITS(mintrackrefsITS1);
235 mcAccCuts1->SetMinNHitTPC(mintrackrefsTPC1);
236 if (QA) {
237 if (SP) { mcAccCuts1->SetQAOn(qaIntSP); }
238 if (LYZ1) { mcAccCuts1->SetQAOn(qaIntLYZ1); }
239 if (LYZ2) { mcAccCuts1->SetQAOn(qaIntLYZ2); }
240 if (LYZEP){ mcAccCuts1->SetQAOn(qaIntLYZEP); }
241 if (GFC) { mcAccCuts1->SetQAOn(qaIntGFC); }
e6614983 242 if (QC) { mcAccCuts1->SetQAOn(qaIntQC); }
9bed2723 243 if (FQD) { mcAccCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 244 if (MCEP) { mcAccCuts1->SetQAOn(qaIntMCEP); }
245 }
246
247 AliCFAcceptanceCuts *mcAccCuts2 = new AliCFAcceptanceCuts("mcAccCuts2","MC acceptance cuts");
248 mcAccCuts2->SetMinNHitITS(mintrackrefsITS2);
249 mcAccCuts2->SetMinNHitTPC(mintrackrefsTPC2);
250 if (QA) {
251 if (SP) { mcAccCuts2->SetQAOn(qaDiffSP); }
252 if (LYZ1) { mcAccCuts2->SetQAOn(qaDiffLYZ1); }
253 if (LYZ2) { mcAccCuts2->SetQAOn(qaDiffLYZ2); }
254 if (LYZEP){ mcAccCuts2->SetQAOn(qaDiffLYZEP); }
255 if (GFC) { mcAccCuts2->SetQAOn(qaDiffGFC); }
e6614983 256 if (QC) { mcAccCuts2->SetQAOn(qaDiffQC); }
9bed2723 257 if (FQD) { mcAccCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 258 if (MCEP) { mcAccCuts2->SetQAOn(qaDiffMCEP); }
259 }
260
261 //############# Rec-Level kinematic cuts
262 AliCFTrackKineCuts *recKineCuts1 = new AliCFTrackKineCuts("recKineCuts1","rec-level kine cuts");
263 recKineCuts1->SetPtRange(ptmin1,ptmax1);
264 recKineCuts1->SetRapidityRange(ymin1,ymax1);
265 recKineCuts1->SetChargeRec(charge1);
266 if (QA) {
267 if (SP) { recKineCuts1->SetQAOn(qaIntSP); }
268 if (LYZ1) { recKineCuts1->SetQAOn(qaIntLYZ1); }
269 if (LYZ2) { recKineCuts1->SetQAOn(qaIntLYZ2); }
270 if (LYZEP){ recKineCuts1->SetQAOn(qaIntLYZEP); }
271 if (GFC) { recKineCuts1->SetQAOn(qaIntGFC); }
e6614983 272 if (QC) { recKineCuts1->SetQAOn(qaIntQC); }
9bed2723 273 if (FQD) { recKineCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 274 if (MCEP) { recKineCuts1->SetQAOn(qaIntMCEP); }
275 }
276
277 AliCFTrackKineCuts *recKineCuts2 = new AliCFTrackKineCuts("recKineCuts2","rec-level kine cuts");
278 recKineCuts2->SetPtRange(ptmin2,ptmax2);
279 recKineCuts2->SetRapidityRange(ymin2,ymax2);
280 recKineCuts2->SetChargeRec(charge2);
281 if (QA) {
282 if (SP) { recKineCuts2->SetQAOn(qaDiffSP); }
283 if (LYZ1) { recKineCuts2->SetQAOn(qaDiffLYZ1); }
284 if (LYZ2) { recKineCuts2->SetQAOn(qaDiffLYZ2); }
285 if (LYZEP){ recKineCuts2->SetQAOn(qaDiffLYZEP); }
286 if (GFC) { recKineCuts2->SetQAOn(qaDiffGFC); }
e6614983 287 if (QC) { recKineCuts2->SetQAOn(qaDiffQC); }
9bed2723 288 if (FQD) { recKineCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 289 if (MCEP) { recKineCuts2->SetQAOn(qaDiffMCEP); }
290 }
291
292 AliCFTrackQualityCuts *recQualityCuts1 = new AliCFTrackQualityCuts("recQualityCuts1","rec-level quality cuts");
293 recQualityCuts1->SetMinNClusterTPC(minclustersTPC1);
294 recQualityCuts1->SetStatus(AliESDtrack::kITSrefit);
295 if (QA) {
296 if (SP) { recQualityCuts1->SetQAOn(qaIntSP); }
297 if (LYZ1) { recQualityCuts1->SetQAOn(qaIntLYZ1); }
298 if (LYZ2) { recQualityCuts1->SetQAOn(qaIntLYZ2); }
299 if (LYZEP){ recQualityCuts1->SetQAOn(qaIntLYZEP); }
300 if (GFC) { recQualityCuts1->SetQAOn(qaIntGFC); }
e6614983 301 if (QC) { recQualityCuts1->SetQAOn(qaIntQC); }
9bed2723 302 if (FQD) { recQualityCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 303 if (MCEP) { recQualityCuts1->SetQAOn(qaIntMCEP); }
304 }
305
306 AliCFTrackQualityCuts *recQualityCuts2 = new AliCFTrackQualityCuts("recQualityCuts2","rec-level quality cuts");
307 recQualityCuts2->SetMinNClusterTPC(minclustersTPC2);
308 recQualityCuts2->SetStatus(AliESDtrack::kITSrefit);
309 if (QA) {
310 if (SP) { recQualityCuts2->SetQAOn(qaDiffSP); }
311 if (LYZ1) { recQualityCuts2->SetQAOn(qaDiffLYZ1); }
312 if (LYZ2) { recQualityCuts2->SetQAOn(qaDiffLYZ2); }
313 if (LYZEP){ recQualityCuts2->SetQAOn(qaDiffLYZEP); }
314 if (GFC) { recQualityCuts2->SetQAOn(qaDiffGFC); }
e6614983 315 if (QC) { recQualityCuts2->SetQAOn(qaDiffQC); }
9bed2723 316 if (FQD) { recQualityCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 317 if (MCEP) { recQualityCuts2->SetQAOn(qaDiffMCEP); }
318 }
9d062fe3 319
bc92c0cb 320 AliCFTrackIsPrimaryCuts *recIsPrimaryCuts1 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts1","rec-level isPrimary cuts");
321 recIsPrimaryCuts1->SetMaxNSigmaToVertex(maxnsigmatovertex1);
322 if (QA) {
323 if (SP) { recIsPrimaryCuts1->SetQAOn(qaIntSP); }
324 if (LYZ1) { recIsPrimaryCuts1->SetQAOn(qaIntLYZ1); }
325 if (LYZ2) { recIsPrimaryCuts1->SetQAOn(qaIntLYZ2); }
326 if (LYZEP){ recIsPrimaryCuts1->SetQAOn(qaIntLYZEP); }
327 if (GFC) { recIsPrimaryCuts1->SetQAOn(qaIntGFC); }
e6614983 328 if (QC) { recIsPrimaryCuts1->SetQAOn(qaIntQC); }
9bed2723 329 if (FQD) { recIsPrimaryCuts1->SetQAOn(qaIntFQD); }
bc92c0cb 330 if (MCEP) { recIsPrimaryCuts1->SetQAOn(qaIntMCEP); }
331 }
332
333 AliCFTrackIsPrimaryCuts *recIsPrimaryCuts2 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts2","rec-level isPrimary cuts");
334 recIsPrimaryCuts2->SetMaxNSigmaToVertex(maxnsigmatovertex2);
335 if (QA) {
336 if (SP) { recIsPrimaryCuts2->SetQAOn(qaDiffSP); }
337 if (LYZ1) { recIsPrimaryCuts2->SetQAOn(qaDiffLYZ1); }
338 if (LYZ2) { recIsPrimaryCuts2->SetQAOn(qaDiffLYZ2); }
339 if (LYZEP){ recIsPrimaryCuts2->SetQAOn(qaDiffLYZEP); }
340 if (GFC) { recIsPrimaryCuts2->SetQAOn(qaDiffGFC); }
e6614983 341 if (QC) { recIsPrimaryCuts2->SetQAOn(qaDiffQC); }
9bed2723 342 if (FQD) { recIsPrimaryCuts2->SetQAOn(qaDiffFQD); }
bc92c0cb 343 if (MCEP) { recIsPrimaryCuts2->SetQAOn(qaDiffMCEP); }
344 }
9d062fe3 345
bc92c0cb 346 int n_species = AliPID::kSPECIES ;
347 Double_t* prior = new Double_t[n_species];
348
349 prior[0] = 0.0244519 ;
350 prior[1] = 0.0143988 ;
351 prior[2] = 0.805747 ;
352 prior[3] = 0.0928785 ;
353 prior[4] = 0.0625243 ;
5ccd39d8 354
355 AliCFTrackCutPid* cutPID1 = NULL;
356 if(UsePIDIntegratedFlow) {
357 AliCFTrackCutPid* cutPID1 = new AliCFTrackCutPid("cutPID1","ESD_PID for integrated flow") ;
358 cutPID1->SetPriors(prior);
359 cutPID1->SetProbabilityCut(0.0);
360 cutPID1->SetDetectors("TPC TOF");
361 switch(TMath::Abs(PDG1)) {
362 case 11 : cutPID1->SetParticleType(AliPID::kElectron, kTRUE); break;
363 case 13 : cutPID1->SetParticleType(AliPID::kMuon , kTRUE); break;
364 case 211 : cutPID1->SetParticleType(AliPID::kPion , kTRUE); break;
365 case 321 : cutPID1->SetParticleType(AliPID::kKaon , kTRUE); break;
366 case 2212 : cutPID1->SetParticleType(AliPID::kProton , kTRUE); break;
367 default : printf("UNDEFINED PID\n"); break;
368 }
369 if (QA) {
370 if (SP) {cutPID1->SetQAOn(qaIntSP);}
371 if (LYZ1) {cutPID1->SetQAOn(qaIntLYZ1);}
372 if (LYZ2) {cutPID1->SetQAOn(qaIntLYZ2);}
373 if (LYZEP){cutPID1->SetQAOn(qaIntLYZEP);}
374 if (GFC) {cutPID1->SetQAOn(qaIntGFC);}
375 if (QC) {cutPID1->SetQAOn(qaIntQC);}
376 if (FQD) {cutPID1->SetQAOn(qaIntFQD);}
377 if (MCEP) {cutPID1->SetQAOn(qaIntMCEP);}
378 }
bc92c0cb 379 }
5ccd39d8 380
381 AliCFTrackCutPid* cutPID2 = NULL;
382 if (UsePIDDifferentialFlow) {
383 AliCFTrackCutPid* cutPID2 = new AliCFTrackCutPid("cutPID2","ESD_PID for differential flow") ;
384 cutPID2->SetPriors(prior);
385 cutPID2->SetProbabilityCut(0.0);
386 cutPID2->SetDetectors("TPC TOF");
387 switch(TMath::Abs(PDG2)) {
388 case 11 : cutPID2->SetParticleType(AliPID::kElectron, kTRUE); break;
389 case 13 : cutPID2->SetParticleType(AliPID::kMuon , kTRUE); break;
390 case 211 : cutPID2->SetParticleType(AliPID::kPion , kTRUE); break;
391 case 321 : cutPID2->SetParticleType(AliPID::kKaon , kTRUE); break;
392 case 2212 : cutPID2->SetParticleType(AliPID::kProton , kTRUE); break;
393 default : printf("UNDEFINED PID\n"); break;
394 }
395 if (QA) {
396 if (SP) {cutPID2->SetQAOn(qaIntSP);}
397 if (LYZ1) {cutPID2->SetQAOn(qaIntLYZ1);}
398 if (LYZ2) {cutPID2->SetQAOn(qaIntLYZ2);}
399 if (LYZEP){cutPID2->SetQAOn(qaIntLYZEP);}
400 if (GFC) {cutPID2->SetQAOn(qaIntGFC);}
401 if (QC) {cutPID2->SetQAOn(qaIntQC);}
402 if (FQD) {cutPID2->SetQAOn(qaIntFQD);}
403 if (MCEP) {cutPID2->SetQAOn(qaIntMCEP);}
404 }
bc92c0cb 405 }
406
407 printf("CREATE MC KINE CUTS\n");
408 TObjArray* mcList1 = new TObjArray(0);
409 mcList1->AddLast(mcKineCuts1);
410 mcList1->AddLast(mcGenCuts1);
411
412 TObjArray* mcList2 = new TObjArray(0);
413 mcList2->AddLast(mcKineCuts2);
414 mcList2->AddLast(mcGenCuts2);
415
416 printf("CREATE ACCEPTANCE CUTS\n");
417 TObjArray* accList1 = new TObjArray(0) ;
418 accList1->AddLast(mcAccCuts1);
419
420 TObjArray* accList2 = new TObjArray(0) ;
421 accList2->AddLast(mcAccCuts2);
422
423 printf("CREATE RECONSTRUCTION CUTS\n");
424 TObjArray* recList1 = new TObjArray(0) ;
425 recList1->AddLast(recKineCuts1);
426 recList1->AddLast(recQualityCuts1);
427 recList1->AddLast(recIsPrimaryCuts1);
428
429 TObjArray* recList2 = new TObjArray(0) ;
430 recList2->AddLast(recKineCuts2);
431 recList2->AddLast(recQualityCuts2);
432 recList2->AddLast(recIsPrimaryCuts2);
433
434 printf("CREATE PID CUTS\n");
435 TObjArray* fPIDCutList1 = new TObjArray(0) ;
5ccd39d8 436 if(UsePIDIntegratedFlow) {fPIDCutList1->AddLast(cutPID1);}
bc92c0cb 437
438 TObjArray* fPIDCutList2 = new TObjArray(0) ;
5ccd39d8 439 if (UsePIDDifferentialFlow) {fPIDCutList2->AddLast(cutPID2);}
bc92c0cb 440
441 printf("CREATE INTERFACE AND CUTS\n");
442 AliCFManager* cfmgr1 = new AliCFManager();
21e694dd 443 // cfmgr1->SetNStepParticle(4); //05nov08
bc92c0cb 444 cfmgr1->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList1);
445 cfmgr1->SetParticleCutsList(AliCFManager::kPartAccCuts,accList1);
446 cfmgr1->SetParticleCutsList(AliCFManager::kPartRecCuts,recList1);
447 cfmgr1->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList1);
448
449 AliCFManager* cfmgr2 = new AliCFManager();
21e694dd 450 // cfmgr2->SetNStepParticle(4); //05nov08
bc92c0cb 451 cfmgr2->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList2);
452 cfmgr2->SetParticleCutsList(AliCFManager::kPartAccCuts,accList2);
453 cfmgr2->SetParticleCutsList(AliCFManager::kPartRecCuts,recList2);
454 cfmgr2->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList2);
455
14db9c04 456 //weights:
457 TFile *weightsFile = NULL;
458 TList *weightsList = NULL;
21e694dd 459
14db9c04 460 if(useWeights) {
461 //open the file with the weights:
462 weightsFile = TFile::Open("weights.root","READ");
463 if(weightsFile) {
464 //access the list which holds the histos with weigths:
465 weightsList = (TList*)weightsFile->Get("weights");
466 }
467 else {
468 cout<<" WARNING: the file <weights.root> with weights from the previous run was not available."<<endl;
469 break;
470 }
471 }
e04e4ec5 472
e04e4ec5 473
bc92c0cb 474 if (LYZ2){
475 // read the input file from the first run
476 TString inputFileNameLYZ2 = "outputLYZ1analysis" ;
477 inputFileNameLYZ2 += type;
e04e4ec5 478 inputFileNameLYZ2 += ".root";
bc92c0cb 479 cout<<"The input file is "<<inputFileNameLYZ2.Data()<<endl;
480 TFile* fInputFileLYZ2 = new TFile(inputFileNameLYZ2.Data(),"READ");
481 if(!fInputFileLYZ2 || fInputFileLYZ2->IsZombie()) {
482 cerr << " ERROR: NO First Run file... " << endl ; }
483 else {
484 TList* fInputListLYZ2 = (TList*)fInputFileLYZ2->Get("cobjLYZ1");
485 if (!fInputListLYZ2) {cout<<"list is NULL pointer!"<<endl;}
486 }
487 cout<<"LYZ2 input file/list read..."<<endl;
488 }
489
490 if (LYZEP) {
491 // read the input file from the second LYZ run
492 TString inputFileNameLYZEP = "outputLYZ2analysis" ;
493 inputFileNameLYZEP += type;
21e694dd 494 inputFileNameLYZEP += "_secondrun.root";
bc92c0cb 495 cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
496 TFile* fInputFileLYZEP = new TFile(inputFileNameLYZEP.Data(),"READ");
497 if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) {
498 cerr << " ERROR: NO First Run file... " << endl ; }
499 else {
500 TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2");
501 if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
21e694dd 502 }kTRUE;
bc92c0cb 503 cout<<"LYZEP input file/list read..."<<endl;
504 }
505
506 //____________________________________________//
507 // Make the analysis manager
508 AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
509
510 if (type == "ESD"){
511 AliVEventHandler* esdH = new AliESDInputHandler;
512 mgr->SetInputEventHandler(esdH);
513 if (MCEP) {
514 AliMCEventHandler *mc = new AliMCEventHandler();
515 mgr->SetMCtruthEventHandler(mc);} }
516
517 if (type == "AOD"){
518 AliVEventHandler* aodH = new AliAODInputHandler;
519 mgr->SetInputEventHandler(aodH);
520 if (MCEP) {
521 AliMCEventHandler *mc = new AliMCEventHandler();
522 mgr->SetMCtruthEventHandler(mc);} }
523
524 if (type == "MC" || type == "ESDMC0" || type == "ESDMC1"){
525 AliVEventHandler* esdH = new AliESDInputHandler;
526 mgr->SetInputEventHandler(esdH);
9d062fe3 527
bc92c0cb 528 AliMCEventHandler *mc = new AliMCEventHandler();
529 mgr->SetMCtruthEventHandler(mc); }
21e694dd 530
bc92c0cb 531 //____________________________________________//
532 // tasks
533 if (SP){
534 if (QA) { AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",kTRUE); }
535 else { AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",kFALSE); }
536 taskSP->SetAnalysisType(type);
537 taskSP->SetCFManager1(cfmgr1);
538 taskSP->SetCFManager2(cfmgr2);
539 if (QA) {
540 taskSP->SetQAList1(qaIntSP);
541 taskSP->SetQAList2(qaDiffSP); }
542 mgr->AddTask(taskSP);
9d062fe3 543 }
bc92c0cb 544 if (LYZ1){
9d062fe3 545 if (QA) { AliAnalysisTaskLeeYangZeros *taskLYZ1 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kTRUE,kTRUE);}
546 else { AliAnalysisTaskLeeYangZeros *taskLYZ1 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kTRUE,kFALSE);}
547 taskLYZ1->SetAnalysisType(type);
548 taskLYZ1->SetFirstRunLYZ(kTRUE);
549 taskLYZ1->SetUseSumLYZ(kTRUE);
550 taskLYZ1->SetCFManager1(cfmgr1);
551 taskLYZ1->SetCFManager2(cfmgr2);
552 if (QA) {
bc92c0cb 553 taskLYZ1->SetQAList1(qaIntLYZ1);
554 taskLYZ1->SetQAList2(qaDiffLYZ1);}
9d062fe3 555 mgr->AddTask(taskLYZ1);
556 }
bc92c0cb 557 if (LYZ2){
9d062fe3 558 if (QA) { AliAnalysisTaskLeeYangZeros *taskLYZ2 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kFALSE,kTRUE);}
559 else { AliAnalysisTaskLeeYangZeros *taskLYZ2 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kFALSE,kFALSE); }
560 taskLYZ2->SetAnalysisType(type);
561 taskLYZ2->SetFirstRunLYZ(kFALSE);
562 taskLYZ2->SetUseSumLYZ(kTRUE);
563 taskLYZ2->SetCFManager1(cfmgr1);
564 taskLYZ2->SetCFManager2(cfmgr2);
565 if (QA) {
bc92c0cb 566 taskLYZ2->SetQAList1(qaIntLYZ2);
567 taskLYZ2->SetQAList2(qaDiffLYZ2); }
9d062fe3 568 mgr->AddTask(taskLYZ2);
569 }
bc92c0cb 570 if (LYZEP){
9d062fe3 571 if (QA) { AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane",kTRUE); }
572 else { AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane",kFALSE); }
573 taskLYZEP->SetAnalysisType(type);
574 taskLYZEP->SetCFManager1(cfmgr1);
575 taskLYZEP->SetCFManager2(cfmgr2);
576 if (QA) {
bc92c0cb 577 taskLYZEP->SetQAList1(qaIntLYZEP);
578 taskLYZEP->SetQAList2(qaDiffLYZEP); }
9d062fe3 579 mgr->AddTask(taskLYZEP);
580 }
bc92c0cb 581 if (GFC){
582 if (QA) { AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",kTRUE);}
583 else { AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",kFALSE);}
584 taskGFC->SetAnalysisType(type);
585 taskGFC->SetCFManager1(cfmgr1);
586 taskGFC->SetCFManager2(cfmgr2);
9d062fe3 587 if (QA) {
bc92c0cb 588 taskGFC->SetQAList1(qaIntGFC);
589 taskGFC->SetQAList2(qaDiffGFC); }
590 mgr->AddTask(taskGFC);
9d062fe3 591 }
e6614983 592 if (QC){
39a10c54 593 if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE,useWeights);}
594 else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE,useWeights);}
e6614983 595 taskQC->SetAnalysisType(type);
596 taskQC->SetCFManager1(cfmgr1);
597 taskQC->SetCFManager2(cfmgr2);
598 if (QA) {
599 taskQC->SetQAList1(qaIntQC);
600 taskQC->SetQAList2(qaDiffQC); }
601 mgr->AddTask(taskQC);
602 }
9bed2723 603 if (FQD){
39a10c54 604 if (QA) { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kTRUE,useWeights);}
605 else { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE,useWeights);}
9bed2723 606 taskFQD->SetAnalysisType(type);
607 taskFQD->SetCFManager1(cfmgr1);
608 taskFQD->SetCFManager2(cfmgr2);
609 if (QA) {
610 taskFQD->SetQAList1(qaIntFQD);
611 taskFQD->SetQAList2(qaDiffFQD); }
612 mgr->AddTask(taskFQD);
613 }
bc92c0cb 614 if (MCEP){
9d062fe3 615 if (QA) { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kTRUE);}
616 else { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kFALSE);}
617 taskMCEP->SetAnalysisType(type);
618 taskMCEP->SetCFManager1(cfmgr1);
619 taskMCEP->SetCFManager2(cfmgr2);
620 if (QA) {
bc92c0cb 621 taskMCEP->SetQAList1(qaIntMCEP);
622 taskMCEP->SetQAList2(qaDiffMCEP); }
9d062fe3 623 mgr->AddTask(taskMCEP);
624 }
21e694dd 625
626
bc92c0cb 627 // Create containers for input/output
628 AliAnalysisDataContainer *cinput1 =
9d062fe3 629 mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
bc92c0cb 630
20e52807 631 if (useWeights) {
632 AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
633 }
634
bc92c0cb 635 if (LYZ2){
636 AliAnalysisDataContainer *cinputLYZ2 = mgr->CreateContainer("cobjLYZ2in",TList::Class(),AliAnalysisManager::kInputContainer); }
637 if (LYZEP){
638 AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer); }
639
640 if(SP) {
641 TString outputSP = "outputSPanalysis";
642 outputSP+= type;
643 outputSP+= ".root";
644 AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
9d062fe3 645 }
9d062fe3 646
bc92c0cb 647 if(LYZ1) {
648 TString outputLYZ1 = "outputLYZ1analysis";
649 outputLYZ1+= type;
21e694dd 650 outputLYZ1+= "_firstrun.root";
bc92c0cb 651 AliAnalysisDataContainer *coutputLYZ1 = mgr->CreateContainer("cobjLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1);
652 }
653
654 if(LYZ2) {
655 TString outputLYZ2 = "outputLYZ2analysis";
656 outputLYZ2+= type;
21e694dd 657 outputLYZ2+= "_secondrun.root";
bc92c0cb 658 AliAnalysisDataContainer *coutputLYZ2 = mgr->CreateContainer("cobjLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2);
659 }
660
661 if(LYZEP) {
662 TString outputLYZEP = "outputLYZEPanalysis";
663 outputLYZEP+= type;
664 outputLYZEP+= ".root";
665 AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
666 }
667
668 if(GFC) {
669 TString outputGFC = "outputGFCanalysis";
670 outputGFC+= type;
671 outputGFC+= ".root";
672 AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
673 }
674
e6614983 675 if(QC) {
676 TString outputQC = "outputQCanalysis";
677 outputQC+= type;
678 outputQC+= ".root";
679 AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
680 }
681
9bed2723 682 if(FQD) {
683 TString outputFQD = "outputFQDanalysis";
684 outputFQD+= type;
685 outputFQD+= ".root";
686 AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
687 }
688
bc92c0cb 689 if(MCEP) {
690 TString outputMCEP = "outputMCEPanalysis";
691 outputMCEP+= type;
692 outputMCEP+= ".root";
693 AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
694 }
21e694dd 695
696
bc92c0cb 697 if (QA) {
698 if(SP) {
699 TString qaNameIntSP = "QAforInt_SP_";
700 qaNameIntSP += type;
701 qaNameIntSP += ".root";
702 AliAnalysisDataContainer *coutputQA1SP =
703 mgr->CreateContainer("QAintSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntSP);
704
705 TString qaNameDiffSP = "QAforDiff_SP_";
706 qaNameDiffSP += type;
707 qaNameDiffSP += ".root";
708 AliAnalysisDataContainer *coutputQA2SP =
709 mgr->CreateContainer("QAdiffSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffSP);
710 }
711 if(LYZ1) {
712 TString qaNameIntLYZ1 = "QAforInt_LYZ1_";
713 qaNameIntLYZ1 += type;
714 qaNameIntLYZ1 += ".root";
715 AliAnalysisDataContainer *coutputQA1LYZ1 =
716 mgr->CreateContainer("QAintLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ1);
717
718 TString qaNameDiffLYZ1 = "QAforDiff_LYZ1_";
719 qaNameDiffLYZ1 += type;
720 qaNameDiffLYZ1 += ".root";
721 AliAnalysisDataContainer *coutputQA2LYZ1 =
722 mgr->CreateContainer("QAdiffLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ1);
723 }
724 if(LYZ2) {
725 TString qaNameIntLYZ2 = "QAforInt_LYZ2_";
726 qaNameIntLYZ2 += type;
727 qaNameIntLYZ2 += ".root";
728 AliAnalysisDataContainer *coutputQA1LYZ2 =
729 mgr->CreateContainer("QAintLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ2);
730
731 TString qaNameDiffLYZ2 = "QAforDiff_LYZ2_";
732 qaNameDiffLYZ2 += type;
733 qaNameDiffLYZ2 += ".root";
734 AliAnalysisDataContainer *coutputQA2LYZ2 =
735 mgr->CreateContainer("QAdiffLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ2);
736 }
737 if(LYZEP) {
738 TString qaNameIntLYZEP = "QAforInt_LYZEP_";
739 qaNameIntLYZEP += type;
740 qaNameIntLYZEP += ".root";
741 AliAnalysisDataContainer *coutputQA1LYZEP =
742 mgr->CreateContainer("QAintLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZEP);
743
744 TString qaNameDiffLYZEP = "QAforDiff_LYZEP_";
745 qaNameDiffLYZEP += type;
746 qaNameDiffLYZEP += ".root";
747 AliAnalysisDataContainer *coutputQA2LYZEP =
748 mgr->CreateContainer("QAdiffLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZEP);
749 }
750 if(GFC) {
751 TString qaNameIntGFC = "QAforInt_GFC_";
752 qaNameIntGFC += type;
753 qaNameIntGFC += ".root";
754 AliAnalysisDataContainer *coutputQA1GFC =
755 mgr->CreateContainer("QAintGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntGFC);
756
757 TString qaNameDiffGFC = "QAforDiff_GFC_";
758 qaNameDiffGFC += type;
759 qaNameDiffGFC += ".root";
760 AliAnalysisDataContainer *coutputQA2GFC =
761 mgr->CreateContainer("QAdiffGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffGFC);
762 }
e6614983 763 if(QC) {
764 TString qaNameIntQC = "QAforInt_QC_";
765 qaNameIntQC += type;
766 qaNameIntQC += ".root";
767 AliAnalysisDataContainer *coutputQA1QC =
768 mgr->CreateContainer("QAintQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntQC);
769
770 TString qaNameDiffQC = "QAforDiff_QC_";
771 qaNameDiffQC += type;
772 qaNameDiffQC += ".root";
773 AliAnalysisDataContainer *coutputQA2QC =
774 mgr->CreateContainer("QAdiffQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffQC);
775 }
9bed2723 776 if(FQQ) {
777 TString qaNameIntFQD = "QAforInt_FQD_";
778 qaNameIntFQD += type;
779 qaNameIntFQD += ".root";
780 AliAnalysisDataContainer *coutputQA1FQD =
781 mgr->CreateContainer("QAintFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntFQD);
782
783 TString qaNameDiffFQD = "QAforDiff_FQD_";
784 qaNameDiffFQD += type;
785 qaNameDiffFQD += ".root";
786 AliAnalysisDataContainer *coutputQA2FQD =
787 mgr->CreateContainer("QAdiffFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffFQD);
788 }
bc92c0cb 789 if(MCEP) {
790 TString qaNameIntMCEP = "QAforInt_MCEP_";
791 qaNameIntMCEP += type;
792 qaNameIntMCEP += ".root";
793 AliAnalysisDataContainer *coutputQA1MCEP =
794 mgr->CreateContainer("QAintMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntMCEP);
795
796 TString qaNameDiffMCEP = "QAforDiff_MCEP_";
797 qaNameDiffMCEP += type;
798 qaNameDiffMCEP += ".root";
799 AliAnalysisDataContainer *coutputQA2MCEP =
800 mgr->CreateContainer("QAdiffMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffMCEP);
801 }
802 }
803
804
805 //____________________________________________//
806
807 if (SP) {
9d062fe3 808 mgr->ConnectInput(taskSP,0,cinput1);
bc92c0cb 809 mgr->ConnectOutput(taskSP,0,coutputSP);
810 if (QA) { mgr->ConnectOutput(taskSP,1,coutputQA1SP);
811 mgr->ConnectOutput(taskSP,2,coutputQA2SP); }
9d062fe3 812 }
bc92c0cb 813 if (LYZ1) {
9d062fe3 814 mgr->ConnectInput(taskLYZ1,0,cinput1);
bc92c0cb 815 mgr->ConnectOutput(taskLYZ1,0,coutputLYZ1);
816 if (QA) { mgr->ConnectOutput(taskLYZ1,1,coutputQA1LYZ1);
817 mgr->ConnectOutput(taskLYZ1,2,coutputQA2LYZ1); }
9d062fe3 818 }
bc92c0cb 819 if (LYZ2) {
9d062fe3 820 mgr->ConnectInput(taskLYZ2,0,cinput1);
bc92c0cb 821 mgr->ConnectInput(taskLYZ2,1,cinputLYZ2);
822 mgr->ConnectOutput(taskLYZ2,0,coutputLYZ2);
823 if (QA) { mgr->ConnectOutput(taskLYZ2,1,coutputQA1LYZ2);
824 mgr->ConnectOutput(taskLYZ2,2,coutputQA2LYZ2); }
825 cinputLYZ2->SetData(fInputListLYZ2);
9d062fe3 826 }
bc92c0cb 827 if (LYZEP) {
9d062fe3 828 mgr->ConnectInput(taskLYZEP,0,cinput1);
bc92c0cb 829 mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
830 mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
831 if (QA) { mgr->ConnectOutput(taskLYZEP,1,coutputQA1LYZEP);
832 mgr->ConnectOutput(taskLYZEP,2,coutputQA2LYZEP); }
833 cinputLYZEP->SetData(fInputListLYZEP);
9d062fe3 834 }
bc92c0cb 835 if (GFC) {
836 mgr->ConnectInput(taskGFC,0,cinput1);
837 mgr->ConnectOutput(taskGFC,0,coutputGFC);
838 if (QA) { mgr->ConnectOutput(taskGFC,1,coutputQA1GFC);
839 mgr->ConnectOutput(taskGFC,2,coutputQA2GFC); }
840 }
e6614983 841 if (QC) {
842 mgr->ConnectInput(taskQC,0,cinput1);
843 mgr->ConnectOutput(taskQC,0,coutputQC);
844 if (QA) { mgr->ConnectOutput(taskQC,1,coutputQA1QC);
845 mgr->ConnectOutput(taskQC,2,coutputQA2QC); }
14db9c04 846 if (useWeights) {
847 mgr->ConnectInput(taskQC,1,cinputWeights);
848 cinputWeights->SetData(weightsList);
849 }
9bed2723 850 }
851 if (FQD) {
852 mgr->ConnectInput(taskFQD,0,cinput1);
853 mgr->ConnectOutput(taskFQD,0,coutputFQD);
854 if (QA) { mgr->ConnectOutput(taskFQD,1,coutputQA1FQD);
855 mgr->ConnectOutput(taskFQD,2,coutputQA2FQD); }
14db9c04 856 if(useWeights) {
857 mgr->ConnectInput(taskFQD,1,cinputWeights);
858 cinputWeights->SetData(weightsList);
859 }
9bed2723 860 }
bc92c0cb 861 if (MCEP) {
9d062fe3 862 mgr->ConnectInput(taskMCEP,0,cinput1);
bc92c0cb 863 mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
864 if (QA) { mgr->ConnectOutput(taskMCEP,1,coutputQA1MCEP);
865 mgr->ConnectOutput(taskMCEP,2,coutputQA2MCEP); }
866 }
867
9d062fe3 868 if (!mgr->InitAnalysis()) return;
869 mgr->PrintStatus();
870 // old way with a chain
871 // mgr->StartAnalysis("proof",chain);
872 mgr->StartAnalysis("proof",data,nRuns,offset);
bc92c0cb 873
9d062fe3 874 timer.Stop();
875 timer.Print();
876}