PWG2/FLOW/macros/runAliAnalysisTaskFlow.C

   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)
  10 // GFC   = Generating Function Cumulants (for PbPb)
  11 // QC    = Q-cumulants                   (for PbPb)
  12 // FQD   = Fitting q-distribution        (for PbPb)
  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) is available
  22 // 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
  33 //SETTING THE ANALYSIS
  34
  35 //Flow analysis methods can be: (set to kTRUE or kFALSE)
  36 Bool_t SP    = kTRUE;
  37 Bool_t LYZ1  = kTRUE;
  38 Bool_t LYZ2  = kFALSE;
  39 Bool_t LYZEP = kFALSE;
  40 Bool_t GFC   = kTRUE;
  41 Bool_t QC    = kTRUE;
  42 Bool_t FQD   = kTRUE;
  43 Bool_t MCEP  = kTRUE;
  44
  45
  46 //Type of analysis can be:
  47 // ESD, AOD, MC, ESDMC0, ESDMC1
  48 const TString type = "ESD";
  49
  50 //Bolean to fill/not fill the QA histograms
  51 Bool_t QA = kFALSE;
  52
  53 //SETTING THE CUTS
  54
  55 //for integrated flow
  56 const Double_t ptmin1 = 0.0;
  57 const Double_t ptmax1 = 10.0;
  58 const Double_t ymin1  = -1.;
  59 const Double_t ymax1  = 1.;
  60 const Int_t mintrackrefsTPC1 = 2;
  61 const Int_t mintrackrefsITS1 = 3;
  62 const Int_t charge1 = 1;
  63 Bool_t UsePIDIntegratedFlow = kFALSE;
  64 const Int_t PDG1 = 211;
  65 const Int_t minclustersTPC1 = 50;
  66 const Int_t maxnsigmatovertex1 = 3;
  67
  68 //for differential flow
  69 const Double_t ptmin2 = 0.0;
  70 const Double_t ptmax2 = 10.0;
  71 const Double_t ymin2  = -1.;
  72 const Double_t ymax2  = 1.;
  73 const Int_t mintrackrefsTPC2 = 2;
  74 const Int_t mintrackrefsITS2 = 3;
  75 const Int_t charge2 = 1;
  76 Bool_t UsePIDDifferentialFlow = kFALSE;
  77 const Int_t PDG2 = 211;
  78 const Int_t minclustersTPC2 = 50;
  79 const Int_t maxnsigmatovertex2 = 3;
  80
  81
  82 //void runAliAnalysisTaskFlow(Int_t nRuns = 10, const Char_t* dataDir="/data/alice2/kolk/Therminator_midcentral", Int_t offset = 0)
  83 void runAliAnalysisTaskFlow(Int_t nRuns = -1, const Char_t* dataDir="/Users/snelling/alice_data/Therminator_midcentral", Int_t offset = 0)
  84
  85 {
  86   TStopwatch timer;
  87   timer.Start();
  88
  89   if (LYZ1 && LYZ2) {cout<<"WARNING: you cannot run LYZ1 and LYZ2 at the same time! LYZ2 needs the output from LYZ1."<<endl; exit(); }
  90   if (LYZ2 && LYZEP) {cout<<"WARNING: you cannot run LYZ2 and LYZEP at the same time! LYZEP needs the output from LYZ2."<<endl; exit(); }
  91   if (LYZ1 && LYZEP) {cout<<"WARNING: you cannot run LYZ1 and LYZEP at the same time! LYZEP needs the output from LYZ2."<<endl; exit(); }
  92
  93   // include path (to find the .h files when compiling)
  94   gSystem->AddIncludePath("-I$ALICE_ROOT/include") ;
  95   gSystem->AddIncludePath("-I$ROOTSYS/include") ;
  96
  97   // load needed libraries
  98   gSystem->Load("libTree.so");
  99   gSystem->Load("libESD.so");
 100   cerr<<"libESD loaded..."<<endl;
 101   gSystem->Load("libANALYSIS.so");
 102   cerr<<"libANALYSIS.so loaded..."<<endl;
 103   gSystem->Load("libANALYSISRL.so");
 104   cerr<<"libANALYSISRL.so loaded..."<<endl;
 105   gSystem->Load("libCORRFW.so");
 106   cerr<<"libCORRFW.so loaded..."<<endl;
 107   gSystem->Load("libPWG2flow.so");
 108   cerr<<"libPWG2flow.so loaded..."<<endl;
 109
 110   // create the TChain. CreateESDChain() is defined in CreateESDChain.C
 111   if (type!="AOD") { TChain* chain = CreateESDChain(dataDir, nRuns, offset);}
 112   //  cout<<"chain ("<<chain<<")"<<endl; }
 113   else { TChain* chain = CreateAODChain(dataDir, nRuns, offset);}
 114   //  cout<<"chain ("<<chain<<")"<<endl; }
 115
 116   //____________________________________________//
 117   //Create cuts using correction framework
 118
 119   //Set TList for the QA histograms
 120   if (QA) {
 121     if (SP){
 122       TList* qaIntSP = new TList();
 123       TList* qaDiffSP = new TList(); }
 124     if (LYZ1) {
 125       TList* qaIntLYZ1 = new TList();
 126       TList* qaDiffLYZ1 = new TList(); }
 127     if (LYZ2) {
 128       TList* qaIntLYZ2 = new TList();
 129       TList* qaDiffLYZ2 = new TList(); }
 130     if (LYZEP) {
 131       TList* qaIntLYZEP = new TList();
 132       TList* qaDiffLYZEP = new TList(); }
 133     if (GFC) {
 134       TList* qaIntGFC = new TList();
 135       TList* qaDiffGFC = new TList(); }
 136     if (QC) {
 137       TList* qaIntQC = new TList();
 138       TList* qaDiffQC = new TList(); }
 139     if (FQD) {
 140       TList* qaIntFQD = new TList();
 141       TList* qaDiffFQD = new TList(); }
 142     if (MCEP) {
 143       TList* qaIntMCEP = new TList();
 144       TList* qaDiffMCEP = new TList(); }
 145   }
 146
 147   //############# cuts on MC
 148   AliCFTrackKineCuts* mcKineCuts1 = new AliCFTrackKineCuts("mcKineCuts1","MC-level kinematic cuts");
 149   mcKineCuts1->SetPtRange(ptmin1,ptmax1);
 150   mcKineCuts1->SetRapidityRange(ymin1,ymax1);
 151   mcKineCuts1->SetChargeMC(charge1);
 152   if (QA) {
 153     if (SP)   { mcKineCuts1->SetQAOn(qaIntSP); }
 154     if (LYZ1) { mcKineCuts1->SetQAOn(qaIntLYZ1); }
 155     if (LYZ2) { mcKineCuts1->SetQAOn(qaIntLYZ2); }
 156     if (LYZEP){ mcKineCuts1->SetQAOn(qaIntLYZEP); }
 157     if (GFC)  { mcKineCuts1->SetQAOn(qaIntGFC); }
 158     if (QC)   { mcKineCuts1->SetQAOn(qaIntQC); }
 159     if (FQD)  { mcKineCuts1->SetQAOn(qaIntFQD); }
 160     if (MCEP) { mcKineCuts1->SetQAOn(qaIntMCEP); }
 161   }
 162
 163   AliCFTrackKineCuts* mcKineCuts2 = new AliCFTrackKineCuts("mcKineCuts2","MC-level kinematic cuts");
 164   mcKineCuts2->SetPtRange(ptmin2,ptmax2);
 165   mcKineCuts2->SetRapidityRange(ymin2,ymax2);
 166   mcKineCuts2->SetChargeMC(charge2);
 167   if (QA) {
 168     if (SP)   { mcKineCuts2->SetQAOn(qaDiffSP); }
 169     if (LYZ1) { mcKineCuts2->SetQAOn(qaDiffLYZ1); }
 170     if (LYZ2) { mcKineCuts2->SetQAOn(qaDiffLYZ2); }
 171     if (LYZEP){ mcKineCuts2->SetQAOn(qaDiffLYZEP); }
 172     if (GFC)  { mcKineCuts2->SetQAOn(qaDiffGFC); }
 173     if (QC)   { mcKineCuts2->SetQAOn(qaDiffQC); }
 174     if (FQD)  { mcKineCuts2->SetQAOn(qaDiffFQD); }
 175     if (MCEP) { mcKineCuts2->SetQAOn(qaDiffMCEP); }
 176   }
 177
 178   AliCFParticleGenCuts* mcGenCuts1 = new AliCFParticleGenCuts("mcGenCuts1","MC particle generation cuts for integrated flow");
 179   mcGenCuts1->SetRequireIsPrimary();
 180   if (UsePIDIntegratedFlow) {mcGenCuts1->SetRequirePdgCode(PDG1);}
 181   if (QA) {
 182     if (SP)   { mcGenCuts1->SetQAOn(qaIntSP); }
 183     if (LYZ1) { mcGenCuts1->SetQAOn(qaIntLYZ1); }
 184     if (LYZ2) { mcGenCuts1->SetQAOn(qaIntLYZ2); }
 185     if (LYZEP){ mcGenCuts1->SetQAOn(qaIntLYZEP); }
 186     if (GFC)  { mcGenCuts1->SetQAOn(qaIntGFC); }
 187     if (QC)   { mcGenCuts1->SetQAOn(qaIntQC); }
 188     if (FQD)  { mcGenCuts1->SetQAOn(qaIntFQD); }
 189     if (MCEP) { mcGenCuts1->SetQAOn(qaIntMCEP); }
 190   }
 191
 192   AliCFParticleGenCuts* mcGenCuts2 = new AliCFParticleGenCuts("mcGenCuts2","MC particle generation cuts for differential flow");
 193   mcGenCuts2->SetRequireIsPrimary();
 194   if (UsePIDDifferentialFlow) {mcGenCuts2->SetRequirePdgCode(PDG2);}
 195   if (QA) {
 196     if (SP)   { mcGenCuts2->SetQAOn(qaDiffSP); }
 197     if (LYZ1) { mcGenCuts2->SetQAOn(qaDiffLYZ1); }
 198     if (LYZ2) { mcGenCuts2->SetQAOn(qaDiffLYZ2); }
 199     if (LYZEP){ mcGenCuts2->SetQAOn(qaDiffLYZEP); }
 200     if (GFC)  { mcGenCuts2->SetQAOn(qaDiffGFC); }
 201     if (QC)   { mcGenCuts2->SetQAOn(qaDiffQC); }
 202     if (FQD)  { mcGenCuts2->SetQAOn(qaDiffFQD); }
 203     if (MCEP) { mcGenCuts2->SetQAOn(qaDiffMCEP); }
 204   }
 205
 206   //############# Acceptance Cuts
 207   AliCFAcceptanceCuts *mcAccCuts1 = new AliCFAcceptanceCuts("mcAccCuts1","MC acceptance cuts");
 208   mcAccCuts1->SetMinNHitITS(mintrackrefsITS1);
 209   mcAccCuts1->SetMinNHitTPC(mintrackrefsTPC1);
 210   if (QA) {
 211     if (SP)   { mcAccCuts1->SetQAOn(qaIntSP); }
 212     if (LYZ1) { mcAccCuts1->SetQAOn(qaIntLYZ1); }
 213     if (LYZ2) { mcAccCuts1->SetQAOn(qaIntLYZ2); }
 214     if (LYZEP){ mcAccCuts1->SetQAOn(qaIntLYZEP); }
 215     if (GFC)  { mcAccCuts1->SetQAOn(qaIntGFC); }
 216     if (QC)   { mcAccCuts1->SetQAOn(qaIntQC); }
 217     if (FQD)  { mcAccCuts1->SetQAOn(qaIntFQD); }
 218     if (MCEP) { mcAccCuts1->SetQAOn(qaIntMCEP); }
 219   }
 220
 221   AliCFAcceptanceCuts *mcAccCuts2 = new AliCFAcceptanceCuts("mcAccCuts2","MC acceptance cuts");
 222   mcAccCuts2->SetMinNHitITS(mintrackrefsITS2);
 223   mcAccCuts2->SetMinNHitTPC(mintrackrefsTPC2);
 224   if (QA) {
 225     if (SP)   { mcAccCuts2->SetQAOn(qaDiffSP); }
 226     if (LYZ1) { mcAccCuts2->SetQAOn(qaDiffLYZ1); }
 227     if (LYZ2) { mcAccCuts2->SetQAOn(qaDiffLYZ2); }
 228     if (LYZEP){ mcAccCuts2->SetQAOn(qaDiffLYZEP); }
 229     if (GFC)  { mcAccCuts2->SetQAOn(qaDiffGFC); }
 230     if (QC)   { mcAccCuts2->SetQAOn(qaDiffQC); }
 231     if (FQD)  { mcAccCuts2->SetQAOn(qaDiffFQD); }
 232     if (MCEP) { mcAccCuts2->SetQAOn(qaDiffMCEP); }
 233   }
 234
 235   //############# Rec-Level kinematic cuts
 236   AliCFTrackKineCuts *recKineCuts1 = new AliCFTrackKineCuts("recKineCuts1","rec-level kine cuts");
 237   recKineCuts1->SetPtRange(ptmin1,ptmax1);
 238   recKineCuts1->SetRapidityRange(ymin1,ymax1);
 239   recKineCuts1->SetChargeRec(charge1);
 240   if (QA) {
 241     if (SP)   { recKineCuts1->SetQAOn(qaIntSP); }
 242     if (LYZ1) { recKineCuts1->SetQAOn(qaIntLYZ1); }
 243     if (LYZ2) { recKineCuts1->SetQAOn(qaIntLYZ2); }
 244     if (LYZEP){ recKineCuts1->SetQAOn(qaIntLYZEP); }
 245     if (GFC)  { recKineCuts1->SetQAOn(qaIntGFC); }
 246     if (QC)   { recKineCuts1->SetQAOn(qaIntQC); }
 247     if (FQD)  { recKineCuts1->SetQAOn(qaIntFQD); }
 248     if (MCEP) { recKineCuts1->SetQAOn(qaIntMCEP); }
 249   }
 250
 251   AliCFTrackKineCuts *recKineCuts2 = new AliCFTrackKineCuts("recKineCuts2","rec-level kine cuts");
 252   recKineCuts2->SetPtRange(ptmin2,ptmax2);
 253   recKineCuts2->SetRapidityRange(ymin2,ymax2);
 254   recKineCuts2->SetChargeRec(charge2);
 255   if (QA) {
 256     if (SP)   { recKineCuts2->SetQAOn(qaDiffSP); }
 257     if (LYZ1) { recKineCuts2->SetQAOn(qaDiffLYZ1); }
 258     if (LYZ2) { recKineCuts2->SetQAOn(qaDiffLYZ2); }
 259     if (LYZEP){ recKineCuts2->SetQAOn(qaDiffLYZEP); }
 260     if (GFC)  { recKineCuts2->SetQAOn(qaDiffGFC); }
 261     if (QC)   { recKineCuts2->SetQAOn(qaDiffQC); }
 262     if (FQD)  { recKineCuts2->SetQAOn(qaDiffFQD); }
 263     if (MCEP) { recKineCuts2->SetQAOn(qaDiffMCEP); }
 264   }
 265
 266   AliCFTrackQualityCuts *recQualityCuts1 = new AliCFTrackQualityCuts("recQualityCuts1","rec-level quality cuts");
 267   recQualityCuts1->SetMinNClusterTPC(minclustersTPC1);
 268   recQualityCuts1->SetStatus(AliESDtrack::kITSrefit);
 269   if (QA) {
 270     if (SP)   { recQualityCuts1->SetQAOn(qaIntSP); }
 271     if (LYZ1) { recQualityCuts1->SetQAOn(qaIntLYZ1); }
 272     if (LYZ2) { recQualityCuts1->SetQAOn(qaIntLYZ2); }
 273     if (LYZEP){ recQualityCuts1->SetQAOn(qaIntLYZEP); }
 274     if (GFC)  { recQualityCuts1->SetQAOn(qaIntGFC); }
 275     if (QC)   { recQualityCuts1->SetQAOn(qaIntQC); }
 276     if (FQD)  { recQualityCuts1->SetQAOn(qaIntFQD); }
 277     if (MCEP) { recQualityCuts1->SetQAOn(qaIntMCEP); }
 278   }
 279
 280   AliCFTrackQualityCuts *recQualityCuts2 = new AliCFTrackQualityCuts("recQualityCuts2","rec-level quality cuts");
 281   recQualityCuts2->SetMinNClusterTPC(minclustersTPC2);
 282   recQualityCuts2->SetStatus(AliESDtrack::kITSrefit);
 283   if (QA) {
 284     if (SP)   { recQualityCuts2->SetQAOn(qaDiffSP); }
 285     if (LYZ1) { recQualityCuts2->SetQAOn(qaDiffLYZ1); }
 286     if (LYZ2) { recQualityCuts2->SetQAOn(qaDiffLYZ2); }
 287     if (LYZEP){ recQualityCuts2->SetQAOn(qaDiffLYZEP); }
 288     if (GFC)  { recQualityCuts2->SetQAOn(qaDiffGFC); }
 289     if (QC)   { recQualityCuts2->SetQAOn(qaDiffQC); }
 290     if (FQD)  { recQualityCuts2->SetQAOn(qaDiffFQD); }
 291     if (MCEP) { recQualityCuts2->SetQAOn(qaDiffMCEP); }
 292   }
 293
 294   AliCFTrackIsPrimaryCuts *recIsPrimaryCuts1 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts1","rec-level isPrimary cuts");
 295   recIsPrimaryCuts1->SetMaxNSigmaToVertex(maxnsigmatovertex1);
 296   if (QA) {
 297     if (SP)   { recIsPrimaryCuts1->SetQAOn(qaIntSP); }
 298     if (LYZ1) { recIsPrimaryCuts1->SetQAOn(qaIntLYZ1); }
 299     if (LYZ2) { recIsPrimaryCuts1->SetQAOn(qaIntLYZ2); }
 300     if (LYZEP){ recIsPrimaryCuts1->SetQAOn(qaIntLYZEP); }
 301     if (GFC)  { recIsPrimaryCuts1->SetQAOn(qaIntGFC); }
 302     if (QC)   { recIsPrimaryCuts1->SetQAOn(qaIntQC); }
 303     if (FQD)  { recIsPrimaryCuts1->SetQAOn(qaIntFQD); }
 304     if (MCEP) { recIsPrimaryCuts1->SetQAOn(qaIntMCEP); }
 305   }
 306
 307   AliCFTrackIsPrimaryCuts *recIsPrimaryCuts2 = new AliCFTrackIsPrimaryCuts("recIsPrimaryCuts2","rec-level isPrimary cuts");
 308   recIsPrimaryCuts2->SetMaxNSigmaToVertex(maxnsigmatovertex2);
 309   if (QA) {
 310     if (SP)   { recIsPrimaryCuts2->SetQAOn(qaDiffSP); }
 311     if (LYZ1) { recIsPrimaryCuts2->SetQAOn(qaDiffLYZ1); }
 312     if (LYZ2) { recIsPrimaryCuts2->SetQAOn(qaDiffLYZ2); }
 313     if (LYZEP){ recIsPrimaryCuts2->SetQAOn(qaDiffLYZEP); }
 314     if (GFC)  { recIsPrimaryCuts2->SetQAOn(qaDiffGFC); }
 315     if (QC)   { recIsPrimaryCuts2->SetQAOn(qaDiffQC); }
 316     if (FQD)  { recIsPrimaryCuts2->SetQAOn(qaDiffFQD); }
 317     if (MCEP) { recIsPrimaryCuts2->SetQAOn(qaDiffMCEP); }
 318   }
 319
 320
 321
 322   int n_species = AliPID::kSPECIES ;
 323   Double_t* prior = new Double_t[n_species];
 324
 325   prior[0] = 0.0244519 ;
 326   prior[1] = 0.0143988 ;
 327   prior[2] = 0.805747  ;
 328   prior[3] = 0.0928785 ;
 329   prior[4] = 0.0625243 ;
 330
 331   AliCFTrackCutPid* cutPID1 = NULL;
 332   if(UsePIDIntegratedFlow) {
 333     AliCFTrackCutPid* cutPID1 = new AliCFTrackCutPid("cutPID1","ESD_PID for integrated flow") ;
 334     cutPID1->SetPriors(prior);
 335     cutPID1->SetProbabilityCut(0.0);
 336     cutPID1->SetDetectors("TPC TOF");
 337     switch(TMath::Abs(PDG1)) {
 338     case 11   : cutPID1->SetParticleType(AliPID::kElectron, kTRUE); break;
 339     case 13   : cutPID1->SetParticleType(AliPID::kMuon    , kTRUE); break;
 340     case 211  : cutPID1->SetParticleType(AliPID::kPion    , kTRUE); break;
 341     case 321  : cutPID1->SetParticleType(AliPID::kKaon    , kTRUE); break;
 342     case 2212 : cutPID1->SetParticleType(AliPID::kProton  , kTRUE); break;
 343     default   : printf("UNDEFINED PID\n"); break;
 344     }
 345     if (QA) {
 346       if (SP) {cutPID1->SetQAOn(qaIntSP);}
 347       if (LYZ1) {cutPID1->SetQAOn(qaIntLYZ1);}
 348       if (LYZ2) {cutPID1->SetQAOn(qaIntLYZ2);}
 349       if (LYZEP){cutPID1->SetQAOn(qaIntLYZEP);}
 350       if (GFC) {cutPID1->SetQAOn(qaIntGFC);}
 351       if (QC) {cutPID1->SetQAOn(qaIntQC);}
 352       if (FQD) {cutPID1->SetQAOn(qaIntFQD);}
 353       if (MCEP) {cutPID1->SetQAOn(qaIntMCEP);}
 354     }
 355   }
 356
 357   AliCFTrackCutPid* cutPID2 = NULL;
 358   if (UsePIDDifferentialFlow) {
 359     AliCFTrackCutPid* cutPID2 = new AliCFTrackCutPid("cutPID2","ESD_PID for differential flow") ;
 360     cutPID2->SetPriors(prior);
 361     cutPID2->SetProbabilityCut(0.0);
 362     cutPID2->SetDetectors("TPC TOF");
 363     switch(TMath::Abs(PDG2)) {
 364     case 11   : cutPID2->SetParticleType(AliPID::kElectron, kTRUE); break;
 365     case 13   : cutPID2->SetParticleType(AliPID::kMuon    , kTRUE); break;
 366     case 211  : cutPID2->SetParticleType(AliPID::kPion    , kTRUE); break;
 367     case 321  : cutPID2->SetParticleType(AliPID::kKaon    , kTRUE); break;
 368     case 2212 : cutPID2->SetParticleType(AliPID::kProton  , kTRUE); break;
 369     default   : printf("UNDEFINED PID\n"); break;
 370     }
 371     if (QA) {
 372       if (SP) {cutPID2->SetQAOn(qaIntSP);}
 373       if (LYZ1) {cutPID2->SetQAOn(qaIntLYZ1);}
 374       if (LYZ2) {cutPID2->SetQAOn(qaIntLYZ2);}
 375       if (LYZEP){cutPID2->SetQAOn(qaIntLYZEP);}
 376       if (GFC) {cutPID2->SetQAOn(qaIntGFC);}
 377       if (QC) {cutPID2->SetQAOn(qaIntQC);}
 378       if (FQD) {cutPID2->SetQAOn(qaIntFQD);}
 379       if (MCEP) {cutPID2->SetQAOn(qaIntMCEP);}
 380     }
 381   }
 382
 383   printf("CREATE MC KINE CUTS\n");
 384   TObjArray* mcList1 = new TObjArray(0);
 385   mcList1->AddLast(mcKineCuts1);
 386   mcList1->AddLast(mcGenCuts1);
 387
 388   TObjArray* mcList2 = new TObjArray(0);
 389   mcList2->AddLast(mcKineCuts2);
 390   mcList2->AddLast(mcGenCuts2);
 391
 392   printf("CREATE ACCEPTANCE CUTS\n");
 393   TObjArray* accList1 = new TObjArray(0) ;
 394   accList1->AddLast(mcAccCuts1);
 395
 396   TObjArray* accList2 = new TObjArray(0) ;
 397   accList2->AddLast(mcAccCuts2);
 398
 399   printf("CREATE RECONSTRUCTION CUTS\n");
 400   TObjArray* recList1 = new TObjArray(0) ;
 401   recList1->AddLast(recKineCuts1);
 402   recList1->AddLast(recQualityCuts1);
 403   recList1->AddLast(recIsPrimaryCuts1);
 404
 405   TObjArray* recList2 = new TObjArray(0) ;
 406   recList2->AddLast(recKineCuts2);
 407   recList2->AddLast(recQualityCuts2);
 408   recList2->AddLast(recIsPrimaryCuts2);
 409
 410   printf("CREATE PID CUTS\n");
 411   TObjArray* fPIDCutList1 = new TObjArray(0) ;
 412   if(UsePIDIntegratedFlow) {fPIDCutList1->AddLast(cutPID1);}
 413
 414   TObjArray* fPIDCutList2 = new TObjArray(0) ;
 415   if (UsePIDDifferentialFlow)  {fPIDCutList2->AddLast(cutPID2);}
 416
 417   printf("CREATE INTERFACE AND CUTS FOR INTEGRATED FLOW\n");
 418   AliCFManager* cfmgr1 = new AliCFManager();
 419   cfmgr1->SetNStepParticle(4); //05nov08
 420   cfmgr1->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList1);       //on MC
 421   cfmgr1->SetParticleCutsList(AliCFManager::kPartAccCuts,accList1);      //on MC
 422   cfmgr1->SetParticleCutsList(AliCFManager::kPartRecCuts,recList1);      //on ESD
 423   cfmgr1->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList1);  //on ESD
 424
 425   printf("CREATE INTERFACE AND CUTS FOR DIFFERENTIAL FLOW\n");
 426   AliCFManager* cfmgr2 = new AliCFManager();
 427   cfmgr2->SetNStepParticle(4); //05nov08
 428   cfmgr2->SetParticleCutsList(AliCFManager::kPartGenCuts,mcList2);
 429   cfmgr2->SetParticleCutsList(AliCFManager::kPartAccCuts,accList2);
 430   cfmgr2->SetParticleCutsList(AliCFManager::kPartRecCuts,recList2);
 431   cfmgr2->SetParticleCutsList(AliCFManager::kPartSelCuts,fPIDCutList2);
 432
 433
 434   if (LYZ2){
 435     // read the input file from the first run
 436     TString inputFileNameLYZ2 = "outputLYZ1analysis" ;
 437     inputFileNameLYZ2 += type;
 438     inputFileNameLYZ2 += ".root";
 439     cout<<"The input file is "<<inputFileNameLYZ2.Data()<<endl;
 440     TFile* fInputFileLYZ2 = new TFile(inputFileNameLYZ2.Data(),"READ");
 441     if(!fInputFileLYZ2 || fInputFileLYZ2->IsZombie()) {
 442       cerr << " ERROR: NO First Run file... " << endl ; }
 443     else {
 444       TList* fInputListLYZ2 = (TList*)fInputFileLYZ2->Get("cobjLYZ1");
 445       if (!fInputListLYZ2) {cout<<"list is NULL pointer!"<<endl;}
 446     }
 447     cout<<"LYZ2 input file/list read..."<<endl;
 448   }
 449
 450   if (LYZEP) {
 451     // read the input file from the second LYZ run
 452     TString inputFileNameLYZEP = "outputLYZ2analysis" ;
 453     inputFileNameLYZEP += type;
 454     inputFileNameLYZEP += ".root";
 455     cout<<"The input file is "<<inputFileNameLYZEP.Data()<<endl;
 456     TFile* fInputFileLYZEP = new TFile(inputFileNameLYZEP.Data(),"READ");
 457     if(!fInputFileLYZEP || fInputFileLYZEP->IsZombie()) { cerr << " ERROR: NO First Run file... " << endl ; }
 458     else {
 459       TList* fInputListLYZEP = (TList*)fInputFileLYZEP->Get("cobjLYZ2");
 460       if (!fInputListLYZEP) {cout<<"list is NULL pointer!"<<endl;}
 461     }
 462     cout<<"LYZEP input file/list read..."<<endl;
 463   }
 464
 465
 466   //____________________________________________//
 467   // Make the analysis manager
 468   AliAnalysisManager *mgr = new AliAnalysisManager("FlowAnalysisManager");
 469
 470   if (type == "ESD"){
 471     AliVEventHandler* esdH = new AliESDInputHandler;
 472     mgr->SetInputEventHandler(esdH);
 473     if (MCEP) {
 474       AliMCEventHandler *mc = new AliMCEventHandler();
 475       mgr->SetMCtruthEventHandler(mc);}  }
 476
 477   if (type == "AOD"){
 478     AliVEventHandler* aodH = new AliAODInputHandler;
 479     mgr->SetInputEventHandler(aodH);
 480     if (MCEP) {
 481       AliMCEventHandler *mc = new AliMCEventHandler();
 482       mgr->SetMCtruthEventHandler(mc);}  }
 483
 484   if (type == "MC" || type == "ESDMC0" || type == "ESDMC1"){
 485     AliVEventHandler* esdH = new AliESDInputHandler;
 486     mgr->SetInputEventHandler(esdH);
 487
 488     AliMCEventHandler *mc = new AliMCEventHandler();
 489     mgr->SetMCtruthEventHandler(mc); }
 490
 491   //____________________________________________//
 492   // Task
 493
 494   if (SP){
 495     if (QA) { AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",kTRUE); }
 496     else { AliAnalysisTaskScalarProduct *taskSP = new AliAnalysisTaskScalarProduct("TaskScalarProduct",kFALSE); }
 497     taskSP->SetAnalysisType(type);
 498     taskSP->SetCFManager1(cfmgr1);
 499     taskSP->SetCFManager2(cfmgr2);
 500     if (QA) {
 501       taskSP->SetQAList1(qaIntSP);
 502       taskSP->SetQAList2(qaDiffSP); }
 503     mgr->AddTask(taskSP);
 504   }
 505   if (LYZ1){
 506     if (QA) { AliAnalysisTaskLeeYangZeros *taskLYZ1 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kTRUE,kTRUE);}
 507     else { AliAnalysisTaskLeeYangZeros *taskLYZ1 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kTRUE,kFALSE);}
 508     taskLYZ1->SetAnalysisType(type);
 509     taskLYZ1->SetFirstRunLYZ(kTRUE);
 510     taskLYZ1->SetUseSumLYZ(kTRUE);
 511     taskLYZ1->SetCFManager1(cfmgr1);
 512     taskLYZ1->SetCFManager2(cfmgr2);
 513     if (QA) {
 514       taskLYZ1->SetQAList1(qaIntLYZ1);
 515       taskLYZ1->SetQAList2(qaDiffLYZ1);}
 516     mgr->AddTask(taskLYZ1);
 517   }
 518   if (LYZ2){
 519     if (QA) { AliAnalysisTaskLeeYangZeros *taskLYZ2 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kFALSE,kTRUE);}
 520     else { AliAnalysisTaskLeeYangZeros *taskLYZ2 = new AliAnalysisTaskLeeYangZeros("TaskLeeYangZeros",kFALSE,kFALSE); }
 521     taskLYZ2->SetAnalysisType(type);
 522     taskLYZ2->SetFirstRunLYZ(kFALSE);
 523     taskLYZ2->SetUseSumLYZ(kTRUE);
 524     taskLYZ2->SetCFManager1(cfmgr1);
 525     taskLYZ2->SetCFManager2(cfmgr2);
 526     if (QA) {
 527       taskLYZ2->SetQAList1(qaIntLYZ2);
 528       taskLYZ2->SetQAList2(qaDiffLYZ2); }
 529     mgr->AddTask(taskLYZ2);
 530   }
 531   if (LYZEP){
 532     if (QA) { AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane",kTRUE); }
 533     else { AliAnalysisTaskLYZEventPlane *taskLYZEP = new AliAnalysisTaskLYZEventPlane("TaskLYZEventPlane",kFALSE); }
 534     taskLYZEP->SetAnalysisType(type);
 535     taskLYZEP->SetCFManager1(cfmgr1);
 536     taskLYZEP->SetCFManager2(cfmgr2);
 537     if (QA) {
 538       taskLYZEP->SetQAList1(qaIntLYZEP);
 539       taskLYZEP->SetQAList2(qaDiffLYZEP); }
 540     mgr->AddTask(taskLYZEP);
 541   }
 542   if (GFC){
 543     if (QA) { AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",kTRUE);}
 544     else { AliAnalysisTaskCumulants *taskGFC = new AliAnalysisTaskCumulants("TaskCumulants",kFALSE);}
 545     taskGFC->SetAnalysisType(type);
 546     taskGFC->SetCFManager1(cfmgr1);
 547     taskGFC->SetCFManager2(cfmgr2);
 548     if (QA) {
 549       taskGFC->SetQAList1(qaIntGFC);
 550       taskGFC->SetQAList2(qaDiffGFC); }
 551     mgr->AddTask(taskGFC);
 552   }
 553   if (QC){
 554     if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE);}
 555     else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE);}
 556     taskQC->SetAnalysisType(type);
 557     taskQC->SetCFManager1(cfmgr1);
 558     taskQC->SetCFManager2(cfmgr2);
 559     if (QA) {
 560       taskQC->SetQAList1(qaIntQC);
 561       taskQC->SetQAList2(qaDiffQC); }
 562     mgr->AddTask(taskQC);
 563   }
 564   if (FQD){
 565     if (QA) { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kTRUE);}
 566     else { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE);}
 567     taskFQD->SetAnalysisType(type);
 568     taskFQD->SetCFManager1(cfmgr1);
 569     taskFQD->SetCFManager2(cfmgr2);
 570     if (QA) {
 571       taskFQD->SetQAList1(qaIntFQD);
 572       taskFQD->SetQAList2(qaDiffFQD); }
 573     mgr->AddTask(taskFQD);
 574   }
 575   if (MCEP){
 576     if (QA) { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kTRUE);}
 577     else { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kFALSE);}
 578     taskMCEP->SetAnalysisType(type);
 579     taskMCEP->SetCFManager1(cfmgr1);
 580     taskMCEP->SetCFManager2(cfmgr2);
 581     if (QA) {
 582       taskMCEP->SetQAList1(qaIntMCEP);
 583       taskMCEP->SetQAList2(qaDiffMCEP); }
 584     mgr->AddTask(taskMCEP);
 585   }
 586
 587
 588   // Create containers for input/output
 589
 590   AliAnalysisDataContainer *cinput1 =
 591     mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
 592
 593   if (LYZ2){
 594     AliAnalysisDataContainer *cinputLYZ2 =
 595       mgr->CreateContainer("cobjLYZ2in",TList::Class(),AliAnalysisManager::kInputContainer); }
 596   if (LYZEP){
 597     AliAnalysisDataContainer *cinputLYZEP =
 598       mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer); }
 599
 600   if(SP) {
 601     TString outputSP = "outputSPanalysis";
 602     outputSP+= type;
 603     outputSP+= ".root";
 604     AliAnalysisDataContainer *coutputSP =
 605       mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
 606   }
 607
 608   if(LYZ1) {
 609     TString outputLYZ1 = "outputLYZ1analysis";
 610     outputLYZ1+= type;
 611     outputLYZ1+= ".root";
 612     AliAnalysisDataContainer *coutputLYZ1 =
 613       mgr->CreateContainer("cobjLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1);
 614   }
 615
 616   if(LYZ2) {
 617     TString outputLYZ2 = "outputLYZ2analysis";
 618     outputLYZ2+= type;
 619     outputLYZ2+= ".root";
 620     AliAnalysisDataContainer *coutputLYZ2 =
 621       mgr->CreateContainer("cobjLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2);
 622   }
 623
 624   if(LYZEP) {
 625     TString outputLYZEP = "outputLYZEPanalysis";
 626     outputLYZEP+= type;
 627     outputLYZEP+= ".root";
 628     AliAnalysisDataContainer *coutputLYZEP =
 629       mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
 630   }
 631
 632   if(GFC) {
 633     TString outputGFC = "outputGFCanalysis";
 634     outputGFC+= type;
 635     outputGFC+= ".root";
 636     AliAnalysisDataContainer *coutputGFC =
 637       mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
 638   }
 639
 640   if(QC) {
 641     TString outputQC = "outputQCanalysis";
 642     outputQC+= type;
 643     outputQC+= ".root";
 644     AliAnalysisDataContainer *coutputQC =
 645       mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
 646   }
 647
 648   if(FQD) {
 649     TString outputFQD = "outputFQDanalysis";
 650     outputFQD+= type;
 651     outputFQD+= ".root";
 652     AliAnalysisDataContainer *coutputFQD =
 653       mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
 654   }
 655
 656   if(MCEP) {
 657     TString outputMCEP = "outputMCEPanalysis";
 658     outputMCEP+= type;
 659     outputMCEP+= ".root";
 660     AliAnalysisDataContainer *coutputMCEP =
 661       mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
 662   }
 663
 664   if (QA) {
 665     if(SP) {
 666       TString qaNameIntSP = "QAforInt_SP_";
 667       qaNameIntSP += type;
 668       qaNameIntSP += ".root";
 669       AliAnalysisDataContainer *coutputQA1SP =
 670         mgr->CreateContainer("QAintSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntSP);
 671
 672       TString qaNameDiffSP = "QAforDiff_SP_";
 673       qaNameDiffSP += type;
 674       qaNameDiffSP += ".root";
 675       AliAnalysisDataContainer *coutputQA2SP =
 676         mgr->CreateContainer("QAdiffSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffSP);
 677     }
 678     if(LYZ1) {
 679       TString qaNameIntLYZ1 = "QAforInt_LYZ1_";
 680       qaNameIntLYZ1 += type;
 681       qaNameIntLYZ1 += ".root";
 682       AliAnalysisDataContainer *coutputQA1LYZ1 =
 683         mgr->CreateContainer("QAintLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ1);
 684
 685       TString qaNameDiffLYZ1 = "QAforDiff_LYZ1_";
 686       qaNameDiffLYZ1 += type;
 687       qaNameDiffLYZ1 += ".root";
 688       AliAnalysisDataContainer *coutputQA2LYZ1 =
 689         mgr->CreateContainer("QAdiffLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ1);
 690     }
 691     if(LYZ2) {
 692       TString qaNameIntLYZ2 = "QAforInt_LYZ2_";
 693       qaNameIntLYZ2 += type;
 694       qaNameIntLYZ2 += ".root";
 695       AliAnalysisDataContainer *coutputQA1LYZ2 =
 696         mgr->CreateContainer("QAintLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ2);
 697
 698       TString qaNameDiffLYZ2 = "QAforDiff_LYZ2_";
 699       qaNameDiffLYZ2 += type;
 700       qaNameDiffLYZ2 += ".root";
 701       AliAnalysisDataContainer *coutputQA2LYZ2 =
 702         mgr->CreateContainer("QAdiffLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ2);
 703     }
 704     if(LYZEP) {
 705       TString qaNameIntLYZEP = "QAforInt_LYZEP_";
 706       qaNameIntLYZEP += type;
 707       qaNameIntLYZEP += ".root";
 708       AliAnalysisDataContainer *coutputQA1LYZEP =
 709         mgr->CreateContainer("QAintLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZEP);
 710
 711       TString qaNameDiffLYZEP = "QAforDiff_LYZEP_";
 712       qaNameDiffLYZEP += type;
 713       qaNameDiffLYZEP += ".root";
 714       AliAnalysisDataContainer *coutputQA2LYZEP =
 715         mgr->CreateContainer("QAdiffLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZEP);
 716     }
 717     if(GFC) {
 718       TString qaNameIntGFC = "QAforInt_GFC_";
 719       qaNameIntGFC += type;
 720       qaNameIntGFC += ".root";
 721       AliAnalysisDataContainer *coutputQA1GFC =
 722         mgr->CreateContainer("QAintGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntGFC);
 723
 724       TString qaNameDiffGFC = "QAforDiff_GFC_";
 725       qaNameDiffGFC += type;
 726       qaNameDiffGFC += ".root";
 727       AliAnalysisDataContainer *coutputQA2GFC =
 728         mgr->CreateContainer("QAdiffGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffGFC);
 729     }
 730     if(QC) {
 731       TString qaNameIntQC = "QAforInt_QC_";
 732       qaNameIntQC += type;
 733       qaNameIntQC += ".root";
 734       AliAnalysisDataContainer *coutputQA1QC =
 735         mgr->CreateContainer("QAintQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntQC);
 736
 737       TString qaNameDiffQC = "QAforDiff_QC_";
 738       qaNameDiffQC += type;
 739       qaNameDiffQC += ".root";
 740       AliAnalysisDataContainer *coutputQA2QC =
 741         mgr->CreateContainer("QAdiffQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffQC);
 742     }
 743     if(FQD) {
 744       TString qaNameIntFQD = "QAforInt_FQD_";
 745       qaNameIntFQD += type;
 746       qaNameIntFQD += ".root";
 747       AliAnalysisDataContainer *coutputQA1FQD =
 748         mgr->CreateContainer("QAintFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntFQD);
 749
 750       TString qaNameDiffFQD = "QAforDiff_FQD_";
 751       qaNameDiffFQD += type;
 752       qaNameDiffFQD += ".root";
 753       AliAnalysisDataContainer *coutputQA2FQD =
 754         mgr->CreateContainer("QAdiffFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffFQD);
 755     }
 756     if(MCEP) {
 757       TString qaNameIntMCEP = "QAforInt_MCEP_";
 758       qaNameIntMCEP += type;
 759       qaNameIntMCEP += ".root";
 760       AliAnalysisDataContainer *coutputQA1MCEP =
 761         mgr->CreateContainer("QAintMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntMCEP);
 762
 763       TString qaNameDiffMCEP = "QAforDiff_MCEP_";
 764       qaNameDiffMCEP += type;
 765       qaNameDiffMCEP += ".root";
 766       AliAnalysisDataContainer *coutputQA2MCEP =
 767         mgr->CreateContainer("QAdiffMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffMCEP);
 768     }
 769   }
 770
 771   //____________________________________________//
 772
 773   if (SP)   {
 774     mgr->ConnectInput(taskSP,0,cinput1);
 775     mgr->ConnectOutput(taskSP,0,coutputSP);
 776     if (QA) { mgr->ConnectOutput(taskSP,1,coutputQA1SP);
 777     mgr->ConnectOutput(taskSP,2,coutputQA2SP); }
 778   }
 779   if (LYZ1) {
 780     mgr->ConnectInput(taskLYZ1,0,cinput1);
 781     mgr->ConnectOutput(taskLYZ1,0,coutputLYZ1);
 782     if (QA) { mgr->ConnectOutput(taskLYZ1,1,coutputQA1LYZ1);
 783     mgr->ConnectOutput(taskLYZ1,2,coutputQA2LYZ1); }
 784   }
 785   if (LYZ2) {
 786     mgr->ConnectInput(taskLYZ2,0,cinput1);
 787     mgr->ConnectInput(taskLYZ2,1,cinputLYZ2);
 788     mgr->ConnectOutput(taskLYZ2,0,coutputLYZ2);
 789     if (QA) { mgr->ConnectOutput(taskLYZ2,1,coutputQA1LYZ2);
 790     mgr->ConnectOutput(taskLYZ2,2,coutputQA2LYZ2); }
 791     cinputLYZ2->SetData(fInputListLYZ2);
 792   }
 793   if (LYZEP) {
 794     mgr->ConnectInput(taskLYZEP,0,cinput1);
 795     mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
 796     mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
 797     if (QA) { mgr->ConnectOutput(taskLYZEP,1,coutputQA1LYZEP);
 798     mgr->ConnectOutput(taskLYZEP,2,coutputQA2LYZEP); }
 799     cinputLYZEP->SetData(fInputListLYZEP);
 800   }
 801   if (GFC)   {
 802     mgr->ConnectInput(taskGFC,0,cinput1);
 803     mgr->ConnectOutput(taskGFC,0,coutputGFC);
 804     if (QA) { mgr->ConnectOutput(taskGFC,1,coutputQA1GFC);
 805     mgr->ConnectOutput(taskGFC,2,coutputQA2GFC); }
 806   }
 807   if (QC)   {
 808     mgr->ConnectInput(taskQC,0,cinput1);
 809     mgr->ConnectOutput(taskQC,0,coutputQC);
 810     if (QA) { mgr->ConnectOutput(taskQC,1,coutputQA1QC);
 811     mgr->ConnectOutput(taskQC,2,coutputQA2QC); }
 812   }
 813   if (FQD)   {
 814     mgr->ConnectInput(taskFQD,0,cinput1);
 815     mgr->ConnectOutput(taskFQD,0,coutputFQD);
 816     if (QA) { mgr->ConnectOutput(taskFQD,1,coutputQA1FQD);
 817     mgr->ConnectOutput(taskFQD,2,coutputQA2FQD); }
 818   }
 819   if (MCEP)  {
 820     mgr->ConnectInput(taskMCEP,0,cinput1);
 821     mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
 822     if (QA) { mgr->ConnectOutput(taskMCEP,1,coutputQA1MCEP);
 823     mgr->ConnectOutput(taskMCEP,2,coutputQA2MCEP); }
 824   }
 825
 826   if (!mgr->InitAnalysis()) return;
 827   mgr->PrintStatus();
 828   mgr->StartAnalysis("local",chain);
 829
 830   timer.Stop();
 831   timer.Print();
 832 }
 833
 834
 835 // Helper macros for creating chains
 836 // from: CreateESDChain.C,v 1.10 jgrosseo Exp
 837
 838 TChain* CreateESDChain(const char* aDataDir, Int_t aRuns, Int_t offset)
 839 {
 840   // creates chain of files in a given directory or file containing a list.
 841   // In case of directory the structure is expected as:
 842   // <aDataDir>/<dir0>/AliESDs.root
 843   // <aDataDir>/<dir1>/AliESDs.root
 844   // ...
 845
 846   if (!aDataDir)
 847     return 0;
 848
 849   Long_t id, size, flags, modtime;
 850   if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
 851     {
 852       printf("%s not found.\n", aDataDir);
 853       return 0;
 854     }
 855
 856   TChain* chain = new TChain("esdTree");
 857   TChain* chaingAlice = 0;
 858
 859   if (flags & 2)
 860     {
 861       TString execDir(gSystem->pwd());
 862       TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
 863       TList* dirList            = baseDir->GetListOfFiles();
 864       Int_t nDirs               = dirList->GetEntries();
 865       gSystem->cd(execDir);
 866
 867       Int_t count = 0;
 868
 869       for (Int_t iDir=0; iDir<nDirs; ++iDir)
 870         {
 871           TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
 872           if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
 873             continue;
 874
 875           if (offset > 0)
 876             {
 877               --offset;
 878               continue;
 879             }
 880
 881           if (count++ == aRuns)
 882             break;
 883
 884           TString presentDirName(aDataDir);
 885           presentDirName += "/";
 886           presentDirName += presentDir->GetName();
 887           chain->Add(presentDirName + "/AliESDs.root/esdTree");
 888           //  cerr<<presentDirName<<endl;
 889         }
 890
 891     }
 892   else
 893     {
 894       // Open the input stream
 895       ifstream in;
 896       in.open(aDataDir);
 897
 898       Int_t count = 0;
 899
 900       // Read the input list of files and add them to the chain
 901       TString esdfile;
 902       while(in.good()) {
 903         in >> esdfile;
 904         if (!esdfile.Contains("root")) continue; // protection
 905
 906         if (offset > 0)
 907           {
 908             --offset;
 909             continue;
 910           }
 911
 912         if (count++ == aRuns)
 913           break;
 914
 915         // add esd file
 916         chain->Add(esdfile);
 917       }
 918
 919       in.close();
 920     }
 921
 922   return chain;
 923 }
 924
 925 // Helper macros for creating chains
 926 // from: CreateESDChain.C,v 1.10 jgrosseo Exp
 927
 928 TChain* CreateAODChain(const char* aDataDir, Int_t aRuns, Int_t offset)
 929 {
 930   // creates chain of files in a given directory or file containing a list.
 931   // In case of directory the structure is expected as:
 932   // <aDataDir>/<dir0>/AliAOD.root
 933   // <aDataDir>/<dir1>/AliAOD.root
 934   // ...
 935
 936   if (!aDataDir)
 937     return 0;
 938
 939   Long_t id, size, flags, modtime;
 940   if (gSystem->GetPathInfo(aDataDir, &id, &size, &flags, &modtime))
 941     {
 942       printf("%s not found.\n", aDataDir);
 943       return 0;
 944     }
 945
 946   TChain* chain = new TChain("aodTree");
 947   TChain* chaingAlice = 0;
 948
 949   if (flags & 2)
 950     {
 951       TString execDir(gSystem->pwd());
 952       TSystemDirectory* baseDir = new TSystemDirectory(".", aDataDir);
 953       TList* dirList            = baseDir->GetListOfFiles();
 954       Int_t nDirs               = dirList->GetEntries();
 955       gSystem->cd(execDir);
 956
 957       Int_t count = 0;
 958
 959       for (Int_t iDir=0; iDir<nDirs; ++iDir)
 960         {
 961           TSystemFile* presentDir = (TSystemFile*) dirList->At(iDir);
 962           if (!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 || strcmp(presentDir->GetName(), "..") == 0)
 963             continue;
 964
 965           if (offset > 0)
 966             {
 967               --offset;
 968               continue;
 969             }
 970
 971           if (count++ == aRuns)
 972             break;
 973
 974           TString presentDirName(aDataDir);
 975           presentDirName += "/";
 976           presentDirName += presentDir->GetName();
 977           chain->Add(presentDirName + "/AliAOD.root/aodTree");
 978           // cerr<<presentDirName<<endl;
 979         }
 980
 981     }
 982   else
 983     {
 984       // Open the input stream
 985       ifstream in;
 986       in.open(aDataDir);
 987
 988       Int_t count = 0;
 989
 990       // Read the input list of files and add them to the chain
 991       TString aodfile;
 992       while(in.good()) {
 993         in >> aodfile;
 994         if (!aodfile.Contains("root")) continue; // protection
 995
 996         if (offset > 0)
 997           {
 998             --offset;
 999             continue;
1000           }
1001
1002         if (count++ == aRuns)
1003           break;
1004
1005         // add aod file
1006         chain->Add(aodfile);
1007       }
1008
1009       in.close();
1010     }
1011
1012   return chain;
1013 }
1014