PWG2/FLOW/macros/showSpread.C

   1 enum libModes {mLocal,mLocalSource};
   2
   3 void showSpread(TString type="", Int_t mode=mLocal)
   4 {
   5  // type:  type of analysis can be ESD, AOD, MC, ESDMC0, ESDMC1
   6  //        (if type="" output files are from MC simulation (default))
   7  // mode:  if mode=mLocal analyze data on your computer using aliroot
   8  //        if mode=mLocalSource analyze data on your computer using root + source files
   9
  10  Bool_t plotLegend = kTRUE; // plot legend on the plot
  11
  12  // load needed libraries:
  13  LoadSpreadLibraries(mode);
  14
  15  // access the path of current directory:
  16  TString pwd(gSystem->pwd());
  17  pwd+="/";
  18
  19  // standard magic:
  20  TString execDir(gSystem->pwd());
  21  TSystemDirectory* baseDir = new TSystemDirectory(".",execDir.Data());
  22  TList* dirList = baseDir->GetListOfFiles();
  23  Int_t nDirs = dirList->GetEntries();
  24  gSystem->cd(execDir);
  25
  26  Int_t countDirectories = 0; // count all directories except the ones with merged results
  27  Int_t countMergedSubsets = 0; // count only directories with merged results (name is subset*)
  28  if(dirList)
  29  {
  30   for(Int_t i=0;i<nDirs;i++)
  31   {
  32    if((dirList->At(i))->InheritsFrom("TSystemDirectory") &&
  33       !(strcmp((dirList->At(i))->GetName(),".") == 0 ) &&
  34       !(strcmp((dirList->At(i))->GetName(),"..") == 0 ))
  35    {
  36     TSystemFile *presentFile = (TSystemFile*)dirList->At(i);
  37     TString presentFileName(gSystem->pwd());
  38     (presentFileName+="/")+=presentFile->GetName();
  39     if(presentFileName.Contains("subset"))
  40     {
  41      countMergedSubsets++;
  42     } else
  43       {
  44        countDirectories++;
  45       }
  46    }
  47   } // end of for(Int_t i=0;i<nDirs;i++)
  48  } // end of if(dirList)
  49
  50  // assigning bin numbers to methods:
  51  Int_t binMCEP = 1;
  52  Int_t binSP = 2;
  53  Int_t binGFC2 = 3;
  54  Int_t binGFC4 = 5;
  55  Int_t binGFC6 = 7;
  56  Int_t binGFC8 = 9;
  57  Int_t binQC2 = 4;
  58  Int_t binQC4 = 6;
  59  Int_t binQC6 = 8;
  60  Int_t binQC8 = 10;
  61  Int_t binFQD = 11;
  62  Int_t binLYZ1SUM = 12;
  63  Int_t binLYZ1PROD = 13;
  64  Int_t binLYZEP = 14;
  65
  66  // option A: one subdirectory gives one estimate for each method (merged subsets ignored):
  67  const Int_t nEstimates = countDirectories;
  68
  69  // option B: one merged subset give one estimate for each method
  70  const Int_t nSubsets = countMergedSubsets;
  71
  72  if(nSubsets == 0)
  73  {
  74   // arrays to store estimates and errors of each method from different small statistics runs:
  75   // MCEP:
  76   Double_t mcepValueNONAME[nEstimates] = {0.};
  77   Double_t mcepErrorNONAME[nEstimates] = {0.};
  78   Double_t mcepMaxValueNONAME = 0.; // to be improved
  79   Double_t mcepMinValueNONAME = 1000.; // to be improved
  80
  81   // SP:
  82   Double_t spValueNONAME[nEstimates] = {0.};
  83   Double_t spErrorNONAME[nEstimates] = {0.};
  84   Double_t spMaxValueNONAME = 0.; // to be improved
  85   Double_t spMinValueNONAME = 1000.; // to be improved
  86
  87   // GFC{2}:
  88   Double_t gfc2ValueNONAME[nEstimates] = {0.};
  89   Double_t gfc2ErrorNONAME[nEstimates] = {0.};
  90   Double_t gfc2MaxValueNONAME = 0.; // to be improved
  91   Double_t gfc2MinValueNONAME = 1000.; // to be improved
  92
  93   // GFC{4}:
  94   Double_t gfc4ValueNONAME[nEstimates] = {0.};
  95   Double_t gfc4ErrorNONAME[nEstimates] = {0.};
  96   Double_t gfc4MaxValueNONAME = 0.; // to be improved
  97   Double_t gfc4MinValueNONAME = 1000.; // to be improved
  98
  99   // GFC{6}:
 100   Double_t gfc6ValueNONAME[nEstimates] = {0.};
 101   Double_t gfc6ErrorNONAME[nEstimates] = {0.};
 102   Double_t gfc6MaxValueNONAME = 0.; // to be improved
 103   Double_t gfc6MinValueNONAME = 1000.; // to be improved
 104
 105   // GFC{8}:
 106   Double_t gfc8ValueNONAME[nEstimates] = {0.};
 107   Double_t gfc8ErrorNONAME[nEstimates] = {0.};
 108   Double_t gfc8MaxValueNONAME = 0.; // to be improved
 109   Double_t gfc8MinValueNONAME = 1000.; // to be improved
 110
 111   // QC{2}:
 112   Double_t qc2ValueNONAME[nEstimates] = {0.};
 113   Double_t qc2ErrorNONAME[nEstimates] = {0.};
 114   Double_t qc2MaxValueNONAME = 0.; // to be improved
 115   Double_t qc2MinValueNONAME = 1000.; // to be improved
 116
 117   // QC{4}:
 118   Double_t qc4ValueNONAME[nEstimates] = {0.};
 119   Double_t qc4ErrorNONAME[nEstimates] = {0.};
 120   Double_t qc4MaxValueNONAME = 0.; // to be improved
 121   Double_t qc4MinValueNONAME = 1000.; // to be improved
 122
 123   // QC{6}:
 124   Double_t qc6ValueNONAME[nEstimates] = {0.};
 125   Double_t qc6ErrorNONAME[nEstimates] = {0.};
 126   Double_t qc6MaxValueNONAME = 0.; // to be improved
 127   Double_t qc6MinValueNONAME = 1000.; // to be improved
 128
 129   // QC{8}:
 130   Double_t qc8ValueNONAME[nEstimates] = {0.};
 131   Double_t qc8ErrorNONAME[nEstimates] = {0.};
 132   Double_t qc8MaxValueNONAME = 0.; // to be improved
 133   Double_t qc8MinValueNONAME = 1000.; // to be improved
 134
 135   // FQD:
 136   Double_t fqdValueNONAME[nEstimates] = {0.};
 137   Double_t fqdErrorNONAME[nEstimates] = {0.};
 138   Double_t fqdMaxValueNONAME = 0.; // to be improved
 139   Double_t fqdMinValueNONAME = 1000.; // to be improved
 140
 141   // LYZ1SUM:
 142   Double_t lyz1sumValueNONAME[nEstimates] = {0.};
 143   Double_t lyz1sumErrorNONAME[nEstimates] = {0.};
 144   Double_t lyz1sumMaxValueNONAME = 0.; // to be improved
 145   Double_t lyz1sumMinValueNONAME = 1000.; // to be improved
 146
 147   // LYZ1PROD:
 148   Double_t lyz1prodValueNONAME[nEstimates] = {0.};
 149   Double_t lyz1prodErrorNONAME[nEstimates] = {0.};
 150   Double_t lyz1prodMaxValueNONAME = 0.; // to be improved
 151   Double_t lyz1prodMinValueNONAME = 1000.; // to be improved
 152
 153   // LYZEP:
 154   Double_t lyzepValueNONAME[nEstimates] = {0.};
 155   Double_t lyzepErrorNONAME[nEstimates] = {0.};
 156   Double_t lyzepMaxValueNONAME = 0.; // to be improved
 157   Double_t lyzepMinValueNONAME = 1000.; // to be improved
 158
 159   Int_t countFilesMCEP = 0;
 160   Int_t countFilesSP = 0;
 161   Int_t countFilesGFC = 0;
 162   Int_t countFilesQC = 0;
 163   Int_t countFilesFQD = 0;
 164   Int_t countFilesLYZ1SUM = 0;
 165   Int_t countFilesLYZ1PROD = 0;
 166   Int_t countFilesLYZEP = 0;
 167
 168   for(Int_t iDir=0;iDir<nDirs;++iDir)
 169   {
 170    TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir);
 171    if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 ||
 172      strcmp(presentDir->GetName(), "..") == 0) continue;
 173
 174    TString presentDirName(gSystem->pwd());
 175    presentDirName += "/";
 176    presentDirName += presentDir->GetName();
 177    presentDirName += "/";
 178
 179    // accessing the small statistics output .root files for each method:
 180    // MCEP:
 181    TString fileNameMCEP = presentDirName;
 182    fileNameMCEP+="outputMCEPanalysis";
 183    (fileNameMCEP+=type.Data())+=".root";
 184    TFile *fileMCEP = TFile::Open(fileNameMCEP.Data(), "READ");
 185    if(fileMCEP)
 186    {
 187     TList *listMCEP = NULL;
 188     AliFlowCommonHistResults *mcepCommonHistRes = NULL;
 189     fileMCEP->GetObject("cobjMCEP",listMCEP);
 190     fileMCEP->Close();
 191     if(listMCEP)
 192     {
 193      mcepCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
 194      if(mcepCommonHistRes && mcepCommonHistRes->GetHistIntFlow())
 195      {
 196       mcepValueNONAME[countFilesMCEP] = (mcepCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 197       mcepErrorNONAME[countFilesMCEP] = (mcepCommonHistRes->GetHistIntFlow())->GetBinError(1);
 198       if(mcepValueNONAME[countFilesMCEP]>=0.) // to be improved
 199       {
 200        if(mcepMaxValueNONAME < mcepValueNONAME[countFilesMCEP]) mcepMaxValueNONAME = mcepValueNONAME[countFilesMCEP];
 201        if(mcepMinValueNONAME > mcepValueNONAME[countFilesMCEP]) mcepMinValueNONAME = mcepValueNONAME[countFilesMCEP];
 202       }
 203      }
 204      countFilesMCEP++;
 205     } // end of if(listMCEP)
 206    } // end of if(fileMCEP)
 207
 208    // SP:
 209    TString fileNameSP = presentDirName;
 210    fileNameSP+="outputSPanalysis";
 211    (fileNameSP+=type.Data())+=".root";
 212    TFile *fileSP = TFile::Open(fileNameSP.Data(), "READ");
 213    if(fileSP)
 214    {
 215     TList *listSP = NULL;
 216     AliFlowCommonHistResults *spCommonHistRes = NULL;
 217     fileSP->GetObject("cobjSP",listSP);
 218     fileSP->Close();
 219     if(listSP)
 220     {
 221      spCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listSP->FindObject("AliFlowCommonHistResultsSP"));
 222      if(spCommonHistRes && spCommonHistRes->GetHistIntFlow())
 223      {
 224       spValueNONAME[countFilesSP] = (spCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 225       spErrorNONAME[countFilesSP] = (spCommonHistRes->GetHistIntFlow())->GetBinError(1);
 226       if(spValueNONAME[countFilesSP]>=0.) // to be improved
 227       {
 228        if(spMaxValueNONAME < spValueNONAME[countFilesSP]) spMaxValueNONAME = spValueNONAME[countFilesSP];
 229        if(spMinValueNONAME > spValueNONAME[countFilesSP]) spMinValueNONAME = spValueNONAME[countFilesSP];
 230       }
 231      }
 232      countFilesSP++;
 233     } // end of if(listSP)
 234    } // end of if(fileSP)
 235
 236    // GFC:
 237    TString fileNameGFC = presentDirName;
 238    fileNameGFC+="outputGFCanalysis";
 239    (fileNameGFC+=type.Data())+=".root";
 240    TFile *fileGFC = TFile::Open(fileNameGFC.Data(), "READ");
 241    if(fileGFC)
 242    {
 243     TList *listGFC = NULL;
 244     AliFlowCommonHistResults *gfc2CommonHistRes = NULL;
 245     AliFlowCommonHistResults *gfc4CommonHistRes = NULL;
 246     AliFlowCommonHistResults *gfc6CommonHistRes = NULL;
 247     AliFlowCommonHistResults *gfc8CommonHistRes = NULL;
 248     fileGFC->GetObject("cobjGFC",listGFC);
 249     fileGFC->Close();
 250     if(listGFC)
 251     {
 252      gfc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
 253      gfc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
 254      gfc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
 255      gfc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
 256      if(gfc2CommonHistRes && gfc2CommonHistRes->GetHistIntFlow())
 257      {
 258       gfc2ValueNONAME[countFilesGFC] = (gfc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 259       gfc2ErrorNONAME[countFilesGFC] = (gfc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
 260       if(gfc2ValueNONAME[countFilesGFC]>=0.) // to be improved
 261       {
 262        if(gfc2MaxValueNONAME < gfc2ValueNONAME[countFilesGFC]) gfc2MaxValueNONAME = gfc2ValueNONAME[countFilesGFC];
 263        if(gfc2MinValueNONAME > gfc2ValueNONAME[countFilesGFC]) gfc2MinValueNONAME = gfc2ValueNONAME[countFilesGFC];
 264       }
 265      }
 266      if(gfc4CommonHistRes && gfc4CommonHistRes->GetHistIntFlow())
 267      {
 268       gfc4ValueNONAME[countFilesGFC] = (gfc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 269       gfc4ErrorNONAME[countFilesGFC] = (gfc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
 270       if(gfc4ValueNONAME[countFilesGFC]>=0.) // to be improved
 271       {
 272        if(gfc4MaxValueNONAME < gfc4ValueNONAME[countFilesGFC]) gfc4MaxValueNONAME = gfc4ValueNONAME[countFilesGFC];
 273        if(gfc4MinValueNONAME > gfc4ValueNONAME[countFilesGFC]) gfc4MinValueNONAME = gfc4ValueNONAME[countFilesGFC];
 274       }
 275      }
 276      if(gfc6CommonHistRes && gfc6CommonHistRes->GetHistIntFlow())
 277      {
 278       gfc6ValueNONAME[countFilesGFC] = (gfc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 279       gfc6ErrorNONAME[countFilesGFC] = (gfc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
 280       if(gfc6ValueNONAME[countFilesGFC]>=0.) // to be improved
 281       {
 282        if(gfc6MaxValueNONAME < gfc6ValueNONAME[countFilesGFC]) gfc6MaxValueNONAME = gfc6ValueNONAME[countFilesGFC];
 283        if(gfc6MinValueNONAME > gfc6ValueNONAME[countFilesGFC]) gfc6MinValueNONAME = gfc6ValueNONAME[countFilesGFC];
 284       }
 285      }
 286      if(gfc8CommonHistRes && gfc8CommonHistRes->GetHistIntFlow())
 287      {
 288       gfc8ValueNONAME[countFilesGFC] = (gfc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 289       gfc8ErrorNONAME[countFilesGFC] = (gfc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
 290       if(gfc8ValueNONAME[countFilesGFC]>=0.) // to be improved
 291       {
 292        if(gfc8MaxValueNONAME < gfc8ValueNONAME[countFilesGFC]) gfc8MaxValueNONAME = gfc8ValueNONAME[countFilesGFC];
 293        if(gfc8MinValueNONAME > gfc8ValueNONAME[countFilesGFC]) gfc8MinValueNONAME = gfc8ValueNONAME[countFilesGFC];
 294       }
 295      }
 296      countFilesGFC++;
 297     } // end of if(listGFC)
 298    } // end of if(fileGFC)
 299
 300    // QC:
 301    TString fileNameQC = presentDirName;
 302    fileNameQC+="outputQCanalysis";
 303    (fileNameQC+=type.Data())+=".root";
 304    TFile *fileQC = TFile::Open(fileNameQC.Data(), "READ");
 305    if(fileQC)
 306    {
 307     TList *listQC = NULL;
 308     AliFlowCommonHistResults *qc2CommonHistRes = NULL;
 309     AliFlowCommonHistResults *qc4CommonHistRes = NULL;
 310     AliFlowCommonHistResults *qc6CommonHistRes = NULL;
 311     AliFlowCommonHistResults *qc8CommonHistRes = NULL;
 312     fileQC->GetObject("cobjQC",listQC);
 313     fileQC->Close();
 314     if(listQC)
 315     {
 316      qc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
 317      qc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
 318      qc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
 319      qc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
 320      if(qc2CommonHistRes && qc2CommonHistRes->GetHistIntFlow())
 321      {
 322       qc2ValueNONAME[countFilesQC] = (qc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 323       qc2ErrorNONAME[countFilesQC] = (qc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
 324       if(qc2ValueNONAME[countFilesQC]>=0.) // to be improved
 325       {
 326        if(qc2MaxValueNONAME < qc2ValueNONAME[countFilesQC]) qc2MaxValueNONAME = qc2ValueNONAME[countFilesQC];
 327        if(qc2MinValueNONAME > qc2ValueNONAME[countFilesQC]) qc2MinValueNONAME = qc2ValueNONAME[countFilesQC];
 328       }
 329      }
 330      if(qc4CommonHistRes && qc4CommonHistRes->GetHistIntFlow())
 331      {
 332       qc4ValueNONAME[countFilesQC] = (qc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 333       qc4ErrorNONAME[countFilesQC] = (qc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
 334       if(qc4ValueNONAME[countFilesQC]>=0.) // to be improved
 335       {
 336        if(qc4MaxValueNONAME < qc4ValueNONAME[countFilesQC]) qc4MaxValueNONAME = qc4ValueNONAME[countFilesQC];
 337        if(qc4MinValueNONAME > qc4ValueNONAME[countFilesQC]) qc4MinValueNONAME = qc4ValueNONAME[countFilesQC];
 338       }
 339      }
 340      if(qc6CommonHistRes && qc6CommonHistRes->GetHistIntFlow())
 341      {
 342       qc6ValueNONAME[countFilesQC] = (qc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 343       qc6ErrorNONAME[countFilesQC] = (qc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
 344       if(qc6ValueNONAME[countFilesQC]>=0.) // to be improved
 345       {
 346        if(qc6MaxValueNONAME < qc6ValueNONAME[countFilesQC]) qc6MaxValueNONAME = qc6ValueNONAME[countFilesQC];
 347        if(qc6MinValueNONAME > qc6ValueNONAME[countFilesQC]) qc6MinValueNONAME = qc6ValueNONAME[countFilesQC];
 348       }
 349      }
 350      if(qc8CommonHistRes && qc8CommonHistRes->GetHistIntFlow())
 351      {
 352       qc8ValueNONAME[countFilesQC] = (qc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 353       qc8ErrorNONAME[countFilesQC] = (qc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
 354       if(qc8ValueNONAME[countFilesQC]>=0.) // to be improved
 355       {
 356        if(qc8MaxValueNONAME < qc8ValueNONAME[countFilesQC]) qc8MaxValueNONAME = qc8ValueNONAME[countFilesQC];
 357        if(qc8MinValueNONAME > qc8ValueNONAME[countFilesQC]) qc8MinValueNONAME = qc8ValueNONAME[countFilesQC];
 358       }
 359      }
 360      countFilesQC++;
 361     } // end of if(listQC)
 362    } // end of if(fileQC)
 363
 364    // FQD:
 365    TString fileNameFQD = presentDirName;
 366    fileNameFQD+="outputFQDanalysis";
 367    (fileNameFQD+=type.Data())+=".root";
 368    TFile *fileFQD = TFile::Open(fileNameFQD.Data(), "READ");
 369    if(fileFQD)
 370    {
 371     TList *listFQD = NULL;
 372     AliFlowCommonHistResults *fqdCommonHistRes = NULL;
 373     fileFQD->GetObject("cobjFQD",listFQD);
 374     fileFQD->Close();
 375     if(listFQD)
 376     {
 377      fqdCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listFQD->FindObject("AliFlowCommonHistResultsFQD"));
 378      if(fqdCommonHistRes && fqdCommonHistRes->GetHistIntFlow())
 379      {
 380       fqdValueNONAME[countFilesFQD] = (fqdCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 381       fqdErrorNONAME[countFilesFQD] = (fqdCommonHistRes->GetHistIntFlow())->GetBinError(1);
 382       if(fqdValueNONAME[countFilesFQD]>=0.) // to be improved
 383       {
 384        if(fqdMaxValueNONAME < fqdValueNONAME[countFilesFQD]) fqdMaxValueNONAME = fqdValueNONAME[countFilesFQD];
 385        if(fqdMinValueNONAME > fqdValueNONAME[countFilesFQD]) fqdMinValueNONAME = fqdValueNONAME[countFilesFQD];
 386       }
 387      }
 388      countFilesFQD++;
 389     } // end of if(listFQD)
 390    } // end of if(fileFQD)
 391
 392    // LYZ1SUM:
 393    TString fileNameLYZ1SUM = presentDirName;
 394    fileNameLYZ1SUM+="outputLYZ1SUManalysis";
 395    (fileNameLYZ1SUM+=type.Data())+=".root";
 396    TFile *fileLYZ1SUM = TFile::Open(fileNameLYZ1SUM.Data(), "READ");
 397    if(fileLYZ1SUM)
 398    {
 399     TList *listLYZ1SUM = NULL;
 400     AliFlowCommonHistResults *lyz1sumCommonHistRes = NULL;
 401     fileLYZ1SUM->GetObject("cobjLYZ1SUM",listLYZ1SUM);
 402     fileLYZ1SUM->Close();
 403     if(listLYZ1SUM)
 404     {
 405      lyz1sumCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listLYZ1SUM->FindObject("AliFlowCommonHistResultsLYZ1SUM"));
 406      if(lyz1sumCommonHistRes && lyz1sumCommonHistRes->GetHistIntFlow())
 407      {
 408       lyz1sumValueNONAME[countFilesLYZ1SUM] = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 409       lyz1sumErrorNONAME[countFilesLYZ1SUM] = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinError(1);
 410       if(lyz1sumValueNONAME[countFilesLYZ1SUM]>=0.) // to be improved
 411       {
 412        if(lyz1sumMaxValueNONAME < lyz1sumValueNONAME[countFilesLYZ1SUM]) lyz1sumMaxValueNONAME = lyz1sumValueNONAME[countFilesLYZ1SUM];
 413        if(lyz1sumMinValueNONAME > lyz1sumValueNONAME[countFilesLYZ1SUM]) lyz1sumMinValueNONAME = lyz1sumValueNONAME[countFilesLYZ1SUM];
 414       }
 415      }
 416      countFilesLYZ1SUM++;
 417     } // end of if(listLYZ1SUM)
 418    } // end of if(fileLYZ1SUM)
 419
 420    // LYZ1PROD:
 421    TString fileNameLYZ1PROD = presentDirName;
 422    fileNameLYZ1PROD+="outputLYZ1PRODanalysis";
 423    (fileNameLYZ1PROD+=type.Data())+=".root";
 424    TFile *fileLYZ1PROD = TFile::Open(fileNameLYZ1PROD.Data(), "READ");
 425    if(fileLYZ1PROD)
 426    {
 427     TList *listLYZ1PROD = NULL;
 428     AliFlowCommonHistResults *lyz1prodCommonHistRes = NULL;
 429     fileLYZ1PROD->GetObject("cobjLYZ1PROD",listLYZ1PROD);
 430     fileLYZ1PROD->Close();
 431     if(listLYZ1PROD)
 432     {
 433      lyz1prodCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listLYZ1PROD->FindObject("AliFlowCommonHistResultsLYZ1PROD"));
 434      if(lyz1prodCommonHistRes && lyz1prodCommonHistRes->GetHistIntFlow())
 435      {
 436       lyz1prodValueNONAME[countFilesLYZ1PROD] = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 437       lyz1prodErrorNONAME[countFilesLYZ1PROD] = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinError(1);
 438       if(lyz1prodValueNONAME[countFilesLYZ1PROD]>=0.) // to be improved
 439       {
 440        if(lyz1prodMaxValueNONAME < lyz1prodValueNONAME[countFilesLYZ1PROD]) lyz1prodMaxValueNONAME = lyz1prodValueNONAME[countFilesLYZ1PROD];
 441        if(lyz1prodMinValueNONAME > lyz1prodValueNONAME[countFilesLYZ1PROD]) lyz1prodMinValueNONAME = lyz1prodValueNONAME[countFilesLYZ1PROD];
 442       }
 443      }
 444      countFilesLYZ1PROD++;
 445     } // end of if(listLYZ1PROD)
 446    } // end of if(fileLYZ1PROD)
 447
 448   } // end of for(Int_t iDir=0;iDir<nDirs;++iDir)
 449  } else if(nSubsets > 0)
 450  {
 451   // arrays to store estimates and errors of each method from merged subsets:
 452   // MCEP:
 453   Double_t mcepValueNONAME[nSubsets] = {0.};
 454   Double_t mcepErrorNONAME[nSubsets] = {0.};
 455   Double_t mcepMaxValueNONAME = 0.; // to be improved
 456   Double_t mcepMinValueNONAME = 1000.; // to be improved
 457
 458   // SP:
 459   Double_t spValueNONAME[nSubsets] = {0.};
 460   Double_t spErrorNONAME[nSubsets] = {0.};
 461   Double_t spMaxValueNONAME = 0.; // to be improved
 462   Double_t spMinValueNONAME = 1000.; // to be improved
 463
 464   // GFC{2}:
 465   Double_t gfc2ValueNONAME[nSubsets] = {0.};
 466   Double_t gfc2ErrorNONAME[nSubsets] = {0.};
 467   Double_t gfc2MaxValueNONAME = 0.; // to be improved
 468   Double_t gfc2MinValueNONAME = 1000.; // to be improved
 469
 470   // GFC{4}:
 471   Double_t gfc4ValueNONAME[nSubsets] = {0.};
 472   Double_t gfc4ErrorNONAME[nSubsets] = {0.};
 473   Double_t gfc4MaxValueNONAME = 0.; // to be improved
 474   Double_t gfc4MinValueNONAME = 1000.; // to be improved
 475
 476   // GFC{6}:
 477   Double_t gfc6ValueNONAME[nSubsets] = {0.};
 478   Double_t gfc6ErrorNONAME[nSubsets] = {0.};
 479   Double_t gfc6MaxValueNONAME = 0.; // to be improved
 480   Double_t gfc6MinValueNONAME = 1000.; // to be improved
 481
 482   // GFC{8}:
 483   Double_t gfc8ValueNONAME[nSubsets] = {0.};
 484   Double_t gfc8ErrorNONAME[nSubsets] = {0.};
 485   Double_t gfc8MaxValueNONAME = 0.; // to be improved
 486   Double_t gfc8MinValueNONAME = 1000.; // to be improved
 487
 488   // QC{2}:
 489   Double_t qc2ValueNONAME[nSubsets] = {0.};
 490   Double_t qc2ErrorNONAME[nSubsets] = {0.};
 491   Double_t qc2MaxValueNONAME = 0.; // to be improved
 492   Double_t qc2MinValueNONAME = 1000.; // to be improved
 493
 494   // QC{4}:
 495   Double_t qc4ValueNONAME[nSubsets] = {0.};
 496   Double_t qc4ErrorNONAME[nSubsets] = {0.};
 497   Double_t qc4MaxValueNONAME = 0.; // to be improved
 498   Double_t qc4MinValueNONAME = 1000.; // to be improved
 499
 500   // QC{6}:
 501   Double_t qc6ValueNONAME[nSubsets] = {0.};
 502   Double_t qc6ErrorNONAME[nSubsets] = {0.};
 503   Double_t qc6MaxValueNONAME = 0.; // to be improved
 504   Double_t qc6MinValueNONAME = 1000.; // to be improved
 505
 506   // QC{8}:
 507   Double_t qc8ValueNONAME[nSubsets] = {0.};
 508   Double_t qc8ErrorNONAME[nSubsets] = {0.};
 509   Double_t qc8MaxValueNONAME = 0.; // to be improved
 510   Double_t qc8MinValueNONAME = 1000.; // to be improved
 511
 512   // FQD:
 513   Double_t fqdValueNONAME[nSubsets] = {0.};
 514   Double_t fqdErrorNONAME[nSubsets] = {0.};
 515   Double_t fqdMaxValueNONAME = 0.; // to be improved
 516   Double_t fqdMinValueNONAME = 1000.; // to be improved
 517
 518   // LYZ1SUM:
 519   Double_t lyz1sumValueNONAME[nSubsets] = {0.};
 520   Double_t lyz1sumErrorNONAME[nSubsets] = {0.};
 521   Double_t lyz1sumMaxValueNONAME = 0.; // to be improved
 522   Double_t lyz1sumMinValueNONAME = 1000.; // to be improved
 523
 524   // LYZ1PROD:
 525   Double_t lyz1prodValueNONAME[nSubsets] = {0.};
 526   Double_t lyz1prodErrorNONAME[nSubsets] = {0.};
 527   Double_t lyz1prodMaxValueNONAME = 0.; // to be improved
 528   Double_t lyz1prodMinValueNONAME = 1000.; // to be improved
 529
 530   // LYZEP:
 531   Double_t lyzepValueNONAME[nSubsets] = {0.};
 532   Double_t lyzepErrorNONAME[nSubsets] = {0.};
 533   Double_t lyzepMaxValueNONAME = 0.; // to be improved
 534   Double_t lyzepMinValueNONAME = 1000.; // to be improved
 535
 536   Int_t countFilesMCEP = 0;
 537   Int_t countFilesSP = 0;
 538   Int_t countFilesGFC = 0;
 539   Int_t countFilesQC = 0;
 540   Int_t countFilesFQD = 0;
 541   Int_t countFilesLYZ1SUM = 0;
 542   Int_t countFilesLYZ1PROD = 0;
 543   Int_t countFilesLYZEP = 0;
 544
 545   for(Int_t iDir=0;iDir<nDirs;iDir++)
 546   {
 547    TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir);
 548    if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 ||
 549      strcmp(presentDir->GetName(), "..") == 0) continue;
 550
 551    TString presentDirName(gSystem->pwd());
 552    presentDirName += "/";
 553    presentDirName += presentDir->GetName();
 554    presentDirName += "/";
 555
 556    if(!(presentDirName.Contains("subset"))) continue;
 557
 558    // accessing the output *.root files from merged subsets for each method:
 559    // MCEP:
 560    TString fileNameMCEP = gSystem->pwd();
 561    fileNameMCEP+="/";
 562    fileNameMCEP+=presentDir->GetName();
 563    fileNameMCEP+="/";
 564    fileNameMCEP+="outputMCEPanalysis";
 565    (fileNameMCEP+=type.Data())+=".root";
 566    TFile *fileMCEP = TFile::Open(fileNameMCEP.Data(), "READ");
 567    if(fileMCEP)
 568    {
 569     TList *listMCEP = NULL;
 570     AliFlowCommonHistResults *mcepCommonHistRes = NULL;
 571     fileMCEP->GetObject("cobjMCEP",listMCEP);
 572     fileMCEP->Close();
 573     if(listMCEP)
 574     {
 575      mcepCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
 576      if(mcepCommonHistRes && mcepCommonHistRes->GetHistIntFlow())
 577      {
 578       mcepValueNONAME[countFilesMCEP] = (mcepCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 579       mcepErrorNONAME[countFilesMCEP] = (mcepCommonHistRes->GetHistIntFlow())->GetBinError(1);
 580       if(mcepValueNONAME[countFilesMCEP]>=0.) // to be improved
 581       {
 582        if(mcepMaxValueNONAME < mcepValueNONAME[countFilesMCEP]) mcepMaxValueNONAME = mcepValueNONAME[countFilesMCEP];
 583        if(mcepMinValueNONAME > mcepValueNONAME[countFilesMCEP]) mcepMinValueNONAME = mcepValueNONAME[countFilesMCEP];
 584       }
 585        countFilesMCEP++;
 586      }
 587     } // end of if(listMCEP)
 588    } // end of if(fileMCEP)
 589
 590    // SP:
 591    TString fileNameSP = gSystem->pwd();
 592    fileNameSP+="/";
 593    fileNameSP+=presentDir->GetName();
 594    fileNameSP+="/";
 595    fileNameSP+="outputSPanalysis";
 596    (fileNameSP+=type.Data())+=".root";
 597    TFile *fileSP = TFile::Open(fileNameSP.Data(), "READ");
 598    if(fileSP)
 599    {
 600     TList *listSP = NULL;
 601     AliFlowCommonHistResults *spCommonHistRes = NULL;
 602     fileSP->GetObject("cobjSP",listSP);
 603     fileSP->Close();
 604     if(listSP)
 605     {
 606      spCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listSP->FindObject("AliFlowCommonHistResultsSP"));
 607      if(spCommonHistRes && spCommonHistRes->GetHistIntFlow())
 608      {
 609       spValueNONAME[countFilesSP] = (spCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 610       spErrorNONAME[countFilesSP] = (spCommonHistRes->GetHistIntFlow())->GetBinError(1);
 611       if(spValueNONAME[countFilesSP]>=0.) // to be improved
 612       {
 613        if(spMaxValueNONAME < spValueNONAME[countFilesSP]) spMaxValueNONAME = spValueNONAME[countFilesSP];
 614        if(spMinValueNONAME > spValueNONAME[countFilesSP]) spMinValueNONAME = spValueNONAME[countFilesSP];
 615       }
 616       countFilesSP++;
 617      }
 618     } // end of if(listSP)
 619    } // end of if(fileSP)
 620
 621    // GFC:
 622    TString fileNameGFC = gSystem->pwd();
 623    fileNameGFC+="/";
 624    fileNameGFC+=presentDir->GetName();
 625    fileNameGFC+="/";
 626    fileNameGFC+="outputGFCanalysis";
 627    (fileNameGFC+=type.Data())+=".root";
 628    TFile *fileGFC = TFile::Open(fileNameGFC.Data(), "READ");
 629    if(fileGFC)
 630    {
 631     TList *listGFC = NULL;
 632     AliFlowCommonHistResults *gfc2CommonHistRes = NULL;
 633     AliFlowCommonHistResults *gfc4CommonHistRes = NULL;
 634     AliFlowCommonHistResults *gfc6CommonHistRes = NULL;
 635     AliFlowCommonHistResults *gfc8CommonHistRes = NULL;
 636     fileGFC->GetObject("cobjGFC",listGFC);
 637     fileGFC->Close();
 638     if(listGFC)
 639     {
 640      gfc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
 641      gfc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
 642      gfc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
 643      gfc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
 644      if(gfc2CommonHistRes && gfc2CommonHistRes->GetHistIntFlow())
 645      {
 646       gfc2ValueNONAME[countFilesGFC] = (gfc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 647       gfc2ErrorNONAME[countFilesGFC] = (gfc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
 648       if(gfc2ValueNONAME[countFilesGFC]>=0.) // to be improved
 649       {
 650        if(gfc2MaxValueNONAME < gfc2ValueNONAME[countFilesGFC]) gfc2MaxValueNONAME = gfc2ValueNONAME[countFilesGFC];
 651        if(gfc2MinValueNONAME > gfc2ValueNONAME[countFilesGFC]) gfc2MinValueNONAME = gfc2ValueNONAME[countFilesGFC];
 652       }
 653      }
 654      if(gfc4CommonHistRes && gfc4CommonHistRes->GetHistIntFlow())
 655      {
 656       gfc4ValueNONAME[countFilesGFC] = (gfc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 657       gfc4ErrorNONAME[countFilesGFC] = (gfc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
 658       if(gfc4ValueNONAME[countFilesGFC]>=0.) // to be improved
 659       {
 660        if(gfc4MaxValueNONAME < gfc4ValueNONAME[countFilesGFC]) gfc4MaxValueNONAME = gfc4ValueNONAME[countFilesGFC];
 661        if(gfc4MinValueNONAME > gfc4ValueNONAME[countFilesGFC]) gfc4MinValueNONAME = gfc4ValueNONAME[countFilesGFC];
 662       }
 663      }
 664      if(gfc6CommonHistRes && gfc6CommonHistRes->GetHistIntFlow())
 665      {
 666       gfc6ValueNONAME[countFilesGFC] = (gfc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 667       gfc6ErrorNONAME[countFilesGFC] = (gfc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
 668       if(gfc6ValueNONAME[countFilesGFC]>=0.) // to be improved
 669       {
 670        if(gfc6MaxValueNONAME < gfc6ValueNONAME[countFilesGFC]) gfc6MaxValueNONAME = gfc6ValueNONAME[countFilesGFC];
 671        if(gfc6MinValueNONAME > gfc6ValueNONAME[countFilesGFC]) gfc6MinValueNONAME = gfc6ValueNONAME[countFilesGFC];
 672       }
 673      }
 674      if(gfc8CommonHistRes && gfc8CommonHistRes->GetHistIntFlow())
 675      {
 676       gfc8ValueNONAME[countFilesGFC] = (gfc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 677       gfc8ErrorNONAME[countFilesGFC] = (gfc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
 678       if(gfc8ValueNONAME[countFilesGFC]>=0.) // to be improved
 679       {
 680        if(gfc8MaxValueNONAME < gfc8ValueNONAME[countFilesGFC]) gfc8MaxValueNONAME = gfc8ValueNONAME[countFilesGFC];
 681        if(gfc8MinValueNONAME > gfc8ValueNONAME[countFilesGFC]) gfc8MinValueNONAME = gfc8ValueNONAME[countFilesGFC];
 682       }
 683       countFilesGFC++;
 684      }
 685     } // end of if(listGFC)
 686    } // end of if(fileGFC)
 687
 688    // QC:
 689    TString fileNameQC = gSystem->pwd();
 690    fileNameQC+="/";
 691    fileNameQC+=presentDir->GetName();
 692    fileNameQC+="/";
 693    fileNameQC+="outputQCanalysis";
 694    (fileNameQC+=type.Data())+=".root";
 695    TFile *fileQC = TFile::Open(fileNameQC.Data(), "READ");
 696    if(fileQC)
 697    {
 698     TList *listQC = NULL;
 699     AliFlowCommonHistResults *qc2CommonHistRes = NULL;
 700     AliFlowCommonHistResults *qc4CommonHistRes = NULL;
 701     AliFlowCommonHistResults *qc6CommonHistRes = NULL;
 702     AliFlowCommonHistResults *qc8CommonHistRes = NULL;
 703     fileQC->GetObject("cobjQC",listQC);
 704     fileQC->Close();
 705     if(listQC)
 706     {
 707      qc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
 708      qc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
 709      qc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
 710      qc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
 711      if(qc2CommonHistRes && qc2CommonHistRes->GetHistIntFlow())
 712      {
 713       qc2ValueNONAME[countFilesQC] = (qc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 714       qc2ErrorNONAME[countFilesQC] = (qc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
 715       if(qc2ValueNONAME[countFilesQC]>=0.) // to be improved
 716       {
 717        if(qc2MaxValueNONAME < qc2ValueNONAME[countFilesQC]) qc2MaxValueNONAME = qc2ValueNONAME[countFilesQC];
 718        if(qc2MinValueNONAME > qc2ValueNONAME[countFilesQC]) qc2MinValueNONAME = qc2ValueNONAME[countFilesQC];
 719       }
 720      }
 721      if(qc4CommonHistRes && qc4CommonHistRes->GetHistIntFlow())
 722      {
 723       qc4ValueNONAME[countFilesQC] = (qc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 724       qc4ErrorNONAME[countFilesQC] = (qc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
 725       if(qc4ValueNONAME[countFilesQC]>=0.) // to be improved
 726       {
 727        if(qc4MaxValueNONAME < qc4ValueNONAME[countFilesQC]) qc4MaxValueNONAME = qc4ValueNONAME[countFilesQC];
 728        if(qc4MinValueNONAME > qc4ValueNONAME[countFilesQC]) qc4MinValueNONAME = qc4ValueNONAME[countFilesQC];
 729       }
 730      }
 731      if(qc6CommonHistRes && qc6CommonHistRes->GetHistIntFlow())
 732      {
 733       qc6ValueNONAME[countFilesQC] = (qc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 734       qc6ErrorNONAME[countFilesQC] = (qc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
 735       if(qc6ValueNONAME[countFilesQC]>=0.) // to be improved
 736       {
 737        if(qc6MaxValueNONAME < qc6ValueNONAME[countFilesQC]) qc6MaxValueNONAME = qc6ValueNONAME[countFilesQC];
 738        if(qc6MinValueNONAME > qc6ValueNONAME[countFilesQC]) qc6MinValueNONAME = qc6ValueNONAME[countFilesQC];
 739       }
 740      }
 741      if(qc8CommonHistRes && qc8CommonHistRes->GetHistIntFlow())
 742      {
 743       qc8ValueNONAME[countFilesQC] = (qc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 744       qc8ErrorNONAME[countFilesQC] = (qc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
 745       if(qc8ValueNONAME[countFilesQC]>=0.) // to be improved
 746       {
 747        if(qc8MaxValueNONAME < qc8ValueNONAME[countFilesQC]) qc8MaxValueNONAME = qc8ValueNONAME[countFilesQC];
 748        if(qc8MinValueNONAME > qc8ValueNONAME[countFilesQC]) qc8MinValueNONAME = qc8ValueNONAME[countFilesQC];
 749       }
 750       countFilesQC++;
 751      }
 752     } // end of if(listQC)
 753    } // end of if(fileQC)
 754
 755    // FQD:
 756    TString fileNameFQD = gSystem->pwd();
 757    fileNameFQD+="/";
 758    fileNameFQD+=presentDir->GetName();
 759    fileNameFQD+="/";
 760    fileNameFQD+="outputFQDanalysis";
 761    (fileNameFQD+=type.Data())+=".root";
 762    TFile *fileFQD = TFile::Open(fileNameFQD.Data(), "READ");
 763    if(fileFQD)
 764    {
 765     TList *listFQD = NULL;
 766     AliFlowCommonHistResults *fqdCommonHistRes = NULL;
 767     fileFQD->GetObject("cobjFQD",listFQD);
 768     fileFQD->Close();
 769     if(listFQD)
 770     {
 771      fqdCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listFQD->FindObject("AliFlowCommonHistResultsFQD"));
 772      if(fqdCommonHistRes && fqdCommonHistRes->GetHistIntFlow())
 773      {
 774       fqdValueNONAME[countFilesFQD] = (fqdCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 775       fqdErrorNONAME[countFilesFQD] = (fqdCommonHistRes->GetHistIntFlow())->GetBinError(1);
 776       if(fqdValueNONAME[countFilesFQD]>=0.) // to be improved
 777       {
 778        if(fqdMaxValueNONAME < fqdValueNONAME[countFilesFQD]) fqdMaxValueNONAME = fqdValueNONAME[countFilesFQD];
 779        if(fqdMinValueNONAME > fqdValueNONAME[countFilesFQD]) fqdMinValueNONAME = fqdValueNONAME[countFilesFQD];
 780       }
 781       countFilesFQD++;
 782      }
 783     } // end of if(listFQD)
 784    } // end of if(fileFQD)
 785
 786    // LYZ1SUM:
 787    TString fileNameLYZ1SUM = gSystem->pwd();
 788    fileNameLYZ1SUM+="/";
 789    fileNameLYZ1SUM+=presentDir->GetName();
 790    fileNameLYZ1SUM+="/";
 791    fileNameLYZ1SUM+="outputLYZ1SUManalysis";
 792    (fileNameLYZ1SUM+=type.Data())+=".root";
 793    TFile *fileLYZ1SUM = TFile::Open(fileNameLYZ1SUM.Data(), "READ");
 794    if(fileLYZ1SUM)
 795    {
 796     TList *listLYZ1SUM = NULL;
 797     AliFlowCommonHistResults *lyz1sumCommonHistRes = NULL;
 798     fileLYZ1SUM->GetObject("cobjLYZ1SUM",listLYZ1SUM);
 799     fileLYZ1SUM->Close();
 800     if(listLYZ1SUM)
 801     {
 802      lyz1sumCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listLYZ1SUM->FindObject("AliFlowCommonHistResultsLYZ1SUM"));
 803      if(lyz1sumCommonHistRes && lyz1sumCommonHistRes->GetHistIntFlow())
 804      {
 805       lyz1sumValueNONAME[countFilesLYZ1SUM] = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 806       lyz1sumErrorNONAME[countFilesLYZ1SUM] = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinError(1);
 807       if(lyz1sumValueNONAME[countFilesLYZ1SUM]>=0.) // to be improved
 808       {
 809        if(lyz1sumMaxValueNONAME < lyz1sumValueNONAME[countFilesLYZ1SUM]) lyz1sumMaxValueNONAME = lyz1sumValueNONAME[countFilesLYZ1SUM];
 810        if(lyz1sumMinValueNONAME > lyz1sumValueNONAME[countFilesLYZ1SUM]) lyz1sumMinValueNONAME = lyz1sumValueNONAME[countFilesLYZ1SUM];
 811       }
 812       countFilesLYZ1SUM++;
 813      }
 814     } // end of if(listLYZ1SUM)
 815    } // end of if(fileLYZ1SUM)
 816
 817    // LYZ1PROD:
 818    TString fileNameLYZ1PROD = gSystem->pwd();
 819    fileNameLYZ1PROD+="/";
 820    fileNameLYZ1PROD+=presentDir->GetName();
 821    fileNameLYZ1PROD+="/";
 822    fileNameLYZ1PROD+="outputLYZ1PRODanalysis";
 823    (fileNameLYZ1PROD+=type.Data())+=".root";
 824    TFile *fileLYZ1PROD = TFile::Open(fileNameLYZ1PROD.Data(), "READ");
 825    if(fileLYZ1PROD)
 826    {
 827     TList *listLYZ1PROD = NULL;
 828     AliFlowCommonHistResults *lyz1prodCommonHistRes = NULL;
 829     fileLYZ1PROD->GetObject("cobjLYZ1PROD",listLYZ1PROD);
 830     fileLYZ1PROD->Close();
 831     if(listLYZ1PROD)
 832     {
 833      lyz1prodCommonHistRes = dynamic_cast<AliFlowCommonHistResults*> (listLYZ1PROD->FindObject("AliFlowCommonHistResultsLYZ1PROD"));
 834      if(lyz1prodCommonHistRes && lyz1prodCommonHistRes->GetHistIntFlow())
 835      {
 836       lyz1prodValueNONAME[countFilesLYZ1PROD] = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 837       lyz1prodErrorNONAME[countFilesLYZ1PROD] = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinError(1);
 838       if(lyz1prodValueNONAME[countFilesLYZ1PROD]>=0.) // to be improved
 839       {
 840        if(lyz1prodMaxValueNONAME < lyz1prodValueNONAME[countFilesLYZ1PROD]) lyz1prodMaxValueNONAME = lyz1prodValueNONAME[countFilesLYZ1PROD];
 841        if(lyz1prodMinValueNONAME > lyz1prodValueNONAME[countFilesLYZ1PROD]) lyz1prodMinValueNONAME = lyz1prodValueNONAME[countFilesLYZ1PROD];
 842       }
 843       countFilesLYZ1PROD++;
 844      }
 845     } // end of if(listLYZ1PROD)
 846    } // end of if(fileLYZ1PROD)
 847   } // end of for(Int_t iDir=0;iDir<nDirs;++iDir)
 848  } // end of else if(nSubsets > 0)
 849
 850
 851  // accessing the large statistics merged output .root files for each method:
 852  // MCEP:
 853  TString mergedOutputFileNameMCEP(pwd.Data());
 854  ((mergedOutputFileNameMCEP+="outputMCEPanalysis")+=type.Data())+=".root";
 855  TFile *mergedOutputFileMCEP = NULL;
 856  TList *mergedOutputListMCEP = NULL;
 857  Double_t mergedValueMCEP = 0.;
 858  Double_t mergedErrorMCEP = 0.;
 859  Double_t mergedAvMMCEP = 0.; // average multiplicity
 860  Double_t mergedNMCEP = 0.;  // number of events
 861  if(gSystem->AccessPathName(mergedOutputFileNameMCEP.Data(),kFileExists))
 862  {
 863   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameMCEP.Data()<<endl;
 864  } else
 865    {
 866     mergedOutputFileMCEP = TFile::Open(mergedOutputFileNameMCEP.Data(),"READ");
 867     if(mergedOutputFileMCEP)
 868     {
 869      mergedOutputFileMCEP->GetObject("cobjMCEP",mergedOutputListMCEP);
 870      mergedOutputFileMCEP->Close();
 871      if(mergedOutputListMCEP)
 872      {
 873       AliFlowCommonHistResults *mcepCommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 874                                                     (mergedOutputListMCEP->FindObject("AliFlowCommonHistResultsMCEP"));
 875       if(mcepCommonHistRes && mcepCommonHistRes->GetHistIntFlow())
 876       {
 877        mergedValueMCEP = (mcepCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 878        mergedErrorMCEP = (mcepCommonHistRes->GetHistIntFlow())->GetBinError(1);
 879       }
 880
 881       AliFlowCommonHist *mcepCommonHist = dynamic_cast<AliFlowCommonHist*>
 882                                                     (mergedOutputListMCEP->FindObject("AliFlowCommonHistMCEP"));
 883       if(mcepCommonHist && mcepCommonHist->GetHistMultRP())
 884       {
 885        mergedAvMMCEP = (mcepCommonHist->GetHistMultRP())->GetMean();
 886        mergedNMCEP = (mcepCommonHist->GetHistMultRP())->GetEntries();
 887       }
 888      }
 889     } // end of if(mergedOutputFileMCEP)
 890    } // end of else
 891
 892  // SP:
 893  TString mergedOutputFileNameSP(pwd.Data());
 894  ((mergedOutputFileNameSP+="outputSPanalysis")+=type.Data())+=".root";
 895  TFile *mergedOutputFileSP = NULL;
 896  TList *mergedOutputListSP = NULL;
 897  Double_t mergedValueSP = 0.;
 898  Double_t mergedErrorSP = 0.;
 899  if(gSystem->AccessPathName(mergedOutputFileNameSP.Data(),kFileExists))
 900  {
 901   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameSP.Data()<<endl;
 902  } else
 903    {
 904     mergedOutputFileSP = TFile::Open(mergedOutputFileNameSP.Data(),"READ");
 905     if(mergedOutputFileSP)
 906     {
 907      mergedOutputFileSP->GetObject("cobjSP",mergedOutputListSP);
 908      mergedOutputFileSP->Close();
 909      if(mergedOutputListSP)
 910      {
 911       AliFlowCommonHistResults *spCommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 912                                                     (mergedOutputListSP->FindObject("AliFlowCommonHistResultsSP"));
 913       if(spCommonHistRes && spCommonHistRes->GetHistIntFlow())
 914       {
 915        mergedValueSP = (spCommonHistRes->GetHistIntFlow())->GetBinContent(1);
 916        mergedErrorSP = (spCommonHistRes->GetHistIntFlow())->GetBinError(1);
 917       }
 918      }
 919     } // end of if(mergedOutputFileSP)
 920    } // end of else
 921
 922  // GFC:
 923  TString mergedOutputFileNameGFC(pwd.Data());
 924  ((mergedOutputFileNameGFC+="outputGFCanalysis")+=type.Data())+=".root";
 925  TFile *mergedOutputFileGFC = NULL;
 926  TList *mergedOutputListGFC = NULL;
 927  Double_t mergedValueGFC2 = 0.;
 928  Double_t mergedErrorGFC2 = 0.;
 929  Double_t mergedValueGFC4 = 0.;
 930  Double_t mergedErrorGFC4 = 0.;
 931  Double_t mergedValueGFC6 = 0.;
 932  Double_t mergedErrorGFC6 = 0.;
 933  Double_t mergedValueGFC8 = 0.;
 934  Double_t mergedErrorGFC8 = 0.;
 935  if(gSystem->AccessPathName(mergedOutputFileNameGFC.Data(),kFileExists))
 936  {
 937   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameGFC.Data()<<endl;
 938  } else
 939    {
 940     mergedOutputFileGFC = TFile::Open(mergedOutputFileNameGFC.Data(),"READ");
 941     if(mergedOutputFileGFC)
 942     {
 943      mergedOutputFileGFC->GetObject("cobjGFC",mergedOutputListGFC);
 944      mergedOutputFileGFC->Close();
 945      if(mergedOutputListGFC)
 946      {
 947       AliFlowCommonHistResults *gfc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 948                                                     (mergedOutputListGFC->FindObject("AliFlowCommonHistResults2ndOrderGFC"));
 949       AliFlowCommonHistResults *gfc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 950                                                     (mergedOutputListGFC->FindObject("AliFlowCommonHistResults4thOrderGFC"));
 951       AliFlowCommonHistResults *gfc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 952                                                     (mergedOutputListGFC->FindObject("AliFlowCommonHistResults6thOrderGFC"));
 953       AliFlowCommonHistResults *gfc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
 954                                                     (mergedOutputListGFC->FindObject("AliFlowCommonHistResults8thOrderGFC"));
 955       if(gfc2CommonHistRes && gfc2CommonHistRes->GetHistIntFlow())
 956       {
 957        mergedValueGFC2 = (gfc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 958        mergedErrorGFC2 = (gfc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
 959       }
 960       if(gfc4CommonHistRes && gfc4CommonHistRes->GetHistIntFlow())
 961       {
 962        mergedValueGFC4 = (gfc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 963        mergedErrorGFC4 = (gfc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
 964       }
 965       if(gfc6CommonHistRes && gfc6CommonHistRes->GetHistIntFlow())
 966       {
 967        mergedValueGFC6 = (gfc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 968        mergedErrorGFC6 = (gfc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
 969       }
 970       if(gfc8CommonHistRes && gfc8CommonHistRes->GetHistIntFlow())
 971       {
 972        mergedValueGFC8 = (gfc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
 973        mergedErrorGFC8 = (gfc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
 974       }
 975      }
 976     } // end of if(mergedOutputFileGFC)
 977    } // end of else
 978
 979  // QC:
 980  TString mergedOutputFileNameQC(pwd.Data());
 981  ((mergedOutputFileNameQC+="outputQCanalysis")+=type.Data())+=".root";
 982  TFile *mergedOutputFileQC = NULL;
 983  TList *mergedOutputListQC = NULL;
 984  Double_t mergedValueQC2 = 0.;
 985  Double_t mergedErrorQC2 = 0.;
 986  Double_t mergedValueQC4 = 0.;
 987  Double_t mergedErrorQC4 = 0.;
 988  Double_t mergedValueQC6 = 0.;
 989  Double_t mergedErrorQC6 = 0.;
 990  Double_t mergedValueQC8 = 0.;
 991  Double_t mergedErrorQC8 = 0.;
 992  if(gSystem->AccessPathName(mergedOutputFileNameQC.Data(),kFileExists))
 993  {
 994   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameQC.Data()<<endl;
 995  } else
 996    {
 997     mergedOutputFileQC = TFile::Open(mergedOutputFileNameQC.Data(),"READ");
 998     if(mergedOutputFileQC)
 999     {
1000      mergedOutputFileQC->GetObject("cobjQC",mergedOutputListQC);
1001      mergedOutputFileQC->Close();
1002      if(mergedOutputListQC)
1003      {
1004       AliFlowCommonHistResults *qc2CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1005                                                     (mergedOutputListQC->FindObject("AliFlowCommonHistResults2ndOrderQC"));
1006       AliFlowCommonHistResults *qc4CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1007                                                     (mergedOutputListQC->FindObject("AliFlowCommonHistResults4thOrderQC"));
1008       AliFlowCommonHistResults *qc6CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1009                                                     (mergedOutputListQC->FindObject("AliFlowCommonHistResults6thOrderQC"));
1010       AliFlowCommonHistResults *qc8CommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1011                                                     (mergedOutputListQC->FindObject("AliFlowCommonHistResults8thOrderQC"));
1012       if(qc2CommonHistRes && qc2CommonHistRes->GetHistIntFlow())
1013       {
1014        mergedValueQC2 = (qc2CommonHistRes->GetHistIntFlow())->GetBinContent(1);
1015        mergedErrorQC2 = (qc2CommonHistRes->GetHistIntFlow())->GetBinError(1);
1016       }
1017       if(qc4CommonHistRes && qc4CommonHistRes->GetHistIntFlow())
1018       {
1019        mergedValueQC4 = (qc4CommonHistRes->GetHistIntFlow())->GetBinContent(1);
1020        mergedErrorQC4 = (qc4CommonHistRes->GetHistIntFlow())->GetBinError(1);
1021       }
1022       if(qc6CommonHistRes && qc6CommonHistRes->GetHistIntFlow())
1023       {
1024        mergedValueQC6 = (qc6CommonHistRes->GetHistIntFlow())->GetBinContent(1);
1025        mergedErrorQC6 = (qc6CommonHistRes->GetHistIntFlow())->GetBinError(1);
1026       }
1027       if(qc8CommonHistRes && qc8CommonHistRes->GetHistIntFlow())
1028       {
1029        mergedValueQC8 = (qc8CommonHistRes->GetHistIntFlow())->GetBinContent(1);
1030        mergedErrorQC8 = (qc8CommonHistRes->GetHistIntFlow())->GetBinError(1);
1031       }
1032      }
1033     } // end of if(mergedOutputFileGFC)
1034    } // end of else
1035
1036  // FQD:
1037  TString mergedOutputFileNameFQD(pwd.Data());
1038  ((mergedOutputFileNameFQD+="outputFQDanalysis")+=type.Data())+=".root";
1039  TFile *mergedOutputFileFQD = NULL;
1040  TList *mergedOutputListFQD = NULL;
1041  Double_t mergedValueFQD = 0.;
1042  Double_t mergedErrorFQD = 0.;
1043  if(gSystem->AccessPathName(mergedOutputFileNameFQD.Data(),kFileExists))
1044  {
1045   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameFQD.Data()<<endl;
1046  } else
1047    {
1048     mergedOutputFileFQD = TFile::Open(mergedOutputFileNameFQD.Data(),"READ");
1049     if(mergedOutputFileFQD)
1050     {
1051      mergedOutputFileFQD->GetObject("cobjFQD",mergedOutputListFQD);
1052      mergedOutputFileFQD->Close();
1053      if(mergedOutputListFQD)
1054      {
1055       AliFlowCommonHistResults *fqdCommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1056                                                     (mergedOutputListFQD->FindObject("AliFlowCommonHistResultsFQD"));
1057       if(fqdCommonHistRes && fqdCommonHistRes->GetHistIntFlow())
1058       {
1059        mergedValueFQD = (fqdCommonHistRes->GetHistIntFlow())->GetBinContent(1);
1060        mergedErrorFQD = (fqdCommonHistRes->GetHistIntFlow())->GetBinError(1);
1061       }
1062      }
1063     } // end of if(mergedOutputFileFQD)
1064    } // end of else
1065
1066  // LYZ1SUM:
1067  TString mergedOutputFileNameLYZ1SUM(pwd.Data());
1068  ((mergedOutputFileNameLYZ1SUM+="outputLYZ1SUManalysis")+=type.Data())+=".root";
1069  TFile *mergedOutputFileLYZ1SUM = NULL;
1070  TList *mergedOutputListLYZ1SUM = NULL;
1071  Double_t mergedValueLYZ1SUM = 0.;
1072  Double_t mergedErrorLYZ1SUM = 0.;
1073  if(gSystem->AccessPathName(mergedOutputFileNameLYZ1SUM.Data(),kFileExists))
1074  {
1075   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameLYZ1SUM.Data()<<endl;
1076  } else
1077    {
1078     mergedOutputFileLYZ1SUM = TFile::Open(mergedOutputFileNameLYZ1SUM.Data(),"READ");
1079     if(mergedOutputFileLYZ1SUM)
1080     {
1081      mergedOutputFileLYZ1SUM->GetObject("cobjLYZ1SUM",mergedOutputListLYZ1SUM);
1082      mergedOutputFileLYZ1SUM->Close();
1083      if(mergedOutputListLYZ1SUM)
1084      {
1085       AliFlowCommonHistResults *lyz1sumCommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1086                                                     (mergedOutputListLYZ1SUM->FindObject("AliFlowCommonHistResultsLYZ1SUM"));
1087       if(lyz1sumCommonHistRes && lyz1sumCommonHistRes->GetHistIntFlow())
1088       {
1089        mergedValueLYZ1SUM = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinContent(1);
1090        mergedErrorLYZ1SUM = (lyz1sumCommonHistRes->GetHistIntFlow())->GetBinError(1);
1091       }
1092      }
1093     } // end of if(mergedOutputFileLYZ1SUM)
1094    } // end of else
1095
1096  // LYZ1PROD:
1097  TString mergedOutputFileNameLYZ1PROD(pwd.Data());
1098  ((mergedOutputFileNameLYZ1PROD+="outputLYZ1PRODanalysis")+=type.Data())+=".root";
1099  TFile *mergedOutputFileLYZ1PROD = NULL;
1100  TList *mergedOutputListLYZ1PROD = NULL;
1101  Double_t mergedValueLYZ1PROD = 0.;
1102  Double_t mergedErrorLYZ1PROD = 0.;
1103  if(gSystem->AccessPathName(mergedOutputFileNameLYZ1PROD.Data(),kFileExists))
1104  {
1105   cout<<"WARNING: You do not have a merged output file "<<mergedOutputFileNameLYZ1PROD.Data()<<endl;
1106  } else
1107    {
1108     mergedOutputFileLYZ1PROD = TFile::Open(mergedOutputFileNameLYZ1PROD.Data(),"READ");
1109     if(mergedOutputFileLYZ1PROD)
1110     {
1111      mergedOutputFileLYZ1PROD->GetObject("cobjLYZ1PROD",mergedOutputListLYZ1PROD);
1112      mergedOutputFileLYZ1PROD->Close();
1113      if(mergedOutputListLYZ1PROD)
1114      {
1115       AliFlowCommonHistResults *lyz1prodCommonHistRes = dynamic_cast<AliFlowCommonHistResults*>
1116                                                     (mergedOutputListLYZ1PROD->FindObject("AliFlowCommonHistResultsLYZ1PROD"));
1117       if(lyz1prodCommonHistRes && lyz1prodCommonHistRes->GetHistIntFlow())
1118       {
1119        mergedValueLYZ1PROD = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinContent(1);
1120        mergedErrorLYZ1PROD = (lyz1prodCommonHistRes->GetHistIntFlow())->GetBinError(1);
1121       }
1122      }
1123     } // end of if(mergedOutputFileLYZ1PROD)
1124    } // end of else
1125
1126  // removing the title and stat. box from all histograms:
1127  // gStyle->SetOptTitle(0);
1128  gStyle->SetOptStat(0);
1129
1130  // box width:
1131  const Double_t boxWidth = 0.25;
1132
1133  // the number of different methods:
1134  const Int_t nMethods = 14;
1135
1136  // the number of small statistics runs:
1137  const Int_t nPointsMCEP = countFilesMCEP;
1138  const Int_t nPointsSP = countFilesSP;
1139  const Int_t nPointsGFC = countFilesGFC;
1140  const Int_t nPointsQC = countFilesQC;
1141  const Int_t nPointsFQD = countFilesFQD;
1142  const Int_t nPointsLYZ1SUM = countFilesLYZ1SUM;
1143  const Int_t nPointsLYZ1PROD = countFilesLYZ1PROD;
1144  const Int_t nPointsLYZEP = countFilesLYZEP;
1145
1146  // booking the style histogram for the integrated flow results from all methods for NONAME, RPs and POIs:
1147  TH1D* intFlowAll = new TH1D("intFlowAll","Integrated Flow",nMethods,0,nMethods);
1148  if(!plotLegend) intFlowAll->SetLabelSize(0.044,"X");
1149  //intFlowAll->SetLabelSize(0.036,"Y");
1150  //intFlowAll->SetMarkerStyle(markerStyle);
1151  //intFlowAll->SetMarkerColor(markerColor);
1152  (intFlowAll->GetYaxis())->SetTickLength(0.01);
1153  (intFlowAll->GetXaxis())->SetBinLabel(binMCEP,"v_{2}{MC}");
1154  (intFlowAll->GetXaxis())->SetBinLabel(binSP,"v_{2}{SP}");
1155  (intFlowAll->GetXaxis())->SetBinLabel(binGFC2,"v_{2}{2,GFC}");
1156  (intFlowAll->GetXaxis())->SetBinLabel(binQC2,"v_{2}{2,QC}");
1157  (intFlowAll->GetXaxis())->SetBinLabel(binGFC4,"v_{2}{4,GFC}");
1158  (intFlowAll->GetXaxis())->SetBinLabel(binQC4,"v_{2}{4,QC}");
1159  (intFlowAll->GetXaxis())->SetBinLabel(binGFC6,"v_{2}{6,GFC}");
1160  (intFlowAll->GetXaxis())->SetBinLabel(binQC6,"v_{2}{6,QC}");
1161  (intFlowAll->GetXaxis())->SetBinLabel(binGFC8,"v_{2}{8,GFC}");
1162  (intFlowAll->GetXaxis())->SetBinLabel(binQC8,"v_{2}{8,QC}");
1163  (intFlowAll->GetXaxis())->SetBinLabel(binFQD,"v_{2}{FQD}");
1164  (intFlowAll->GetXaxis())->SetBinLabel(binLYZ1SUM,"v_{2}{LYZ,sum}");
1165  (intFlowAll->GetXaxis())->SetBinLabel(binLYZ1PROD,"v_{2}{LYZ,prod}");
1166  (intFlowAll->GetXaxis())->SetBinLabel(binLYZEP,"v_{2}{LYZEP}");
1167
1168  //=============================================================================
1169  //                             NONAME histogram
1170  //=============================================================================
1171
1172  TH1D *intFlowNONAME = new TH1D(*intFlowAll);
1173
1174  Double_t mcepNONAME[nPointsMCEP];
1175  Double_t spNONAME[nPointsSP];
1176  Double_t gfc2NONAME[nPointsGFC];
1177  Double_t gfc4NONAME[nPointsGFC];
1178  Double_t gfc6NONAME[nPointsGFC];
1179  Double_t gfc8NONAME[nPointsGFC];
1180  Double_t qc2NONAME[nPointsQC];
1181  Double_t qc4NONAME[nPointsQC];
1182  Double_t qc6NONAME[nPointsQC];
1183  Double_t qc8NONAME[nPointsQC];
1184  Double_t fqdNONAME[nPointsFQD];
1185  Double_t lyz1sumNONAME[nPointsLYZ1SUM];
1186  Double_t lyz1prodNONAME[nPointsLYZ1PROD];
1187  Double_t lyzepNONAME[nPointsLYZEP];
1188
1189  for(Int_t i=0;i<nPointsMCEP;i++)
1190  {
1191   mcepNONAME[i]=binMCEP-0.5;
1192  }
1193  for(Int_t i=0;i<nPointsSP;i++)
1194  {
1195   spNONAME[i]=binSP-0.5;
1196  }
1197  for(Int_t i=0;i<nPointsGFC;i++)
1198  {
1199   gfc2NONAME[i]=binGFC2-0.5;
1200   gfc4NONAME[i]=binGFC4-0.5;
1201   gfc6NONAME[i]=binGFC6-0.5;
1202   gfc8NONAME[i]=binGFC8-0.5;
1203  }
1204  for(Int_t i=0;i<nPointsQC;i++)
1205  {
1206   qc2NONAME[i]=binQC2-0.5;
1207   qc4NONAME[i]=binQC4-0.5;
1208   qc6NONAME[i]=binQC6-0.5;
1209   qc8NONAME[i]=binQC8-0.5;
1210  }
1211  for(Int_t i=0;i<nPointsFQD;i++)
1212  {
1213   fqdNONAME[i]=binFQD-0.5;
1214  }
1215  for(Int_t i=0;i<nPointsLYZ1SUM;i++)
1216  {
1217   lyz1sumNONAME[i]=binLYZ1SUM-0.5;
1218  }
1219  for(Int_t i=0;i<nPointsLYZ1PROD;i++)
1220  {
1221   lyz1prodNONAME[i]=binLYZ1PROD-0.5;
1222  }
1223  for(Int_t i=0;i<nPointsLYZEP;i++)
1224  {
1225   lyzepNONAME[i]=binLYZEP-0.5;
1226  }
1227
1228  // MCEP:
1229  TGraphErrors *mcepMeanNONAME = new TGraphErrors(1);
1230  mcepMeanNONAME->SetPoint(0,binMCEP-0.5,mergedValueMCEP);
1231  mcepMeanNONAME->SetPointError(0,0,mergedErrorMCEP);
1232  mcepMeanNONAME->SetMarkerStyle(25);
1233  mcepMeanNONAME->SetMarkerColor(kBlack);
1234  mcepMeanNONAME->SetLineColor(kBlack);
1235  mcepMeanNONAME->SetMarkerSize(1.25);
1236
1237  TGraph *mcepTGraphNONAME = NULL;
1238  if(nPointsMCEP>0)
1239  {
1240   mcepTGraphNONAME = new TGraph(nPointsMCEP, mcepNONAME, mcepValueNONAME);
1241   mcepTGraphNONAME->SetMarkerStyle(21);
1242   mcepTGraphNONAME->SetMarkerColor(kGray+1);
1243   mcepTGraphNONAME->SetMarkerSize(0.75);
1244  }
1245
1246  TGraph *mcepBoxNONAME = new TGraph(5);
1247  mcepBoxNONAME->SetPoint(0,(binMCEP-0.5)-boxWidth,mcepMinValueNONAME);
1248  mcepBoxNONAME->SetPoint(1,(binMCEP-0.5)+boxWidth,mcepMinValueNONAME);
1249  mcepBoxNONAME->SetPoint(2,(binMCEP-0.5)+boxWidth,mcepMaxValueNONAME);
1250  mcepBoxNONAME->SetPoint(3,(binMCEP-0.5)-boxWidth,mcepMaxValueNONAME);
1251  mcepBoxNONAME->SetPoint(4,(binMCEP-0.5)-boxWidth,mcepMinValueNONAME);
1252  mcepBoxNONAME->SetFillStyle(1001);
1253  mcepBoxNONAME->SetFillColor(kGray);
1254
1255  // SP:
1256  TGraphErrors *spMeanNONAME = new TGraphErrors(1);
1257  spMeanNONAME->SetPoint(0,binSP-0.5,mergedValueSP);
1258  spMeanNONAME->SetPointError(0,0,mergedErrorSP);
1259  spMeanNONAME->SetMarkerStyle(25);
1260  spMeanNONAME->SetMarkerColor(kBlack);
1261  spMeanNONAME->SetLineColor(kBlack);
1262  spMeanNONAME->SetMarkerSize(1.25);
1263
1264  TGraph *spTGraphNONAME = NULL;
1265  if(nPointsSP>0)
1266  {
1267   spTGraphNONAME = new TGraph(nPointsSP, spNONAME, spValueNONAME);
1268   spTGraphNONAME->SetMarkerStyle(21);
1269   spTGraphNONAME->SetMarkerColor(kViolet-8);
1270   spTGraphNONAME->SetMarkerSize(0.75);
1271  }
1272
1273  TGraph *spBoxNONAME = new TGraph(5);
1274  spBoxNONAME->SetPoint(0,(binSP-0.5)-boxWidth,spMinValueNONAME);
1275  spBoxNONAME->SetPoint(1,(binSP-0.5)+boxWidth,spMinValueNONAME);
1276  spBoxNONAME->SetPoint(2,(binSP-0.5)+boxWidth,spMaxValueNONAME);
1277  spBoxNONAME->SetPoint(3,(binSP-0.5)-boxWidth,spMaxValueNONAME);
1278  spBoxNONAME->SetPoint(4,(binSP-0.5)-boxWidth,spMinValueNONAME);
1279  spBoxNONAME->SetFillStyle(1001);
1280  spBoxNONAME->SetFillColor(kViolet-9);
1281
1282  // GFC{2}:
1283  TGraphErrors *gfc2MeanNONAME = new TGraphErrors(1);
1284  gfc2MeanNONAME->SetPoint(0,binGFC2-0.5,mergedValueGFC2);
1285  gfc2MeanNONAME->SetPointError(0,0,mergedErrorGFC2);
1286  gfc2MeanNONAME->SetMarkerStyle(25);
1287  gfc2MeanNONAME->SetMarkerColor(kBlack);
1288  gfc2MeanNONAME->SetLineColor(kBlack);
1289  gfc2MeanNONAME->SetMarkerSize(1.25);
1290
1291
1292  TGraph *gfc2TGraphNONAME = NULL;
1293  if(nPointsGFC>0)
1294  {
1295   gfc2TGraphNONAME = new TGraph(nPointsGFC, gfc2NONAME, gfc2ValueNONAME);
1296   gfc2TGraphNONAME->SetMarkerStyle(21);
1297   gfc2TGraphNONAME->SetMarkerColor(kBlue-9);
1298   gfc2TGraphNONAME->SetMarkerSize(0.75);
1299  }
1300
1301  TGraph *gfc2BoxNONAME = new TGraph(5);
1302  gfc2BoxNONAME->SetPoint(0,(binGFC2-0.5)-boxWidth,gfc2MinValueNONAME);
1303  gfc2BoxNONAME->SetPoint(1,(binGFC2-0.5)+boxWidth,gfc2MinValueNONAME);
1304  gfc2BoxNONAME->SetPoint(2,(binGFC2-0.5)+boxWidth,gfc2MaxValueNONAME);
1305  gfc2BoxNONAME->SetPoint(3,(binGFC2-0.5)-boxWidth,gfc2MaxValueNONAME);
1306  gfc2BoxNONAME->SetPoint(4,(binGFC2-0.5)-boxWidth,gfc2MinValueNONAME);
1307  gfc2BoxNONAME->SetFillStyle(1001);
1308  gfc2BoxNONAME->SetFillColor(kBlue-10);
1309
1310  // GFC{4}:
1311  TGraphErrors *gfc4MeanNONAME = new TGraphErrors(1);
1312  gfc4MeanNONAME->SetPoint(0,binGFC4-0.5,mergedValueGFC4);
1313  gfc4MeanNONAME->SetPointError(0,0,mergedErrorGFC4);
1314  gfc4MeanNONAME->SetMarkerStyle(25);
1315  gfc4MeanNONAME->SetMarkerColor(kBlack);
1316  gfc4MeanNONAME->SetLineColor(kBlack);
1317  gfc4MeanNONAME->SetMarkerSize(1.25);
1318
1319  TGraph *gfc4TGraphNONAME = NULL;
1320  if(nPointsGFC>0)
1321  {
1322   gfc4TGraphNONAME = new TGraph(nPointsGFC, gfc4NONAME, gfc4ValueNONAME);
1323   gfc4TGraphNONAME->SetMarkerStyle(21);
1324   gfc4TGraphNONAME->SetMarkerColor(kBlue-9);
1325   gfc4TGraphNONAME->SetMarkerSize(0.75);
1326  }
1327
1328  TGraph *gfc4BoxNONAME = new TGraph(5);
1329  gfc4BoxNONAME->SetPoint(0,(binGFC4-0.5)-boxWidth,gfc4MinValueNONAME);
1330  gfc4BoxNONAME->SetPoint(1,(binGFC4-0.5)+boxWidth,gfc4MinValueNONAME);
1331  gfc4BoxNONAME->SetPoint(2,(binGFC4-0.5)+boxWidth,gfc4MaxValueNONAME);
1332  gfc4BoxNONAME->SetPoint(3,(binGFC4-0.5)-boxWidth,gfc4MaxValueNONAME);
1333  gfc4BoxNONAME->SetPoint(4,(binGFC4-0.5)-boxWidth,gfc4MinValueNONAME);
1334  gfc4BoxNONAME->SetFillStyle(1001);
1335  gfc4BoxNONAME->SetFillColor(kBlue-10);
1336
1337  // GFC{6}:
1338  TGraphErrors *gfc6MeanNONAME = new TGraphErrors(1);
1339  gfc6MeanNONAME->SetPoint(0,binGFC6-0.5,mergedValueGFC6);
1340  gfc6MeanNONAME->SetPointError(0,0,mergedErrorGFC6);
1341  gfc6MeanNONAME->SetMarkerStyle(25);
1342  gfc6MeanNONAME->SetMarkerColor(kBlack);
1343  gfc6MeanNONAME->SetLineColor(kBlack);
1344  gfc6MeanNONAME->SetMarkerSize(1.25);
1345
1346  TGraph *gfc6TGraphNONAME = NULL;
1347  if(nPointsGFC>0)
1348  {
1349   gfc6TGraphNONAME = new TGraph(nPointsGFC, gfc6NONAME, gfc6ValueNONAME);
1350   gfc6TGraphNONAME->SetMarkerStyle(21);
1351   gfc6TGraphNONAME->SetMarkerColor(kBlue-9);
1352   gfc6TGraphNONAME->SetMarkerSize(0.75);
1353  }
1354
1355  TGraph *gfc6BoxNONAME = new TGraph(5);
1356  gfc6BoxNONAME->SetPoint(0,(binGFC6-0.5)-boxWidth,gfc6MinValueNONAME);
1357  gfc6BoxNONAME->SetPoint(1,(binGFC6-0.5)+boxWidth,gfc6MinValueNONAME);
1358  gfc6BoxNONAME->SetPoint(2,(binGFC6-0.5)+boxWidth,gfc6MaxValueNONAME);
1359  gfc6BoxNONAME->SetPoint(3,(binGFC6-0.5)-boxWidth,gfc6MaxValueNONAME);
1360  gfc6BoxNONAME->SetPoint(4,(binGFC6-0.5)-boxWidth,gfc6MinValueNONAME);
1361  gfc6BoxNONAME->SetFillStyle(1001);
1362  gfc6BoxNONAME->SetFillColor(kBlue-10);
1363
1364  // GFC{8}:
1365  TGraphErrors *gfc8MeanNONAME = new TGraphErrors(1);
1366  gfc8MeanNONAME->SetPoint(0,binGFC8-0.5,mergedValueGFC8);
1367  gfc8MeanNONAME->SetPointError(0,0,mergedErrorGFC8);
1368  gfc8MeanNONAME->SetMarkerStyle(25);
1369  gfc8MeanNONAME->SetMarkerColor(kBlack);
1370  gfc8MeanNONAME->SetLineColor(kBlack);
1371  gfc8MeanNONAME->SetMarkerSize(1.25);
1372
1373  TGraph *gfc8TGraphNONAME = NULL;
1374  if(nPointsGFC>0)
1375  {
1376   gfc8TGraphNONAME = new TGraph(nPointsGFC, gfc8NONAME, gfc8ValueNONAME);
1377   gfc8TGraphNONAME->SetMarkerStyle(21);
1378   gfc8TGraphNONAME->SetMarkerColor(kBlue-9);
1379   gfc8TGraphNONAME->SetMarkerSize(0.75);
1380  }
1381
1382  TGraph *gfc8BoxNONAME = new TGraph(5);
1383  gfc8BoxNONAME->SetPoint(0,(binGFC8-0.5)-boxWidth,gfc8MinValueNONAME);
1384  gfc8BoxNONAME->SetPoint(1,(binGFC8-0.5)+boxWidth,gfc8MinValueNONAME);
1385  gfc8BoxNONAME->SetPoint(2,(binGFC8-0.5)+boxWidth,gfc8MaxValueNONAME);
1386  gfc8BoxNONAME->SetPoint(3,(binGFC8-0.5)-boxWidth,gfc8MaxValueNONAME);
1387  gfc8BoxNONAME->SetPoint(4,(binGFC8-0.5)-boxWidth,gfc8MinValueNONAME);
1388  gfc8BoxNONAME->SetFillStyle(1001);
1389  gfc8BoxNONAME->SetFillColor(kBlue-10);
1390
1391  // QC{2}:
1392  TGraphErrors *qc2MeanNONAME = new TGraphErrors(1);
1393  qc2MeanNONAME->SetPoint(0,binQC2-0.5,mergedValueQC2);
1394  qc2MeanNONAME->SetPointError(0,0,mergedErrorQC2);
1395  qc2MeanNONAME->SetMarkerStyle(25);
1396  qc2MeanNONAME->SetMarkerColor(kBlack);
1397  qc2MeanNONAME->SetLineColor(kBlack);
1398  qc2MeanNONAME->SetMarkerSize(1.25);
1399
1400  TGraph *qc2TGraphNONAME = NULL;
1401  if(nPointsQC>0)
1402  {
1403   qc2TGraphNONAME = new TGraph(nPointsQC, qc2NONAME, qc2ValueNONAME);
1404   qc2TGraphNONAME->SetMarkerStyle(21);
1405   qc2TGraphNONAME->SetMarkerColor(kRed-7);
1406   qc2TGraphNONAME->SetMarkerSize(0.75);
1407  }
1408
1409  TGraph *qc2BoxNONAME = new TGraph(5);
1410  qc2BoxNONAME->SetPoint(0,(binQC2-0.5)-boxWidth,qc2MinValueNONAME);
1411  qc2BoxNONAME->SetPoint(1,(binQC2-0.5)+boxWidth,qc2MinValueNONAME);
1412  qc2BoxNONAME->SetPoint(2,(binQC2-0.5)+boxWidth,qc2MaxValueNONAME);
1413  qc2BoxNONAME->SetPoint(3,(binQC2-0.5)-boxWidth,qc2MaxValueNONAME);
1414  qc2BoxNONAME->SetPoint(4,(binQC2-0.5)-boxWidth,qc2MinValueNONAME);
1415  qc2BoxNONAME->SetFillStyle(1001);
1416  qc2BoxNONAME->SetFillColor(kRed-10);
1417
1418  // QC{4}:
1419  TGraphErrors *qc4MeanNONAME = new TGraphErrors(1);
1420  qc4MeanNONAME->SetPoint(0,binQC4-0.5,mergedValueQC4);
1421  qc4MeanNONAME->SetPointError(0,0,mergedErrorQC4);
1422  qc4MeanNONAME->SetMarkerStyle(25);
1423  qc4MeanNONAME->SetMarkerColor(kBlack);
1424  qc4MeanNONAME->SetLineColor(kBlack);
1425  qc4MeanNONAME->SetMarkerSize(1.25);
1426
1427  TGraph *qc4TGraphNONAME = NULL;
1428  if(nPointsQC>0)
1429  {
1430   qc4TGraphNONAME = new TGraph(nPointsQC, qc4NONAME, qc4ValueNONAME);
1431   qc4TGraphNONAME->SetMarkerStyle(21);
1432   qc4TGraphNONAME->SetMarkerColor(kRed-7);
1433   qc4TGraphNONAME->SetMarkerSize(0.75);
1434  }
1435
1436  TGraph *qc4BoxNONAME = new TGraph(5);
1437  qc4BoxNONAME->SetPoint(0,(binQC4-0.5)-boxWidth,qc4MinValueNONAME);
1438  qc4BoxNONAME->SetPoint(1,(binQC4-0.5)+boxWidth,qc4MinValueNONAME);
1439  qc4BoxNONAME->SetPoint(2,(binQC4-0.5)+boxWidth,qc4MaxValueNONAME);
1440  qc4BoxNONAME->SetPoint(3,(binQC4-0.5)-boxWidth,qc4MaxValueNONAME);
1441  qc4BoxNONAME->SetPoint(4,(binQC4-0.5)-boxWidth,qc4MinValueNONAME);
1442  qc4BoxNONAME->SetFillStyle(1001);
1443  qc4BoxNONAME->SetFillColor(kRed-10);
1444
1445  // QC{6}:
1446  TGraphErrors *qc6MeanNONAME = new TGraphErrors(1);
1447  qc6MeanNONAME->SetPoint(0,binQC6-0.5,mergedValueQC6);
1448  qc6MeanNONAME->SetPointError(0,0,mergedErrorQC6);
1449  qc6MeanNONAME->SetMarkerStyle(25);
1450  qc6MeanNONAME->SetMarkerColor(kBlack);
1451  qc6MeanNONAME->SetLineColor(kBlack);
1452  qc6MeanNONAME->SetMarkerSize(1.25);
1453
1454  TGraph *qc6TGraphNONAME = NULL;
1455  if(nPointsQC>0)
1456  {
1457   qc6TGraphNONAME = new TGraph(nPointsQC, qc6NONAME, qc6ValueNONAME);
1458   qc6TGraphNONAME->SetMarkerStyle(21);
1459   qc6TGraphNONAME->SetMarkerColor(kRed-7);
1460   qc6TGraphNONAME->SetMarkerSize(0.75);
1461  }
1462
1463  TGraph *qc6BoxNONAME = new TGraph(5);
1464  qc6BoxNONAME->SetPoint(0,(binQC6-0.5)-boxWidth,qc6MinValueNONAME);
1465  qc6BoxNONAME->SetPoint(1,(binQC6-0.5)+boxWidth,qc6MinValueNONAME);
1466  qc6BoxNONAME->SetPoint(2,(binQC6-0.5)+boxWidth,qc6MaxValueNONAME);
1467  qc6BoxNONAME->SetPoint(3,(binQC6-0.5)-boxWidth,qc6MaxValueNONAME);
1468  qc6BoxNONAME->SetPoint(4,(binQC6-0.5)-boxWidth,qc6MinValueNONAME);
1469  qc6BoxNONAME->SetFillStyle(1001);
1470  qc6BoxNONAME->SetFillColor(kRed-10);
1471
1472  // QC{8}:
1473  TGraphErrors *qc8MeanNONAME = new TGraphErrors(1);
1474  qc8MeanNONAME->SetPoint(0,binQC8-0.5,mergedValueQC8);
1475  qc8MeanNONAME->SetPointError(0,0,mergedErrorQC8);
1476  qc8MeanNONAME->SetMarkerStyle(25);
1477  qc8MeanNONAME->SetMarkerColor(kBlack);
1478  qc8MeanNONAME->SetLineColor(kBlack);
1479  qc8MeanNONAME->SetMarkerSize(1.25);
1480
1481  TGraph *qc8TGraphNONAME = NULL;
1482  if(nPointsQC>0)
1483  {
1484   qc8TGraphNONAME = new TGraph(nPointsQC, qc8NONAME, qc8ValueNONAME);
1485   qc8TGraphNONAME->SetMarkerStyle(21);
1486   qc8TGraphNONAME->SetMarkerColor(kRed-7);
1487   qc8TGraphNONAME->SetMarkerSize(0.75);
1488  }
1489
1490  TGraph *qc8BoxNONAME = new TGraph(5);
1491  qc8BoxNONAME->SetPoint(0,(binQC8-0.5)-boxWidth,qc8MinValueNONAME);
1492  qc8BoxNONAME->SetPoint(1,(binQC8-0.5)+boxWidth,qc8MinValueNONAME);
1493  qc8BoxNONAME->SetPoint(2,(binQC8-0.5)+boxWidth,qc8MaxValueNONAME);
1494  qc8BoxNONAME->SetPoint(3,(binQC8-0.5)-boxWidth,qc8MaxValueNONAME);
1495  qc8BoxNONAME->SetPoint(4,(binQC8-0.5)-boxWidth,qc8MinValueNONAME);
1496  qc8BoxNONAME->SetFillStyle(1001);
1497  qc8BoxNONAME->SetFillColor(kRed-10);
1498
1499  // FQD:
1500  TGraphErrors *fqdMeanNONAME = new TGraphErrors(1);
1501  fqdMeanNONAME->SetPoint(0,binFQD-0.5,mergedValueFQD);
1502  fqdMeanNONAME->SetPointError(0,0,mergedErrorFQD);
1503  fqdMeanNONAME->SetMarkerStyle(25);
1504  fqdMeanNONAME->SetMarkerColor(kBlack);
1505  fqdMeanNONAME->SetLineColor(kBlack);
1506  fqdMeanNONAME->SetMarkerSize(1.25);
1507
1508  TGraph *fqdTGraphNONAME = NULL;
1509  if(nPointsFQD>0)
1510  {
1511   fqdTGraphNONAME = new TGraph(nPointsFQD, fqdNONAME, fqdValueNONAME);
1512   fqdTGraphNONAME->SetMarkerStyle(21);
1513   fqdTGraphNONAME->SetMarkerColor(kOrange-8);
1514   fqdTGraphNONAME->SetMarkerSize(0.75);
1515  }
1516
1517  TGraph *fqdBoxNONAME = new TGraph(5);
1518  fqdBoxNONAME->SetPoint(0,(binFQD-0.5)-boxWidth,fqdMinValueNONAME);
1519  fqdBoxNONAME->SetPoint(1,(binFQD-0.5)+boxWidth,fqdMinValueNONAME);
1520  fqdBoxNONAME->SetPoint(2,(binFQD-0.5)+boxWidth,fqdMaxValueNONAME);
1521  fqdBoxNONAME->SetPoint(3,(binFQD-0.5)-boxWidth,fqdMaxValueNONAME);
1522  fqdBoxNONAME->SetPoint(4,(binFQD-0.5)-boxWidth,fqdMinValueNONAME);
1523  fqdBoxNONAME->SetFillStyle(1001);
1524  fqdBoxNONAME->SetFillColor(kOrange-9);
1525
1526  // LYZ1SUM:
1527  TGraphErrors *lyz1sumMeanNONAME = new TGraphErrors(1);
1528  lyz1sumMeanNONAME->SetPoint(0,binLYZ1SUM-0.5,mergedValueLYZ1SUM);
1529  lyz1sumMeanNONAME->SetPointError(0,0,mergedErrorLYZ1SUM);
1530  lyz1sumMeanNONAME->SetMarkerStyle(25);
1531  lyz1sumMeanNONAME->SetMarkerColor(kBlack);
1532  lyz1sumMeanNONAME->SetLineColor(kBlack);
1533  lyz1sumMeanNONAME->SetMarkerSize(1.25);
1534
1535  TGraph *lyz1sumTGraphNONAME = NULL;
1536  if(nPointsLYZ1SUM>0)
1537  {
1538   lyz1sumTGraphNONAME = new TGraph(nPointsLYZ1SUM, lyz1sumNONAME, lyz1sumValueNONAME);
1539   lyz1sumTGraphNONAME->SetMarkerStyle(21);
1540   lyz1sumTGraphNONAME->SetMarkerColor(kYellow-5);
1541   lyz1sumTGraphNONAME->SetMarkerSize(0.75);
1542  }
1543
1544  TGraph *lyz1sumBoxNONAME = new TGraph(5);
1545  lyz1sumBoxNONAME->SetPoint(0,(binLYZ1SUM-0.5)-boxWidth,lyz1sumMinValueNONAME);
1546  lyz1sumBoxNONAME->SetPoint(1,(binLYZ1SUM-0.5)+boxWidth,lyz1sumMinValueNONAME);
1547  lyz1sumBoxNONAME->SetPoint(2,(binLYZ1SUM-0.5)+boxWidth,lyz1sumMaxValueNONAME);
1548  lyz1sumBoxNONAME->SetPoint(3,(binLYZ1SUM-0.5)-boxWidth,lyz1sumMaxValueNONAME);
1549  lyz1sumBoxNONAME->SetPoint(4,(binLYZ1SUM-0.5)-boxWidth,lyz1sumMinValueNONAME);
1550  lyz1sumBoxNONAME->SetFillStyle(1001);
1551  lyz1sumBoxNONAME->SetFillColor(kYellow-8);
1552
1553  // LYZ1PROD:
1554  TGraphErrors *lyz1prodMeanNONAME = new TGraphErrors(1);
1555  lyz1prodMeanNONAME->SetPoint(0,binLYZ1PROD-0.5,mergedValueLYZ1PROD);
1556  lyz1prodMeanNONAME->SetPointError(0,0,mergedErrorLYZ1PROD);
1557  lyz1prodMeanNONAME->SetMarkerStyle(25);
1558  lyz1prodMeanNONAME->SetMarkerColor(kBlack);
1559  lyz1prodMeanNONAME->SetLineColor(kBlack);
1560  lyz1prodMeanNONAME->SetMarkerSize(1.25);
1561
1562  TGraph *lyz1prodTGraphNONAME = NULL;
1563  if(nPointsLYZ1PROD>0)
1564  {
1565   lyz1prodTGraphNONAME = new TGraph(nPointsLYZ1PROD, lyz1prodNONAME, lyz1prodValueNONAME);
1566   lyz1prodTGraphNONAME->SetMarkerStyle(21);
1567   lyz1prodTGraphNONAME->SetMarkerColor(kYellow-2);
1568   lyz1prodTGraphNONAME->SetMarkerSize(0.75);
1569  }
1570
1571  TGraph *lyz1prodBoxNONAME = new TGraph(5);
1572  lyz1prodBoxNONAME->SetPoint(0,(binLYZ1PROD-0.5)-boxWidth,lyz1prodMinValueNONAME);
1573  lyz1prodBoxNONAME->SetPoint(1,(binLYZ1PROD-0.5)+boxWidth,lyz1prodMinValueNONAME);
1574  lyz1prodBoxNONAME->SetPoint(2,(binLYZ1PROD-0.5)+boxWidth,lyz1prodMaxValueNONAME);
1575  lyz1prodBoxNONAME->SetPoint(3,(binLYZ1PROD-0.5)-boxWidth,lyz1prodMaxValueNONAME);
1576  lyz1prodBoxNONAME->SetPoint(4,(binLYZ1PROD-0.5)-boxWidth,lyz1prodMinValueNONAME);
1577  lyz1prodBoxNONAME->SetFillStyle(1001);
1578  lyz1prodBoxNONAME->SetFillColor(kYellow-6);
1579
1580  TCanvas* intFlowCanvasNONAME = new TCanvas("Integrated Flow NONAME","Integrated Flow NONAME",1000,600);
1581
1582  if(plotLegend)
1583  {
1584   intFlowCanvasNONAME->Divide(2,1);
1585
1586   // 1st pad is for plot:
1587   (intFlowCanvasNONAME->cd(1))->SetPad(0.0,0.0,0.75,1.0);
1588  }
1589
1590  if(intFlowNONAME)
1591  {
1592   TString intFlowNameNONAME("Superimposing ");
1593   if(nPointsMCEP != 0) // to be improved
1594   {
1595    intFlowNameNONAME+=nPointsMCEP;
1596   } else if (nPointsSP != 0)
1597     {
1598      intFlowNameNONAME+=nPointsSP;
1599     } else if (nPointsGFC != 0)
1600       {
1601        intFlowNameNONAME+=nPointsGFC;
1602       } else if (nPointsQC != 0)
1603         {
1604          intFlowNameNONAME+=nPointsQC;
1605         } else if (nPointsFQD != 0)
1606           {
1607            intFlowNameNONAME+=nPointsFQD;
1608           } else if (nPointsLYZ1SUM != 0)
1609             {
1610              intFlowNameNONAME+=nPointsLYZ1SUM;
1611             } else if (nPointsLYZ1PROD != 0)
1612               {
1613                intFlowNameNONAME+=nPointsLYZ1PROD;
1614               } else if (nPointsLYZEP != 0)
1615                 {
1616                  intFlowNameNONAME+=nPointsLYZEP;
1617                 }
1618
1619   intFlowNameNONAME+=" independent runs";
1620   intFlowNONAME->SetTitle(intFlowNameNONAME.Data());
1621   (intFlowNONAME->GetYaxis())->SetRangeUser(0,0.20);
1622   intFlowNONAME->Draw();
1623  }
1624
1625  // MCEP:
1626  if(mcepBoxNONAME && mcepMinValueNONAME < 1000.) mcepBoxNONAME->Draw("LFSAME");
1627  if(mcepTGraphNONAME) mcepTGraphNONAME->Draw("PSAME");
1628  if(mcepMeanNONAME) mcepMeanNONAME->Draw("PSAME");
1629
1630  // SP:
1631  if(spBoxNONAME && spMinValueNONAME < 1000.) spBoxNONAME->Draw("LFSAME");
1632  if(spTGraphNONAME) spTGraphNONAME->Draw("PSAME");
1633  if(spMeanNONAME) spMeanNONAME->Draw("PSAME");
1634
1635  // GFC{2}:
1636  if(gfc2BoxNONAME && gfc2MinValueNONAME < 1000.) gfc2BoxNONAME->Draw("LFSAME");
1637  if(gfc2TGraphNONAME) gfc2TGraphNONAME->Draw("PSAME");
1638  if(gfc2MeanNONAME) gfc2MeanNONAME->Draw("PSAME");
1639
1640  // GFC{4}:
1641  if(gfc4BoxNONAME && gfc4MinValueNONAME < 1000.) gfc4BoxNONAME->Draw("LFSAME");
1642  if(gfc4TGraphNONAME) gfc4TGraphNONAME->Draw("PSAME");
1643  if(gfc4MeanNONAME) gfc4MeanNONAME->Draw("PSAME");
1644
1645  // GFC{6}:
1646  if(gfc6BoxNONAME && gfc6MinValueNONAME < 1000.) gfc6BoxNONAME->Draw("LFSAME");
1647  if(gfc6TGraphNONAME) gfc6TGraphNONAME->Draw("PSAME");
1648  if(gfc6MeanNONAME) gfc6MeanNONAME->Draw("PSAME");
1649
1650  // GFC{8}:
1651  if(gfc8BoxNONAME && gfc8MinValueNONAME < 1000.) gfc8BoxNONAME->Draw("LFSAME");
1652  if(gfc8TGraphNONAME) gfc8TGraphNONAME->Draw("PSAME");
1653  if(gfc8MeanNONAME) gfc8MeanNONAME->Draw("PSAME");
1654
1655  // QC{2}:
1656  if(qc2BoxNONAME && qc2MinValueNONAME < 1000.) qc2BoxNONAME->Draw("LFSAME");
1657  if(qc2TGraphNONAME) qc2TGraphNONAME->Draw("PSAME");
1658  if(qc2MeanNONAME) qc2MeanNONAME->Draw("PSAME");
1659
1660  // QC{4}:
1661  if(qc4BoxNONAME && qc4MinValueNONAME < 1000.) qc4BoxNONAME->Draw("LFSAME");
1662  if(qc4TGraphNONAME) qc4TGraphNONAME->Draw("PSAME");
1663  if(qc4MeanNONAME) qc4MeanNONAME->Draw("PSAME");
1664
1665  // QC{6}:
1666  if(qc6BoxNONAME && qc6MinValueNONAME < 1000.) qc6BoxNONAME->Draw("LFSAME");
1667  if(qc6TGraphNONAME) qc6TGraphNONAME->Draw("PSAME");
1668  if(qc6MeanNONAME) qc6MeanNONAME->Draw("PSAME");
1669
1670  // QC{8}:
1671  if(qc8BoxNONAME && qc8MinValueNONAME < 1000.) qc8BoxNONAME->Draw("LFSAME");
1672  if(qc8TGraphNONAME) qc8TGraphNONAME->Draw("PSAME");
1673  if(qc8MeanNONAME) qc8MeanNONAME->Draw("PSAME");
1674
1675  // FQD:
1676  if(fqdBoxNONAME && fqdMinValueNONAME < 1000.) fqdBoxNONAME->Draw("LFSAME");
1677  if(fqdTGraphNONAME) fqdTGraphNONAME->Draw("PSAME");
1678  if(fqdMeanNONAME) fqdMeanNONAME->Draw("PSAME");
1679
1680  // LYZ1SUM:
1681  if(lyz1sumBoxNONAME && lyz1sumMinValueNONAME < 1000.) lyz1sumBoxNONAME->Draw("LFSAME");
1682  if(lyz1sumTGraphNONAME) lyz1sumTGraphNONAME->Draw("PSAME");
1683  if(lyz1sumMeanNONAME) lyz1sumMeanNONAME->Draw("PSAME");
1684
1685  // LYZ1PROD:
1686  if(lyz1prodBoxNONAME && lyz1prodMinValueNONAME < 1000.) lyz1prodBoxNONAME->Draw("LFSAME");
1687  if(lyz1prodTGraphNONAME) lyz1prodTGraphNONAME->Draw("PSAME");
1688  if(lyz1prodMeanNONAME) lyz1prodMeanNONAME->Draw("PSAME");
1689
1690  if(plotLegend)
1691  {
1692   // 2nd pad is for legend:
1693   (intFlowCanvasNONAME->cd(2))->SetPad(0.75,0.0,1.0,1.0);
1694  }
1695
1696  // count real estimates:
1697  Int_t mcepCountRealNONAME = 0;
1698  Int_t spCountRealNONAME = 0;
1699  Int_t gfc2CountRealNONAME = 0;
1700  Int_t gfc4CountRealNONAME = 0;
1701  Int_t gfc6CountRealNONAME = 0;
1702  Int_t gfc8CountRealNONAME = 0;
1703  Int_t qc2CountRealNONAME = 0;
1704  Int_t qc4CountRealNONAME = 0;
1705  Int_t qc6CountRealNONAME = 0;
1706  Int_t qc8CountRealNONAME = 0;
1707  Int_t fqdCountRealNONAME = 0;
1708  Int_t lyz1sumCountRealNONAME = 0;
1709  Int_t lyz1prodCountRealNONAME = 0;
1710  Int_t lyzepCountRealNONAME = 0;
1711
1712  Int_t N = 0;
1713  if(nSubsets > 0)
1714  {
1715   N = nSubsets;
1716  } else
1717    {
1718     N = nEstimates;
1719    }
1720
1721  for(Int_t i=0;i<N;i++)
1722  {
1723   if(mcepValueNONAME[i]>0.) mcepCountRealNONAME++;
1724   if(spValueNONAME[i]>0.) spCountRealNONAME++;
1725   if(gfc2ValueNONAME[i]>0.) gfc2CountRealNONAME++;
1726   if(gfc4ValueNONAME[i]>0.) gfc4CountRealNONAME++;
1727   if(gfc6ValueNONAME[i]>0.) gfc6CountRealNONAME++;
1728   if(gfc8ValueNONAME[i]>0.) gfc8CountRealNONAME++;
1729   if(qc2ValueNONAME[i]>0.) qc2CountRealNONAME++;
1730   if(qc4ValueNONAME[i]>0.) qc4CountRealNONAME++;
1731   if(qc6ValueNONAME[i]>0.) qc6CountRealNONAME++;
1732   if(qc8ValueNONAME[i]>0.) qc8CountRealNONAME++;
1733   if(fqdValueNONAME[i]>0.) fqdCountRealNONAME++;
1734   if(lyz1sumValueNONAME[i]>0.) lyz1sumCountRealNONAME++;
1735   if(lyz1prodValueNONAME[i]>0.) lyz1prodCountRealNONAME++;
1736   if(lyzepValueNONAME[i]>0.) lyzepCountRealNONAME++;
1737  }
1738
1739  TPaveText *textDefaultNONAME = new TPaveText(0.05,0.71,0.95,0.95,"NDC");
1740  textDefaultNONAME->SetTextFont(72);
1741  textDefaultNONAME->SetTextSize(0.08);
1742
1743  TString *entryDefaultRealNONAME = new TString("Real estimates");
1744  //TString *entryDefaultOutOfNONAME = new TString("out of");
1745  TString *entryDefaultTotalNumberNONAME = new TString(" out of total number of ");
1746  TString *entryDefaultTotalIndNONAME = new TString("independent");
1747  TString *entryDefaultTotalSimNONAME = new TString("simulations:");
1748
1749  textDefaultNONAME->AddText(entryDefaultRealNONAME->Data());
1750  //textDefaultNONAME->AddText(entryDefaultOutOfNONAME->Data());
1751  textDefaultNONAME->AddText(entryDefaultTotalNumberNONAME->Data());
1752  textDefaultNONAME->AddText(entryDefaultTotalIndNONAME->Data());
1753  textDefaultNONAME->AddText(entryDefaultTotalSimNONAME->Data());
1754
1755  // average multiplicity and number of events: (to be improved)
1756  TPaveText *textAvMNevtsNONAME = new TPaveText(0.05,0.05,0.95,0.14,"NDC");
1757  textAvMNevtsNONAME->SetTextFont(72);
1758  textAvMNevtsNONAME->SetTextSize(0.06);
1759
1760  TString *entryNevtsNONAME = new TString("MC .... nEvts = ");
1761  TString *entryAvMNONAME   = new TString("MC .... AvM = ");
1762
1763  (*entryNevtsNONAME)+=(Long_t)mergedNMCEP;
1764  (*entryAvMNONAME)+=(Long_t)mergedAvMMCEP;
1765
1766  textAvMNevtsNONAME->AddText(entryNevtsNONAME->Data());
1767  textAvMNevtsNONAME->AddText(entryAvMNONAME->Data());
1768
1769  // results:
1770  TPaveText *textResultsNONAME = new TPaveText(0.05,0.17,0.95,0.68,"NDC");
1771  textResultsNONAME->SetTextFont(72);
1772  textResultsNONAME->SetTextSize(0.06);
1773
1774  // entries:
1775  TString *entryIntFlowMCNONAME       = new TString("MC ................ ");
1776  TString *entryIntFlowSPNONAME       = new TString("SP ................ ");
1777  TString *entryIntFlowGFC2NONAME     = new TString("GFC{2} ........ ");
1778  TString *entryIntFlowGFC4NONAME     = new TString("GFC{4} ........ ");
1779  TString *entryIntFlowGFC6NONAME     = new TString("GFC{6} ........ ");
1780  TString *entryIntFlowGFC8NONAME     = new TString("GFC{8} ........ ");
1781  TString *entryIntFlowQC2NONAME      = new TString("QC{2} .......... ");
1782  TString *entryIntFlowQC4NONAME      = new TString("QC{4} .......... ");
1783  TString *entryIntFlowQC6NONAME      = new TString("QC{6} .......... ");
1784  TString *entryIntFlowQC8NONAME      = new TString("QC{8} .......... ");
1785  TString *entryIntFlowFQDNONAME      = new TString("FQD ............. ");
1786  TString *entryIntFlowLYZ1SUMNONAME  = new TString("LYZ{sum} ......... ");
1787  TString *entryIntFlowLYZ1PRODNONAME = new TString("LYZ{prod} ........ ");
1788  TString *entryIntFlowLYZEPNONAME    = new TString("LYZEP ........ ");
1789
1790  if(entryIntFlowMCNONAME)
1791  {
1792   (*entryIntFlowMCNONAME)+=(Long_t)mcepCountRealNONAME;
1793   entryIntFlowMCNONAME->Append(" out of ");
1794   (*entryIntFlowMCNONAME)+=(Long_t)nPointsMCEP;
1795   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowMCNONAME->Data());
1796  }
1797
1798  if(entryIntFlowSPNONAME)
1799  {
1800   (*entryIntFlowSPNONAME)+=(Long_t)spCountRealNONAME;
1801   entryIntFlowSPNONAME->Append(" out of ");
1802   (*entryIntFlowSPNONAME)+=(Long_t)nPointsSP;
1803   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowSPNONAME->Data());
1804  }
1805
1806  if(entryIntFlowGFC2NONAME)
1807  {
1808   (*entryIntFlowGFC2NONAME)+=(Long_t)gfc2CountRealNONAME;
1809   entryIntFlowGFC2NONAME->Append(" out of ");
1810   (*entryIntFlowGFC2NONAME)+=(Long_t)nPointsGFC;
1811   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowGFC2NONAME->Data());
1812  }
1813
1814  if(entryIntFlowGFC4NONAME)
1815  {
1816   (*entryIntFlowGFC4NONAME)+=(Long_t)gfc4CountRealNONAME;
1817   entryIntFlowGFC4NONAME->Append(" out of ");
1818   (*entryIntFlowGFC4NONAME)+=(Long_t)nPointsGFC;
1819   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowGFC4NONAME->Data());
1820  }
1821
1822  if(entryIntFlowGFC6NONAME)
1823  {
1824   (*entryIntFlowGFC6NONAME)+=(Long_t)gfc6CountRealNONAME;
1825   entryIntFlowGFC6NONAME->Append(" out of ");
1826   (*entryIntFlowGFC6NONAME)+=(Long_t)nPointsGFC;
1827   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowGFC6NONAME->Data());
1828  }
1829
1830  if(entryIntFlowGFC8NONAME)
1831  {
1832   (*entryIntFlowGFC8NONAME)+=(Long_t)gfc8CountRealNONAME;
1833   entryIntFlowGFC8NONAME->Append(" out of ");
1834   (*entryIntFlowGFC8NONAME)+=(Long_t)nPointsGFC;
1835   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowGFC8NONAME->Data());
1836  }
1837
1838  if(entryIntFlowQC2NONAME)
1839  {
1840   (*entryIntFlowQC2NONAME)+=(Long_t)qc2CountRealNONAME;
1841   entryIntFlowQC2NONAME->Append(" out of ");
1842   (*entryIntFlowQC2NONAME)+=(Long_t)nPointsQC;
1843   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowQC2NONAME->Data());
1844  }
1845
1846  if(entryIntFlowQC4NONAME)
1847  {
1848   (*entryIntFlowQC4NONAME)+=(Long_t)qc4CountRealNONAME;
1849   entryIntFlowQC4NONAME->Append(" out of ");
1850   (*entryIntFlowQC4NONAME)+=(Long_t)nPointsQC;
1851   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowQC4NONAME->Data());
1852  }
1853
1854  if(entryIntFlowQC2NONAME)
1855  {
1856   (*entryIntFlowQC6NONAME)+=(Long_t)qc6CountRealNONAME;
1857   entryIntFlowQC6NONAME->Append(" out of ");
1858   (*entryIntFlowQC6NONAME)+=(Long_t)nPointsQC;
1859   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowQC6NONAME->Data());
1860  }
1861
1862  if(entryIntFlowQC8NONAME)
1863  {
1864   (*entryIntFlowQC8NONAME)+=(Long_t)qc8CountRealNONAME;
1865   entryIntFlowQC8NONAME->Append(" out of ");
1866   (*entryIntFlowQC8NONAME)+=(Long_t)nPointsQC;
1867   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowQC8NONAME->Data());
1868  }
1869
1870  if(entryIntFlowFQDNONAME)
1871  {
1872   (*entryIntFlowFQDNONAME)+=(Long_t)fqdCountRealNONAME;
1873   entryIntFlowFQDNONAME->Append(" out of ");
1874   (*entryIntFlowFQDNONAME)+=(Long_t)nPointsFQD;
1875   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowFQDNONAME->Data());
1876  }
1877
1878  if(entryIntFlowLYZ1SUMNONAME)
1879  {
1880   (*entryIntFlowLYZ1SUMNONAME)+=(Long_t)lyz1sumCountRealNONAME;
1881   entryIntFlowLYZ1SUMNONAME->Append(" out of ");
1882   (*entryIntFlowLYZ1SUMNONAME)+=(Long_t)nPointsLYZ1SUM;
1883   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowLYZ1SUMNONAME->Data());
1884  }
1885
1886  if(entryIntFlowLYZ1PRODNONAME)
1887  {
1888   (*entryIntFlowLYZ1PRODNONAME)+=(Long_t)lyz1prodCountRealNONAME;
1889   entryIntFlowLYZ1PRODNONAME->Append(" out of ");
1890   (*entryIntFlowLYZ1PRODNONAME)+=(Long_t)nPointsLYZ1PROD;
1891   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowLYZ1PRODNONAME->Data());
1892  }
1893
1894  if(entryIntFlowLYZEPNONAME)
1895  {
1896   (*entryIntFlowLYZEPNONAME)+=(Long_t)lyzepCountRealNONAME;
1897   entryIntFlowLYZEPNONAME->Append(" out of ");
1898   (*entryIntFlowLYZEPNONAME)+=(Long_t)nPointsLYZEP;
1899   if(textResultsNONAME)textResultsNONAME->AddText(entryIntFlowLYZEPNONAME->Data());
1900  }
1901
1902  if(plotLegend)
1903  {
1904   if(textDefaultNONAME) textDefaultNONAME->Draw();
1905   if(textResultsNONAME) textResultsNONAME->Draw();
1906   if(textAvMNevtsNONAME) textAvMNevtsNONAME->Draw();
1907  }
1908 }
1909
1910 void LoadSpreadLibraries(const libModes mode) {
1911
1912   //--------------------------------------
1913   // Load the needed libraries most of them already loaded by aliroot
1914   //--------------------------------------
1915   gSystem->Load("libTree.so");
1916   gSystem->Load("libGeom.so");
1917   gSystem->Load("libVMC.so");
1918   gSystem->Load("libXMLIO.so");
1919   gSystem->Load("libPhysics.so");
1920
1921   //----------------------------------------------------------
1922   // >>>>>>>>>>> Local mode <<<<<<<<<<<<<<
1923   //----------------------------------------------------------
1924   if (mode==mLocal) {
1925     //--------------------------------------------------------
1926     // If you want to use already compiled libraries
1927     // in the aliroot distribution
1928     //--------------------------------------------------------
1929
1930   //==================================================================================
1931   //load needed libraries:
1932   gSystem->AddIncludePath("-I$ROOTSYS/include");
1933   gSystem->Load("libTree.so");
1934
1935   // for AliRoot
1936   gSystem->AddIncludePath("-I$ALICE_ROOT/include");
1937   gSystem->Load("libANALYSIS.so");
1938   gSystem->Load("libPWG2flowCommon.so");
1939   cerr<<"libPWG2flowCommon.so loaded ..."<<endl;
1940
1941   }
1942
1943   else if (mode==mLocalSource) {
1944
1945     // In root inline compile
1946
1947     // Constants
1948     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonConstants.cxx+");
1949     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZConstants.cxx+");
1950     gROOT->LoadMacro("AliFlowCommon/AliFlowCumuConstants.cxx+");
1951
1952     // Flow event
1953     gROOT->LoadMacro("AliFlowCommon/AliFlowVector.cxx+");
1954     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimple.cxx+");
1955     gROOT->LoadMacro("AliFlowCommon/AliFlowEventSimple.cxx+");
1956
1957     // Cuts
1958     gROOT->LoadMacro("AliFlowCommon/AliFlowTrackSimpleCuts.cxx+");
1959
1960     // Output histosgrams
1961     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHist.cxx+");
1962     gROOT->LoadMacro("AliFlowCommon/AliFlowCommonHistResults.cxx+");
1963     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist1.cxx+");
1964     gROOT->LoadMacro("AliFlowCommon/AliFlowLYZHist2.cxx+");
1965
1966     cout << "finished loading macros!" << endl;
1967
1968   }
1969
1970
1971 }
1972
1973