PWG2/FLOW/macros/mergeOutput.C

   1 enum libModes {mLocal,mLocalSource};
   2
   3 void mergeOutput(TString type="", Int_t mode=mLocal)
   4 {
   5  // type:  type of analysis can be ESD, AOD, MC, ESDMC0, ESDMC1
   6  //        (if type="" than output files are from MC simulation (default))
   7  // mode:  if mode=mLocal than analyze data on your computer using aliroot
   8  //        if mode=mLocalSource than analyze data on your computer using root + source files
   9
  10  // settings for merging:
  11  Bool_t devideOutputFilesInEqualSubsets = kFALSE; // if kFALSE: All output files will be merged in a single output file
  12                                                  //            (this is deafult for merging on Grid).
  13                                                  // if kTRUE: All output files will be merged in a single output file, but ALSO
  14                                                  //           all output files will be devided in N equal subsets (nSubsets) and for
  15                                                  //           each subset merging will be done separately. Merged output files for subsets
  16                                                  //           are stored in subdirectories subset1, subset2, ..., subsetN.
  17                                                  //           This feature is used to estimate the spread.
  18
  19  const Int_t nSubsets = 10; //number od subsets used to estimate spread
  20  const Int_t cycle = 10; // merging is done in cycles and this is the cycle period
  21
  22  // default names of subdirectories in which merged output files for subsets are stored:
  23  TString *dirNameSubset = NULL;
  24  if(devideOutputFilesInEqualSubsets)
  25  {
  26   dirNameSubset = new TString("subset");
  27  }
  28
  29  if(cycle>100 && !devideOutputFilesInEqualSubsets)
  30  {
  31   cout<<"WARNING: Cycle is too big !!!!"<<endl;
  32   cout<<"         Set const Int_t cycle to smaller value in the macro."<<endl;
  33   exit(0);
  34  }
  35
  36  if(cycle>10 && devideOutputFilesInEqualSubsets)
  37  {
  38   cout<<"WARNING: Cycle is too big !!!!"<<endl;
  39   cout<<"         Set const Int_t cycle to smaller value in the macro."<<endl;
  40   exit(0);
  41  }
  42
  43  if(cycle<=0)
  44  {
  45   cout<<"WARNING: Cycle must be a positive integer !!!!"<<endl;
  46   cout<<"         Set const Int_t cycle to a positive integer in the macro."<<endl;
  47   exit(0);
  48  }
  49
  50  if(devideOutputFilesInEqualSubsets && nSubsets<=0)
  51  {
  52   cout<<"WARNING: Number od subsets must be a positive integer !!!!"<<endl;
  53   cout<<"         Set const Int_t nSubsets to a positive integer in the macro."<<endl;
  54   exit(0);
  55  }
  56
  57  // load needed libraries:
  58  LoadLibrariesMO(mode);
  59
  60  // standard magic:
  61  TString *baseDirPath = new TString(gSystem->pwd());
  62  TSystemDirectory* baseDir = new TSystemDirectory(".",baseDirPath->Data());
  63  TList* listOfFilesInBaseDir = baseDir->GetListOfFiles();
  64  // listOfFilesInBaseDir->Print();
  65  Int_t nFiles = listOfFilesInBaseDir->GetEntries();
  66
  67  // checking if subdirectories with default names for subsets already exist:
  68  gSystem->cd(baseDirPath->Data());
  69  if(devideOutputFilesInEqualSubsets)
  70  {
  71   for(Int_t iFile=0;iFile<nFiles;iFile++)
  72   {
  73    TSystemFile* presentFile = (TSystemFile*)listOfFilesInBaseDir->At(iFile);
  74    TString presentFileName = baseDirPath->Data();
  75    (presentFileName+="/")+=presentFile->GetName();
  76    if(presentFileName.Contains("subset"))
  77    {
  78     cout<<"WARNING: You already have directory "<<presentFileName.Data()<<" !!!!"<<endl;
  79     cout<<"         Remove this directory and start macro again."<<endl;
  80     exit(0);
  81    }
  82   } // end of for(Int_t iFile=0;iFile<nFiles;iFile++)
  83  } // end of if(devideOutputFilesInEqualSubsets)
  84
  85  // create subdirectories for storing merged results for subsets:
  86  gSystem->cd(baseDirPath->Data());
  87  if(devideOutputFilesInEqualSubsets)
  88  {
  89   for(Int_t i=0;i<nSubsets;i++)
  90   {
  91    TString currentDirForSpreadName(dirNameSubset->Data());
  92    Bool_t bDirectoryMade = gSystem->mkdir((currentDirForSpreadName += (i+1)).Data());
  93    if(bDirectoryMade)
  94    {
  95     cout<<"WARNING: The directory "<<currentDirForSpreadName.Data()<<" could not be created (illegal path name) !!!!"<<endl;
  96     exit(0);
  97    }
  98   }
  99  }
 100
 101  // loop over directories and add output *.root files to TFileMerger:
 102  gSystem->cd(baseDirPath->Data());
 103
 104  // MCEP:
 105  Int_t fileCounterMCEP = 0;
 106  Int_t fileCounterLastSubsetMCEP = 0;
 107  TFileMerger *fileMergerMCEP = new TFileMerger();
 108  TFileMerger fileMergerForSubsetsMCEP[nSubsets];
 109
 110  // SP:
 111  Int_t fileCounterSP = 0;
 112  Int_t fileCounterLastSubsetSP = 0;
 113  TFileMerger *fileMergerSP = new TFileMerger();
 114  TFileMerger fileMergerForSubsetsSP[nSubsets];
 115
 116  // GFC:
 117  Int_t fileCounterGFC = 0;
 118  Int_t fileCounterLastSubsetGFC = 0;
 119  TFileMerger *fileMergerGFC = new TFileMerger();
 120  TFileMerger fileMergerForSubsetsGFC[nSubsets];
 121
 122  // QC:
 123  Int_t fileCounterQC = 0;
 124  Int_t fileCounterLastSubsetQC = 0;
 125  TFileMerger *fileMergerQC = new TFileMerger();
 126  TFileMerger fileMergerForSubsetsQC[nSubsets];
 127
 128  // FQD:
 129  Int_t fileCounterFQD = 0;
 130  Int_t fileCounterLastSubsetFQD = 0;
 131  TFileMerger *fileMergerFQD = new TFileMerger();
 132  TFileMerger fileMergerForSubsetsFQD[nSubsets];
 133
 134  // LYZ1SUM:
 135  Int_t fileCounterLYZ1SUM = 0;
 136  Int_t fileCounterLastSubsetLYZ1SUM = 0;
 137  TFileMerger *fileMergerLYZ1SUM = new TFileMerger();
 138  TFileMerger fileMergerForSubsetsLYZ1SUM[nSubsets];
 139
 140  // LYZ1PROD:
 141  Int_t fileCounterLYZ1PROD = 0;
 142  Int_t fileCounterLastSubsetLYZ1PROD = 0;
 143  TFileMerger *fileMergerLYZ1PROD = new TFileMerger();
 144  TFileMerger fileMergerForSubsetsLYZ1PROD[nSubsets];
 145
 146  // LYZEP:
 147  Int_t fileCounterLYZEP = 0;
 148  Int_t fileCounterLastSubsetLYZEP = 0;
 149  TFileMerger *fileMergerLYZEP = new TFileMerger();
 150  TFileMerger fileMergerForSubsetsLYZEP[nSubsets];
 151
 152  for(Int_t iFile=0;iFile<nFiles;iFile++)
 153  {
 154   TSystemFile* presentFile = (TSystemFile*)listOfFilesInBaseDir->At(iFile);
 155
 156   if(!presentFile || !presentFile->IsDirectory() || strcmp(presentFile->GetName(), ".") == 0 ||
 157      strcmp(presentFile->GetName(), "..") == 0) continue;
 158
 159   TString presentDirName = baseDirPath->Data();
 160   (presentDirName+="/")+=presentFile->GetName();
 161   presentDirName+="/";
 162
 163   // accessing the output *.root file in this directory:
 164   // MCEP:
 165   TString fileNameMCEP = presentDirName;
 166   ((fileNameMCEP+="outputMCEPanalysis")+=type.Data())+=".root";
 167   if(!(gSystem->AccessPathName(fileNameMCEP.Data(),kFileExists)))
 168   {
 169    fileCounterMCEP++;
 170    fileMergerMCEP->AddFile(fileNameMCEP.Data());
 171
 172    if(devideOutputFilesInEqualSubsets)
 173    {
 174     fileMergerForSubsetsMCEP[(fileCounterMCEP-1) % nSubsets].AddFile(fileNameMCEP.Data());
 175     if(fileCounterMCEP % nSubsets == 0)
 176     {
 177      fileCounterLastSubsetMCEP++;
 178     }
 179    }
 180
 181    // global merging:
 182    if(fileCounterMCEP % cycle == 0)
 183    {
 184     TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
 185     (*mergedFileForPreviousCycleMCEP)+=type.Data();
 186     (*mergedFileForPreviousCycleMCEP)+=(fileCounterMCEP/cycle - 1);
 187     (*mergedFileForPreviousCycleMCEP)+=".root";
 188
 189     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleMCEP->Data(),kFileExists)))
 190     {
 191      fileMergerMCEP->AddFile(mergedFileForPreviousCycleMCEP->Data());
 192      // delete merged output from previous cycle:
 193      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleMCEP->Data(),gSystem->pwd());
 194      file->Delete();
 195      delete file;
 196     }
 197
 198     TString *mergedFileForCurrentCycleMCEP = new TString("mergedMCEPanalysis");
 199     (*mergedFileForCurrentCycleMCEP)+=type.Data();
 200     (*mergedFileForCurrentCycleMCEP)+=(fileCounterMCEP/cycle);
 201     (*mergedFileForCurrentCycleMCEP)+=".root";
 202
 203     fileMergerMCEP->OutputFile(mergedFileForCurrentCycleMCEP->Data());
 204     fileMergerMCEP->Merge();
 205     fileMergerMCEP->Reset();
 206
 207     delete mergedFileForPreviousCycleMCEP;
 208     delete mergedFileForCurrentCycleMCEP;
 209    } // end of if(fileCounterMCEP % cycle == 0)
 210
 211    // merging for subsets:
 212    if(devideOutputFilesInEqualSubsets)
 213    {
 214     if(fileCounterLastSubsetMCEP > 0 && fileCounterLastSubsetMCEP % cycle == 0 && fileCounterMCEP % cycle == 0)
 215     {
 216      TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
 217      TString mergedFileForCurrentCycleForSubsetMCEP[nSubsets];
 218      for(Int_t i=0;i<nSubsets;i++)
 219      {
 220       mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
 221       mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
 222       mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
 223       mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
 224       mergedFileForPreviousCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle - 1);
 225       mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
 226
 227       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),kFileExists)))
 228       {
 229        fileMergerForSubsetsMCEP[i].AddFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data());
 230        // delete merged output from previous cycle:
 231        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
 232        file->Delete();
 233        delete file;
 234       }
 235
 236       mergedFileForCurrentCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
 237       mergedFileForCurrentCycleForSubsetMCEP[i]+=(i+1);
 238       mergedFileForCurrentCycleForSubsetMCEP[i]+=type.Data();
 239       mergedFileForCurrentCycleForSubsetMCEP[i]+="CycleNo";
 240       mergedFileForCurrentCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle);
 241       mergedFileForCurrentCycleForSubsetMCEP[i]+=".root";
 242
 243       fileMergerForSubsetsMCEP[i].OutputFile(mergedFileForCurrentCycleForSubsetMCEP[i].Data());
 244       fileMergerForSubsetsMCEP[i].Merge();
 245       fileMergerForSubsetsMCEP[i].Reset();
 246
 247      } // end of for(Int_t i=0;i<nSubsets;i++)
 248     } // end of if(fileCounterLastSubsetMCEP % cycle == 0)
 249    } // end of if(devideOutputFilesInEqualSubsets)
 250   } // end of if(!(gSystem->AccessPathName(fileNameMCEP.Data(),kFileExists)))
 251
 252   // SP:
 253   TString fileNameSP = presentDirName;
 254   ((fileNameSP+="outputSPanalysis")+=type.Data())+=".root";
 255   if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
 256   {
 257    fileCounterSP++;
 258    fileMergerSP->AddFile(fileNameSP.Data());
 259
 260    if(devideOutputFilesInEqualSubsets)
 261    {
 262     fileMergerForSubsetsSP[(fileCounterSP-1) % nSubsets].AddFile(fileNameSP.Data());
 263     if(fileCounterSP % nSubsets == 0)
 264     {
 265      fileCounterLastSubsetSP++;
 266     }
 267    }
 268
 269    // global merging:
 270    if(fileCounterSP % cycle == 0)
 271    {
 272     TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
 273     (*mergedFileForPreviousCycleSP)+=type.Data();
 274     (*mergedFileForPreviousCycleSP)+=(fileCounterSP/cycle - 1);
 275     (*mergedFileForPreviousCycleSP)+=".root";
 276
 277     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleSP->Data(),kFileExists)))
 278     {
 279      fileMergerSP->AddFile(mergedFileForPreviousCycleSP->Data());
 280      // delete merged output from previous cycle:
 281      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleSP->Data(),gSystem->pwd());
 282      file->Delete();
 283      delete file;
 284     }
 285
 286     TString *mergedFileForCurrentCycleSP = new TString("mergedSPanalysis");
 287     (*mergedFileForCurrentCycleSP)+=type.Data();
 288     (*mergedFileForCurrentCycleSP)+=(fileCounterSP/cycle);
 289     (*mergedFileForCurrentCycleSP)+=".root";
 290
 291     fileMergerSP->OutputFile(mergedFileForCurrentCycleSP->Data());
 292     fileMergerSP->Merge();
 293     fileMergerSP->Reset();
 294
 295     delete mergedFileForPreviousCycleSP;
 296     delete mergedFileForCurrentCycleSP;
 297    } // end of if(fileCounterSP % cycle == 0)
 298
 299    // merging for subsets:
 300    if(devideOutputFilesInEqualSubsets)
 301    {
 302     if(fileCounterLastSubsetSP > 0 && fileCounterLastSubsetSP % cycle == 0  && fileCounterSP % cycle == 0)
 303     {
 304      TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
 305      TString mergedFileForCurrentCycleForSubsetSP[nSubsets];
 306      for(Int_t i=0;i<nSubsets;i++)
 307      {
 308       mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
 309       mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
 310       mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
 311       mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
 312       mergedFileForPreviousCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle - 1);
 313       mergedFileForPreviousCycleForSubsetSP[i]+=".root";
 314
 315       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetSP[i].Data(),kFileExists)))
 316       {
 317        fileMergerForSubsetsSP[i].AddFile(mergedFileForPreviousCycleForSubsetSP[i].Data());
 318        // delete merged output from previous cycle:
 319        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
 320        file->Delete();
 321        delete file;
 322       }
 323
 324       mergedFileForCurrentCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
 325       mergedFileForCurrentCycleForSubsetSP[i]+=(i+1);
 326       mergedFileForCurrentCycleForSubsetSP[i]+=type.Data();
 327       mergedFileForCurrentCycleForSubsetSP[i]+="CycleNo";
 328       mergedFileForCurrentCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle);
 329       mergedFileForCurrentCycleForSubsetSP[i]+=".root";
 330
 331       fileMergerForSubsetsSP[i].OutputFile(mergedFileForCurrentCycleForSubsetSP[i].Data());
 332       fileMergerForSubsetsSP[i].Merge();
 333       fileMergerForSubsetsSP[i].Reset();
 334
 335      } // end of for(Int_t i=0;i<nSubsets;i++)
 336     } // end of if(fileCounterLastSubsetSP % cycle == 0)
 337    } // end of if(devideOutputFilesInEqualSubsets)
 338   } // end of if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
 339
 340   // GFC:
 341   TString fileNameGFC = presentDirName;
 342   ((fileNameGFC+="outputGFCanalysis")+=type.Data())+=".root";
 343   if(!(gSystem->AccessPathName(fileNameGFC.Data(),kFileExists)))
 344   {
 345    fileCounterGFC++;
 346    fileMergerGFC->AddFile(fileNameGFC.Data());
 347
 348    if(devideOutputFilesInEqualSubsets)
 349    {
 350     fileMergerForSubsetsGFC[(fileCounterGFC-1) % nSubsets].AddFile(fileNameGFC.Data());
 351     if(fileCounterGFC % nSubsets == 0)
 352     {
 353      fileCounterLastSubsetGFC++;
 354     }
 355    }
 356
 357    // global merging:
 358    if(fileCounterGFC % cycle == 0)
 359    {
 360     TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
 361     (*mergedFileForPreviousCycleGFC)+=type.Data();
 362     (*mergedFileForPreviousCycleGFC)+=(fileCounterGFC/cycle - 1);
 363     (*mergedFileForPreviousCycleGFC)+=".root";
 364
 365     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleGFC->Data(),kFileExists)))
 366     {
 367      fileMergerGFC->AddFile(mergedFileForPreviousCycleGFC->Data());
 368      // delete merged output from previous cycle:
 369      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleGFC->Data(),gSystem->pwd());
 370      file->Delete();
 371      delete file;
 372     }
 373
 374     TString *mergedFileForCurrentCycleGFC = new TString("mergedGFCanalysis");
 375     (*mergedFileForCurrentCycleGFC)+=type.Data();
 376     (*mergedFileForCurrentCycleGFC)+=(fileCounterGFC/cycle);
 377     (*mergedFileForCurrentCycleGFC)+=".root";
 378
 379     fileMergerGFC->OutputFile(mergedFileForCurrentCycleGFC->Data());
 380     fileMergerGFC->Merge();
 381     fileMergerGFC->Reset();
 382
 383     delete mergedFileForPreviousCycleGFC;
 384     delete mergedFileForCurrentCycleGFC;
 385    } // end of if(fileCounterGFC % cycle == 0)
 386
 387    // merging for subsets:
 388    if(devideOutputFilesInEqualSubsets)
 389    {
 390     if(fileCounterLastSubsetGFC > 0 && fileCounterLastSubsetGFC % cycle == 0  && fileCounterGFC % cycle == 0)
 391     {
 392      TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
 393      TString mergedFileForCurrentCycleForSubsetGFC[nSubsets];
 394      for(Int_t i=0;i<nSubsets;i++)
 395      {
 396       mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
 397       mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
 398       mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
 399       mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
 400       mergedFileForPreviousCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle - 1);
 401       mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
 402
 403       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetGFC[i].Data(),kFileExists)))
 404       {
 405        fileMergerForSubsetsGFC[i].AddFile(mergedFileForPreviousCycleForSubsetGFC[i].Data());
 406        // delete merged output from previous cycle:
 407        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
 408        file->Delete();
 409        delete file;
 410       }
 411
 412       mergedFileForCurrentCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
 413       mergedFileForCurrentCycleForSubsetGFC[i]+=(i+1);
 414       mergedFileForCurrentCycleForSubsetGFC[i]+=type.Data();
 415       mergedFileForCurrentCycleForSubsetGFC[i]+="CycleNo";
 416       mergedFileForCurrentCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle);
 417       mergedFileForCurrentCycleForSubsetGFC[i]+=".root";
 418
 419       fileMergerForSubsetsGFC[i].OutputFile(mergedFileForCurrentCycleForSubsetGFC[i].Data());
 420       fileMergerForSubsetsGFC[i].Merge();
 421       fileMergerForSubsetsGFC[i].Reset();
 422
 423      } // end of for(Int_t i=0;i<nSubsets;i++)
 424     } // end of if(fileCounterLastSubsetGFC % cycle == 0)
 425    } // end of if(devideOutputFilesInEqualSubsets)
 426   } // end of if(!(gSystem->AccessPathName(fileNameGFC.Data(),kFileExists)))
 427
 428   // QC:
 429   TString fileNameQC = presentDirName;
 430   ((fileNameQC+="outputQCanalysis")+=type.Data())+=".root";
 431   if(!(gSystem->AccessPathName(fileNameQC.Data(),kFileExists)))
 432   {
 433    fileCounterQC++;
 434    fileMergerQC->AddFile(fileNameQC.Data());
 435
 436    if(devideOutputFilesInEqualSubsets)
 437    {
 438     fileMergerForSubsetsQC[(fileCounterQC-1) % nSubsets].AddFile(fileNameQC.Data());
 439     if(fileCounterQC % nSubsets == 0)
 440     {
 441      fileCounterLastSubsetQC++;
 442     }
 443    }
 444
 445    // global merging:
 446    if(fileCounterQC % cycle == 0)
 447    {
 448     TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
 449     (*mergedFileForPreviousCycleQC)+=type.Data();
 450     (*mergedFileForPreviousCycleQC)+=(fileCounterQC/cycle - 1);
 451     (*mergedFileForPreviousCycleQC)+=".root";
 452
 453     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleQC->Data(),kFileExists)))
 454     {
 455      fileMergerQC->AddFile(mergedFileForPreviousCycleQC->Data());
 456      // delete merged output from previous cycle:
 457      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleQC->Data(),gSystem->pwd());
 458      file->Delete();
 459      delete file;
 460     }
 461
 462     TString *mergedFileForCurrentCycleQC = new TString("mergedQCanalysis");
 463     (*mergedFileForCurrentCycleQC)+=type.Data();
 464     (*mergedFileForCurrentCycleQC)+=(fileCounterQC/cycle);
 465     (*mergedFileForCurrentCycleQC)+=".root";
 466
 467     fileMergerQC->OutputFile(mergedFileForCurrentCycleQC->Data());
 468     fileMergerQC->Merge();
 469     fileMergerQC->Reset();
 470
 471     delete mergedFileForPreviousCycleQC;
 472     delete mergedFileForCurrentCycleQC;
 473    } // end of if(fileCounterQC % cycle == 0)
 474
 475    // merging for subsets:
 476    if(devideOutputFilesInEqualSubsets)
 477    {
 478     if(fileCounterLastSubsetQC > 0 && fileCounterLastSubsetQC % cycle == 0  && fileCounterQC % cycle == 0)
 479     {
 480      TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
 481      TString mergedFileForCurrentCycleForSubsetQC[nSubsets];
 482      for(Int_t i=0;i<nSubsets;i++)
 483      {
 484       mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
 485       mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
 486       mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
 487       mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
 488       mergedFileForPreviousCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle - 1);
 489       mergedFileForPreviousCycleForSubsetQC[i]+=".root";
 490
 491       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetQC[i].Data(),kFileExists)))
 492       {
 493        fileMergerForSubsetsQC[i].AddFile(mergedFileForPreviousCycleForSubsetQC[i].Data());
 494        // delete merged output from previous cycle:
 495        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
 496        file->Delete();
 497        delete file;
 498       }
 499
 500       mergedFileForCurrentCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
 501       mergedFileForCurrentCycleForSubsetQC[i]+=(i+1);
 502       mergedFileForCurrentCycleForSubsetQC[i]+=type.Data();
 503       mergedFileForCurrentCycleForSubsetQC[i]+="CycleNo";
 504       mergedFileForCurrentCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle);
 505       mergedFileForCurrentCycleForSubsetQC[i]+=".root";
 506
 507       fileMergerForSubsetsQC[i].OutputFile(mergedFileForCurrentCycleForSubsetQC[i].Data());
 508       fileMergerForSubsetsQC[i].Merge();
 509       fileMergerForSubsetsQC[i].Reset();
 510
 511      } // end of for(Int_t i=0;i<nSubsets;i++)
 512     } // end of if(fileCounterLastSubsetQC % cycle == 0)
 513    } // end of if(devideOutputFilesInEqualSubsets)
 514   } // end of if(!(gSystem->AccessPathName(fileNameQC.Data(),kFileExists)))
 515
 516   // FQD:
 517   TString fileNameFQD = presentDirName;
 518   ((fileNameFQD+="outputFQDanalysis")+=type.Data())+=".root";
 519   if(!(gSystem->AccessPathName(fileNameFQD.Data(),kFileExists)))
 520   {
 521    fileCounterFQD++;
 522    fileMergerFQD->AddFile(fileNameFQD.Data());
 523
 524    if(devideOutputFilesInEqualSubsets)
 525    {
 526     fileMergerForSubsetsFQD[(fileCounterFQD-1) % nSubsets].AddFile(fileNameFQD.Data());
 527     if(fileCounterFQD % nSubsets == 0)
 528     {
 529      fileCounterLastSubsetFQD++;
 530     }
 531    }
 532
 533    // global merging:
 534    if(fileCounterFQD % cycle == 0)
 535    {
 536     TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
 537     (*mergedFileForPreviousCycleFQD)+=type.Data();
 538     (*mergedFileForPreviousCycleFQD)+=(fileCounterFQD/cycle - 1);
 539     (*mergedFileForPreviousCycleFQD)+=".root";
 540
 541     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleFQD->Data(),kFileExists)))
 542     {
 543      fileMergerFQD->AddFile(mergedFileForPreviousCycleFQD->Data());
 544      // delete merged output from previous cycle:
 545      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleFQD->Data(),gSystem->pwd());
 546      file->Delete();
 547      delete file;
 548     }
 549
 550     TString *mergedFileForCurrentCycleFQD = new TString("mergedFQDanalysis");
 551     (*mergedFileForCurrentCycleFQD)+=type.Data();
 552     (*mergedFileForCurrentCycleFQD)+=(fileCounterFQD/cycle);
 553     (*mergedFileForCurrentCycleFQD)+=".root";
 554
 555     fileMergerFQD->OutputFile(mergedFileForCurrentCycleFQD->Data());
 556     fileMergerFQD->Merge();
 557     fileMergerFQD->Reset();
 558
 559     delete mergedFileForPreviousCycleFQD;
 560     delete mergedFileForCurrentCycleFQD;
 561    } // end of if(fileCounterFQD % cycle == 0)
 562
 563    // merging for subsets:
 564    if(devideOutputFilesInEqualSubsets)
 565    {
 566     if(fileCounterLastSubsetFQD > 0 && fileCounterLastSubsetFQD % cycle == 0  && fileCounterFQD % cycle == 0)
 567     {
 568      TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
 569      TString mergedFileForCurrentCycleForSubsetFQD[nSubsets];
 570      for(Int_t i=0;i<nSubsets;i++)
 571      {
 572       mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
 573       mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
 574       mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
 575       mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
 576       mergedFileForPreviousCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle - 1);
 577       mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
 578
 579       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetFQD[i].Data(),kFileExists)))
 580       {
 581        fileMergerForSubsetsFQD[i].AddFile(mergedFileForPreviousCycleForSubsetFQD[i].Data());
 582        // delete merged output from previous cycle:
 583        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
 584        file->Delete();
 585        delete file;
 586       }
 587
 588       mergedFileForCurrentCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
 589       mergedFileForCurrentCycleForSubsetFQD[i]+=(i+1);
 590       mergedFileForCurrentCycleForSubsetFQD[i]+=type.Data();
 591       mergedFileForCurrentCycleForSubsetFQD[i]+="CycleNo";
 592       mergedFileForCurrentCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle);
 593       mergedFileForCurrentCycleForSubsetFQD[i]+=".root";
 594
 595       fileMergerForSubsetsFQD[i].OutputFile(mergedFileForCurrentCycleForSubsetFQD[i].Data());
 596       fileMergerForSubsetsFQD[i].Merge();
 597       fileMergerForSubsetsFQD[i].Reset();
 598
 599      } // end of for(Int_t i=0;i<nSubsets;i++)
 600     } // end of if(fileCounterLastSubsetFQD % cycle == 0)
 601    } // end of if(devideOutputFilesInEqualSubsets)
 602   } // end of if(!(gSystem->AccessPathName(fileNameFQD.Data(),kFileExists)))
 603
 604   // LYZ1SUM:
 605   TString fileNameLYZ1SUM = presentDirName;
 606   ((fileNameLYZ1SUM+="outputLYZ1SUManalysis")+=type.Data())+=".root";
 607   if(!(gSystem->AccessPathName(fileNameLYZ1SUM.Data(),kFileExists)))
 608   {
 609    fileCounterLYZ1SUM++;
 610    fileMergerLYZ1SUM->AddFile(fileNameLYZ1SUM.Data());
 611
 612    if(devideOutputFilesInEqualSubsets)
 613    {
 614     fileMergerForSubsetsLYZ1SUM[(fileCounterLYZ1SUM-1) % nSubsets].AddFile(fileNameLYZ1SUM.Data());
 615     if(fileCounterLYZ1SUM % nSubsets == 0)
 616     {
 617      fileCounterLastSubsetLYZ1SUM++;
 618     }
 619    }
 620
 621    // global merging:
 622    if(fileCounterLYZ1SUM % cycle == 0)
 623    {
 624     TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
 625     (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
 626     (*mergedFileForPreviousCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle - 1);
 627     (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
 628
 629     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1SUM->Data(),kFileExists)))
 630     {
 631      fileMergerLYZ1SUM->AddFile(mergedFileForPreviousCycleLYZ1SUM->Data());
 632      // delete merged output from previous cycle:
 633      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1SUM->Data(),gSystem->pwd());
 634      file->Delete();
 635      delete file;
 636     }
 637
 638     TString *mergedFileForCurrentCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
 639     (*mergedFileForCurrentCycleLYZ1SUM)+=type.Data();
 640     (*mergedFileForCurrentCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle);
 641     (*mergedFileForCurrentCycleLYZ1SUM)+=".root";
 642
 643     fileMergerLYZ1SUM->OutputFile(mergedFileForCurrentCycleLYZ1SUM->Data());
 644     fileMergerLYZ1SUM->Merge();
 645     fileMergerLYZ1SUM->Reset();
 646
 647     delete mergedFileForPreviousCycleLYZ1SUM;
 648     delete mergedFileForCurrentCycleLYZ1SUM;
 649    } // end of if(fileCounterLYZ1SUM % cycle == 0)
 650
 651    // merging for subsets:
 652    if(devideOutputFilesInEqualSubsets)
 653    {
 654     if(fileCounterLastSubsetLYZ1SUM > 0 && fileCounterLastSubsetLYZ1SUM % cycle == 0  && fileCounterLYZ1SUM % cycle == 0)
 655     {
 656      TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
 657      TString mergedFileForCurrentCycleForSubsetLYZ1SUM[nSubsets];
 658      for(Int_t i=0;i<nSubsets;i++)
 659      {
 660       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
 661       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
 662       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
 663       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
 664       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle - 1);
 665       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
 666
 667       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),kFileExists)))
 668       {
 669        fileMergerForSubsetsLYZ1SUM[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data());
 670        // delete merged output from previous cycle:
 671        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
 672        file->Delete();
 673        delete file;
 674       }
 675
 676       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
 677       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=(i+1);
 678       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=type.Data();
 679       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+="CycleNo";
 680       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle);
 681       mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=".root";
 682
 683       fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZ1SUM[i].Data());
 684       fileMergerForSubsetsLYZ1SUM[i].Merge();
 685       fileMergerForSubsetsLYZ1SUM[i].Reset();
 686
 687      } // end of for(Int_t i=0;i<nSubsets;i++)
 688     } // end of if(fileCounterLastSubsetLYZ1SUM % cycle == 0)
 689    } // end of if(devideOutputFilesInEqualSubsets)
 690   } // end of if(!(gSystem->AccessPathName(fileNameLYZ1SUM.Data(),kFileExists)))
 691
 692   // LYZ1PROD:
 693   TString fileNameLYZ1PROD = presentDirName;
 694   ((fileNameLYZ1PROD+="outputLYZ1PRODanalysis")+=type.Data())+=".root";
 695   if(!(gSystem->AccessPathName(fileNameLYZ1PROD.Data(),kFileExists)))
 696   {
 697    fileCounterLYZ1PROD++;
 698    fileMergerLYZ1PROD->AddFile(fileNameLYZ1PROD.Data());
 699
 700    if(devideOutputFilesInEqualSubsets)
 701    {
 702     fileMergerForSubsetsLYZ1PROD[(fileCounterLYZ1PROD-1) % nSubsets].AddFile(fileNameLYZ1PROD.Data());
 703     if(fileCounterLYZ1PROD % nSubsets == 0)
 704     {
 705      fileCounterLastSubsetLYZ1PROD++;
 706     }
 707    }
 708
 709    // global merging:
 710    if(fileCounterLYZ1PROD % cycle == 0)
 711    {
 712     TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
 713     (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
 714     (*mergedFileForPreviousCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle - 1);
 715     (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
 716
 717     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1PROD->Data(),kFileExists)))
 718     {
 719      fileMergerLYZ1PROD->AddFile(mergedFileForPreviousCycleLYZ1PROD->Data());
 720      // delete merged output from previous cycle:
 721      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1PROD->Data(),gSystem->pwd());
 722      file->Delete();
 723      delete file;
 724     }
 725
 726     TString *mergedFileForCurrentCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
 727     (*mergedFileForCurrentCycleLYZ1PROD)+=type.Data();
 728     (*mergedFileForCurrentCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle);
 729     (*mergedFileForCurrentCycleLYZ1PROD)+=".root";
 730
 731     fileMergerLYZ1PROD->OutputFile(mergedFileForCurrentCycleLYZ1PROD->Data());
 732     fileMergerLYZ1PROD->Merge();
 733     fileMergerLYZ1PROD->Reset();
 734
 735     delete mergedFileForPreviousCycleLYZ1PROD;
 736     delete mergedFileForCurrentCycleLYZ1PROD;
 737    } // end of if(fileCounterLYZ1PROD % cycle == 0)
 738
 739    // merging for subsets:
 740    if(devideOutputFilesInEqualSubsets)
 741    {
 742     if(fileCounterLastSubsetLYZ1PROD > 0 && fileCounterLastSubsetLYZ1PROD % cycle == 0  && fileCounterLYZ1PROD % cycle == 0)
 743     {
 744      TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
 745      TString mergedFileForCurrentCycleForSubsetLYZ1PROD[nSubsets];
 746      for(Int_t i=0;i<nSubsets;i++)
 747      {
 748       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
 749       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
 750       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
 751       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
 752       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle - 1);
 753       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
 754
 755       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),kFileExists)))
 756       {
 757        fileMergerForSubsetsLYZ1PROD[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data());
 758        // delete merged output from previous cycle:
 759        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
 760        file->Delete();
 761        delete file;
 762       }
 763
 764       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
 765       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=(i+1);
 766       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=type.Data();
 767       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+="CycleNo";
 768       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle);
 769       mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=".root";
 770
 771       fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZ1PROD[i].Data());
 772       fileMergerForSubsetsLYZ1PROD[i].Merge();
 773       fileMergerForSubsetsLYZ1PROD[i].Reset();
 774
 775      } // end of for(Int_t i=0;i<nSubsets;i++)
 776     } // end of if(fileCounterLastSubsetLYZ1PROD % cycle == 0)
 777    } // end of if(devideOutputFilesInEqualSubsets)
 778   } // end of if(!(gSystem->AccessPathName(fileNameLYZ1PROD.Data(),kFileExists)))
 779
 780   // LYZEP:
 781   TString fileNameLYZEP = presentDirName;
 782   ((fileNameLYZEP+="outputLYZEPanalysis")+=type.Data())+=".root";
 783   if(!(gSystem->AccessPathName(fileNameLYZEP.Data(),kFileExists)))
 784   {
 785    fileCounterLYZEP++;
 786    fileMergerLYZEP->AddFile(fileNameLYZEP.Data());
 787
 788    if(devideOutputFilesInEqualSubsets)
 789    {
 790     fileMergerForSubsetsLYZEP[(fileCounterLYZEP-1) % nSubsets].AddFile(fileNameLYZEP.Data());
 791     if(fileCounterLYZEP % nSubsets == 0)
 792     {
 793      fileCounterLastSubsetLYZEP++;
 794     }
 795    }
 796
 797    // global merging:
 798    if(fileCounterLYZEP % cycle == 0)
 799    {
 800     TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
 801     (*mergedFileForPreviousCycleLYZEP)+=type.Data();
 802     (*mergedFileForPreviousCycleLYZEP)+=(fileCounterLYZEP/cycle - 1);
 803     (*mergedFileForPreviousCycleLYZEP)+=".root";
 804
 805     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZEP->Data(),kFileExists)))
 806     {
 807      fileMergerLYZEP->AddFile(mergedFileForPreviousCycleLYZEP->Data());
 808      // delete merged output from previous cycle:
 809      TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZEP->Data(),gSystem->pwd());
 810      file->Delete();
 811      delete file;
 812     }
 813
 814     TString *mergedFileForCurrentCycleLYZEP = new TString("mergedLYZEPanalysis");
 815     (*mergedFileForCurrentCycleLYZEP)+=type.Data();
 816     (*mergedFileForCurrentCycleLYZEP)+=(fileCounterLYZEP/cycle);
 817     (*mergedFileForCurrentCycleLYZEP)+=".root";
 818
 819     fileMergerLYZEP->OutputFile(mergedFileForCurrentCycleLYZEP->Data());
 820     fileMergerLYZEP->Merge();
 821     fileMergerLYZEP->Reset();
 822
 823     delete mergedFileForPreviousCycleLYZEP;
 824     delete mergedFileForCurrentCycleLYZEP;
 825    } // end of if(fileCounterLYZEP % cycle == 0)
 826
 827    // merging for subsets:
 828    if(devideOutputFilesInEqualSubsets)
 829    {
 830     if(fileCounterLastSubsetLYZEP > 0 && fileCounterLastSubsetLYZEP % cycle == 0  && fileCounterLYZEP % cycle == 0)
 831     {
 832      TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
 833      TString mergedFileForCurrentCycleForSubsetLYZEP[nSubsets];
 834      for(Int_t i=0;i<nSubsets;i++)
 835      {
 836       mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
 837       mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
 838       mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
 839       mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
 840       mergedFileForPreviousCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle - 1);
 841       mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
 842
 843       if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),kFileExists)))
 844       {
 845        fileMergerForSubsetsLYZEP[i].AddFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data());
 846        // delete merged output from previous cycle:
 847        TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
 848        file->Delete();
 849        delete file;
 850       }
 851
 852       mergedFileForCurrentCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
 853       mergedFileForCurrentCycleForSubsetLYZEP[i]+=(i+1);
 854       mergedFileForCurrentCycleForSubsetLYZEP[i]+=type.Data();
 855       mergedFileForCurrentCycleForSubsetLYZEP[i]+="CycleNo";
 856       mergedFileForCurrentCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle);
 857       mergedFileForCurrentCycleForSubsetLYZEP[i]+=".root";
 858
 859       fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZEP[i].Data());
 860       fileMergerForSubsetsLYZEP[i].Merge();
 861       fileMergerForSubsetsLYZEP[i].Reset();
 862
 863      } // end of for(Int_t i=0;i<nSubsets;i++)
 864     } // end of if(fileCounterLastSubsetLYZEP % cycle == 0)
 865    } // end of if(devideOutputFilesInEqualSubsets)
 866   } // end of if(!(gSystem->AccessPathName(fileNameLYZEP.Data(),kFileExists)))
 867
 868  } // end of for(Int_t iFile=0;iFile<nFiles;iFile++)
 869
 870
 871  //=================================================================================================
 872
 873
 874  // global merging at the end of the day:
 875  gSystem->cd(baseDirPath->Data());
 876  // MCEP:
 877  if(fileCounterMCEP < cycle)
 878  {
 879   TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
 880   (*mergedFileFinalMCEP)+=type.Data();
 881   (*mergedFileFinalMCEP)+=".root";
 882   fileMergerMCEP->OutputFile(mergedFileFinalMCEP->Data());
 883   fileMergerMCEP->Merge();
 884   delete mergedFileFinalMCEP;
 885  } else if (fileCounterMCEP % cycle == 0)
 886    {
 887     TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
 888     (*mergedFileForPreviousCycleMCEP)+=type.Data();
 889     (*mergedFileForPreviousCycleMCEP)+=(fileCounterMCEP/cycle);
 890     (*mergedFileForPreviousCycleMCEP)+=".root";
 891     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleMCEP->Data(),kFileExists)))
 892     {
 893      TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
 894      (*mergedFileFinalMCEP)+=type.Data();
 895      (*mergedFileFinalMCEP)+=".root";
 896      gSystem->Rename(mergedFileForPreviousCycleMCEP->Data(),mergedFileFinalMCEP->Data());
 897     }
 898    } else
 899      {
 900       TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
 901       (*mergedFileForPreviousCycleMCEP)+=type.Data();
 902       (*mergedFileForPreviousCycleMCEP)+=((Int_t)fileCounterMCEP/cycle);
 903       (*mergedFileForPreviousCycleMCEP)+=".root";
 904
 905       fileMergerMCEP->AddFile(mergedFileForPreviousCycleMCEP->Data());
 906
 907       // delete merged output from previous cycle:
 908       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleMCEP->Data(),gSystem->pwd());
 909       file->Delete();
 910       delete file;
 911
 912       TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
 913       (*mergedFileFinalMCEP)+=type.Data();
 914       (*mergedFileFinalMCEP)+=".root";
 915       fileMergerMCEP->OutputFile(mergedFileFinalMCEP->Data());
 916       fileMergerMCEP->Merge();
 917
 918       delete mergedFileForPreviousCycleMCEP;
 919       delete mergedFileFinalMCEP;
 920      }
 921
 922   // merging for subsets at the end of the day:
 923   gSystem->cd(baseDirPath->Data());
 924   if(devideOutputFilesInEqualSubsets)
 925   {
 926    if(fileCounterLastSubsetMCEP < cycle)
 927    {
 928     TString mergedFileFinalForSubsetMCEP[nSubsets];
 929     for(Int_t i=0;i<nSubsets;i++)
 930     {
 931      mergedFileFinalForSubsetMCEP[i]="subset";
 932      mergedFileFinalForSubsetMCEP[i]+=(i+1);
 933      mergedFileFinalForSubsetMCEP[i]+="/";
 934      mergedFileFinalForSubsetMCEP[i]+="mergedMCEPanalysis";
 935      mergedFileFinalForSubsetMCEP[i]+=type.Data();
 936      mergedFileFinalForSubsetMCEP[i]+=".root";
 937
 938      fileMergerForSubsetsMCEP[i].OutputFile(mergedFileFinalForSubsetMCEP[i].Data());
 939      fileMergerForSubsetsMCEP[i].Merge();
 940      fileMergerForSubsetsMCEP[i].Reset();
 941     } // end of for(Int_t i=0;i<nSubsets;i++)
 942    } else if (fileCounterLastSubsetMCEP % cycle == 0 && fileCounterMCEP % cycle == 0)
 943     {
 944      TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
 945      TString mergedFileFinalForSubsetMCEP[nSubsets];
 946      for(Int_t i=0;i<nSubsets;i++)
 947      {
 948       mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
 949       mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
 950       mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
 951       mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
 952       mergedFileForPreviousCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle);
 953       mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
 954       // move and rename this file to subdirectory subset*:
 955       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
 956       TString *subdir = new TString("subset");
 957       (*subdir)+=(i+1);
 958       (*subdir)+="/";
 959       (*subdir)+="mergedMCEPanalysis";
 960       (*subdir)+=type.Data();
 961       (*subdir)+=".root";
 962       file->Move(subdir->Data());
 963       delete file;
 964       delete subdir;
 965      } // end of for(Int_t i=0;i<nSubsets;i++)
 966     } else
 967       {
 968        TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
 969        TString mergedFileFinalForSubsetMCEP[nSubsets];
 970        for(Int_t i=0;i<nSubsets;i++)
 971        {
 972         mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
 973         mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
 974         mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
 975         mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
 976         mergedFileForPreviousCycleForSubsetMCEP[i]+=((Int_t)fileCounterLastSubsetMCEP/cycle);
 977         mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
 978
 979         fileMergerForSubsetsMCEP[i].AddFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data());
 980
 981         // delete merged output from previous cycle:
 982         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
 983         file->Delete();
 984         delete file;
 985
 986         mergedFileFinalForSubsetMCEP[i]="subset";
 987         mergedFileFinalForSubsetMCEP[i]+=(i+1);
 988         mergedFileFinalForSubsetMCEP[i]+="/";
 989         mergedFileFinalForSubsetMCEP[i]+="mergedMCEPanalysis";
 990         mergedFileFinalForSubsetMCEP[i]+=type.Data();
 991         mergedFileFinalForSubsetMCEP[i]+=".root";
 992
 993         fileMergerForSubsetsMCEP[i].OutputFile(mergedFileFinalForSubsetMCEP[i].Data());
 994
 995         fileMergerForSubsetsMCEP[i].Merge();
 996         fileMergerForSubsetsMCEP[i].Reset();
 997        } // end of for(Int_t i=0;i<nSubsets;i++)
 998       } // end of last else
 999   } // end of if(devideOutputFilesInEqualSubsets)
