PWG2/FLOW/macros/runProofFlow.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   = Cumulants                     (for PbPb)
  11 // QC    = Q-cumulants                   (for PbPb or pp)
  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)
  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
  33 // RUN SETTINGS
  34
  35 // Flow analysis method 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 // Analysis type can be ESD, AOD, MC, ESDMC0, ESDMC1
  46 const TString type = "ESD";
  47
  48 // Boolean to fill/not fill the QA histograms
  49 Bool_t QA = kFALSE;
  50
  51 // Weights
  52 //Use weights for Q vector
  53 Bool_t usePhiWeights = kFALSE; //Phi
  54 Bool_t usePtWeights  = kFALSE; //v'(pt)
  55 Bool_t useEtaWeights = kFALSE; //v'(eta)
  56 Bool_t useWeights = usePhiWeights||usePtWeights||useEtaWeights;
  57
  58
  59 // SETTING THE CUTS
  60
  61 // For integrated flow
  62 const Double_t ptmin1 = 0.0;
  63 const Double_t ptmax1 = 10.0;
  64 const Double_t ymin1  = -1.;
  65 const Double_t ymax1  = 1.;
  66 const Int_t mintrackrefsTPC1 = 2;
  67 const Int_t mintrackrefsITS1 = 3;
  68 const Int_t charge1 = 1;
  69 Bool_t UsePIDIntegratedFlow = kFALSE;
  70 const Int_t PDG1 = 211;
  71 const Int_t minclustersTPC1 = 50;
  72 const Int_t maxnsigmatovertex1 = 3;
  73
  74 // For differential flow
  75 const Double_t ptmin2 = 0.0;
  76 const Double_t ptmax2 = 10.0;
  77 const Double_t ymin2  = -1.;
  78 const Double_t ymax2  = 1.;
  79 const Int_t mintrackrefsTPC2 = 2;
  80 const Int_t mintrackrefsITS2 = 3;
  81 const Int_t charge2 = 1;
  82 Bool_t UsePIDDifferentialFlow = kFALSE;
  83 const Int_t PDG2 = 211;
  84 const Int_t minclustersTPC2 = 50;
  85 const 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) {
  89 //void runProofFlow(const Char_t* data="/COMMON/COMMON/LHC08c18_0.9TeV_0T_Phojet", Int_t nRuns=-1, Int_t offset=0) {
  90
  91 //ESD (therminator)
  92 //void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_ESD", Int_t nRuns=-1, Int_t offset=0) {
  93
  94 void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_c2030", Int_t nRuns=-1, Int_t offset=0) {
  95 //void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_central", Int_t nRuns=-1, Int_t offset=0) {
  96 //void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral", Int_t nRuns=-1, Int_t offset=0) {
  97
  98 //AOD
  99 //void runProofFlow(const Char_t* data="/PWG2/nkolk/myDataSet", Int_t nRuns=-1, Int_t offset=0) {
 100 //void runProofFlow(const Char_t* data="/PWG2/akisiel/Therminator_midcentral_AOD", Int_t nRuns=44, Int_t offset=0) {
 101
 102   TStopwatch timer;
 103   timer.Start();
 104
 105   if (LYZ1 && LYZ2) {cout<<"WARNING: you cannot run LYZ1 and LYZ2 at the same time! LYZ2 needs the output from LYZ1."<<endl; exit(); }
 106   if (LYZ2 && LYZEP) {cout<<"WARNING: you cannot run LYZ2 and LYZEP at the same time! LYZEP needs the output from LYZ2."<<endl; exit(); }
 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
 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");
 112
 113   printf("*** Connect to PROOF ***\n");
 114   //  TProof::Open("abilandz@alicecaf.cern.ch");
 115   TProof::Open("snelling@localhost");
 116
 117   //gProof->UploadPackage("AF-v4-15");
 118   //gProof->EnablePackage("AF-v4-15");
 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");
 131   gProof->ClearPackage("CORRFW.par");
 132   gProof->UploadPackage("CORRFW.par");
 133   gProof->EnablePackage("CORRFW");
 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");
 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(); }
 162     if (QC) {
 163       TList* qaIntQC = new TList();
 164       TList* qaDiffQC = new TList(); }
 165     if (FQD) {
 166       TList* qaIntFQD = new TList();
 167       TList* qaDiffFQD = new TList(); }
 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); }
 184     if (QC)   { mcKineCuts1->SetQAOn(qaIntQC); }
 185     if (FQD)  { mcKineCuts1->SetQAOn(qaIntFQD); }
 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); }
 199     if (QC)   { mcKineCuts2->SetQAOn(qaDiffQC); }
 200     if (FQD)  { mcKineCuts2->SetQAOn(qaDiffFQD); }
 201     if (MCEP) { mcKineCuts2->SetQAOn(qaDiffMCEP); }
 202   }
 203
 204   AliCFParticleGenCuts* mcGenCuts1 = new AliCFParticleGenCuts("mcGenCuts1","MC particle generation cuts for integrated flow");
 205   mcGenCuts1->SetRequireIsPrimary();
 206   if (UsePIDIntegratedFlow) {mcGenCuts1->SetRequirePdgCode(PDG1);}
 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); }
 213     if (QC)   { mcGenCuts1->SetQAOn(qaIntQC); }
 214     if (FQD)  { mcGenCuts1->SetQAOn(qaIntFQD); }
 215     if (MCEP) { mcGenCuts1->SetQAOn(qaIntMCEP); }
 216   }
 217
 218   AliCFParticleGenCuts* mcGenCuts2 = new AliCFParticleGenCuts("mcGenCuts2","MC particle generation cuts for differential flow");
 219   mcGenCuts2->SetRequireIsPrimary();
 220   if (UsePIDDifferentialFlow) {mcGenCuts2->SetRequirePdgCode(PDG2);}
 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); }
 227     if (QC)   { mcGenCuts2->SetQAOn(qaDiffQC); }
 228     if (FQD)  { mcGenCuts2->SetQAOn(qaDiffFQD); }
 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); }
 242     if (QC)   { mcAccCuts1->SetQAOn(qaIntQC); }
 243     if (FQD)  { mcAccCuts1->SetQAOn(qaIntFQD); }
 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); }
 256     if (QC)   { mcAccCuts2->SetQAOn(qaDiffQC); }
 257     if (FQD)  { mcAccCuts2->SetQAOn(qaDiffFQD); }
 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); }
 272     if (QC)   { recKineCuts1->SetQAOn(qaIntQC); }
 273     if (FQD)  { recKineCuts1->SetQAOn(qaIntFQD); }
 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); }
 287     if (QC)   { recKineCuts2->SetQAOn(qaDiffQC); }
 288     if (FQD)  { recKineCuts2->SetQAOn(qaDiffFQD); }
 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); }
 301     if (QC)   { recQualityCuts1->SetQAOn(qaIntQC); }
 302     if (FQD)  { recQualityCuts1->SetQAOn(qaIntFQD); }
 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); }
 315     if (QC)   { recQualityCuts2->SetQAOn(qaDiffQC); }
 316     if (FQD)  { recQualityCuts2->SetQAOn(qaDiffFQD); }
 317     if (MCEP) { recQualityCuts2->SetQAOn(qaDiffMCEP); }
 318   }
 319
 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); }
 328     if (QC)   { recIsPrimaryCuts1->SetQAOn(qaIntQC); }
 329     if (FQD)  { recIsPrimaryCuts1->SetQAOn(qaIntFQD); }
 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); }
 341     if (QC)   { recIsPrimaryCuts2->SetQAOn(qaDiffQC); }
 342     if (FQD)  { recIsPrimaryCuts2->SetQAOn(qaDiffFQD); }
 343     if (MCEP) { recIsPrimaryCuts2->SetQAOn(qaDiffMCEP); }
 344   }
 345
 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 ;
 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     }
 379   }
 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     }
 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) ;
 436   if(UsePIDIntegratedFlow) {fPIDCutList1->AddLast(cutPID1);}
 437
 438   TObjArray* fPIDCutList2 = new TObjArray(0) ;
 439   if (UsePIDDifferentialFlow)  {fPIDCutList2->AddLast(cutPID2);}
 440
 441   printf("CREATE INTERFACE AND CUTS\n");
 442   AliCFManager* cfmgr1 = new AliCFManager();
 443   //  cfmgr1->SetNStepParticle(4); //05nov08
 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();
 450   //  cfmgr2->SetNStepParticle(4); //05nov08
 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
 456   //weights:
 457   TFile *weightsFile = NULL;
 458   TList *weightsList = NULL;
 459
 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   }
 472
 473
 474   if (LYZ2){
 475     // read the input file from the first run
 476     TString inputFileNameLYZ2 = "outputLYZ1analysis" ;
 477     inputFileNameLYZ2 += type;
 478     inputFileNameLYZ2 += ".root";
 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;
 494     inputFileNameLYZEP += "_secondrun.root";
 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;}
 502     }
 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);
 527
 528     AliMCEventHandler *mc = new AliMCEventHandler();
 529     mgr->SetMCtruthEventHandler(mc); }
 530
 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);
 543   }
 544   if (LYZ1){
 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) {
 553       taskLYZ1->SetQAList1(qaIntLYZ1);
 554       taskLYZ1->SetQAList2(qaDiffLYZ1);}
 555     mgr->AddTask(taskLYZ1);
 556   }
 557   if (LYZ2){
 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) {
 566       taskLYZ2->SetQAList1(qaIntLYZ2);
 567       taskLYZ2->SetQAList2(qaDiffLYZ2); }
 568     mgr->AddTask(taskLYZ2);
 569   }
 570   if (LYZEP){
 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) {
 577       taskLYZEP->SetQAList1(qaIntLYZEP);
 578       taskLYZEP->SetQAList2(qaDiffLYZEP); }
 579     mgr->AddTask(taskLYZEP);
 580   }
 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);
 587     if (QA) {
 588       taskGFC->SetQAList1(qaIntGFC);
 589       taskGFC->SetQAList2(qaDiffGFC); }
 590     mgr->AddTask(taskGFC);
 591   }
 592   if (QC){
 593     if (QA) { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kTRUE,useWeights);}
 594     else { AliAnalysisTaskQCumulants *taskQC = new AliAnalysisTaskQCumulants("TaskQCumulants",kFALSE,useWeights);}
 595     taskQC->SetAnalysisType(type);
 596     taskQC->SetUsePhiWeights(usePhiWeights);
 597     taskQC->SetUsePtWeights(usePtWeights);
 598     taskQC->SetUseEtaWeights(useEtaWeights);
 599     taskQC->SetCFManager1(cfmgr1);
 600     taskQC->SetCFManager2(cfmgr2);
 601     if (QA) {
 602       taskQC->SetQAList1(qaIntQC);
 603       taskQC->SetQAList2(qaDiffQC); }
 604     mgr->AddTask(taskQC);
 605   }
 606   if (FQD){
 607     if (QA) { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kTRUE,useWeights);}
 608     else { AliAnalysisTaskFittingQDistribution *taskFQD = new AliAnalysisTaskFittingQDistribution("TaskFittingQDistribution",kFALSE,useWeights);}
 609     taskFQD->SetAnalysisType(type);
 610     taskFQD->SetUsePhiWeights(usePhiWeights);
 611     taskFQD->SetUsePtWeights(usePtWeights);
 612     taskFQD->SetUseEtaWeights(useEtaWeights);
 613     taskFQD->SetCFManager1(cfmgr1);
 614     taskFQD->SetCFManager2(cfmgr2);
 615     if (QA) {
 616       taskFQD->SetQAList1(qaIntFQD);
 617       taskFQD->SetQAList2(qaDiffFQD); }
 618     mgr->AddTask(taskFQD);
 619   }
 620   if (MCEP){
 621     if (QA) { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kTRUE);}
 622     else { AliAnalysisTaskMCEventPlane *taskMCEP = new AliAnalysisTaskMCEventPlane("TaskMCEventPlane",kFALSE);}
 623     taskMCEP->SetAnalysisType(type);
 624     taskMCEP->SetCFManager1(cfmgr1);
 625     taskMCEP->SetCFManager2(cfmgr2);
 626     if (QA) {
 627       taskMCEP->SetQAList1(qaIntMCEP);
 628       taskMCEP->SetQAList2(qaDiffMCEP); }
 629     mgr->AddTask(taskMCEP);
 630   }
 631
 632
 633   // Create containers for input/output
 634   AliAnalysisDataContainer *cinput1 =
 635     mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
 636
 637   if (useWeights) {
 638     AliAnalysisDataContainer *cinputWeights = mgr->CreateContainer("cobjWeights",TList::Class(),AliAnalysisManager::kInputContainer);
 639   }
 640
 641   if (LYZ2){
 642     AliAnalysisDataContainer *cinputLYZ2 = mgr->CreateContainer("cobjLYZ2in",TList::Class(),AliAnalysisManager::kInputContainer); }
 643   if (LYZEP){
 644     AliAnalysisDataContainer *cinputLYZEP = mgr->CreateContainer("cobjLYZEPin",TList::Class(),AliAnalysisManager::kInputContainer); }
 645
 646   if(SP) {
 647     TString outputSP = "outputSPanalysis";
 648     outputSP+= type;
 649     outputSP+= ".root";
 650     AliAnalysisDataContainer *coutputSP = mgr->CreateContainer("cobjSP", TList::Class(),AliAnalysisManager::kOutputContainer,outputSP);
 651   }
 652
 653   if(LYZ1) {
 654     TString outputLYZ1 = "outputLYZ1analysis";
 655     outputLYZ1+= type;
 656     outputLYZ1+= "_firstrun.root";
 657     AliAnalysisDataContainer *coutputLYZ1 = mgr->CreateContainer("cobjLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ1);
 658   }
 659
 660   if(LYZ2) {
 661     TString outputLYZ2 = "outputLYZ2analysis";
 662     outputLYZ2+= type;
 663     outputLYZ2+= "_secondrun.root";
 664     AliAnalysisDataContainer *coutputLYZ2 = mgr->CreateContainer("cobjLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZ2);
 665   }
 666
 667   if(LYZEP) {
 668     TString outputLYZEP = "outputLYZEPanalysis";
 669     outputLYZEP+= type;
 670     outputLYZEP+= ".root";
 671     AliAnalysisDataContainer *coutputLYZEP = mgr->CreateContainer("cobjLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputLYZEP);
 672   }
 673
 674   if(GFC) {
 675     TString outputGFC = "outputGFCanalysis";
 676     outputGFC+= type;
 677     outputGFC+= ".root";
 678     AliAnalysisDataContainer *coutputGFC = mgr->CreateContainer("cobjGFC", TList::Class(),AliAnalysisManager::kOutputContainer,outputGFC);
 679   }
 680
 681   if(QC) {
 682     TString outputQC = "outputQCanalysis";
 683     outputQC+= type;
 684     outputQC+= ".root";
 685     AliAnalysisDataContainer *coutputQC = mgr->CreateContainer("cobjQC", TList::Class(),AliAnalysisManager::kOutputContainer,outputQC);
 686   }
 687
 688   if(FQD) {
 689     TString outputFQD = "outputFQDanalysis";
 690     outputFQD+= type;
 691     outputFQD+= ".root";
 692     AliAnalysisDataContainer *coutputFQD = mgr->CreateContainer("cobjFQD", TList::Class(),AliAnalysisManager::kOutputContainer,outputFQD);
 693   }
 694
 695   if(MCEP) {
 696     TString outputMCEP = "outputMCEPanalysis";
 697     outputMCEP+= type;
 698     outputMCEP+= ".root";
 699     AliAnalysisDataContainer *coutputMCEP = mgr->CreateContainer("cobjMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,outputMCEP);
 700   }
 701
 702
 703   if (QA) {
 704     if(SP) {
 705       TString qaNameIntSP = "QAforInt_SP_";
 706       qaNameIntSP += type;
 707       qaNameIntSP += ".root";
 708       AliAnalysisDataContainer *coutputQA1SP =
 709         mgr->CreateContainer("QAintSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntSP);
 710
 711       TString qaNameDiffSP = "QAforDiff_SP_";
 712       qaNameDiffSP += type;
 713       qaNameDiffSP += ".root";
 714       AliAnalysisDataContainer *coutputQA2SP =
 715         mgr->CreateContainer("QAdiffSP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffSP);
 716     }
 717     if(LYZ1) {
 718       TString qaNameIntLYZ1 = "QAforInt_LYZ1_";
 719       qaNameIntLYZ1 += type;
 720       qaNameIntLYZ1 += ".root";
 721       AliAnalysisDataContainer *coutputQA1LYZ1 =
 722         mgr->CreateContainer("QAintLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ1);
 723
 724       TString qaNameDiffLYZ1 = "QAforDiff_LYZ1_";
 725       qaNameDiffLYZ1 += type;
 726       qaNameDiffLYZ1 += ".root";
 727       AliAnalysisDataContainer *coutputQA2LYZ1 =
 728         mgr->CreateContainer("QAdiffLYZ1", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ1);
 729     }
 730     if(LYZ2) {
 731       TString qaNameIntLYZ2 = "QAforInt_LYZ2_";
 732       qaNameIntLYZ2 += type;
 733       qaNameIntLYZ2 += ".root";
 734       AliAnalysisDataContainer *coutputQA1LYZ2 =
 735         mgr->CreateContainer("QAintLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZ2);
 736
 737       TString qaNameDiffLYZ2 = "QAforDiff_LYZ2_";
 738       qaNameDiffLYZ2 += type;
 739       qaNameDiffLYZ2 += ".root";
 740       AliAnalysisDataContainer *coutputQA2LYZ2 =
 741         mgr->CreateContainer("QAdiffLYZ2", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZ2);
 742     }
 743     if(LYZEP) {
 744       TString qaNameIntLYZEP = "QAforInt_LYZEP_";
 745       qaNameIntLYZEP += type;
 746       qaNameIntLYZEP += ".root";
 747       AliAnalysisDataContainer *coutputQA1LYZEP =
 748         mgr->CreateContainer("QAintLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntLYZEP);
 749
 750       TString qaNameDiffLYZEP = "QAforDiff_LYZEP_";
 751       qaNameDiffLYZEP += type;
 752       qaNameDiffLYZEP += ".root";
 753       AliAnalysisDataContainer *coutputQA2LYZEP =
 754         mgr->CreateContainer("QAdiffLYZEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffLYZEP);
 755     }
 756     if(GFC) {
 757       TString qaNameIntGFC = "QAforInt_GFC_";
 758       qaNameIntGFC += type;
 759       qaNameIntGFC += ".root";
 760       AliAnalysisDataContainer *coutputQA1GFC =
 761         mgr->CreateContainer("QAintGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntGFC);
 762
 763       TString qaNameDiffGFC = "QAforDiff_GFC_";
 764       qaNameDiffGFC += type;
 765       qaNameDiffGFC += ".root";
 766       AliAnalysisDataContainer *coutputQA2GFC =
 767         mgr->CreateContainer("QAdiffGFC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffGFC);
 768     }
 769     if(QC) {
 770       TString qaNameIntQC = "QAforInt_QC_";
 771       qaNameIntQC += type;
 772       qaNameIntQC += ".root";
 773       AliAnalysisDataContainer *coutputQA1QC =
 774         mgr->CreateContainer("QAintQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntQC);
 775
 776       TString qaNameDiffQC = "QAforDiff_QC_";
 777       qaNameDiffQC += type;
 778       qaNameDiffQC += ".root";
 779       AliAnalysisDataContainer *coutputQA2QC =
 780         mgr->CreateContainer("QAdiffQC", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffQC);
 781     }
 782     if(FQQ) {
 783       TString qaNameIntFQD = "QAforInt_FQD_";
 784       qaNameIntFQD += type;
 785       qaNameIntFQD += ".root";
 786       AliAnalysisDataContainer *coutputQA1FQD =
 787         mgr->CreateContainer("QAintFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntFQD);
 788
 789       TString qaNameDiffFQD = "QAforDiff_FQD_";
 790       qaNameDiffFQD += type;
 791       qaNameDiffFQD += ".root";
 792       AliAnalysisDataContainer *coutputQA2FQD =
 793         mgr->CreateContainer("QAdiffFQD", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffFQD);
 794     }
 795     if(MCEP) {
 796       TString qaNameIntMCEP = "QAforInt_MCEP_";
 797       qaNameIntMCEP += type;
 798       qaNameIntMCEP += ".root";
 799       AliAnalysisDataContainer *coutputQA1MCEP =
 800         mgr->CreateContainer("QAintMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameIntMCEP);
 801
 802       TString qaNameDiffMCEP = "QAforDiff_MCEP_";
 803       qaNameDiffMCEP += type;
 804       qaNameDiffMCEP += ".root";
 805       AliAnalysisDataContainer *coutputQA2MCEP =
 806         mgr->CreateContainer("QAdiffMCEP", TList::Class(),AliAnalysisManager::kOutputContainer,qaNameDiffMCEP);
 807     }
 808   }
 809
 810
 811   //____________________________________________//
 812
 813   if (SP)   {
 814     mgr->ConnectInput(taskSP,0,cinput1);
 815     mgr->ConnectOutput(taskSP,0,coutputSP);
 816     if (QA) { mgr->ConnectOutput(taskSP,1,coutputQA1SP);
 817     mgr->ConnectOutput(taskSP,2,coutputQA2SP); }
 818   }
 819   if (LYZ1) {
 820     mgr->ConnectInput(taskLYZ1,0,cinput1);
 821     mgr->ConnectOutput(taskLYZ1,0,coutputLYZ1);
 822     if (QA) { mgr->ConnectOutput(taskLYZ1,1,coutputQA1LYZ1);
 823     mgr->ConnectOutput(taskLYZ1,2,coutputQA2LYZ1); }
 824   }
 825   if (LYZ2) {
 826     mgr->ConnectInput(taskLYZ2,0,cinput1);
 827     mgr->ConnectInput(taskLYZ2,1,cinputLYZ2);
 828     mgr->ConnectOutput(taskLYZ2,0,coutputLYZ2);
 829     if (QA) { mgr->ConnectOutput(taskLYZ2,1,coutputQA1LYZ2);
 830     mgr->ConnectOutput(taskLYZ2,2,coutputQA2LYZ2); }
 831     cinputLYZ2->SetData(fInputListLYZ2);
 832   }
 833   if (LYZEP) {
 834     mgr->ConnectInput(taskLYZEP,0,cinput1);
 835     mgr->ConnectInput(taskLYZEP,1,cinputLYZEP);
 836     mgr->ConnectOutput(taskLYZEP,0,coutputLYZEP);
 837     if (QA) { mgr->ConnectOutput(taskLYZEP,1,coutputQA1LYZEP);
 838     mgr->ConnectOutput(taskLYZEP,2,coutputQA2LYZEP); }
 839     cinputLYZEP->SetData(fInputListLYZEP);
 840   }
 841   if (GFC)   {
 842     mgr->ConnectInput(taskGFC,0,cinput1);
 843     mgr->ConnectOutput(taskGFC,0,coutputGFC);
 844     if (QA) { mgr->ConnectOutput(taskGFC,1,coutputQA1GFC);
 845     mgr->ConnectOutput(taskGFC,2,coutputQA2GFC); }
 846   }
 847   if (QC)   {
 848     mgr->ConnectInput(taskQC,0,cinput1);
 849     mgr->ConnectOutput(taskQC,0,coutputQC);
 850     if (QA) { mgr->ConnectOutput(taskQC,1,coutputQA1QC);
 851     mgr->ConnectOutput(taskQC,2,coutputQA2QC); }
 852     if (useWeights) {
 853       mgr->ConnectInput(taskQC,1,cinputWeights);
 854       cinputWeights->SetData(weightsList);
 855     }
 856   }
 857   if (FQD)   {
 858     mgr->ConnectInput(taskFQD,0,cinput1);
 859     mgr->ConnectOutput(taskFQD,0,coutputFQD);
 860     if (QA) { mgr->ConnectOutput(taskFQD,1,coutputQA1FQD);
 861     mgr->ConnectOutput(taskFQD,2,coutputQA2FQD); }
 862     if(useWeights) {
 863       mgr->ConnectInput(taskFQD,1,cinputWeights);
 864       cinputWeights->SetData(weightsList);
 865     }
 866   }
 867   if (MCEP)  {
 868     mgr->ConnectInput(taskMCEP,0,cinput1);
 869     mgr->ConnectOutput(taskMCEP,0,coutputMCEP);
 870     if (QA) { mgr->ConnectOutput(taskMCEP,1,coutputQA1MCEP);
 871     mgr->ConnectOutput(taskMCEP,2,coutputQA2MCEP); }
 872   }
 873
 874   if (!mgr->InitAnalysis()) return;
 875   mgr->PrintStatus();
 876   // old way with a chain
 877   //  mgr->StartAnalysis("proof",chain);
 878   mgr->StartAnalysis("proof",data,nRuns,offset);
 879
 880   timer.Stop();
 881   timer.Print();
 882 }