PWG2/FLOW/macros/redoFinish.C

   1 enum libModes {mLocal,mLocalSource};
   2
   3 void redoFinish(TString type="", Int_t mode=mLocal)
   4 {
   5  // type:  type of analysis can be ESD, AOD, MC, ESDMC0, ESDMC1
   6  //        (if type="" output files are from MC simulation (default))
   7  // mode:  if mode=mLocal analyze data on your computer using aliroot
   8  //        if mode=mLocalSource analyze data on your computer using root + source files
   9
  10  Bool_t redoFinishAlsoInSubsets = kFALSE;
  11
  12  // load needed libraries:
  13  LoadLibrariesRDF(mode);
  14
  15  // access the path of current diretory:
  16  TString pwd(gSystem->pwd());
  17  pwd+="/";
  18
  19  cout<<endl;
  20  // access the merged output files and redo the flow analysis on them:
  21  // MCEP:
  22  TString mergedFileNameMCEP("mergedMCEPanalysis");
  23  (mergedFileNameMCEP+=(type.Data()))+=(".root");
  24  TFile *mergedFileMCEP = NULL;
  25  TList *mergedListMCEP = NULL;
  26  TString pwdMCEP=pwd.Data();
  27  pwdMCEP+=mergedFileNameMCEP;
  28  if(gSystem->AccessPathName(pwdMCEP.Data(),kFileExists))
  29  {
  30   cout<<"WARNING: You do not have a merged output file "<<pwdMCEP.Data()<<endl;
  31  } else
  32    {
  33     mergedFileMCEP = TFile::Open(pwdMCEP.Data(),"READ");
  34     if(mergedFileMCEP)
  35     {
  36      mergedFileMCEP->GetObject("cobjMCEP",mergedListMCEP);
  37      mergedFileMCEP->Close();
  38     }
  39    }
  40  if(mergedListMCEP)
  41  {
  42   AliFlowAnalysisWithMCEventPlane* mcep = new AliFlowAnalysisWithMCEventPlane();
  43   mcep->GetOutputHistograms(mergedListMCEP);
  44   mcep->Finish();
  45   // save the final results for MCEP in final output file:
  46   TString finalOutputFileNameMCEP("outputMCEPanalysis");
  47   (finalOutputFileNameMCEP+=(type.Data()))+=(".root");
  48   TString pwdFinalMCEP=pwd.Data();
  49   pwdFinalMCEP+=finalOutputFileNameMCEP;
  50   TFile *finalOutputMCEP = new TFile(pwdFinalMCEP.Data(),"NEW");
  51   mergedListMCEP->SetName("cobjMCEP");
  52   mergedListMCEP->Write(mergedListMCEP->GetName(),TObject::kSingleKey);
  53   finalOutputMCEP->Close();
  54   delete mcep;
  55   delete finalOutputMCEP;
  56  } else
  57    {
  58     cout<<"WARNING: mergedListMCEP is NULL !!!!"<<endl;
  59    }
  60
  61  // SP:
  62  TString mergedFileNameSP("mergedSPanalysis");
  63  (mergedFileNameSP+=(type.Data()))+=(".root");
  64  TFile *mergedFileSP = NULL;
  65  TList *mergedListSP = NULL;
  66  TString pwdSP=pwd.Data();
  67  pwdSP+=mergedFileNameSP;
  68  if(gSystem->AccessPathName(pwdSP.Data(),kFileExists))
  69  {
  70   cout<<"WARNING: You do not have a merged output file "<<pwdSP.Data()<<endl;
  71  } else
  72    {
  73     mergedFileSP = TFile::Open(pwdSP.Data(),"READ");
  74     if(mergedFileSP)
  75     {
  76      mergedFileSP->GetObject("cobjSP",mergedListSP);
  77      mergedFileSP->Close();
  78     }
  79    }
  80  if(mergedListSP)
  81  {
  82   AliFlowAnalysisWithScalarProduct* sp = new AliFlowAnalysisWithScalarProduct();
  83   sp->GetOutputHistograms(mergedListSP);
  84   sp->Finish();
  85   // save the final results for SP in final output file:
  86   TString finalOutputFileNameSP("outputSPanalysis");
  87   (finalOutputFileNameSP+=(type.Data()))+=(".root");
  88   TString pwdFinalSP=pwd.Data();
  89   pwdFinalSP+=finalOutputFileNameSP;
  90   TFile *finalOutputSP = new TFile(pwdFinalSP.Data(),"NEW");
  91   mergedListSP->SetName("cobjSP");
  92   mergedListSP->Write(mergedListSP->GetName(),TObject::kSingleKey);
  93   finalOutputSP->Close();
  94   delete sp;
  95   delete finalOutputSP;
  96  } else
  97    {
  98     cout<<"WARNING: mergedListSP is NULL !!!!"<<endl;
  99    }
 100
 101  // GFC:
 102  TString mergedFileNameGFC("mergedGFCanalysis");
 103  (mergedFileNameGFC+=(type.Data()))+=(".root");
 104  TFile *mergedFileGFC = NULL;
 105  TList *mergedListGFC = NULL;
 106  TString pwdGFC=pwd.Data();
 107  pwdGFC+=mergedFileNameGFC;
 108  if(gSystem->AccessPathName(pwdGFC.Data(),kFileExists))
 109  {
 110   cout<<"WARNING: You do not have a merged output file "<<pwdGFC.Data()<<endl;
 111  } else
 112    {
 113     mergedFileGFC = TFile::Open(pwdGFC.Data(),"READ");
 114     if(mergedFileGFC)
 115     {
 116      mergedFileGFC->GetObject("cobjGFC",mergedListGFC);
 117      mergedFileGFC->Close();
 118     }
 119    }
 120  if(mergedListGFC)
 121  {
 122   AliFlowAnalysisWithCumulants* gfc = new AliFlowAnalysisWithCumulants();
 123   gfc->GetOutputHistograms(mergedListGFC);
 124   gfc->Finish();
 125   // save the final results for GFC in final output file:
 126   TString finalOutputFileNameGFC("outputGFCanalysis");
 127   (finalOutputFileNameGFC+=(type.Data()))+=(".root");
 128   TString pwdFinalGFC=pwd.Data();
 129   pwdFinalGFC+=finalOutputFileNameGFC;
 130   TFile *finalOutputGFC = new TFile(pwdFinalGFC.Data(),"NEW");
 131   mergedListGFC->SetName("cobjGFC");
 132   mergedListGFC->Write(mergedListGFC->GetName(),TObject::kSingleKey);
 133   finalOutputGFC->Close();
 134   delete gfc;
 135   delete finalOutputGFC;
 136  } else
 137    {
 138     cout<<"WARNING: mergedListGFC is NULL !!!!"<<endl;
 139    }
 140
 141  // QC:
 142  TString mergedFileNameQC("mergedQCanalysis");
 143  (mergedFileNameQC+=(type.Data()))+=(".root");
 144  TFile *mergedFileQC = NULL;
 145  TList *mergedListQC = NULL;
 146  TString pwdQC=pwd.Data();
 147  pwdQC+=mergedFileNameQC;
 148  if(gSystem->AccessPathName(pwdQC.Data(),kFileExists))
 149  {
 150   cout<<"WARNING: You do not have a merged output file "<<pwdQC.Data()<<endl;
 151  } else
 152    {
 153     mergedFileQC = TFile::Open(pwdQC.Data(),"READ");
 154     if(mergedFileQC)
 155     {
 156      mergedFileQC->GetObject("cobjQC",mergedListQC);
 157      mergedFileQC->Close();
 158     }
 159    }
 160  if(mergedListQC)
 161  {
 162   AliFlowAnalysisWithQCumulants* qc = new AliFlowAnalysisWithQCumulants();
 163   qc->GetOutputHistograms(mergedListQC);
 164   qc->Finish();
 165   // save the final results for QC in final output file:
 166   TString finalOutputFileNameQC("outputQCanalysis");
 167   (finalOutputFileNameQC+=(type.Data()))+=(".root");
 168   TString pwdFinalQC=pwd.Data();
 169   pwdFinalQC+=finalOutputFileNameQC;
 170   TFile *finalOutputQC = new TFile(pwdFinalQC.Data(),"NEW");
 171   mergedListQC->SetName("cobjQC");
 172   mergedListQC->Write(mergedListQC->GetName(),TObject::kSingleKey);
 173   finalOutputQC->Close();
 174   delete qc;
 175   delete finalOutputQC;
 176  } else
 177    {
 178     cout<<"WARNING: mergedListQC is NULL !!!!"<<endl;
 179    }
 180
 181  // FQD:
 182  TString mergedFileNameFQD("mergedFQDanalysis");
 183  (mergedFileNameFQD+=(type.Data()))+=(".root");
 184  TFile *mergedFileFQD = NULL;
 185  TList *mergedListFQD = NULL;
 186  TString pwdFQD=pwd.Data();
 187  pwdFQD+=mergedFileNameFQD;
 188  if(gSystem->AccessPathName(pwdFQD.Data(),kFileExists))
 189  {
 190   cout<<"WARNING: You do not have a merged output file "<<pwdFQD.Data()<<endl;
 191  } else
 192    {
 193     mergedFileFQD = TFile::Open(pwdFQD.Data(),"READ");
 194     if(mergedFileFQD)
 195     {
 196      mergedFileFQD->GetObject("cobjFQD",mergedListFQD);
 197      mergedFileFQD->Close();
 198     }
 199    }
 200  if(mergedListFQD)
 201  {
 202   AliFlowAnalysisWithFittingQDistribution* fqd = new AliFlowAnalysisWithFittingQDistribution();
 203   fqd->GetOutputHistograms(mergedListFQD);
 204   fqd->Finish(kTRUE);
 205   // save the final results for FQD in final output file:
 206   TString finalOutputFileNameFQD("outputFQDanalysis");
 207   (finalOutputFileNameFQD+=(type.Data()))+=(".root");
 208   TString pwdFinalFQD=pwd.Data();
 209   pwdFinalFQD+=finalOutputFileNameFQD;
 210   TFile *finalOutputFQD = new TFile(pwdFinalFQD.Data(),"NEW");
 211   mergedListFQD->SetName("cobjFQD");
 212   mergedListFQD->Write(mergedListFQD->GetName(),TObject::kSingleKey);
 213   finalOutputFQD->Close();
 214   delete fqd;
 215   delete finalOutputFQD;
 216  } else
 217    {
 218     cout<<"WARNING: mergedListFQD is NULL !!!!"<<endl;
 219    }
 220
 221  // LYZ1SUM:
 222  TString mergedFileNameLYZ1SUM("mergedLYZ1SUManalysis");
 223  (mergedFileNameLYZ1SUM+=(type.Data()))+=(".root");
 224  TFile *mergedFileLYZ1SUM = NULL;
 225  TList *mergedListLYZ1SUM = NULL;
 226  TString pwdLYZ1SUM=pwd.Data();
 227  pwdLYZ1SUM+=mergedFileNameLYZ1SUM;
 228  if(gSystem->AccessPathName(pwdLYZ1SUM.Data(),kFileExists))
 229  {
 230   cout<<"WARNING: You do not have a merged output file "<<pwdLYZ1SUM.Data()<<endl;
 231  } else
 232    {
 233     mergedFileLYZ1SUM = TFile::Open(pwdLYZ1SUM.Data(),"READ");
 234     if(mergedFileLYZ1SUM)
 235     {
 236      mergedFileLYZ1SUM->GetObject("cobjLYZ1SUM",mergedListLYZ1SUM);
 237      mergedFileLYZ1SUM->Close();
 238     }
 239    }
 240  if(mergedListLYZ1SUM)
 241  {
 242   AliFlowAnalysisWithLeeYangZeros* lyz1sum = new AliFlowAnalysisWithLeeYangZeros();
 243   lyz1sum->SetFirstRun(kTRUE);
 244   lyz1sum->SetUseSum(kTRUE);
 245   lyz1sum->GetOutputHistograms(mergedListLYZ1SUM);
 246   lyz1sum->Finish();
 247   // save the final results for LYZ1SUM in final output file:
 248   TString finalOutputFileNameLYZ1SUM("outputLYZ1SUManalysis");
 249   (finalOutputFileNameLYZ1SUM+=(type.Data()))+=(".root");
 250   TString pwdFinalLYZ1SUM=pwd.Data();
 251   pwdFinalLYZ1SUM+=finalOutputFileNameLYZ1SUM;
 252   TFile *finalOutputLYZ1SUM = new TFile(pwdFinalLYZ1SUM.Data(),"NEW");
 253   mergedListLYZ1SUM->SetName("cobjLYZ1SUM");
 254   mergedListLYZ1SUM->Write(mergedListLYZ1SUM->GetName(),TObject::kSingleKey);
 255   finalOutputLYZ1SUM->Close();
 256   delete lyz1sum;
 257   delete finalOutputLYZ1SUM;
 258  } else
 259    {
 260     cout<<"WARNING: mergedListLYZ1SUM is NULL !!!!"<<endl;
 261    }
 262
 263  // LYZ2SUM:
 264  TString mergedFileNameLYZ2SUM("mergedLYZ2SUManalysis");
 265  (mergedFileNameLYZ2SUM+=(type.Data()))+=(".root");
 266  TFile *mergedFileLYZ2SUM = NULL;
 267  TList *mergedListLYZ2SUM = NULL;
 268  TString pwdLYZ2SUM=pwd.Data();
 269  pwdLYZ2SUM+=mergedFileNameLYZ2SUM;
 270  if(gSystem->AccessPathName(pwdLYZ2SUM.Data(),kFileExists))
 271  {
 272   cout<<"WARNING: You do not have a merged output file "<<pwdLYZ2SUM.Data()<<endl;
 273  } else
 274    {
 275     mergedFileLYZ2SUM = TFile::Open(pwdLYZ2SUM.Data(),"READ");
 276     if(mergedFileLYZ2SUM)
 277     {
 278      mergedFileLYZ2SUM->GetObject("cobjLYZ2SUM",mergedListLYZ2SUM);
 279      mergedFileLYZ2SUM->Close();
 280     }
 281    }
 282  if(mergedListLYZ2SUM)
 283  {
 284   AliFlowAnalysisWithLeeYangZeros* lyz2sum = new AliFlowAnalysisWithLeeYangZeros();
 285   lyz2sum->SetFirstRun(kFALSE);
 286   lyz2sum->SetUseSum(kTRUE);
 287   lyz2sum->GetOutputHistograms(mergedListLYZ2SUM);
 288   lyz2sum->Finish();
 289   // save the final results for LYZ2SUM in final output file:
 290   TString finalOutputFileNameLYZ2SUM("outputLYZ2SUManalysis");
 291   (finalOutputFileNameLYZ2SUM+=(type.Data()))+=(".root");
 292   TString pwdFinalLYZ2SUM=pwd.Data();
 293   pwdFinalLYZ2SUM+=finalOutputFileNameLYZ2SUM;
 294   TFile *finalOutputLYZ2SUM = new TFile(pwdFinalLYZ2SUM.Data(),"NEW");
 295   mergedListLYZ2SUM->SetName("cobjLYZ2SUM");
 296   mergedListLYZ2SUM->Write(mergedListLYZ2SUM->GetName(),TObject::kSingleKey);
 297   finalOutputLYZ2SUM->Close();
 298   delete lyz2sum;
 299   delete finalOutputLYZ2SUM ;
 300  } else
 301    {
 302     cout<<"WARNING: mergedListLYZ2SUM is NULL !!!!"<<endl;
 303    }
 304
 305  // LYZ1PROD:
 306  TString mergedFileNameLYZ1PROD("mergedLYZ1PRODanalysis");
 307  (mergedFileNameLYZ1PROD+=(type.Data()))+=(".root");
 308  TFile *mergedFileLYZ1PROD = NULL;
 309  TList *mergedListLYZ1PROD = NULL;
 310  TString pwdLYZ1PROD=pwd.Data();
 311  pwdLYZ1PROD+=mergedFileNameLYZ1PROD;
 312  if(gSystem->AccessPathName(pwdLYZ1PROD.Data(),kFileExists))
 313  {
 314   cout<<"WARNING: You do not have a merged output file "<<pwdLYZ1PROD.Data()<<endl;
 315  } else
 316    {
 317     mergedFileLYZ1PROD = TFile::Open(pwdLYZ1PROD.Data(),"READ");
 318     if(mergedFileLYZ1PROD)
 319     {
 320      mergedFileLYZ1PROD->GetObject("cobjLYZ1PROD",mergedListLYZ1PROD);
 321      mergedFileLYZ1PROD->Close();
 322     }
 323    }
 324  if(mergedListLYZ1PROD)
 325  {
 326   AliFlowAnalysisWithLeeYangZeros* lyz1prod = new AliFlowAnalysisWithLeeYangZeros();
 327   lyz1prod->SetFirstRun(kTRUE);
 328   lyz1prod->SetUseSum(kFALSE);
 329   lyz1prod->GetOutputHistograms(mergedListLYZ1PROD);
 330   lyz1prod->Finish();
 331   // save the final results for LYZ1PROD in final output file:
 332   TString finalOutputFileNameLYZ1PROD("outputLYZ1PRODanalysis");
 333   (finalOutputFileNameLYZ1PROD+=(type.Data()))+=(".root");
 334   TString pwdFinalLYZ1PROD=pwd.Data();
 335   pwdFinalLYZ1PROD+=finalOutputFileNameLYZ1PROD;
 336   TFile *finalOutputLYZ1PROD = new TFile(pwdFinalLYZ1PROD.Data(),"NEW");
 337   mergedListLYZ1PROD->SetName("cobjLYZ1PROD");
 338   mergedListLYZ1PROD->Write(mergedListLYZ1PROD->GetName(),TObject::kSingleKey);
 339   finalOutputLYZ1PROD->Close();
 340   delete lyz1prod;
 341   delete finalOutputLYZ1PROD;
 342  } else
 343    {
 344     cout<<"WARNING: mergedListLYZ1PROD is NULL !!!!"<<endl;
 345    }
 346
 347  // LYZ2PROD:
 348  TString mergedFileNameLYZ2PROD("mergedLYZ2PRODanalysis");
 349  (mergedFileNameLYZ2PROD+=(type.Data()))+=(".root");
 350  TFile *mergedFileLYZ2PROD = NULL;
 351  TList *mergedListLYZ2PROD = NULL;
 352  TString pwdLYZ2PROD=pwd.Data();
 353  pwdLYZ2PROD+=mergedFileNameLYZ2PROD;
 354  if(gSystem->AccessPathName(pwdLYZ2PROD.Data(),kFileExists))
 355  {
 356   cout<<"WARNING: You do not have a merged output file "<<pwdLYZ2PROD.Data()<<endl;
 357  } else
 358    {
 359     mergedFileLYZ2PROD = TFile::Open(pwdLYZ2PROD.Data(),"READ");
 360     if(mergedFileLYZ2PROD)
 361     {
 362      mergedFileLYZ2PROD->GetObject("cobjLYZ2PROD",mergedListLYZ2PROD);
 363      mergedFileLYZ2PROD->Close();
 364     }
 365    }
 366  if(mergedListLYZ2PROD)
 367  {
 368   AliFlowAnalysisWithLeeYangZeros* lyz2prod = new AliFlowAnalysisWithLeeYangZeros();
 369   lyz2prod->SetFirstRun(kFALSE);
 370   lyz2prod->SetUseSum(kFALSE);
 371   lyz2prod->GetOutputHistograms(mergedListLYZ2PROD);
 372   lyz2prod->Finish();
 373   // save the final results for LYZ2PROD in final output file:
 374   TString finalOutputFileNameLYZ2PROD("outputLYZ2PRODanalysis");
 375   (finalOutputFileNameLYZ2PROD+=(type.Data()))+=(".root");
 376   TString pwdFinalLYZ2PROD=pwd.Data();
 377   pwdFinalLYZ2PROD+=finalOutputFileNameLYZ2PROD;
 378   TFile *finalOutputLYZ2PROD = new TFile(pwdFinalLYZ2PROD.Data(),"NEW");
 379   mergedListLYZ2PROD->SetName("cobjLYZ2PROD");
 380   mergedListLYZ2PROD->Write(mergedListLYZ2PROD->GetName(),TObject::kSingleKey);
 381   finalOutputLYZ2PROD->Close();
 382   delete lyz2prod;
 383   delete finalOutputLYZ2PROD;
 384  } else
 385    {
 386     cout<<"WARNING: mergedListLYZ2PROD is NULL !!!!"<<endl;
 387    }
 388
 389  // LYZEP:
 390  TString mergedFileNameLYZEP("mergedLYZEPanalysis");
 391  (mergedFileNameLYZEP+=(type.Data()))+=(".root");
 392  TFile *mergedFileLYZEP = NULL;
 393  TList *mergedListLYZEP = NULL;
 394  TString pwdLYZEP=pwd.Data();
 395  pwdLYZEP+=mergedFileNameLYZEP;
 396  if(gSystem->AccessPathName(pwdLYZEP.Data(),kFileExists))
 397  {
 398   cout<<"WARNING: You do not have a merged output file "<<pwdLYZEP.Data()<<endl;
 399  } else
 400    {
 401     mergedFileLYZEP = TFile::Open(pwdLYZEP.Data(),"READ");
 402     if(mergedFileLYZEP)
 403     {
 404      mergedFileLYZEP->GetObject("cobjLYZEP",mergedListLYZEP);
 405      mergedFileLYZEP->Close();
 406     }
 407    }
 408  if(mergedListLYZEP)
 409  {
 410   AliFlowAnalysisWithLYZEventPlane* lyzep = new AliFlowAnalysisWithLYZEventPlane();
 411   lyzep->GetOutputHistograms(mergedListLYZEP);
 412   lyzep->Finish();
 413   // save the final results for LYZEP in final output file:
 414   TString finalOutputFileNameLYZEP("outputLYZEPanalysis");
 415   (finalOutputFileNameLYZEP+=(type.Data()))+=(".root");
 416   TString pwdFinalLYZEP=pwd.Data();
 417   pwdFinalLYZEP+=finalOutputFileNameLYZEP;
 418   TFile *finalOutputLYZEP = new TFile(pwdFinalLYZEP.Data(),"NEW");
 419   mergedListLYZEP->SetName("cobjLYZEP");
 420   mergedListLYZEP->Write(mergedListLYZEP->GetName(),TObject::kSingleKey);
 421   finalOutputLYZEP->Close();
 422   delete lyzep;
 423   delete finalOutputLYZEP;
 424  } else
 425    {
 426     cout<<"WARNING: mergedListLYZEP is NULL !!!!"<<endl;
 427    }
 428
 429  // redoing Finish() also in subsets:
 430  if(redoFinishAlsoInSubsets)
 431  {
 432   // standard magic:
 433   TString *baseDirPath = new TString(gSystem->pwd());
 434   TSystemDirectory* baseDir = new TSystemDirectory(".",baseDirPath->Data());
 435   TList* listOfFilesInBaseDir = baseDir->GetListOfFiles();
 436   // listOfFilesInBaseDir->Print();
 437   Int_t nFiles = listOfFilesInBaseDir->GetEntries();
 438   Int_t nSubsets = 0;
 439   gSystem->cd(baseDirPath->Data());
 440   // count subsets:
 441   for(Int_t iFile=0;iFile<nFiles;iFile++)
 442   {
 443    TSystemFile* presentFile = (TSystemFile*)listOfFilesInBaseDir->At(iFile);
 444    TString presentFileName = baseDirPath->Data();
 445    (presentFileName+="/")+=presentFile->GetName();
 446    if(presentFileName.Contains("subset"))
 447    {
 448     nSubsets++;
 449    }
 450   } // end of for(Int_t iFile=0;iFile<nFiles;iFile++)
 451
 452   // redo finish in each subset:
 453   gSystem->cd(baseDirPath->Data());
 454   for(Int_t i=0;i<nSubsets;i++)
 455   {
 456    cout<<endl;
 457    // access the merged output files and redo the flow analysis on them:
 458    // MCEP:
 459    TString *mergedFileNameInSubsetMCEP = new TString("subset");
 460    (*mergedFileNameInSubsetMCEP)+=(i+1);
 461    (*mergedFileNameInSubsetMCEP)+="/";
 462    (*mergedFileNameInSubsetMCEP)+="mergedMCEPanalysis";
 463    (*mergedFileNameInSubsetMCEP)+=type.Data();
 464    (*mergedFileNameInSubsetMCEP)+=".root";
 465
 466    TFile *mergedFileInSubsetMCEP = NULL;
 467    TList *mergedListInSubsetMCEP = NULL;
 468    if(gSystem->AccessPathName(mergedFileNameInSubsetMCEP->Data(),kFileExists))
 469    {
 470     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetMCEP->Data()<<endl;
 471     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 472    } else
 473      {
 474       mergedFileinSubsetMCEP = TFile::Open(mergedFileNameInSubsetMCEP->Data(),"READ");
 475       delete mergedFileNameInSubsetMCEP;
 476       if(mergedFileinSubsetMCEP)
 477       {
 478        mergedFileinSubsetMCEP->GetObject("cobjMCEP",mergedListInSubsetMCEP);
 479        mergedFileinSubsetMCEP->Close();
 480       }
 481      }
 482      if(mergedListInSubsetMCEP)
 483      {
 484       AliFlowAnalysisWithMCEventPlane* mcep = new AliFlowAnalysisWithMCEventPlane();
 485       mcep->GetOutputHistograms(mergedListInSubsetMCEP);
 486       mcep->Finish();
 487       // save the final results for MCEP in final output file:
 488       TString *finalOutputFileNameinSubsetMCEP = new TString("subset");
 489       (*finalOutputFileNameinSubsetMCEP)+=(i+1);
 490       (*finalOutputFileNameinSubsetMCEP)+="/";
 491       (*finalOutputFileNameinSubsetMCEP)+="outputMCEPanalysis";
 492       (*finalOutputFileNameinSubsetMCEP)+=type.Data();
 493       (*finalOutputFileNameinSubsetMCEP)+=".root";
 494       TFile *finalOutputInSubsetMCEP = new TFile(finalOutputFileNameinSubsetMCEP->Data(),"NEW");
 495       mergedListInSubsetMCEP->SetName("cobjMCEP");
 496       mergedListInSubsetMCEP->Write(mergedListInSubsetMCEP->GetName(),TObject::kSingleKey);
 497       finalOutputInSubsetMCEP->Close();
 498       delete finalOutputFileNameinSubsetMCEP;
 499       delete finalOutputInSubsetMCEP;
 500       delete mcep;
 501      } else
 502        {
 503         cout<<"WARNING: mergedListMCEP is NULL !!!!"<<endl;
 504        }
 505
 506    // SP:
 507    TString *mergedFileNameInSubsetSP = new TString("subset");
 508    (*mergedFileNameInSubsetSP)+=(i+1);
 509    (*mergedFileNameInSubsetSP)+="/";
 510    (*mergedFileNameInSubsetSP)+="mergedSPanalysis";
 511    (*mergedFileNameInSubsetSP)+=type.Data();
 512    (*mergedFileNameInSubsetSP)+=".root";
 513
 514    TFile *mergedFileInSubsetSP = NULL;
 515    TList *mergedListInSubsetSP = NULL;
 516    if(gSystem->AccessPathName(mergedFileNameInSubsetSP->Data(),kFileExists))
 517    {
 518     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetSP->Data()<<endl;
 519     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 520    } else
 521      {
 522       mergedFileinSubsetSP = TFile::Open(mergedFileNameInSubsetSP->Data(),"READ");
 523       delete mergedFileNameInSubsetSP;
 524       if(mergedFileinSubsetSP)
 525       {
 526        mergedFileinSubsetSP->GetObject("cobjSP",mergedListInSubsetSP);
 527        mergedFileinSubsetSP->Close();
 528       }
 529      }
 530      if(mergedListInSubsetSP)
 531      {
 532       AliFlowAnalysisWithScalarProduct *sp = new AliFlowAnalysisWithScalarProduct();
 533       sp->GetOutputHistograms(mergedListInSubsetSP);
 534       sp->Finish();
 535       // save the final results for SP in final output file:
 536       TString *finalOutputFileNameinSubsetSP = new TString("subset");
 537       (*finalOutputFileNameinSubsetSP)+=(i+1);
 538       (*finalOutputFileNameinSubsetSP)+="/";
 539       (*finalOutputFileNameinSubsetSP)+="outputSPanalysis";
 540       (*finalOutputFileNameinSubsetSP)+=type.Data();
 541       (*finalOutputFileNameinSubsetSP)+=".root";
 542       TFile *finalOutputInSubsetSP = new TFile(finalOutputFileNameinSubsetSP->Data(),"NEW");
 543       mergedListInSubsetSP->SetName("cobjSP");
 544       mergedListInSubsetSP->Write(mergedListInSubsetSP->GetName(),TObject::kSingleKey);
 545       finalOutputInSubsetSP->Close();
 546       delete finalOutputFileNameinSubsetSP;
 547       delete finalOutputInSubsetSP;
 548       delete sp;
 549      } else
 550        {
 551         cout<<"WARNING: mergedListSP is NULL !!!!"<<endl;
 552        }
 553
 554    // GFC:
 555    TString *mergedFileNameInSubsetGFC = new TString("subset");
 556    (*mergedFileNameInSubsetGFC)+=(i+1);
 557    (*mergedFileNameInSubsetGFC)+="/";
 558    (*mergedFileNameInSubsetGFC)+="mergedGFCanalysis";
 559    (*mergedFileNameInSubsetGFC)+=type.Data();
 560    (*mergedFileNameInSubsetGFC)+=".root";
 561
 562    TFile *mergedFileInSubsetGFC = NULL;
 563    TList *mergedListInSubsetGFC = NULL;
 564    if(gSystem->AccessPathName(mergedFileNameInSubsetGFC->Data(),kFileExists))
 565    {
 566     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetGFC->Data()<<endl;
 567     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 568    } else
 569      {
 570       mergedFileinSubsetGFC = TFile::Open(mergedFileNameInSubsetGFC->Data(),"READ");
 571       delete mergedFileNameInSubsetGFC;
 572       if(mergedFileinSubsetGFC)
 573       {
 574        mergedFileinSubsetGFC->GetObject("cobjGFC",mergedListInSubsetGFC);
 575        mergedFileinSubsetGFC->Close();
 576       }
 577      }
 578      if(mergedListInSubsetGFC)
 579      {
 580       AliFlowAnalysisWithCumulants *gfc = new AliFlowAnalysisWithCumulants();
 581       gfc->GetOutputHistograms(mergedListInSubsetGFC);
 582       gfc->Finish();
 583       // save the final results for GFC in final output file:
 584       TString *finalOutputFileNameinSubsetGFC = new TString("subset");
 585       (*finalOutputFileNameinSubsetGFC)+=(i+1);
 586       (*finalOutputFileNameinSubsetGFC)+="/";
 587       (*finalOutputFileNameinSubsetGFC)+="outputGFCanalysis";
 588       (*finalOutputFileNameinSubsetGFC)+=type.Data();
 589       (*finalOutputFileNameinSubsetGFC)+=".root";
 590       TFile *finalOutputInSubsetGFC = new TFile(finalOutputFileNameinSubsetGFC->Data(),"NEW");
 591       mergedListInSubsetGFC->SetName("cobjGFC");
 592       mergedListInSubsetGFC->Write(mergedListInSubsetGFC->GetName(),TObject::kSingleKey);
 593       finalOutputInSubsetGFC->Close();
 594       delete finalOutputFileNameinSubsetGFC;
 595       delete finalOutputInSubsetGFC;
 596       delete gfc;
 597      } else
 598        {
 599         cout<<"WARNING: mergedListGFC is NULL !!!!"<<endl;
 600        }
 601
 602    // QC:
 603    TString *mergedFileNameInSubsetQC = new TString("subset");
 604    (*mergedFileNameInSubsetQC)+=(i+1);
 605    (*mergedFileNameInSubsetQC)+="/";
 606    (*mergedFileNameInSubsetQC)+="mergedQCanalysis";
 607    (*mergedFileNameInSubsetQC)+=type.Data();
 608    (*mergedFileNameInSubsetQC)+=".root";
 609
 610    TFile *mergedFileInSubsetQC = NULL;
 611    TList *mergedListInSubsetQC = NULL;
 612    if(gSystem->AccessPathName(mergedFileNameInSubsetQC->Data(),kFileExists))
 613    {
 614     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetQC->Data()<<endl;
 615     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 616    } else
 617      {
 618       mergedFileinSubsetQC = TFile::Open(mergedFileNameInSubsetQC->Data(),"READ");
 619       delete mergedFileNameInSubsetQC;
 620       if(mergedFileinSubsetQC)
 621       {
 622        mergedFileinSubsetQC->GetObject("cobjQC",mergedListInSubsetQC);
 623        mergedFileinSubsetQC->Close();
 624       }
 625      }
 626      if(mergedListInSubsetQC)
 627      {
 628       AliFlowAnalysisWithQCumulants *qc = new AliFlowAnalysisWithQCumulants();
 629       qc->GetOutputHistograms(mergedListInSubsetQC);
 630       qc->Finish();
 631       // save the final results for QC in final output file:
 632       TString *finalOutputFileNameinSubsetQC = new TString("subset");
 633       (*finalOutputFileNameinSubsetQC)+=(i+1);
 634       (*finalOutputFileNameinSubsetQC)+="/";
 635       (*finalOutputFileNameinSubsetQC)+="outputQCanalysis";
 636       (*finalOutputFileNameinSubsetQC)+=type.Data();
 637       (*finalOutputFileNameinSubsetQC)+=".root";
 638       TFile *finalOutputInSubsetQC = new TFile(finalOutputFileNameinSubsetQC->Data(),"NEW");
 639       mergedListInSubsetQC->SetName("cobjQC");
 640       mergedListInSubsetQC->Write(mergedListInSubsetQC->GetName(),TObject::kSingleKey);
 641       finalOutputInSubsetQC->Close();
 642       delete finalOutputFileNameinSubsetQC;
 643       delete finalOutputInSubsetQC;
 644       delete qc;
 645      } else
 646        {
 647         cout<<"WARNING: mergedListQC is NULL !!!!"<<endl;
 648        }
 649
 650    // FQD:
 651    TString *mergedFileNameInSubsetFQD = new TString("subset");
 652    (*mergedFileNameInSubsetFQD)+=(i+1);
 653    (*mergedFileNameInSubsetFQD)+="/";
 654    (*mergedFileNameInSubsetFQD)+="mergedFQDanalysis";
 655    (*mergedFileNameInSubsetFQD)+=type.Data();
 656    (*mergedFileNameInSubsetFQD)+=".root";
 657
 658    TFile *mergedFileInSubsetFQD = NULL;
 659    TList *mergedListInSubsetFQD = NULL;
 660    if(gSystem->AccessPathName(mergedFileNameInSubsetFQD->Data(),kFileExists))
 661    {
 662     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetFQD->Data()<<endl;
 663     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 664    } else
 665      {
 666       mergedFileinSubsetFQD = TFile::Open(mergedFileNameInSubsetFQD->Data(),"READ");
 667       if(mergedFileinSubsetFQD)
 668       {
 669        mergedFileinSubsetFQD->GetObject("cobjFQD",mergedListInSubsetFQD);
 670        mergedFileinSubsetFQD->Close();
 671       }
 672      }
 673      if(mergedListInSubsetFQD)
 674      {
 675       AliFlowAnalysisWithFittingQDistribution *fqd = new AliFlowAnalysisWithFittingQDistribution();
 676       fqd->GetOutputHistograms(mergedListInSubsetFQD);
 677       cout<<endl;
 678       cout<<"!!!! WARNING WARNING WARNING WARNING !!!!"<<endl;
 679       cout<<endl;
 680       cout<<"     If Minuit crashed here, remove the file "<<mergedFileNameInSubsetFQD->Data()<<endl;
 681       cout<<"     and lunch redoFinish.C again. Good luck! "<<endl;
 682       cout<<endl;
 683       cout<<"!!!! WARNING WARNING WARNING WARNING !!!!"<<endl;
 684       cout<<endl;
 685       delete mergedFileNameInSubsetFQD;
 686       fqd->Finish(kTRUE);
 687       // save the final results for FQD in final output file:
 688       TString *finalOutputFileNameinSubsetFQD = new TString("subset");
 689       (*finalOutputFileNameinSubsetFQD)+=(i+1);
 690       (*finalOutputFileNameinSubsetFQD)+="/";
 691       (*finalOutputFileNameinSubsetFQD)+="outputFQDanalysis";
 692       (*finalOutputFileNameinSubsetFQD)+=type.Data();
 693       (*finalOutputFileNameinSubsetFQD)+=".root";
 694       TFile *finalOutputInSubsetFQD = new TFile(finalOutputFileNameinSubsetFQD->Data(),"NEW");
 695       mergedListInSubsetFQD->SetName("cobjFQD");
 696       mergedListInSubsetFQD->Write(mergedListInSubsetFQD->GetName(),TObject::kSingleKey);
 697       finalOutputInSubsetFQD->Close();
 698       delete finalOutputFileNameinSubsetFQD;
 699       delete finalOutputInSubsetFQD;
 700       delete fqd;
 701      } else
 702        {
 703         cout<<"WARNING: mergedListFQD is NULL !!!!"<<endl;
 704        }
 705
 706    // LYZ1SUM:
 707    TString *mergedFileNameInSubsetLYZ1SUM = new TString("subset");
 708    (*mergedFileNameInSubsetLYZ1SUM)+=(i+1);
 709    (*mergedFileNameInSubsetLYZ1SUM)+="/";
 710    (*mergedFileNameInSubsetLYZ1SUM)+="mergedLYZ1SUManalysis";
 711    (*mergedFileNameInSubsetLYZ1SUM)+=type.Data();
 712    (*mergedFileNameInSubsetLYZ1SUM)+=".root";
 713
 714    TFile *mergedFileInSubsetLYZ1SUM = NULL;
 715    TList *mergedListInSubsetLYZ1SUM = NULL;
 716    if(gSystem->AccessPathName(mergedFileNameInSubsetLYZ1SUM->Data(),kFileExists))
 717    {
 718     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetLYZ1SUM->Data()<<endl;
 719     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 720    } else
 721      {
 722       mergedFileinSubsetLYZ1SUM = TFile::Open(mergedFileNameInSubsetLYZ1SUM->Data(),"READ");
 723       delete mergedFileNameInSubsetLYZ1SUM;
 724       if(mergedFileinSubsetLYZ1SUM)
 725       {
 726        mergedFileinSubsetLYZ1SUM->GetObject("cobjLYZ1SUM",mergedListInSubsetLYZ1SUM);
 727        mergedFileinSubsetLYZ1SUM->Close();
 728       }
 729      }
 730      if(mergedListInSubsetLYZ1SUM)
 731      {
 732       AliFlowAnalysisWithLeeYangZeros *lyz1sum = new AliFlowAnalysisWithLeeYangZeros();
 733       lyz1sum->SetFirstRun(kTRUE);
 734       lyz1sum->SetUseSum(kTRUE);
 735       lyz1sum->GetOutputHistograms(mergedListInSubsetLYZ1SUM);
 736       lyz1sum->Finish();
 737       // save the final results for LYZ1SUM in final output file:
 738       TString *finalOutputFileNameinSubsetLYZ1SUM = new TString("subset");
 739       (*finalOutputFileNameinSubsetLYZ1SUM)+=(i+1);
 740       (*finalOutputFileNameinSubsetLYZ1SUM)+="/";
 741       (*finalOutputFileNameinSubsetLYZ1SUM)+="outputLYZ1SUManalysis";
 742       (*finalOutputFileNameinSubsetLYZ1SUM)+=type.Data();
 743       (*finalOutputFileNameinSubsetLYZ1SUM)+=".root";
 744       TFile *finalOutputInSubsetLYZ1SUM = new TFile(finalOutputFileNameinSubsetLYZ1SUM->Data(),"NEW");
 745       mergedListInSubsetLYZ1SUM->SetName("cobjLYZ1SUM");
 746       mergedListInSubsetLYZ1SUM->Write(mergedListInSubsetLYZ1SUM->GetName(),TObject::kSingleKey);
 747       finalOutputInSubsetLYZ1SUM->Close();
 748       delete finalOutputFileNameinSubsetLYZ1SUM;
 749       delete finalOutputInSubsetLYZ1SUM;
 750       delete lyz1sum;
 751      } else
 752        {
 753         cout<<"WARNING: mergedListLYZ1SUM is NULL !!!!"<<endl;
 754        }
 755
 756    // LYZ1PROD:
 757    TString *mergedFileNameInSubsetLYZ1PROD = new TString("subset");
 758    (*mergedFileNameInSubsetLYZ1PROD)+=(i+1);
 759    (*mergedFileNameInSubsetLYZ1PROD)+="/";
 760    (*mergedFileNameInSubsetLYZ1PROD)+="mergedLYZ1PRODanalysis";
 761    (*mergedFileNameInSubsetLYZ1PROD)+=type.Data();
 762    (*mergedFileNameInSubsetLYZ1PROD)+=".root";
 763
 764    TFile *mergedFileInSubsetLYZ1PROD = NULL;
 765    TList *mergedListInSubsetLYZ1PROD = NULL;
 766    if(gSystem->AccessPathName(mergedFileNameInSubsetLYZ1PROD->Data(),kFileExists))
 767    {
 768     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetLYZ1PROD->Data()<<endl;
 769     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 770    } else
 771      {
 772       mergedFileinSubsetLYZ1PROD = TFile::Open(mergedFileNameInSubsetLYZ1PROD->Data(),"READ");
 773       delete mergedFileNameInSubsetLYZ1PROD;
 774       if(mergedFileinSubsetLYZ1PROD)
 775       {
 776        mergedFileinSubsetLYZ1PROD->GetObject("cobjLYZ1PROD",mergedListInSubsetLYZ1PROD);
 777        mergedFileinSubsetLYZ1PROD->Close();
 778       }
 779      }
 780      if(mergedListInSubsetLYZ1PROD)
 781      {
 782       AliFlowAnalysisWithLeeYangZeros *lyz1prod = new AliFlowAnalysisWithLeeYangZeros();
 783       lyz1prod->SetFirstRun(kTRUE);
 784       lyz1prod->SetUseSum(kFALSE);
 785       lyz1prod->GetOutputHistograms(mergedListInSubsetLYZ1PROD);
 786       lyz1prod->Finish();
 787       // save the final results for LYZ1PROD in final output file:
 788       TString *finalOutputFileNameinSubsetLYZ1PROD = new TString("subset");
 789       (*finalOutputFileNameinSubsetLYZ1PROD)+=(i+1);
 790       (*finalOutputFileNameinSubsetLYZ1PROD)+="/";
 791       (*finalOutputFileNameinSubsetLYZ1PROD)+="outputLYZ1PRODanalysis";
 792       (*finalOutputFileNameinSubsetLYZ1PROD)+=type.Data();
 793       (*finalOutputFileNameinSubsetLYZ1PROD)+=".root";
 794       TFile *finalOutputInSubsetLYZ1PROD = new TFile(finalOutputFileNameinSubsetLYZ1PROD->Data(),"NEW");
 795       mergedListInSubsetLYZ1PROD->SetName("cobjLYZ1PROD");
 796       mergedListInSubsetLYZ1PROD->Write(mergedListInSubsetLYZ1PROD->GetName(),TObject::kSingleKey);
 797       finalOutputInSubsetLYZ1PROD->Close();
 798       delete finalOutputFileNameinSubsetLYZ1PROD;
 799       delete finalOutputInSubsetLYZ1PROD;
 800       delete lyz1prod;
 801      } else
 802        {
 803         cout<<"WARNING: mergedListLYZ1PROD is NULL !!!!"<<endl;
 804        }
 805
 806    // LYZ2SUM:
 807    TString *mergedFileNameInSubsetLYZ2SUM = new TString("subset");
 808    (*mergedFileNameInSubsetLYZ2SUM)+=(i+1);
 809    (*mergedFileNameInSubsetLYZ2SUM)+="/";
 810    (*mergedFileNameInSubsetLYZ2SUM)+="mergedLYZ2SUManalysis";
 811    (*mergedFileNameInSubsetLYZ2SUM)+=type.Data();
 812    (*mergedFileNameInSubsetLYZ2SUM)+=".root";
 813
 814    TFile *mergedFileInSubsetLYZ2SUM = NULL;
 815    TList *mergedListInSubsetLYZ2SUM = NULL;
 816    if(gSystem->AccessPathName(mergedFileNameInSubsetLYZ2SUM->Data(),kFileExists))
 817    {
 818     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetLYZ2SUM->Data()<<endl;
 819     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 820    } else
 821      {
 822       mergedFileinSubsetLYZ2SUM = TFile::Open(mergedFileNameInSubsetLYZ2SUM->Data(),"READ");
 823       delete mergedFileNameInSubsetLYZ2SUM;
 824       if(mergedFileinSubsetLYZ2SUM)
 825       {
 826        mergedFileinSubsetLYZ2SUM->GetObject("cobjLYZ2SUM",mergedListInSubsetLYZ2SUM);
 827        mergedFileinSubsetLYZ2SUM->Close();
 828       }
 829      }
 830      if(mergedListInSubsetLYZ2SUM)
 831      {
 832       AliFlowAnalysisWithLeeYangZeros *lyz2sum = new AliFlowAnalysisWithLeeYangZeros();
 833       lyz2sum->SetFirstRun(kFALSE);
 834       lyz2sum->SetUseSum(kTRUE);
 835       lyz2sum->GetOutputHistograms(mergedListInSubsetLYZ2SUM);
 836       lyz2sum->Finish();
 837       // save the final results for LYZ2SUM in final output file:
 838       TString *finalOutputFileNameinSubsetLYZ2SUM = new TString("subset");
 839       (*finalOutputFileNameinSubsetLYZ2SUM)+=(i+1);
 840       (*finalOutputFileNameinSubsetLYZ2SUM)+="/";
 841       (*finalOutputFileNameinSubsetLYZ2SUM)+="outputLYZ2SUManalysis";
 842       (*finalOutputFileNameinSubsetLYZ2SUM)+=type.Data();
 843       (*finalOutputFileNameinSubsetLYZ2SUM)+=".root";
 844       TFile *finalOutputInSubsetLYZ2SUM = new TFile(finalOutputFileNameinSubsetLYZ2SUM->Data(),"NEW");
 845       mergedListInSubsetLYZ2SUM->SetName("cobjLYZ2SUM");
 846       mergedListInSubsetLYZ2SUM->Write(mergedListInSubsetLYZ2SUM->GetName(),TObject::kSingleKey);
 847       finalOutputInSubsetLYZ2SUM->Close();
 848       delete finalOutputFileNameinSubsetLYZ2SUM;
 849       delete finalOutputInSubsetLYZ2SUM;
 850       delete lyz2sum;
 851      } else
 852        {
 853         cout<<"WARNING: mergedListLYZ2SUM is NULL !!!!"<<endl;
 854        }
 855
 856    // LYZ2PROD:
 857    TString *mergedFileNameInSubsetLYZ2PROD = new TString("subset");
 858    (*mergedFileNameInSubsetLYZ2PROD)+=(i+1);
 859    (*mergedFileNameInSubsetLYZ2PROD)+="/";
 860    (*mergedFileNameInSubsetLYZ2PROD)+="mergedLYZ2PRODanalysis";
 861    (*mergedFileNameInSubsetLYZ2PROD)+=type.Data();
 862    (*mergedFileNameInSubsetLYZ2PROD)+=".root";
 863
 864    TFile *mergedFileInSubsetLYZ2PROD = NULL;
 865    TList *mergedListInSubsetLYZ2PROD = NULL;
 866    if(gSystem->AccessPathName(mergedFileNameInSubsetLYZ2PROD->Data(),kFileExists))
 867    {
 868     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetLYZ2PROD->Data()<<endl;
 869     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 870    } else
 871      {
 872       mergedFileinSubsetLYZ2PROD = TFile::Open(mergedFileNameInSubsetLYZ2PROD->Data(),"READ");
 873       delete mergedFileNameInSubsetLYZ2PROD;
 874       if(mergedFileinSubsetLYZ2PROD)
 875       {
 876        mergedFileinSubsetLYZ2PROD->GetObject("cobjLYZ2PROD",mergedListInSubsetLYZ2PROD);
 877        mergedFileinSubsetLYZ2PROD->Close();
 878       }
 879      }
 880      if(mergedListInSubsetLYZ2PROD)
 881      {
 882       AliFlowAnalysisWithLeeYangZeros *lyz2prod = new AliFlowAnalysisWithLeeYangZeros();
 883       lyz2prod->SetFirstRun(kFALSE);
 884       lyz2prod->SetUseSum(kFALSE);
 885       lyz2prod->GetOutputHistograms(mergedListInSubsetLYZ2PROD);
 886       lyz2prod->Finish();
 887       // save the final results for LYZ2PROD in final output file:
 888       TString *finalOutputFileNameinSubsetLYZ2PROD = new TString("subset");
 889       (*finalOutputFileNameinSubsetLYZ2PROD)+=(i+1);
 890       (*finalOutputFileNameinSubsetLYZ2PROD)+="/";
 891       (*finalOutputFileNameinSubsetLYZ2PROD)+="outputLYZ2PRODanalysis";
 892       (*finalOutputFileNameinSubsetLYZ2PROD)+=type.Data();
 893       (*finalOutputFileNameinSubsetLYZ2PROD)+=".root";
 894       TFile *finalOutputInSubsetLYZ2PROD = new TFile(finalOutputFileNameinSubsetLYZ2PROD->Data(),"NEW");
 895       mergedListInSubsetLYZ2PROD->SetName("cobjLYZ2PROD");
 896       mergedListInSubsetLYZ2PROD->Write(mergedListInSubsetLYZ2PROD->GetName(),TObject::kSingleKey);
 897       finalOutputInSubsetLYZ2PROD->Close();
 898       delete finalOutputFileNameinSubsetLYZ2PROD;
 899       delete finalOutputInSubsetLYZ2PROD;
 900       delete lyz2prod;
 901      } else
 902        {
 903         cout<<"WARNING: mergedListLYZ2PROD is NULL !!!!"<<endl;
 904        }
 905
 906    // LYZEP:
 907    TString *mergedFileNameInSubsetLYZEP = new TString("subset");
 908    (*mergedFileNameInSubsetLYZEP)+=(i+1);
 909    (*mergedFileNameInSubsetLYZEP)+="/";
 910    (*mergedFileNameInSubsetLYZEP)+="mergedLYZEPanalysis";
 911    (*mergedFileNameInSubsetLYZEP)+=type.Data();
 912    (*mergedFileNameInSubsetLYZEP)+=".root";
 913
 914    TFile *mergedFileInSubsetLYZEP = NULL;
 915    TList *mergedListInSubsetLYZEP = NULL;
 916    if(gSystem->AccessPathName(mergedFileNameInSubsetLYZEP->Data(),kFileExists))
 917    {
 918     cout<<"WARNING: You do not have a merged output file "<<mergedFileNameInSubsetLYZEP->Data()<<endl;
 919     cout<<"         Couldn't redo Finish() on this file in subdirectory subset"<<i+1<<endl;
 920    } else
 921      {
 922       mergedFileinSubsetLYZEP = TFile::Open(mergedFileNameInSubsetLYZEP->Data(),"READ");
 923       delete mergedFileNameInSubsetLYZEP;
 924       if(mergedFileinSubsetLYZEP)
 925       {
 926        mergedFileinSubsetLYZEP->GetObject("cobjLYZEP",mergedListInSubsetLYZEP);
 927        mergedFileinSubsetLYZEP->Close();
 928       }
 929      }
 930      if(mergedListInSubsetLYZEP)
 931      {
 932       AliFlowAnalysisWithLYZEventPlane *lyzep = new AliFlowAnalysisWithLYZEventPlane();
 933       lyzep->GetOutputHistograms(mergedListInSubsetLYZEP);
 934       lyzep->Finish(kTRUE);
 935       // save the final results for LYZEP in final output file:
 936       TString *finalOutputFileNameinSubsetLYZEP = new TString("subset");
 937       (*finalOutputFileNameinSubsetLYZEP)+=(i+1);
 938       (*finalOutputFileNameinSubsetLYZEP)+="/";
 939       (*finalOutputFileNameinSubsetLYZEP)+="outputLYZEPanalysis";
 940       (*finalOutputFileNameinSubsetLYZEP)+=type.Data();
 941       (*finalOutputFileNameinSubsetLYZEP)+=".root";
 942       TFile *finalOutputInSubsetLYZEP = new TFile(finalOutputFileNameinSubsetLYZEP->Data(),"NEW");
 943       mergedListInSubsetLYZEP->SetName("cobjLYZEP");
 944       mergedListInSubsetLYZEP->Write(mergedListInSubsetLYZEP->GetName(),TObject::kSingleKey);
 945       finalOutputInSubsetLYZEP->Close();
 946       delete finalOutputFileNameinSubsetLYZEP;
 947       delete finalOutputInSubsetLYZEP;
 948       delete lyzep;
 949      } else
 950        {
 951         cout<<"WARNING: mergedListLYZEP is NULL !!!!"<<endl;
 952        }
 953    } // end of for(Int_t i=0,i<nSubsets;i++)
 954
 955   delete baseDirPath;
 956   delete baseDir;
 957
 958  } // end of if(redoFinishAlsoInSubsets)
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980 } // end of void reCallFinish(TString type="", Int_t mode=mLocal)
 981
 982 void LoadLibrariesRDF(const libModes mode) {
 983
 984   //--------------------------------------
 985   // Load the needed libraries most of them already loaded by aliroot
 986   //--------------------------------------
 987   gSystem->Load("libTree.so");
 988   gSystem->Load("libGeom.so");
 989   gSystem->Load("libVMC.so");
 990   gSystem->Load("libXMLIO.so");
 991   gSystem->Load("libPhysics.so");
 992
 993   //----------------------------------------------------------
 994   // >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
 995   //----------------------------------------------------------
 996   if (mode==mLocal) {
 997     //--------------------------------------------------------
 998     // If you want to use already compiled libraries
 999     // in the aliroot distribution
1000     //--------------------------------------------------------
1001
1002   //==================================================================================
1003   //load needed libraries:
1004   gSystem->AddIncludePath("-I$ROOTSYS/include");
1005   gSystem->Load("libTree.so");
1006
1007   // for AliRoot
1008   gSystem->AddIncludePath("-I$ALICE_ROOT/include");
1009   gSystem->Load("libANALYSIS.so");
1010   gSystem->Load("libPWG2flowCommon.so");
1011   cerr<<"libPWG2flowCommon.so loaded ..."<<endl;
1012
1013   }
1014
1015   else if (mode==mLocalSource) {
1016
1017     // In root inline compile
1018
1019     // Constants
1020     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonConstants.cxx+");
1021     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZConstants.cxx+");
1022     gROOT->LoadMacro("AliFlowCommon/AliFlowCumuConstants.cxx+");
1023
1024     // Flow event
1025     gROOT->LoadMacro("AliFlowCommon/AliFlowVector.cxx+");
1026     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimple.cxx+");
1027     gROOT->LoadMacro("AliFlowCommon/AliFlowEventSimple.cxx+");
1028
1029     // Cuts
1030     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimpleCuts.cxx+");
1031
1032     // Output histosgrams
1033     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHist.cxx+");
1034     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHistResults.cxx+");
1035     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist1.cxx+");
1036     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist2.cxx+");
1037
1038     cout << "finished loading macros!" << endl;
1039
1040   } // end of else if (mode==mLocalSource)
1041
1042 } // end of void LoadLibrariesRDF(const libModes mode)
1043
1044