1000
1001  // SP:
1002  if(fileCounterSP < cycle)
1003  {
1004   TString *mergedFileFinalSP = new TString("mergedSPanalysis");
1005   (*mergedFileFinalSP)+=type.Data();
1006   (*mergedFileFinalSP)+=".root";
1007   fileMergerSP->OutputFile(mergedFileFinalSP->Data());
1008   fileMergerSP->Merge();
1009   delete mergedFileFinalSP;
1010  } else if (fileCounterSP % cycle == 0)
1011    {
1012     TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
1013     (*mergedFileForPreviousCycleSP)+=type.Data();
1014     (*mergedFileForPreviousCycleSP)+=(fileCounterSP/cycle);
1015     (*mergedFileForPreviousCycleSP)+=".root";
1016     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleSP->Data(),kFileExists)))
1017     {
1018      TString *mergedFileFinalSP = new TString("mergedSPanalysis");
1019      (*mergedFileFinalSP)+=type.Data();
1020      (*mergedFileFinalSP)+=".root";
1021      gSystem->Rename(mergedFileForPreviousCycleSP->Data(),mergedFileFinalSP->Data());
1022     }
1023    } else
1024      {
1025       TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
1026       (*mergedFileForPreviousCycleSP)+=type.Data();
1027       (*mergedFileForPreviousCycleSP)+=((Int_t)fileCounterSP/cycle);
1028       (*mergedFileForPreviousCycleSP)+=".root";
1029
1030       fileMergerSP->AddFile(mergedFileForPreviousCycleSP->Data());
1031
1032       // delete merged output from previous cycle:
1033       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleSP->Data(),gSystem->pwd());
1034       file->Delete();
1035       delete file;
1036
1037       TString *mergedFileFinalSP = new TString("mergedSPanalysis");
1038       (*mergedFileFinalSP)+=type.Data();
1039       (*mergedFileFinalSP)+=".root";
1040       fileMergerSP->OutputFile(mergedFileFinalSP->Data());
1041       fileMergerSP->Merge();
1042
1043       delete mergedFileForPreviousCycleSP;
1044       delete mergedFileFinalSP;
1045      }
1046
1047   // merging for subsets at the end of the day:
1048   gSystem->cd(baseDirPath->Data());
1049   if(devideOutputFilesInEqualSubsets)
1050   {
1051    if(fileCounterLastSubsetSP < cycle)
1052    {
1053     TString mergedFileFinalForSubsetSP[nSubsets];
1054     for(Int_t i=0;i<nSubsets;i++)
1055     {
1056      mergedFileFinalForSubsetSP[i]="subset";
1057      mergedFileFinalForSubsetSP[i]+=(i+1);
1058      mergedFileFinalForSubsetSP[i]+="/";
1059      mergedFileFinalForSubsetSP[i]+="mergedSPanalysis";
1060      mergedFileFinalForSubsetSP[i]+=type.Data();
1061      mergedFileFinalForSubsetSP[i]+=".root";
1062
1063      fileMergerForSubsetsSP[i].OutputFile(mergedFileFinalForSubsetSP[i].Data());
1064      fileMergerForSubsetsSP[i].Merge();
1065      fileMergerForSubsetsSP[i].Reset();
1066     } // end of for(Int_t i=0;i<nSubsets;i++)
1067    } else if (fileCounterLastSubsetSP % cycle == 0  && fileCounterSP % cycle == 0)
1068     {
1069      TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
1070      TString mergedFileFinalForSubsetSP[nSubsets];
1071      for(Int_t i=0;i<nSubsets;i++)
1072      {
1073       mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
1074       mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
1075       mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
1076       mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
1077       mergedFileForPreviousCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle);
1078       mergedFileForPreviousCycleForSubsetSP[i]+=".root";
1079       // move and rename this file to subdirectory subset*:
1080       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
1081       TString *subdir = new TString("subset");
1082       (*subdir)+=(i+1);
1083       (*subdir)+="/";
1084       (*subdir)+="mergedSPanalysis";
1085       (*subdir)+=type.Data();
1086       (*subdir)+=".root";
1087       file->Move(subdir->Data());
1088       delete file;
1089       delete subdir;
1090      } // end of for(Int_t i=0;i<nSubsets;i++)
1091     } else
1092       {
1093        TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
1094        TString mergedFileFinalForSubsetSP[nSubsets];
1095        for(Int_t i=0;i<nSubsets;i++)
1096        {
1097         mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
1098         mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
1099         mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
1100         mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
1101         mergedFileForPreviousCycleForSubsetSP[i]+=((Int_t)fileCounterLastSubsetSP/cycle);
1102         mergedFileForPreviousCycleForSubsetSP[i]+=".root";
1103
1104         fileMergerForSubsetsSP[i].AddFile(mergedFileForPreviousCycleForSubsetSP[i].Data());
1105
1106         // delete merged output from previous cycle:
1107         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
1108         file->Delete();
1109         delete file;
1110
1111         mergedFileFinalForSubsetSP[i]="subset";
1112         mergedFileFinalForSubsetSP[i]+=(i+1);
1113         mergedFileFinalForSubsetSP[i]+="/";
1114         mergedFileFinalForSubsetSP[i]+="mergedSPanalysis";
1115         mergedFileFinalForSubsetSP[i]+=type.Data();
1116         mergedFileFinalForSubsetSP[i]+=".root";
1117
1118         fileMergerForSubsetsSP[i].OutputFile(mergedFileFinalForSubsetSP[i].Data());
1119         fileMergerForSubsetsSP[i].Merge();
1120         fileMergerForSubsetsSP[i].Reset();
1121        } // end of for(Int_t i=0;i<nSubsets;i++)
1122       } // end of last else
1123   } // end of if(devideOutputFilesInEqualSubsets)
1124
1125  // GFC:
1126  if(fileCounterGFC < cycle)
1127  {
1128   TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
1129   (*mergedFileFinalGFC)+=type.Data();
1130   (*mergedFileFinalGFC)+=".root";
1131   fileMergerGFC->OutputFile(mergedFileFinalGFC->Data());
1132   fileMergerGFC->Merge();
1133   delete mergedFileFinalGFC;
1134  } else if (fileCounterGFC % cycle == 0)
1135    {
1136     TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
1137     (*mergedFileForPreviousCycleGFC)+=type.Data();
1138     (*mergedFileForPreviousCycleGFC)+=(fileCounterGFC/cycle);
1139     (*mergedFileForPreviousCycleGFC)+=".root";
1140     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleGFC->Data(),kFileExists)))
1141     {
1142      TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
1143      (*mergedFileFinalGFC)+=type.Data();
1144      (*mergedFileFinalGFC)+=".root";
1145      gSystem->Rename(mergedFileForPreviousCycleGFC->Data(),mergedFileFinalGFC->Data());
1146     }
1147    } else
1148      {
1149       TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
1150       (*mergedFileForPreviousCycleGFC)+=type.Data();
1151       (*mergedFileForPreviousCycleGFC)+=((Int_t)fileCounterGFC/cycle);
1152       (*mergedFileForPreviousCycleGFC)+=".root";
1153
1154       fileMergerGFC->AddFile(mergedFileForPreviousCycleGFC->Data());
1155
1156       // delete merged output from previous cycle:
1157       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleGFC->Data(),gSystem->pwd());
1158       file->Delete();
1159       delete file;
1160
1161       TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
1162       (*mergedFileFinalGFC)+=type.Data();
1163       (*mergedFileFinalGFC)+=".root";
1164       fileMergerGFC->OutputFile(mergedFileFinalGFC->Data());
1165       fileMergerGFC->Merge();
1166
1167       delete mergedFileForPreviousCycleGFC;
1168       delete mergedFileFinalGFC;
1169      }
1170
1171   // merging for subsets at the end of the day:
1172   gSystem->cd(baseDirPath->Data());
1173   if(devideOutputFilesInEqualSubsets)
1174   {
1175    if(fileCounterLastSubsetGFC < cycle)
1176    {
1177     TString mergedFileFinalForSubsetGFC[nSubsets];
1178     for(Int_t i=0;i<nSubsets;i++)
1179     {
1180      mergedFileFinalForSubsetGFC[i]="subset";
1181      mergedFileFinalForSubsetGFC[i]+=(i+1);
1182      mergedFileFinalForSubsetGFC[i]+="/";
1183      mergedFileFinalForSubsetGFC[i]+="mergedGFCanalysis";
1184      mergedFileFinalForSubsetGFC[i]+=type.Data();
1185      mergedFileFinalForSubsetGFC[i]+=".root";
1186
1187      fileMergerForSubsetsGFC[i].OutputFile(mergedFileFinalForSubsetGFC[i].Data());
1188      fileMergerForSubsetsGFC[i].Merge();
1189      fileMergerForSubsetsGFC[i].Reset();
1190     } // end of for(Int_t i=0;i<nSubsets;i++)
1191    } else if (fileCounterLastSubsetGFC % cycle == 0  && fileCounterGFC % cycle == 0)
1192     {
1193      TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
1194      TString mergedFileFinalForSubsetGFC[nSubsets];
1195      for(Int_t i=0;i<nSubsets;i++)
1196      {
1197       mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
1198       mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
1199       mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
1200       mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
1201       mergedFileForPreviousCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle);
1202       mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
1203       // move and rename this file to subdirectory subset*:
1204       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
1205       TString *subdir = new TString("subset");
1206       (*subdir)+=(i+1);
1207       (*subdir)+="/";
1208       (*subdir)+="mergedGFCanalysis";
1209       (*subdir)+=type.Data();
1210       (*subdir)+=".root";
1211       file->Move(subdir->Data());
1212       delete file;
1213       delete subdir;
1214      } // end of for(Int_t i=0;i<nSubsets;i++)
1215     } else
1216       {
1217        TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
1218        TString mergedFileFinalForSubsetGFC[nSubsets];
1219        for(Int_t i=0;i<nSubsets;i++)
1220        {
1221         mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
1222         mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
1223         mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
1224         mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
1225         mergedFileForPreviousCycleForSubsetGFC[i]+=((Int_t)fileCounterLastSubsetGFC/cycle);
1226         mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
1227
1228         fileMergerForSubsetsGFC[i].AddFile(mergedFileForPreviousCycleForSubsetGFC[i].Data());
1229
1230         // delete merged output from previous cycle:
1231         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
1232         file->Delete();
1233         delete file;
1234
1235         mergedFileFinalForSubsetGFC[i]="subset";
1236         mergedFileFinalForSubsetGFC[i]+=(i+1);
1237         mergedFileFinalForSubsetGFC[i]+="/";
1238         mergedFileFinalForSubsetGFC[i]+="mergedGFCanalysis";
1239         mergedFileFinalForSubsetGFC[i]+=type.Data();
1240         mergedFileFinalForSubsetGFC[i]+=".root";
1241
1242         fileMergerForSubsetsGFC[i].OutputFile(mergedFileFinalForSubsetGFC[i].Data());
1243         fileMergerForSubsetsGFC[i].Merge();
1244         fileMergerForSubsetsGFC[i].Reset();
1245        } // end of for(Int_t i=0;i<nSubsets;i++)
1246       } // end of last else
1247   } // end of if(devideOutputFilesInEqualSubsets)
1248
1249  // QC:
1250  if(fileCounterQC < cycle)
1251  {
1252   TString *mergedFileFinalQC = new TString("mergedQCanalysis");
1253   (*mergedFileFinalQC)+=type.Data();
1254   (*mergedFileFinalQC)+=".root";
1255   fileMergerQC->OutputFile(mergedFileFinalQC->Data());
1256   fileMergerQC->Merge();
1257   delete mergedFileFinalQC;
1258  } else if (fileCounterQC % cycle == 0)
1259    {
1260     TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
1261     (*mergedFileForPreviousCycleQC)+=type.Data();
1262     (*mergedFileForPreviousCycleQC)+=(fileCounterQC/cycle);
1263     (*mergedFileForPreviousCycleQC)+=".root";
1264     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleQC->Data(),kFileExists)))
1265     {
1266      TString *mergedFileFinalQC = new TString("mergedQCanalysis");
1267      (*mergedFileFinalQC)+=type.Data();
1268      (*mergedFileFinalQC)+=".root";
1269      gSystem->Rename(mergedFileForPreviousCycleQC->Data(),mergedFileFinalQC->Data());
1270     }
1271    } else
1272      {
1273       TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
1274       (*mergedFileForPreviousCycleQC)+=type.Data();
1275       (*mergedFileForPreviousCycleQC)+=((Int_t)fileCounterQC/cycle);
1276       (*mergedFileForPreviousCycleQC)+=".root";
1277
1278       fileMergerQC->AddFile(mergedFileForPreviousCycleQC->Data());
1279
1280       // delete merged output from previous cycle:
1281       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleQC->Data(),gSystem->pwd());
1282       file->Delete();
1283       delete file;
1284
1285       TString *mergedFileFinalQC = new TString("mergedQCanalysis");
1286       (*mergedFileFinalQC)+=type.Data();
1287       (*mergedFileFinalQC)+=".root";
1288       fileMergerQC->OutputFile(mergedFileFinalQC->Data());
1289       fileMergerQC->Merge();
1290
1291       delete mergedFileForPreviousCycleQC;
1292       delete mergedFileFinalQC;
1293      }
1294
1295   // merging for subsets at the end of the day:
1296   gSystem->cd(baseDirPath->Data());
1297   if(devideOutputFilesInEqualSubsets)
1298   {
1299    if(fileCounterLastSubsetQC < cycle)
1300    {
1301     TString mergedFileFinalForSubsetQC[nSubsets];
1302     for(Int_t i=0;i<nSubsets;i++)
1303     {
1304      mergedFileFinalForSubsetQC[i]="subset";
1305      mergedFileFinalForSubsetQC[i]+=(i+1);
1306      mergedFileFinalForSubsetQC[i]+="/";
1307      mergedFileFinalForSubsetQC[i]+="mergedQCanalysis";
1308      mergedFileFinalForSubsetQC[i]+=type.Data();
1309      mergedFileFinalForSubsetQC[i]+=".root";
1310
1311      fileMergerForSubsetsQC[i].OutputFile(mergedFileFinalForSubsetQC[i].Data());
1312      fileMergerForSubsetsQC[i].Merge();
1313      fileMergerForSubsetsQC[i].Reset();
1314     } // end of for(Int_t i=0;i<nSubsets;i++)
1315    } else if (fileCounterLastSubsetQC % cycle == 0  && fileCounterQC % cycle == 0)
1316     {
1317      TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
1318      TString mergedFileFinalForSubsetQC[nSubsets];
1319      for(Int_t i=0;i<nSubsets;i++)
1320      {
1321       mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
1322       mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
1323       mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
1324       mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
1325       mergedFileForPreviousCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle);
1326       mergedFileForPreviousCycleForSubsetQC[i]+=".root";
1327       // move and rename this file to subdirectory subset*:
1328       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
1329       TString *subdir = new TString("subset");
1330       (*subdir)+=(i+1);
1331       (*subdir)+="/";
1332       (*subdir)+="mergedQCanalysis";
1333       (*subdir)+=type.Data();
1334       (*subdir)+=".root";
1335       file->Move(subdir->Data());
1336       delete file;
1337       delete subdir;
1338      } // end of for(Int_t i=0;i<nSubsets;i++)
1339     } else
1340       {
1341        TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
1342        TString mergedFileFinalForSubsetQC[nSubsets];
1343        for(Int_t i=0;i<nSubsets;i++)
1344        {
1345         mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
1346         mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
1347         mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
1348         mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
1349         mergedFileForPreviousCycleForSubsetQC[i]+=((Int_t)fileCounterLastSubsetQC/cycle);
1350         mergedFileForPreviousCycleForSubsetQC[i]+=".root";
1351
1352         fileMergerForSubsetsQC[i].AddFile(mergedFileForPreviousCycleForSubsetQC[i].Data());
1353
1354         // delete merged output from previous cycle:
1355         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
1356         file->Delete();
1357         delete file;
1358
1359         mergedFileFinalForSubsetQC[i]="subset";
1360         mergedFileFinalForSubsetQC[i]+=(i+1);
1361         mergedFileFinalForSubsetQC[i]+="/";
1362         mergedFileFinalForSubsetQC[i]+="mergedQCanalysis";
1363         mergedFileFinalForSubsetQC[i]+=type.Data();
1364         mergedFileFinalForSubsetQC[i]+=".root";
1365
1366         fileMergerForSubsetsQC[i].OutputFile(mergedFileFinalForSubsetQC[i].Data());
1367         fileMergerForSubsetsQC[i].Merge();
1368         fileMergerForSubsetsQC[i].Reset();
1369        } // end of for(Int_t i=0;i<nSubsets;i++)
1370       } // end of last else
1371   } // end of if(devideOutputFilesInEqualSubsets)
1372
1373  // FQD:
1374  if(fileCounterFQD < cycle)
1375  {
1376   TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
1377   (*mergedFileFinalFQD)+=type.Data();
1378   (*mergedFileFinalFQD)+=".root";
1379   fileMergerFQD->OutputFile(mergedFileFinalFQD->Data());
1380   fileMergerFQD->Merge();
1381   delete mergedFileFinalFQD;
1382  } else if (fileCounterFQD % cycle == 0)
1383    {
1384     TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
1385     (*mergedFileForPreviousCycleFQD)+=type.Data();
1386     (*mergedFileForPreviousCycleFQD)+=(fileCounterFQD/cycle);
1387     (*mergedFileForPreviousCycleFQD)+=".root";
1388     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleFQD->Data(),kFileExists)))
1389     {
1390      TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
1391      (*mergedFileFinalFQD)+=type.Data();
1392      (*mergedFileFinalFQD)+=".root";
1393      gSystem->Rename(mergedFileForPreviousCycleFQD->Data(),mergedFileFinalFQD->Data());
1394     }
1395    } else
1396      {
1397       TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
1398       (*mergedFileForPreviousCycleFQD)+=type.Data();
1399       (*mergedFileForPreviousCycleFQD)+=((Int_t)fileCounterFQD/cycle);
1400       (*mergedFileForPreviousCycleFQD)+=".root";
1401
1402       fileMergerFQD->AddFile(mergedFileForPreviousCycleFQD->Data());
1403
1404       // delete merged output from previous cycle:
1405       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleFQD->Data(),gSystem->pwd());
1406       file->Delete();
1407       delete file;
1408
1409       TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
1410       (*mergedFileFinalFQD)+=type.Data();
1411       (*mergedFileFinalFQD)+=".root";
1412       fileMergerFQD->OutputFile(mergedFileFinalFQD->Data());
1413       fileMergerFQD->Merge();
1414
1415       delete mergedFileForPreviousCycleFQD;
1416       delete mergedFileFinalFQD;
1417      }
1418
1419   // merging for subsets at the end of the day:
1420   gSystem->cd(baseDirPath->Data());
1421   if(devideOutputFilesInEqualSubsets)
1422   {
1423    if(fileCounterLastSubsetFQD < cycle)
1424    {
1425     TString mergedFileFinalForSubsetFQD[nSubsets];
1426     for(Int_t i=0;i<nSubsets;i++)
1427     {
1428      mergedFileFinalForSubsetFQD[i]="subset";
1429      mergedFileFinalForSubsetFQD[i]+=(i+1);
1430      mergedFileFinalForSubsetFQD[i]+="/";
1431      mergedFileFinalForSubsetFQD[i]+="mergedFQDanalysis";
1432      mergedFileFinalForSubsetFQD[i]+=type.Data();
1433      mergedFileFinalForSubsetFQD[i]+=".root";
1434
1435      fileMergerForSubsetsFQD[i].OutputFile(mergedFileFinalForSubsetFQD[i].Data());
1436      fileMergerForSubsetsFQD[i].Merge();
1437      fileMergerForSubsetsFQD[i].Reset();
1438     } // end of for(Int_t i=0;i<nSubsets;i++)
1439    } else if (fileCounterLastSubsetFQD % cycle == 0  && fileCounterFQD % cycle == 0)
1440     {
1441      TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
1442      TString mergedFileFinalForSubsetFQD[nSubsets];
1443      for(Int_t i=0;i<nSubsets;i++)
1444      {
1445       mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
1446       mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
1447       mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
1448       mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
1449       mergedFileForPreviousCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle);
1450       mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
1451       // move and rename this file to subdirectory subset*:
1452       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
1453       TString *subdir = new TString("subset");
1454       (*subdir)+=(i+1);
1455       (*subdir)+="/";
1456       (*subdir)+="mergedFQDanalysis";
1457       (*subdir)+=type.Data();
1458       (*subdir)+=".root";
1459       file->Move(subdir->Data());
1460       delete file;
1461       delete subdir;
1462      } // end of for(Int_t i=0;i<nSubsets;i++)
1463     } else
1464       {
1465        TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
1466        TString mergedFileFinalForSubsetFQD[nSubsets];
1467        for(Int_t i=0;i<nSubsets;i++)
1468        {
1469         mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
1470         mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
1471         mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
1472         mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
1473         mergedFileForPreviousCycleForSubsetFQD[i]+=((Int_t)fileCounterLastSubsetFQD/cycle);
1474         mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
1475
1476         fileMergerForSubsetsFQD[i].AddFile(mergedFileForPreviousCycleForSubsetFQD[i].Data());
1477
1478         // delete merged output from previous cycle:
1479         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
1480         file->Delete();
1481         delete file;
1482
1483         mergedFileFinalForSubsetFQD[i]="subset";
1484         mergedFileFinalForSubsetFQD[i]+=(i+1);
1485         mergedFileFinalForSubsetFQD[i]+="/";
1486         mergedFileFinalForSubsetFQD[i]+="mergedFQDanalysis";
1487         mergedFileFinalForSubsetFQD[i]+=type.Data();
1488         mergedFileFinalForSubsetFQD[i]+=".root";
1489
1490         fileMergerForSubsetsFQD[i].OutputFile(mergedFileFinalForSubsetFQD[i].Data());
1491         fileMergerForSubsetsFQD[i].Merge();
1492         fileMergerForSubsetsFQD[i].Reset();
1493        } // end of for(Int_t i=0;i<nSubsets;i++)
1494       } // end of last else
1495   } // end of if(devideOutputFilesInEqualSubsets)
1496
1497  // LYZ1SUM:
1498  if(fileCounterLYZ1SUM < cycle)
1499  {
1500   TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
1501   (*mergedFileFinalLYZ1SUM)+=type.Data();
1502   (*mergedFileFinalLYZ1SUM)+=".root";
1503   fileMergerLYZ1SUM->OutputFile(mergedFileFinalLYZ1SUM->Data());
1504   fileMergerLYZ1SUM->Merge();
1505   delete mergedFileFinalLYZ1SUM;
1506  } else if (fileCounterLYZ1SUM % cycle == 0)
1507    {
1508     TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
1509     (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
1510     (*mergedFileForPreviousCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle);
1511     (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
1512     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1SUM->Data(),kFileExists)))
1513     {
1514      TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
1515      (*mergedFileFinalLYZ1SUM)+=type.Data();
1516      (*mergedFileFinalLYZ1SUM)+=".root";
1517      gSystem->Rename(mergedFileForPreviousCycleLYZ1SUM->Data(),mergedFileFinalLYZ1SUM->Data());
1518     }
1519    } else
1520      {
1521       TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
1522       (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
1523       (*mergedFileForPreviousCycleLYZ1SUM)+=((Int_t)fileCounterLYZ1SUM/cycle);
1524       (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
1525
1526       fileMergerLYZ1SUM->AddFile(mergedFileForPreviousCycleLYZ1SUM->Data());
1527
1528       // delete merged output from previous cycle:
1529       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1SUM->Data(),gSystem->pwd());
1530       file->Delete();
1531       delete file;
1532
1533       TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
1534       (*mergedFileFinalLYZ1SUM)+=type.Data();
1535       (*mergedFileFinalLYZ1SUM)+=".root";
1536       fileMergerLYZ1SUM->OutputFile(mergedFileFinalLYZ1SUM->Data());
1537       fileMergerLYZ1SUM->Merge();
1538
1539       delete mergedFileForPreviousCycleLYZ1SUM;
1540       delete mergedFileFinalLYZ1SUM;
1541      }
1542
1543   // merging for subsets at the end of the day:
1544   gSystem->cd(baseDirPath->Data());
1545   if(devideOutputFilesInEqualSubsets)
1546   {
1547    if(fileCounterLastSubsetLYZ1SUM < cycle)
1548    {
1549     TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
1550     for(Int_t i=0;i<nSubsets;i++)
1551     {
1552      mergedFileFinalForSubsetLYZ1SUM[i]="subset";
1553      mergedFileFinalForSubsetLYZ1SUM[i]+=(i+1);
1554      mergedFileFinalForSubsetLYZ1SUM[i]+="/";
1555      mergedFileFinalForSubsetLYZ1SUM[i]+="mergedLYZ1SUManalysis";
1556      mergedFileFinalForSubsetLYZ1SUM[i]+=type.Data();
1557      mergedFileFinalForSubsetLYZ1SUM[i]+=".root";
1558
1559      fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileFinalForSubsetLYZ1SUM[i].Data());
1560      fileMergerForSubsetsLYZ1SUM[i].Merge();
1561      fileMergerForSubsetsLYZ1SUM[i].Reset();
1562     } // end of for(Int_t i=0;i<nSubsets;i++)
1563    } else if (fileCounterLastSubsetLYZ1SUM % cycle == 0  && fileCounterLYZ1SUM % cycle == 0)
1564     {
1565      TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
1566      TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
1567      for(Int_t i=0;i<nSubsets;i++)
1568      {
1569       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
1570       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
1571       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
1572       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
1573       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle);
1574       mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
1575       // move and rename this file to subdirectory subset*:
1576       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
1577       TString *subdir = new TString("subset");
1578       (*subdir)+=(i+1);
1579       (*subdir)+="/";
1580       (*subdir)+="mergedLYZ1SUManalysis";
1581       (*subdir)+=type.Data();
1582       (*subdir)+=".root";
1583       file->Move(subdir->Data());
1584       delete file;
1585       delete subdir;
1586      } // end of for(Int_t i=0;i<nSubsets;i++)
1587     } else
1588       {
1589        TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
1590        TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
1591        for(Int_t i=0;i<nSubsets;i++)
1592        {
1593         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
1594         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
1595         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
1596         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
1597         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=((Int_t)fileCounterLastSubsetLYZ1SUM/cycle);
1598         mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
1599
1600         fileMergerForSubsetsLYZ1SUM[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data());
1601
1602         // delete merged output from previous cycle:
1603         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
1604         file->Delete();
1605         delete file;
1606
1607         mergedFileFinalForSubsetLYZ1SUM[i]="subset";
1608         mergedFileFinalForSubsetLYZ1SUM[i]+=(i+1);
1609         mergedFileFinalForSubsetLYZ1SUM[i]+="/";
1610         mergedFileFinalForSubsetLYZ1SUM[i]+="mergedLYZ1SUManalysis";
1611         mergedFileFinalForSubsetLYZ1SUM[i]+=type.Data();
1612         mergedFileFinalForSubsetLYZ1SUM[i]+=".root";
1613
1614         fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileFinalForSubsetLYZ1SUM[i].Data());
1615         fileMergerForSubsetsLYZ1SUM[i].Merge();
1616         fileMergerForSubsetsLYZ1SUM[i].Reset();
1617        } // end of for(Int_t i=0;i<nSubsets;i++)
1618       } // end of last else
1619   } // end of if(devideOutputFilesInEqualSubsets)
1620
1621  // LYZ1PROD:
1622  if(fileCounterLYZ1PROD < cycle)
1623  {
1624   TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
1625   (*mergedFileFinalLYZ1PROD)+=type.Data();
1626   (*mergedFileFinalLYZ1PROD)+=".root";
1627   fileMergerLYZ1PROD->OutputFile(mergedFileFinalLYZ1PROD->Data());
1628   fileMergerLYZ1PROD->Merge();
1629   delete mergedFileFinalLYZ1PROD;
1630  } else if (fileCounterLYZ1PROD % cycle == 0)
1631    {
1632     TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
1633     (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
1634     (*mergedFileForPreviousCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle);
1635     (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
1636     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1PROD->Data(),kFileExists)))
1637     {
1638      TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
1639      (*mergedFileFinalLYZ1PROD)+=type.Data();
1640      (*mergedFileFinalLYZ1PROD)+=".root";
1641      gSystem->Rename(mergedFileForPreviousCycleLYZ1PROD->Data(),mergedFileFinalLYZ1PROD->Data());
1642     }
1643    } else
1644      {
1645       TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
1646       (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
1647       (*mergedFileForPreviousCycleLYZ1PROD)+=((Int_t)fileCounterLYZ1PROD/cycle);
1648       (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
1649
1650       fileMergerLYZ1PROD->AddFile(mergedFileForPreviousCycleLYZ1PROD->Data());
1651
1652       // delete merged output from previous cycle:
1653       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1PROD->Data(),gSystem->pwd());
1654       file->Delete();
1655       delete file;
1656
1657       TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
1658       (*mergedFileFinalLYZ1PROD)+=type.Data();
1659       (*mergedFileFinalLYZ1PROD)+=".root";
1660       fileMergerLYZ1PROD->OutputFile(mergedFileFinalLYZ1PROD->Data());
1661       fileMergerLYZ1PROD->Merge();
1662
1663       delete mergedFileForPreviousCycleLYZ1PROD;
1664       delete mergedFileFinalLYZ1PROD;
1665      }
1666
1667   // merging for subsets at the end of the day:
1668   gSystem->cd(baseDirPath->Data());
1669   if(devideOutputFilesInEqualSubsets)
1670   {
1671    if(fileCounterLastSubsetLYZ1PROD < cycle)
1672    {
1673     TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
1674     for(Int_t i=0;i<nSubsets;i++)
1675     {
1676      mergedFileFinalForSubsetLYZ1PROD[i]="subset";
1677      mergedFileFinalForSubsetLYZ1PROD[i]+=(i+1);
1678      mergedFileFinalForSubsetLYZ1PROD[i]+="/";
1679      mergedFileFinalForSubsetLYZ1PROD[i]+="mergedLYZ1PRODanalysis";
1680      mergedFileFinalForSubsetLYZ1PROD[i]+=type.Data();
1681      mergedFileFinalForSubsetLYZ1PROD[i]+=".root";
1682
1683      fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileFinalForSubsetLYZ1PROD[i].Data());
1684      fileMergerForSubsetsLYZ1PROD[i].Merge();
1685      fileMergerForSubsetsLYZ1PROD[i].Reset();
1686     } // end of for(Int_t i=0;i<nSubsets;i++)
1687    } else if (fileCounterLastSubsetLYZ1PROD % cycle == 0  && fileCounterLYZ1PROD % cycle == 0)
1688     {
1689      TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
1690      TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
1691      for(Int_t i=0;i<nSubsets;i++)
1692      {
1693       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
1694       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
1695       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
1696       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
1697       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle);
1698       mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
1699       // move and rename this file to subdirectory subset*:
1700       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
1701       TString *subdir = new TString("subset");
1702       (*subdir)+=(i+1);
1703       (*subdir)+="/";
1704       (*subdir)+="mergedLYZ1PRODanalysis";
1705       (*subdir)+=type.Data();
1706       (*subdir)+=".root";
1707       file->Move(subdir->Data());
1708       delete file;
1709       delete subdir;
1710      } // end of for(Int_t i=0;i<nSubsets;i++)
1711     } else
1712       {
1713        TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
1714        TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
1715        for(Int_t i=0;i<nSubsets;i++)
1716        {
1717         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
1718         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
1719         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
1720         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
1721         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=((Int_t)fileCounterLastSubsetLYZ1PROD/cycle);
1722         mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
1723
1724         fileMergerForSubsetsLYZ1PROD[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data());
1725
1726         // delete merged output from previous cycle:
1727         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
1728         file->Delete();
1729         delete file;
1730
1731         mergedFileFinalForSubsetLYZ1PROD[i]="subset";
1732         mergedFileFinalForSubsetLYZ1PROD[i]+=(i+1);
1733         mergedFileFinalForSubsetLYZ1PROD[i]+="/";
1734         mergedFileFinalForSubsetLYZ1PROD[i]+="mergedLYZ1PRODanalysis";
1735         mergedFileFinalForSubsetLYZ1PROD[i]+=type.Data();
1736         mergedFileFinalForSubsetLYZ1PROD[i]+=".root";
1737
1738         fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileFinalForSubsetLYZ1PROD[i].Data());
1739         fileMergerForSubsetsLYZ1PROD[i].Merge();
1740         fileMergerForSubsetsLYZ1PROD[i].Reset();
1741        } // end of for(Int_t i=0;i<nSubsets;i++)
1742       } // end of last else
1743   } // end of if(devideOutputFilesInEqualSubsets)
1744
1745  // LYZEP:
1746  if(fileCounterLYZEP < cycle)
1747  {
1748   TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
1749   (*mergedFileFinalLYZEP)+=type.Data();
1750   (*mergedFileFinalLYZEP)+=".root";
1751   fileMergerLYZEP->OutputFile(mergedFileFinalLYZEP->Data());
1752   fileMergerLYZEP->Merge();
1753   delete mergedFileFinalLYZEP;
1754  } else if (fileCounterLYZEP % cycle == 0)
1755    {
1756     TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
1757     (*mergedFileForPreviousCycleLYZEP)+=type.Data();
1758     (*mergedFileForPreviousCycleLYZEP)+=(fileCounterLYZEP/cycle);
1759     (*mergedFileForPreviousCycleLYZEP)+=".root";
1760     if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZEP->Data(),kFileExists)))
1761     {
1762      TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
1763      (*mergedFileFinalLYZEP)+=type.Data();
1764      (*mergedFileFinalLYZEP)+=".root";
1765      gSystem->Rename(mergedFileForPreviousCycleLYZEP->Data(),mergedFileFinalLYZEP->Data());
1766     }
1767    } else
1768      {
1769       TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
1770       (*mergedFileForPreviousCycleLYZEP)+=type.Data();
1771       (*mergedFileForPreviousCycleLYZEP)+=((Int_t)fileCounterLYZEP/cycle);
1772       (*mergedFileForPreviousCycleLYZEP)+=".root";
1773
1774       fileMergerLYZEP->AddFile(mergedFileForPreviousCycleLYZEP->Data());
1775
1776       // delete merged output from previous cycle:
1777       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZEP->Data(),gSystem->pwd());
1778       file->Delete();
1779       delete file;
1780
1781       TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
1782       (*mergedFileFinalLYZEP)+=type.Data();
1783       (*mergedFileFinalLYZEP)+=".root";
1784       fileMergerLYZEP->OutputFile(mergedFileFinalLYZEP->Data());
1785       fileMergerLYZEP->Merge();
1786
1787       delete mergedFileForPreviousCycleLYZEP;
1788       delete mergedFileFinalLYZEP;
1789      }
1790
1791   // merging for subsets at the end of the day:
1792   gSystem->cd(baseDirPath->Data());
1793   if(devideOutputFilesInEqualSubsets)
1794   {
1795    if(fileCounterLastSubsetLYZEP < cycle)
1796    {
1797     TString mergedFileFinalForSubsetLYZEP[nSubsets];
1798     for(Int_t i=0;i<nSubsets;i++)
1799     {
1800      mergedFileFinalForSubsetLYZEP[i]="subset";
1801      mergedFileFinalForSubsetLYZEP[i]+=(i+1);
1802      mergedFileFinalForSubsetLYZEP[i]+="/";
1803      mergedFileFinalForSubsetLYZEP[i]+="mergedLYZEPanalysis";
1804      mergedFileFinalForSubsetLYZEP[i]+=type.Data();
1805      mergedFileFinalForSubsetLYZEP[i]+=".root";
1806
1807      fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileFinalForSubsetLYZEP[i].Data());
1808      fileMergerForSubsetsLYZEP[i].Merge();
1809      fileMergerForSubsetsLYZEP[i].Reset();
1810     } // end of for(Int_t i=0;i<nSubsets;i++)
1811    } else if (fileCounterLastSubsetLYZEP % cycle == 0  && fileCounterLYZEP % cycle == 0)
1812     {
1813      TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
1814      TString mergedFileFinalForSubsetLYZEP[nSubsets];
1815      for(Int_t i=0;i<nSubsets;i++)
1816      {
1817       mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
1818       mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
1819       mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
1820       mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
1821       mergedFileForPreviousCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle);
1822       mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
1823       // move and rename this file to subdirectory subset*:
1824       TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
1825       TString *subdir = new TString("subset");
1826       (*subdir)+=(i+1);
1827       (*subdir)+="/";
1828       (*subdir)+="mergedLYZEPanalysis";
1829       (*subdir)+=type.Data();
1830       (*subdir)+=".root";
1831       file->Move(subdir->Data());
1832       delete file;
1833       delete subdir;
1834      } // end of for(Int_t i=0;i<nSubsets;i++)
1835     } else
1836       {
1837        TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
1838        TString mergedFileFinalForSubsetLYZEP[nSubsets];
1839        for(Int_t i=0;i<nSubsets;i++)
1840        {
1841         mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
1842         mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
1843         mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
1844         mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
1845         mergedFileForPreviousCycleForSubsetLYZEP[i]+=((Int_t)fileCounterLastSubsetLYZEP/cycle);
1846         mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
1847
1848         fileMergerForSubsetsLYZEP[i].AddFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data());
1849
1850         // delete merged output from previous cycle:
1851         TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
1852         file->Delete();
1853         delete file;
1854
1855         mergedFileFinalForSubsetLYZEP[i]="subset";
1856         mergedFileFinalForSubsetLYZEP[i]+=(i+1);
1857         mergedFileFinalForSubsetLYZEP[i]+="/";
1858         mergedFileFinalForSubsetLYZEP[i]+="mergedLYZEPanalysis";
1859         mergedFileFinalForSubsetLYZEP[i]+=type.Data();
1860         mergedFileFinalForSubsetLYZEP[i]+=".root";
1861
1862         fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileFinalForSubsetLYZEP[i].Data());
1863         fileMergerForSubsetsLYZEP[i].Merge();
1864         fileMergerForSubsetsLYZEP[i].Reset();
1865        } // end of for(Int_t i=0;i<nSubsets;i++)
1866       } // end of last else
1867   } // end of if(devideOutputFilesInEqualSubsets)
1868
1869  delete dirNameSubset;
1870  delete baseDirPath;
1871  delete baseDir;
1872
1873 } // end of void mergeOutput(TString type="", Int_t mode=mLocal)
1874
1875 void LoadLibrariesMO(const libModes mode) {
1876
1877   //--------------------------------------
1878   // Load the needed libraries most of them already loaded by aliroot
1879   //--------------------------------------
1880   gSystem->Load("libTree");
1881   gSystem->Load("libGeom");
1882   gSystem->Load("libVMC");
1883   gSystem->Load("libXMLIO");
1884   gSystem->Load("libPhysics");
1885
1886   //----------------------------------------------------------
1887   // >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
1888   //----------------------------------------------------------
1889   if (mode==mLocal) {
1890     //--------------------------------------------------------
1891     // If you want to use already compiled libraries
1892     // in the aliroot distribution
1893     //--------------------------------------------------------
1894
1895   //==================================================================================
1896   //load needed libraries:
1897   gSystem->AddIncludePath("-I$ROOTSYS/include");
1898   gSystem->Load("libTree");
1899
1900   // for AliRoot
1901   gSystem->AddIncludePath("-I$ALICE_ROOT/include");
1902   gSystem->Load("libANALYSIS");
1903   gSystem->Load("libPWG2flowCommon");
1904   //cerr<<"libPWG2flowCommon loaded ..."<<endl;
1905
1906   }
1907
1908   else if (mode==mLocalSource) {
1909
1910     // In root inline compile
1911
1912     // Constants
1913     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonConstants.cxx+");
1914     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZConstants.cxx+");
1915     gROOT->LoadMacro("AliFlowCommon/AliFlowCumuConstants.cxx+");
1916
1917     // Flow event
1918     gROOT->LoadMacro("AliFlowCommon/AliFlowVector.cxx+");
1919     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimple.cxx+");
1920     gROOT->LoadMacro("AliFlowCommon/AliFlowEventSimple.cxx+");
1921
1922     // Cuts
1923     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimpleCuts.cxx+");
1924
1925     // Output histosgrams
1926     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHist.cxx+");
1927     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHistResults.cxx+");
1928     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist1.cxx+");
1929     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist2.cxx+");
1930
1931     cout << "finished loading macros!" << endl;
1932
1933   } // end of else if (mode==mLocalSource)
1934
1935 } // end of void LoadLibrariesMO(const libModes mode)