PWG2/FLOW/macros/mergeOutput.C

   1 enum libModes {mLocal,mLocalSource};
   2
   3 void mergeOutput(TString type="", Int_t nRuns=-1, 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  // nRuns: specify here how many output .root files will be merged
   8  //        (if nRuns = -1 all of them will be merged)
   9  // mode:  if mode=mLocal analyze data on your computer using aliroot
  10  //        if mode=mLocalSource analyze data on your computer using root + source files
  11
  12  Int_t cycle = 50; // if you cannot have >= 50 open files in memory, simply decrease this number
  13
  14  // load needed libraries:
  15  LoadSpreadLibrariesMO(mode);
  16
  17  // access the path of current directory:
  18  TString pwd(gSystem->pwd());
  19  pwd+="/";
  20
  21  // file mergers for the output file of each method separately:
  22  // MCEP:
  23  TFileMerger *mcepFileMerger = new TFileMerger();
  24  TString mergedFileNameMCEP("mergedMCEPanalysis");
  25  (mergedFileNameMCEP+=(type.Data()))+=(".root");
  26  TString pwdMCEP=pwd.Data();
  27  if(!(gSystem->AccessPathName((pwdMCEP+=mergedFileNameMCEP).Data(),kFileExists)))
  28  {
  29   cout<<"WARNING: You already have a merged output for MCEP !!!!"<<endl;
  30   break;
  31  }
  32  //mcepFileMerger->OutputFile(mergedFileNameMCEP);
  33
  34  // SP:
  35  TFileMerger *spFileMerger = new TFileMerger();
  36  TString mergedFileNameSP("mergedSPanalysis");
  37  (mergedFileNameSP+=(type.Data()))+=(".root");
  38  TString pwdSP=pwd.Data();
  39  if(!(gSystem->AccessPathName((pwdSP+=mergedFileNameSP).Data(),kFileExists)))
  40  {
  41   cout<<"WARNING: You already have a merged output for SP !!!!"<<endl;
  42   break;
  43  }
  44  spFileMerger->OutputFile(mergedFileNameSP);
  45
  46  // GFC:
  47  TFileMerger *gfcFileMerger = new TFileMerger();
  48  TString mergedFileNameGFC("mergedGFCanalysis");
  49  (mergedFileNameGFC+=(type.Data()))+=(".root");
  50  TString pwdGFC=pwd.Data();
  51  if(!(gSystem->AccessPathName((pwdGFC+=mergedFileNameGFC).Data(),kFileExists)))
  52  {
  53   cout<<"WARNING: You already have a merged output for GFC !!!!"<<endl;
  54   break;
  55  }
  56  gfcFileMerger->OutputFile(mergedFileNameGFC);
  57
  58  // QC:
  59  TFileMerger *qcFileMerger = new TFileMerger();
  60  TString mergedFileNameQC("mergedQCanalysis");
  61  (mergedFileNameQC+=(type.Data()))+=(".root");
  62  TString pwdQC=pwd.Data();
  63  if(!(gSystem->AccessPathName((pwdQC+=mergedFileNameQC).Data(),kFileExists)))
  64  {
  65   cout<<"WARNING: You already have a merged output for QC !!!!"<<endl;
  66   break;
  67  }
  68  qcFileMerger->OutputFile(mergedFileNameQC);
  69
  70  // FQD:
  71  TFileMerger *fqdFileMerger = new TFileMerger();
  72  TString mergedFileNameFQD("mergedFQDanalysis");
  73  (mergedFileNameFQD+=(type.Data()))+=(".root");
  74  TString pwdFQD=pwd.Data();
  75  if(!(gSystem->AccessPathName((pwdFQD+=mergedFileNameFQD).Data(),kFileExists)))
  76  {
  77   cout<<"WARNING: You already have a merged output for FQD !!!!"<<endl;
  78   break;
  79  }
  80  fqdFileMerger->OutputFile(mergedFileNameFQD);
  81
  82  // LYZ1:
  83  TFileMerger *lyz1FileMerger = new TFileMerger();
  84  TString mergedFileNameLYZ1("mergedLYZ1analysis");
  85  (mergedFileNameLYZ1+=(type.Data()))+=(".root");
  86  TString pwdLYZ1=pwd.Data();
  87  if(!(gSystem->AccessPathName((pwdLYZ1+=mergedFileNameLYZ1).Data(),kFileExists)))
  88  {
  89   cout<<"WARNING: You already have a merged output for LYZ1 !!!!"<<endl;
  90   break;
  91  }
  92  lyz1FileMerger->OutputFile(mergedFileNameLYZ1);
  93
  94  // LYZ2:
  95  TFileMerger *lyz2FileMerger = new TFileMerger();
  96  TString mergedFileNameLYZ2("mergedLYZ2analysis");
  97  (mergedFileNameLYZ2+=(type.Data()))+=(".root");
  98  TString pwdLYZ2=pwd.Data();
  99  if(!(gSystem->AccessPathName((pwdLYZ2+=mergedFileNameLYZ2).Data(),kFileExists)))
 100  {
 101   cout<<"WARNING: You already have a merged output for LYZ2 !!!!"<<endl;
 102   break;
 103  }
 104  lyz2FileMerger->OutputFile(mergedFileNameLYZ2);
 105
 106  // LYZEP:
 107  TFileMerger *lyzepFileMerger = new TFileMerger();
 108  TString mergedFileNameLYZEP("mergedLYZEPanalysis");
 109  (mergedFileNameLYZEP+=(type.Data()))+=(".root");
 110  TString pwdLYZEP=pwd.Data();
 111  if(!(gSystem->AccessPathName((pwdLYZEP+=mergedFileNameLYZEP).Data(),kFileExists)))
 112  {
 113   cout<<"WARNING: You already have a merged output for LYZEP !!!!"<<endl;
 114   break;
 115  }
 116  lyzepFileMerger->OutputFile(mergedFileNameLYZEP);
 117
 118  // standard magic:
 119  TString execDir(gSystem->pwd());
 120  TSystemDirectory* baseDir = new TSystemDirectory(".",execDir.Data());
 121  TList* dirList = baseDir->GetListOfFiles();
 122  Int_t nDirs = dirList->GetEntries();
 123  gSystem->cd(execDir);
 124
 125  Int_t counter = 0;
 126
 127  Int_t counterMCEP = 0;
 128  Int_t maxCycleMCEP = 0;
 129  Int_t counterSP = 0;
 130  Int_t maxCycleSP = 0;
 131  Int_t counterGFC = 0;
 132  Int_t maxCycleGFC = 0;
 133  Int_t counterQC = 0;
 134  Int_t maxCycleQC = 0;
 135  Int_t counterFQD = 0;
 136  Int_t maxCycleFQD = 0;
 137  Int_t counterLYZ1 = 0;
 138  Int_t maxCycleLYZ1 = 0;
 139
 140  if(cycle>nDirs) // to be improved (temporary workaroud)
 141  {
 142   cout<<"WARNING: Cycle "<<cycle<<" is too big. Decrease it's value in the declaration Int_t cycle in the macro !!!!"<<endl;
 143   break;
 144  }
 145
 146  for(Int_t iDir=0;iDir<nDirs;++iDir)
 147  {
 148   TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir);
 149   if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 ||
 150      strcmp(presentDir->GetName(), "..") == 0) continue;
 151
 152   if(nRuns != -1)
 153   {
 154    if (counter >= nRuns) break;
 155   }
 156
 157   TString presentDirName(gSystem->pwd());
 158   presentDirName += "/";
 159   presentDirName += presentDir->GetName();
 160   presentDirName += "/";
 161
 162   // accessing the output .root files from independent analysis for each method:
 163   // MCEP:
 164   TString fileNameMCEP = presentDirName;
 165   ((fileNameMCEP+="outputMCEPanalysis")+=type.Data())+=".root";
 166   if(!(gSystem->AccessPathName(fileNameMCEP.Data(),kFileExists)))
 167   {
 168    mcepFileMerger->AddFile(fileNameMCEP.Data());
 169    counterMCEP++;
 170   } else
 171     {
 172      cout<<"WARNING: Couldn't find a file "<<fileNameMCEP.Data()<<". Merging will continue without this file."<<endl;
 173     }
 174
 175   if(counterMCEP % cycle == 0)
 176   {
 177    maxCycleMCEP = counterMCEP/cycle;
 178    TString mergedFileNameCurrentCycleMCEP("mergedMCEPanalysis");
 179    ((mergedFileNameCurrentCycleMCEP+=(type.Data()))+=counterMCEP/cycle)+=(".root");
 180    mcepFileMerger->OutputFile(mergedFileNameCurrentCycleMCEP);
 181
 182    TString mergedFileNamePreviousCycleMCEP("mergedMCEPanalysis");
 183    ((mergedFileNamePreviousCycleMCEP+=(type.Data()))+=(counterMCEP/cycle-1))+=(".root");
 184    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleMCEP.Data(),kFileExists)))
 185    {
 186     mcepFileMerger->AddFile(mergedFileNamePreviousCycleMCEP.Data());
 187    }
 188
 189    Bool_t mcepMerged = kFALSE;
 190    if(mcepFileMerger)
 191    {
 192     mcepMerged = mcepFileMerger->Merge();
 193     mcepFileMerger->Reset();
 194    }
 195
 196    if(mcepMerged)
 197    {
 198     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleMCEP.Data(),gSystem->pwd());
 199     if(previousCycle) previousCycle->Delete();
 200     delete previousCycle;
 201    }
 202   } // end of if(counterMCEP % cycle == 0)
 203
 204   // SP:
 205   TString fileNameSP = presentDirName;
 206   ((fileNameSP+="outputSPanalysis")+=type.Data())+=".root";
 207   if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
 208   {
 209    spFileMerger->AddFile(fileNameSP.Data());
 210    counterSP++;
 211   } else
 212     {
 213      cout<<"WARNING: Couldn't find a file "<<fileNameSP.Data()<<". Merging will continue without this file."<<endl;
 214     }
 215
 216   if(counterSP % cycle == 0)
 217   {
 218    maxCycleSP = counterSP/cycle;
 219    TString mergedFileNameCurrentCycleSP("mergedSPanalysis");
 220    ((mergedFileNameCurrentCycleSP+=(type.Data()))+=counterSP/cycle)+=(".root");
 221    spFileMerger->OutputFile(mergedFileNameCurrentCycleSP);
 222
 223    TString mergedFileNamePreviousCycleSP("mergedSPanalysis");
 224    ((mergedFileNamePreviousCycleSP+=(type.Data()))+=(counterSP/cycle-1))+=(".root");
 225    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleSP.Data(),kFileExists)))
 226    {
 227     spFileMerger->AddFile(mergedFileNamePreviousCycleSP.Data());
 228    }
 229
 230    Bool_t spMerged = kFALSE;
 231    if(spFileMerger)
 232    {
 233     spMerged = spFileMerger->Merge();
 234     spFileMerger->Reset();
 235    }
 236
 237    if(spMerged)
 238    {
 239     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleSP.Data(),gSystem->pwd());
 240     if(previousCycle) previousCycle->Delete();
 241     delete previousCycle;
 242    }
 243   } // end of if(counterSP % cycle == 0)
 244
 245   // GFC:
 246   TString fileNameGFC = presentDirName;
 247   ((fileNameGFC+="outputGFCanalysis")+=type.Data())+=".root";
 248   if(!(gSystem->AccessPathName(fileNameGFC.Data(),kFileExists)))
 249   {
 250    gfcFileMerger->AddFile(fileNameGFC.Data());
 251    counterGFC++;
 252   } else
 253     {
 254      cout<<"WARNING: Couldn't find a file "<<fileNameGFC.Data()<<". Merging will continue without this file."<<endl;
 255     }
 256
 257   if(counterGFC % cycle == 0)
 258   {
 259    maxCycleGFC = counterGFC/cycle;
 260    TString mergedFileNameCurrentCycleGFC("mergedGFCanalysis");
 261    ((mergedFileNameCurrentCycleGFC+=(type.Data()))+=counterGFC/cycle)+=(".root");
 262    gfcFileMerger->OutputFile(mergedFileNameCurrentCycleGFC);
 263
 264    TString mergedFileNamePreviousCycleGFC("mergedGFCanalysis");
 265    ((mergedFileNamePreviousCycleGFC+=(type.Data()))+=(counterGFC/cycle-1))+=(".root");
 266    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleGFC.Data(),kFileExists)))
 267    {
 268     gfcFileMerger->AddFile(mergedFileNamePreviousCycleGFC.Data());
 269    }
 270
 271    Bool_t gfcMerged = kFALSE;
 272    if(gfcFileMerger)
 273    {
 274     gfcMerged = gfcFileMerger->Merge();
 275     gfcFileMerger->Reset();
 276    }
 277
 278    if(gfcMerged)
 279    {
 280     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleGFC.Data(),gSystem->pwd());
 281     if(previousCycle) previousCycle->Delete();
 282     delete previousCycle;
 283    }
 284   } // end of if(counterGFC % cycle == 0)
 285
 286   // QC:
 287   TString fileNameQC = presentDirName;
 288   ((fileNameQC+="outputQCanalysis")+=type.Data())+=".root";
 289   if(!(gSystem->AccessPathName(fileNameQC.Data(),kFileExists)))
 290   {
 291    qcFileMerger->AddFile(fileNameQC.Data());
 292    counterQC++;
 293   } else
 294     {
 295      cout<<"WARNING: Couldn't find a file "<<fileNameQC.Data()<<". Merging will continue without this file."<<endl;
 296     }
 297
 298   if(counterQC % cycle == 0)
 299   {
 300    maxCycleQC = counterQC/cycle;
 301    TString mergedFileNameCurrentCycleQC("mergedQCanalysis");
 302    ((mergedFileNameCurrentCycleQC+=(type.Data()))+=counterQC/cycle)+=(".root");
 303    qcFileMerger->OutputFile(mergedFileNameCurrentCycleQC);
 304
 305    TString mergedFileNamePreviousCycleQC("mergedQCanalysis");
 306    ((mergedFileNamePreviousCycleQC+=(type.Data()))+=(counterQC/cycle-1))+=(".root");
 307    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleQC.Data(),kFileExists)))
 308    {
 309     qcFileMerger->AddFile(mergedFileNamePreviousCycleQC.Data());
 310    }
 311
 312    Bool_t qcMerged = kFALSE;
 313    if(qcFileMerger)
 314    {
 315     qcMerged = qcFileMerger->Merge();
 316     qcFileMerger->Reset();
 317    }
 318
 319    if(qcMerged)
 320    {
 321     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleQC.Data(),gSystem->pwd());
 322     if(previousCycle) previousCycle->Delete();
 323     delete previousCycle;
 324    }
 325   } // end of if(counterQC % cycle == 0)
 326
 327   // FQD:
 328   TString fileNameFQD = presentDirName;
 329   ((fileNameFQD+="outputFQDanalysis")+=type.Data())+=".root";
 330   if(!(gSystem->AccessPathName(fileNameFQD.Data(),kFileExists)))
 331   {
 332    fqdFileMerger->AddFile(fileNameFQD.Data());
 333    counterFQD++;
 334   } else
 335     {
 336      cout<<"WARNING: Couldn't find a file "<<fileNameFQD.Data()<<". Merging will continue without this file."<<endl;
 337     }
 338
 339   if(counterFQD % cycle == 0)
 340   {
 341    maxCycleFQD = counterFQD/cycle;
 342    TString mergedFileNameCurrentCycleFQD("mergedFQDanalysis");
 343    ((mergedFileNameCurrentCycleFQD+=(type.Data()))+=counterFQD/cycle)+=(".root");
 344    fqdFileMerger->OutputFile(mergedFileNameCurrentCycleFQD);
 345
 346    TString mergedFileNamePreviousCycleFQD("mergedFQDanalysis");
 347    ((mergedFileNamePreviousCycleFQD+=(type.Data()))+=(counterFQD/cycle-1))+=(".root");
 348    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleFQD.Data(),kFileExists)))
 349    {
 350     fqdFileMerger->AddFile(mergedFileNamePreviousCycleFQD.Data());
 351    }
 352
 353    Bool_t fqdMerged = kFALSE;
 354    if(fqdFileMerger)
 355    {
 356     fqdMerged = fqdFileMerger->Merge();
 357     fqdFileMerger->Reset();
 358    }
 359
 360    if(fqdMerged)
 361    {
 362     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleFQD.Data(),gSystem->pwd());
 363     if(previousCycle) previousCycle->Delete();
 364     delete previousCycle;
 365    }
 366   } // end of if(counterFQD % cycle == 0)
 367
 368   // LYZ1:
 369   TString fileNameLYZ1 = presentDirName;
 370   ((fileNameLYZ1+="outputLYZ1analysis")+=type.Data())+=".root";
 371   if(!(gSystem->AccessPathName(fileNameLYZ1.Data(),kFileExists)))
 372   {
 373    lyz1FileMerger->AddFile(fileNameLYZ1.Data());
 374    counterLYZ1++;
 375   } else
 376     {
 377      cout<<"WARNING: Couldn't find a file "<<fileNameLYZ1.Data()<<". Merging will continue without this file."<<endl;
 378     }
 379
 380   if(counterLYZ1 % cycle == 0)
 381   {
 382    maxCycleLYZ1 = counterLYZ1/cycle;
 383    TString mergedFileNameCurrentCycleLYZ1("mergedLYZ1analysis");
 384    ((mergedFileNameCurrentCycleLYZ1+=(type.Data()))+=counterLYZ1/cycle)+=(".root");
 385    lyz1FileMerger->OutputFile(mergedFileNameCurrentCycleLYZ1);
 386
 387    TString mergedFileNamePreviousCycleLYZ1("mergedLYZ1analysis");
 388    ((mergedFileNamePreviousCycleLYZ1+=(type.Data()))+=(counterLYZ1/cycle-1))+=(".root");
 389    if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleLYZ1.Data(),kFileExists)))
 390    {
 391     lyz1FileMerger->AddFile(mergedFileNamePreviousCycleLYZ1.Data());
 392    }
 393
 394    Bool_t lyz1Merged = kFALSE;
 395    if(lyz1FileMerger)
 396    {
 397     lyz1Merged = lyz1FileMerger->Merge();
 398     lyz1FileMerger->Reset();
 399    }
 400
 401    if(lyz1Merged)
 402    {
 403     TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleLYZ1.Data(),gSystem->pwd());
 404     if(previousCycle) previousCycle->Delete();
 405     delete previousCycle;
 406    }
 407   } // end of if(counterLYZ1 % cycle == 0)
 408
 409   counter++;
 410
 411  } // end of for(Int_t iDir=0;iDir<nDirs;++iDir)
 412
 413  // last cycle MCEP:
 414  if(counterMCEP % cycle != 0)
 415  {
 416   TString mergedFileNameCurrentCycleMCEP("mergedMCEPanalysis");
 417   ((mergedFileNameCurrentCycleMCEP+=(type.Data()))+=(maxCycleMCEP+1))+=(".root");
 418   mcepFileMerger->OutputFile(mergedFileNameCurrentCycleMCEP);
 419
 420   TString mergedFileNamePreviousCycleMCEP("mergedMCEPanalysis");
 421   ((mergedFileNamePreviousCycleMCEP+=(type.Data()))+=(maxCycleMCEP))+=(".root");
 422   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleMCEP.Data(),kFileExists)))
 423   {
 424    mcepFileMerger->AddFile(mergedFileNamePreviousCycleMCEP.Data());
 425   }
 426
 427   Bool_t mcepMerged = kFALSE;
 428   if(mcepFileMerger)
 429   {
 430    mcepMerged = mcepFileMerger->Merge();
 431    mcepFileMerger->Reset();
 432   }
 433
 434   if(mcepMerged)
 435   {
 436    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleMCEP.Data(),gSystem->pwd());
 437    if(previousCycle) previousCycle->Delete();
 438    delete previousCycle;
 439   }
 440   maxCycleMCEP++;
 441  } // end of if(counterMCEP % cycle != 0)
 442
 443  // renaming the final merged output for MCEP:
 444  TString finalMergedFileNameMCEP("mergedMCEPanalysis");
 445  ((finalMergedFileNameMCEP+=(type.Data()))+=maxCycleMCEP)+=(".root");
 446  TSystemFile *finalMergedFileMCEP = new TSystemFile(finalMergedFileNameMCEP.Data(),gSystem->pwd());
 447  TString defaultMergedFileNameMCEP("mergedMCEPanalysis");
 448  (defaultMergedFileNameMCEP+=(type.Data()))+=(".root");
 449  if(finalMergedFileMCEP) finalMergedFileMCEP->Rename(defaultMergedFileNameMCEP.Data());
 450
 451  // last cycle SP:
 452  if(counterSP % cycle != 0)
 453  {
 454   TString mergedFileNameCurrentCycleSP("mergedSPanalysis");
 455   ((mergedFileNameCurrentCycleSP+=(type.Data()))+=(maxCycleSP+1))+=(".root");
 456   spFileMerger->OutputFile(mergedFileNameCurrentCycleSP);
 457
 458   TString mergedFileNamePreviousCycleSP("mergedSPanalysis");
 459   ((mergedFileNamePreviousCycleSP+=(type.Data()))+=(maxCycleSP))+=(".root");
 460   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleSP.Data(),kFileExists)))
 461   {
 462    spFileMerger->AddFile(mergedFileNamePreviousCycleSP.Data());
 463   }
 464
 465   Bool_t spMerged = kFALSE;
 466   if(spFileMerger)
 467   {
 468    spMerged = spFileMerger->Merge();
 469    spFileMerger->Reset();
 470   }
 471
 472   if(spMerged)
 473   {
 474    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleSP.Data(),gSystem->pwd());
 475    if(previousCycle) previousCycle->Delete();
 476    delete previousCycle;
 477   }
 478   maxCycleSP++;
 479  } // end of if(counterSP % cycle != 0)
 480
 481  // renaming the final merged output for SP:
 482  TString finalMergedFileNameSP("mergedSPanalysis");
 483  ((finalMergedFileNameSP+=(type.Data()))+=maxCycleSP)+=(".root");
 484  TSystemFile *finalMergedFileSP = new TSystemFile(finalMergedFileNameSP.Data(),gSystem->pwd());
 485  TString defaultMergedFileNameSP("mergedSPanalysis");
 486  (defaultMergedFileNameSP+=(type.Data()))+=(".root");
 487  if(finalMergedFileSP) finalMergedFileSP->Rename(defaultMergedFileNameSP.Data());
 488
 489  // last cycle GFC:
 490  if(counterGFC % cycle != 0)
 491  {
 492   TString mergedFileNameCurrentCycleGFC("mergedGFCanalysis");
 493   ((mergedFileNameCurrentCycleGFC+=(type.Data()))+=(maxCycleGFC+1))+=(".root");
 494   gfcFileMerger->OutputFile(mergedFileNameCurrentCycleGFC);
 495
 496   TString mergedFileNamePreviousCycleGFC("mergedGFCanalysis");
 497   ((mergedFileNamePreviousCycleGFC+=(type.Data()))+=(maxCycleGFC))+=(".root");
 498   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleGFC.Data(),kFileExists)))
 499   {
 500    gfcFileMerger->AddFile(mergedFileNamePreviousCycleGFC.Data());
 501   }
 502
 503   Bool_t gfcMerged = kFALSE;
 504   if(gfcFileMerger)
 505   {
 506    gfcMerged = gfcFileMerger->Merge();
 507    gfcFileMerger->Reset();
 508   }
 509
 510   if(gfcMerged)
 511   {
 512    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleGFC.Data(),gSystem->pwd());
 513    if(previousCycle) previousCycle->Delete();
 514    delete previousCycle;
 515   }
 516   maxCycleGFC++;
 517  } // end of if(counterGFC % cycle != 0)
 518
 519  // renaming the final merged output for GFC:
 520  TString finalMergedFileNameGFC("mergedGFCanalysis");
 521  ((finalMergedFileNameGFC+=(type.Data()))+=maxCycleGFC)+=(".root");
 522  TSystemFile *finalMergedFileGFC = new TSystemFile(finalMergedFileNameGFC.Data(),gSystem->pwd());
 523  TString defaultMergedFileNameGFC("mergedGFCanalysis");
 524  (defaultMergedFileNameGFC+=(type.Data()))+=(".root");
 525  if(finalMergedFileGFC) finalMergedFileGFC->Rename(defaultMergedFileNameGFC.Data());
 526
 527  // last cycle QC:
 528  if(counterQC % cycle != 0)
 529  {
 530   TString mergedFileNameCurrentCycleQC("mergedQCanalysis");
 531   ((mergedFileNameCurrentCycleQC+=(type.Data()))+=(maxCycleQC+1))+=(".root");
 532   qcFileMerger->OutputFile(mergedFileNameCurrentCycleQC);
 533
 534   TString mergedFileNamePreviousCycleQC("mergedQCanalysis");
 535   ((mergedFileNamePreviousCycleQC+=(type.Data()))+=(maxCycleQC))+=(".root");
 536   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleQC.Data(),kFileExists)))
 537   {
 538    qcFileMerger->AddFile(mergedFileNamePreviousCycleQC.Data());
 539   }
 540
 541   Bool_t qcMerged = kFALSE;
 542   if(qcFileMerger)
 543   {
 544    qcMerged = qcFileMerger->Merge();
 545    qcFileMerger->Reset();
 546   }
 547
 548   if(qcMerged)
 549   {
 550    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleQC.Data(),gSystem->pwd());
 551    if(previousCycle) previousCycle->Delete();
 552    delete previousCycle;
 553   }
 554   maxCycleQC++;
 555  } // end of if(counterQC % cycle != 0)
 556
 557  // renaming the final merged output for QC:
 558  TString finalMergedFileNameQC("mergedQCanalysis");
 559  ((finalMergedFileNameQC+=(type.Data()))+=maxCycleQC)+=(".root");
 560  TSystemFile *finalMergedFileQC = new TSystemFile(finalMergedFileNameQC.Data(),gSystem->pwd());
 561  TString defaultMergedFileNameQC("mergedQCanalysis");
 562  (defaultMergedFileNameQC+=(type.Data()))+=(".root");
 563  if(finalMergedFileQC) finalMergedFileQC->Rename(defaultMergedFileNameQC.Data());
 564
 565  // last cycle FQD:
 566  if(counterFQD % cycle != 0)
 567  {
 568   TString mergedFileNameCurrentCycleFQD("mergedFQDanalysis");
 569   ((mergedFileNameCurrentCycleFQD+=(type.Data()))+=(maxCycleFQD+1))+=(".root");
 570   fqdFileMerger->OutputFile(mergedFileNameCurrentCycleFQD);
 571
 572   TString mergedFileNamePreviousCycleFQD("mergedFQDanalysis");
 573   ((mergedFileNamePreviousCycleFQD+=(type.Data()))+=(maxCycleFQD))+=(".root");
 574   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleFQD.Data(),kFileExists)))
 575   {
 576    fqdFileMerger->AddFile(mergedFileNamePreviousCycleFQD.Data());
 577   }
 578
 579   Bool_t fqdMerged = kFALSE;
 580   if(fqdFileMerger)
 581   {
 582    fqdMerged = fqdFileMerger->Merge();
 583    fqdFileMerger->Reset();
 584   }
 585
 586   if(fqdMerged)
 587   {
 588    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleFQD.Data(),gSystem->pwd());
 589    if(previousCycle) previousCycle->Delete();
 590    delete previousCycle;
 591   }
 592   maxCycleFQD++;
 593  } // end of if(counterFQD % cycle != 0)
 594
 595  // renaming the final merged output for FQD:
 596  TString finalMergedFileNameFQD("mergedFQDanalysis");
 597  ((finalMergedFileNameFQD+=(type.Data()))+=maxCycleFQD)+=(".root");
 598  TSystemFile *finalMergedFileFQD = new TSystemFile(finalMergedFileNameFQD.Data(),gSystem->pwd());
 599  TString defaultMergedFileNameFQD("mergedFQDanalysis");
 600  (defaultMergedFileNameFQD+=(type.Data()))+=(".root");
 601  if(finalMergedFileFQD) finalMergedFileFQD->Rename(defaultMergedFileNameFQD.Data());
 602
 603  // last cycle LYZ1:
 604  if(counterLYZ1 % cycle != 0)
 605  {
 606   TString mergedFileNameCurrentCycleLYZ1("mergedLYZ1analysis");
 607   ((mergedFileNameCurrentCycleLYZ1+=(type.Data()))+=(maxCycleLYZ1+1))+=(".root");
 608   lyz1FileMerger->OutputFile(mergedFileNameCurrentCycleLYZ1);
 609
 610   TString mergedFileNamePreviousCycleLYZ1("mergedLYZ1analysis");
 611   ((mergedFileNamePreviousCycleLYZ1+=(type.Data()))+=(maxCycleLYZ1))+=(".root");
 612   if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleLYZ1.Data(),kFileExists)))
 613   {
 614    lyz1FileMerger->AddFile(mergedFileNamePreviousCycleLYZ1.Data());
 615   }
 616
 617   Bool_t lyz1Merged = kFALSE;
 618   if(lyz1FileMerger)
 619   {
 620    lyz1Merged = lyz1FileMerger->Merge();
 621    lyz1FileMerger->Reset();
 622   }
 623
 624   if(lyz1Merged)
 625   {
 626    TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleLYZ1.Data(),gSystem->pwd());
 627    if(previousCycle) previousCycle->Delete();
 628    delete previousCycle;
 629   }
 630   maxCycleLYZ1++;
 631  } // end of if(counterLYZ1 % cycle != 0)
 632
 633  // renaming the final merged output for LYZ1:
 634  TString finalMergedFileNameLYZ1("mergedLYZ1analysis");
 635  ((finalMergedFileNameLYZ1+=(type.Data()))+=maxCycleLYZ1)+=(".root");
 636  TSystemFile *finalMergedFileLYZ1 = new TSystemFile(finalMergedFileNameLYZ1.Data(),gSystem->pwd());
 637  TString defaultMergedFileNameLYZ1("mergedLYZ1analysis");
 638  (defaultMergedFileNameLYZ1+=(type.Data()))+=(".root");
 639  if(finalMergedFileLYZ1) finalMergedFileLYZ1->Rename(defaultMergedFileNameLYZ1.Data());
 640
 641 } // end of void mergeOutput(TString type="", const Int_t nRuns=-1, Int_t mode=mLocal)
 642
 643 void LoadSpreadLibrariesMO(const libModes mode) {
 644
 645   //--------------------------------------
 646   // Load the needed libraries most of them already loaded by aliroot
 647   //--------------------------------------
 648   gSystem->Load("libTree.so");
 649   gSystem->Load("libGeom.so");
 650   gSystem->Load("libVMC.so");
 651   gSystem->Load("libXMLIO.so");
 652   gSystem->Load("libPhysics.so");
 653
 654   //----------------------------------------------------------
 655   // >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
 656   //----------------------------------------------------------
 657   if (mode==mLocal) {
 658     //--------------------------------------------------------
 659     // If you want to use already compiled libraries
 660     // in the aliroot distribution
 661     //--------------------------------------------------------
 662
 663   //==================================================================================
 664   //load needed libraries:
 665   gSystem->AddIncludePath("-I$ROOTSYS/include");
 666   gSystem->Load("libTree.so");
 667
 668   // for AliRoot
 669   gSystem->AddIncludePath("-I$ALICE_ROOT/include");
 670   gSystem->Load("libANALYSIS.so");
 671   gSystem->Load("libPWG2flowCommon.so");
 672   //cerr<<"libPWG2flowCommon.so loaded ..."<<endl;
 673
 674   }
 675
 676   else if (mode==mLocalSource) {
 677
 678     // In root inline compile
 679
 680     // Constants
 681     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonConstants.cxx+");
 682     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZConstants.cxx+");
 683     gROOT->LoadMacro("AliFlowCommon/AliFlowCumuConstants.cxx+");
 684
 685     // Flow event
 686     gROOT->LoadMacro("AliFlowCommon/AliFlowVector.cxx+");
 687     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimple.cxx+");
 688     gROOT->LoadMacro("AliFlowCommon/AliFlowEventSimple.cxx+");
 689
 690     // Cuts
 691     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimpleCuts.cxx+");
 692
 693     // Output histosgrams
 694     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHist.cxx+");
 695     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHistResults.cxx+");
 696     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist1.cxx+");
 697     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist2.cxx+");
 698
 699     cout << "finished loading macros!" << endl;
 700
 701   } // end of else if (mode==mLocalSource)
 702
 703 } // end of void LoadSpreadLibrariesMO(const libModes mode)
 704
 705