enum libModes {mLocal,mLocalSource};
-void mergeOutput(TString type="", Int_t nRuns=-1, Int_t mode=mLocal)
+void mergeOutput(TString type="", Int_t mode=mLocal)
{
// type: type of analysis can be ESD, AOD, MC, ESDMC0, ESDMC1
- // (if type="" output files are from MC simulation (default))
- // nRuns: specify here how many output .root files will be merged
- // (if nRuns = -1 all of them will be merged)
- // mode: if mode=mLocal analyze data on your computer using aliroot
- // if mode=mLocalSource analyze data on your computer using root + source files
-
- Int_t cycle = 50; // if you cannot have >= 50 open files in memory, simply decrease this number
-
- // load needed libraries:
- LoadSpreadLibrariesMO(mode);
-
- // access the path of current directory:
- TString pwd(gSystem->pwd());
- pwd+="/";
-
- // file mergers for the output file of each method separately:
- // MCEP:
- TFileMerger *mcepFileMerger = new TFileMerger();
- TString mergedFileNameMCEP("mergedMCEPanalysis");
- (mergedFileNameMCEP+=(type.Data()))+=(".root");
- TString pwdMCEP=pwd.Data();
- if(!(gSystem->AccessPathName((pwdMCEP+=mergedFileNameMCEP).Data(),kFileExists)))
+ // (if type="" than output files are from MC simulation (default))
+ // mode: if mode=mLocal than analyze data on your computer using aliroot
+ // if mode=mLocalSource than analyze data on your computer using root + source files
+
+ // settings for merging:
+ Bool_t devideOutputFilesInEqualSubsets = kFALSE; // if kFALSE: All output files will be merged in a single output file
+ // (this is deafult for merging on Grid).
+ // if kTRUE: All output files will be merged in a single output file, but ALSO
+ // all output files will be devided in N equal subsets (nSubsets) and for
+ // each subset merging will be done separately. Merged output files for subsets
+ // are stored in subdirectories subset1, subset2, ..., subsetN.
+ // This feature is used to estimate the spread.
+
+ const Int_t nSubsets = 10; //number od subsets used to estimate spread
+ const Int_t cycle = 10; // merging is done in cycles and this is the cycle period
+
+ // default names of subdirectories in which merged output files for subsets are stored:
+ TString *dirNameSubset = NULL;
+ if(devideOutputFilesInEqualSubsets)
{
- cout<<"WARNING: You already have a merged output for MCEP !!!!"<<endl;
- break;
+ dirNameSubset = new TString("subset");
}
- //mcepFileMerger->OutputFile(mergedFileNameMCEP);
- // SP:
- TFileMerger *spFileMerger = new TFileMerger();
- TString mergedFileNameSP("mergedSPanalysis");
- (mergedFileNameSP+=(type.Data()))+=(".root");
- TString pwdSP=pwd.Data();
- if(!(gSystem->AccessPathName((pwdSP+=mergedFileNameSP).Data(),kFileExists)))
+ if(cycle>100 && !devideOutputFilesInEqualSubsets)
{
- cout<<"WARNING: You already have a merged output for SP !!!!"<<endl;
- break;
+ cout<<"WARNING: Cycle is too big !!!!"<<endl;
+ cout<<" Set const Int_t cycle to smaller value in the macro."<<endl;
+ exit(0);
}
- spFileMerger->OutputFile(mergedFileNameSP);
- // GFC:
- TFileMerger *gfcFileMerger = new TFileMerger();
- TString mergedFileNameGFC("mergedGFCanalysis");
- (mergedFileNameGFC+=(type.Data()))+=(".root");
- TString pwdGFC=pwd.Data();
- if(!(gSystem->AccessPathName((pwdGFC+=mergedFileNameGFC).Data(),kFileExists)))
+ if(cycle>10 && devideOutputFilesInEqualSubsets)
{
- cout<<"WARNING: You already have a merged output for GFC !!!!"<<endl;
- break;
+ cout<<"WARNING: Cycle is too big !!!!"<<endl;
+ cout<<" Set const Int_t cycle to smaller value in the macro."<<endl;
+ exit(0);
}
- gfcFileMerger->OutputFile(mergedFileNameGFC);
-
- // QC:
- TFileMerger *qcFileMerger = new TFileMerger();
- TString mergedFileNameQC("mergedQCanalysis");
- (mergedFileNameQC+=(type.Data()))+=(".root");
- TString pwdQC=pwd.Data();
- if(!(gSystem->AccessPathName((pwdQC+=mergedFileNameQC).Data(),kFileExists)))
+
+ if(cycle<=0)
{
- cout<<"WARNING: You already have a merged output for QC !!!!"<<endl;
- break;
+ cout<<"WARNING: Cycle must be a positive integer !!!!"<<endl;
+ cout<<" Set const Int_t cycle to a positive integer in the macro."<<endl;
+ exit(0);
}
- qcFileMerger->OutputFile(mergedFileNameQC);
- // FQD:
- TFileMerger *fqdFileMerger = new TFileMerger();
- TString mergedFileNameFQD("mergedFQDanalysis");
- (mergedFileNameFQD+=(type.Data()))+=(".root");
- TString pwdFQD=pwd.Data();
- if(!(gSystem->AccessPathName((pwdFQD+=mergedFileNameFQD).Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets && nSubsets<=0)
{
- cout<<"WARNING: You already have a merged output for FQD !!!!"<<endl;
- break;
+ cout<<"WARNING: Number od subsets must be a positive integer !!!!"<<endl;
+ cout<<" Set const Int_t nSubsets to a positive integer in the macro."<<endl;
+ exit(0);
}
- fqdFileMerger->OutputFile(mergedFileNameFQD);
- // LYZ1:
- TFileMerger *lyz1FileMerger = new TFileMerger();
- TString mergedFileNameLYZ1("mergedLYZ1analysis");
- (mergedFileNameLYZ1+=(type.Data()))+=(".root");
- TString pwdLYZ1=pwd.Data();
- if(!(gSystem->AccessPathName((pwdLYZ1+=mergedFileNameLYZ1).Data(),kFileExists)))
- {
- cout<<"WARNING: You already have a merged output for LYZ1 !!!!"<<endl;
- break;
- }
- lyz1FileMerger->OutputFile(mergedFileNameLYZ1);
+ // load needed libraries:
+ LoadLibrariesMO(mode);
+
+ // standard magic:
+ TString *baseDirPath = new TString(gSystem->pwd());
+ TSystemDirectory* baseDir = new TSystemDirectory(".",baseDirPath->Data());
+ TList* listOfFilesInBaseDir = baseDir->GetListOfFiles();
+ // listOfFilesInBaseDir->Print();
+ Int_t nFiles = listOfFilesInBaseDir->GetEntries();
- // LYZ2:
- TFileMerger *lyz2FileMerger = new TFileMerger();
- TString mergedFileNameLYZ2("mergedLYZ2analysis");
- (mergedFileNameLYZ2+=(type.Data()))+=(".root");
- TString pwdLYZ2=pwd.Data();
- if(!(gSystem->AccessPathName((pwdLYZ2+=mergedFileNameLYZ2).Data(),kFileExists)))
+ // checking if subdirectories with default names for subsets already exist:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- cout<<"WARNING: You already have a merged output for LYZ2 !!!!"<<endl;
- break;
- }
- lyz2FileMerger->OutputFile(mergedFileNameLYZ2);
-
- // LYZEP:
- TFileMerger *lyzepFileMerger = new TFileMerger();
- TString mergedFileNameLYZEP("mergedLYZEPanalysis");
- (mergedFileNameLYZEP+=(type.Data()))+=(".root");
- TString pwdLYZEP=pwd.Data();
- if(!(gSystem->AccessPathName((pwdLYZEP+=mergedFileNameLYZEP).Data(),kFileExists)))
+ for(Int_t iFile=0;iFile<nFiles;iFile++)
+ {
+ TSystemFile* presentFile = (TSystemFile*)listOfFilesInBaseDir->At(iFile);
+ TString presentFileName = baseDirPath->Data();
+ (presentFileName+="/")+=presentFile->GetName();
+ if(presentFileName.Contains("subset"))
+ {
+ cout<<"WARNING: You already have directory "<<presentFileName.Data()<<" !!!!"<<endl;
+ cout<<" Remove this directory and start macro again."<<endl;
+ exit(0);
+ }
+ } // end of for(Int_t iFile=0;iFile<nFiles;iFile++)
+ } // end of if(devideOutputFilesInEqualSubsets)
+
+ // create subdirectories for storing merged results for subsets:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- cout<<"WARNING: You already have a merged output for LYZEP !!!!"<<endl;
- break;
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ TString currentDirForSpreadName(dirNameSubset->Data());
+ Bool_t bDirectoryMade = gSystem->mkdir((currentDirForSpreadName += (i+1)).Data());
+ if(bDirectoryMade)
+ {
+ cout<<"WARNING: The directory "<<currentDirForSpreadName.Data()<<" could not be created (illegal path name) !!!!"<<endl;
+ exit(0);
+ }
+ }
}
- lyzepFileMerger->OutputFile(mergedFileNameLYZEP);
- // standard magic:
- TString execDir(gSystem->pwd());
- TSystemDirectory* baseDir = new TSystemDirectory(".",execDir.Data());
- TList* dirList = baseDir->GetListOfFiles();
- Int_t nDirs = dirList->GetEntries();
- gSystem->cd(execDir);
-
- Int_t counter = 0;
+ // loop over directories and add output *.root files to TFileMerger:
+ gSystem->cd(baseDirPath->Data());
- Int_t counterMCEP = 0;
- Int_t maxCycleMCEP = 0;
- Int_t counterSP = 0;
- Int_t maxCycleSP = 0;
- Int_t counterGFC = 0;
- Int_t maxCycleGFC = 0;
- Int_t counterQC = 0;
- Int_t maxCycleQC = 0;
- Int_t counterFQD = 0;
- Int_t maxCycleFQD = 0;
- Int_t counterLYZ1 = 0;
- Int_t maxCycleLYZ1 = 0;
-
- if(cycle>nDirs) // to be improved (temporary workaroud)
- {
- cout<<"WARNING: Cycle "<<cycle<<" is too big. Decrease it's value in the declaration Int_t cycle in the macro !!!!"<<endl;
- break;
- }
-
- for(Int_t iDir=0;iDir<nDirs;++iDir)
+ // MCEP:
+ Int_t fileCounterMCEP = 0;
+ Int_t fileCounterLastSubsetMCEP = 0;
+ TFileMerger *fileMergerMCEP = new TFileMerger();
+ TFileMerger fileMergerForSubsetsMCEP[nSubsets];
+
+ // SP:
+ Int_t fileCounterSP = 0;
+ Int_t fileCounterLastSubsetSP = 0;
+ TFileMerger *fileMergerSP = new TFileMerger();
+ TFileMerger fileMergerForSubsetsSP[nSubsets];
+
+ // GFC:
+ Int_t fileCounterGFC = 0;
+ Int_t fileCounterLastSubsetGFC = 0;
+ TFileMerger *fileMergerGFC = new TFileMerger();
+ TFileMerger fileMergerForSubsetsGFC[nSubsets];
+
+ // QC:
+ Int_t fileCounterQC = 0;
+ Int_t fileCounterLastSubsetQC = 0;
+ TFileMerger *fileMergerQC = new TFileMerger();
+ TFileMerger fileMergerForSubsetsQC[nSubsets];
+
+ // FQD:
+ Int_t fileCounterFQD = 0;
+ Int_t fileCounterLastSubsetFQD = 0;
+ TFileMerger *fileMergerFQD = new TFileMerger();
+ TFileMerger fileMergerForSubsetsFQD[nSubsets];
+
+ // LYZ1SUM:
+ Int_t fileCounterLYZ1SUM = 0;
+ Int_t fileCounterLastSubsetLYZ1SUM = 0;
+ TFileMerger *fileMergerLYZ1SUM = new TFileMerger();
+ TFileMerger fileMergerForSubsetsLYZ1SUM[nSubsets];
+
+ // LYZ1PROD:
+ Int_t fileCounterLYZ1PROD = 0;
+ Int_t fileCounterLastSubsetLYZ1PROD = 0;
+ TFileMerger *fileMergerLYZ1PROD = new TFileMerger();
+ TFileMerger fileMergerForSubsetsLYZ1PROD[nSubsets];
+
+ // LYZEP:
+ Int_t fileCounterLYZEP = 0;
+ Int_t fileCounterLastSubsetLYZEP = 0;
+ TFileMerger *fileMergerLYZEP = new TFileMerger();
+ TFileMerger fileMergerForSubsetsLYZEP[nSubsets];
+
+ for(Int_t iFile=0;iFile<nFiles;iFile++)
{
- TSystemFile* presentDir = (TSystemFile*)dirList->At(iDir);
- if(!presentDir || !presentDir->IsDirectory() || strcmp(presentDir->GetName(), ".") == 0 ||
- strcmp(presentDir->GetName(), "..") == 0) continue;
-
- if(nRuns != -1)
- {
- if (counter >= nRuns) break;
- }
-
- TString presentDirName(gSystem->pwd());
- presentDirName += "/";
- presentDirName += presentDir->GetName();
- presentDirName += "/";
-
- // accessing the output .root files from independent analysis for each method:
- // MCEP:
- TString fileNameMCEP = presentDirName;
+ TSystemFile* presentFile = (TSystemFile*)listOfFilesInBaseDir->At(iFile);
+
+ if(!presentFile || !presentFile->IsDirectory() || strcmp(presentFile->GetName(), ".") == 0 ||
+ strcmp(presentFile->GetName(), "..") == 0) continue;
+
+ TString presentDirName = baseDirPath->Data();
+ (presentDirName+="/")+=presentFile->GetName();
+ presentDirName+="/";
+
+ // accessing the output *.root file in this directory:
+ // MCEP:
+ TString fileNameMCEP = presentDirName;
((fileNameMCEP+="outputMCEPanalysis")+=type.Data())+=".root";
if(!(gSystem->AccessPathName(fileNameMCEP.Data(),kFileExists)))
{
- mcepFileMerger->AddFile(fileNameMCEP.Data());
- counterMCEP++;
- } else
- {
- cout<<"WARNING: Couldn't find a file "<<fileNameMCEP.Data()<<". Merging will continue without this file."<<endl;
- }
-
- if(counterMCEP % cycle == 0)
- {
- maxCycleMCEP = counterMCEP/cycle;
- TString mergedFileNameCurrentCycleMCEP("mergedMCEPanalysis");
- ((mergedFileNameCurrentCycleMCEP+=(type.Data()))+=counterMCEP/cycle)+=(".root");
- mcepFileMerger->OutputFile(mergedFileNameCurrentCycleMCEP);
+ fileCounterMCEP++;
+ fileMergerMCEP->AddFile(fileNameMCEP.Data());
- TString mergedFileNamePreviousCycleMCEP("mergedMCEPanalysis");
- ((mergedFileNamePreviousCycleMCEP+=(type.Data()))+=(counterMCEP/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleMCEP.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- mcepFileMerger->AddFile(mergedFileNamePreviousCycleMCEP.Data());
- }
-
- Bool_t mcepMerged = kFALSE;
- if(mcepFileMerger)
- {
- mcepMerged = mcepFileMerger->Merge();
- mcepFileMerger->Reset();
- }
+ fileMergerForSubsetsMCEP[(fileCounterMCEP-1) % nSubsets].AddFile(fileNameMCEP.Data());
+ if(fileCounterMCEP % nSubsets == 0)
+ {
+ fileCounterLastSubsetMCEP++;
+ }
+ }
- if(mcepMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleMCEP.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterMCEP % cycle == 0)
-
- // SP:
- TString fileNameSP = presentDirName;
- ((fileNameSP+="outputSPanalysis")+=type.Data())+=".root";
- if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
- {
- spFileMerger->AddFile(fileNameSP.Data());
- counterSP++;
- } else
+ // global merging:
+ if(fileCounterMCEP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileForPreviousCycleMCEP)+=type.Data();
+ (*mergedFileForPreviousCycleMCEP)+=(fileCounterMCEP/cycle - 1);
+ (*mergedFileForPreviousCycleMCEP)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleMCEP->Data(),kFileExists)))
{
- cout<<"WARNING: Couldn't find a file "<<fileNameSP.Data()<<". Merging will continue without this file."<<endl;
- }
+ fileMergerMCEP->AddFile(mergedFileForPreviousCycleMCEP->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleMCEP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileForCurrentCycleMCEP)+=type.Data();
+ (*mergedFileForCurrentCycleMCEP)+=(fileCounterMCEP/cycle);
+ (*mergedFileForCurrentCycleMCEP)+=".root";
+
+ fileMergerMCEP->OutputFile(mergedFileForCurrentCycleMCEP->Data());
+ fileMergerMCEP->Merge();
+ fileMergerMCEP->Reset();
- if(counterSP % cycle == 0)
+ delete mergedFileForPreviousCycleMCEP;
+ delete mergedFileForCurrentCycleMCEP;
+ } // end of if(fileCounterMCEP % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetMCEP > 0 && fileCounterLastSubsetMCEP % cycle == 0 && fileCounterMCEP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetMCEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle - 1);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsMCEP[i].AddFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetMCEP[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetMCEP[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetMCEP[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle);
+ mergedFileForCurrentCycleForSubsetMCEP[i]+=".root";
+
+ fileMergerForSubsetsMCEP[i].OutputFile(mergedFileForCurrentCycleForSubsetMCEP[i].Data());
+ fileMergerForSubsetsMCEP[i].Merge();
+ fileMergerForSubsetsMCEP[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetMCEP % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameMCEP.Data(),kFileExists)))
+
+ // SP:
+ TString fileNameSP = presentDirName;
+ ((fileNameSP+="outputSPanalysis")+=type.Data())+=".root";
+ if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
{
- maxCycleSP = counterSP/cycle;
- TString mergedFileNameCurrentCycleSP("mergedSPanalysis");
- ((mergedFileNameCurrentCycleSP+=(type.Data()))+=counterSP/cycle)+=(".root");
- spFileMerger->OutputFile(mergedFileNameCurrentCycleSP);
+ fileCounterSP++;
+ fileMergerSP->AddFile(fileNameSP.Data());
- TString mergedFileNamePreviousCycleSP("mergedSPanalysis");
- ((mergedFileNamePreviousCycleSP+=(type.Data()))+=(counterSP/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleSP.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- spFileMerger->AddFile(mergedFileNamePreviousCycleSP.Data());
- }
-
- Bool_t spMerged = kFALSE;
- if(spFileMerger)
- {
- spMerged = spFileMerger->Merge();
- spFileMerger->Reset();
- }
+ fileMergerForSubsetsSP[(fileCounterSP-1) % nSubsets].AddFile(fileNameSP.Data());
+ if(fileCounterSP % nSubsets == 0)
+ {
+ fileCounterLastSubsetSP++;
+ }
+ }
- if(spMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleSP.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterSP % cycle == 0)
+ // global merging:
+ if(fileCounterSP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
+ (*mergedFileForPreviousCycleSP)+=type.Data();
+ (*mergedFileForPreviousCycleSP)+=(fileCounterSP/cycle - 1);
+ (*mergedFileForPreviousCycleSP)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleSP->Data(),kFileExists)))
+ {
+ fileMergerSP->AddFile(mergedFileForPreviousCycleSP->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleSP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleSP = new TString("mergedSPanalysis");
+ (*mergedFileForCurrentCycleSP)+=type.Data();
+ (*mergedFileForCurrentCycleSP)+=(fileCounterSP/cycle);
+ (*mergedFileForCurrentCycleSP)+=".root";
+
+ fileMergerSP->OutputFile(mergedFileForCurrentCycleSP->Data());
+ fileMergerSP->Merge();
+ fileMergerSP->Reset();
+
+ delete mergedFileForPreviousCycleSP;
+ delete mergedFileForCurrentCycleSP;
+ } // end of if(fileCounterSP % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetSP > 0 && fileCounterLastSubsetSP % cycle == 0 && fileCounterSP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetSP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle - 1);
+ mergedFileForPreviousCycleForSubsetSP[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetSP[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsSP[i].AddFile(mergedFileForPreviousCycleForSubsetSP[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetSP[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetSP[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetSP[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle);
+ mergedFileForCurrentCycleForSubsetSP[i]+=".root";
+
+ fileMergerForSubsetsSP[i].OutputFile(mergedFileForCurrentCycleForSubsetSP[i].Data());
+ fileMergerForSubsetsSP[i].Merge();
+ fileMergerForSubsetsSP[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetSP % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameSP.Data(),kFileExists)))
- // GFC:
- TString fileNameGFC = presentDirName;
+ // GFC:
+ TString fileNameGFC = presentDirName;
((fileNameGFC+="outputGFCanalysis")+=type.Data())+=".root";
if(!(gSystem->AccessPathName(fileNameGFC.Data(),kFileExists)))
{
- gfcFileMerger->AddFile(fileNameGFC.Data());
- counterGFC++;
- } else
- {
- cout<<"WARNING: Couldn't find a file "<<fileNameGFC.Data()<<". Merging will continue without this file."<<endl;
- }
-
- if(counterGFC % cycle == 0)
- {
- maxCycleGFC = counterGFC/cycle;
- TString mergedFileNameCurrentCycleGFC("mergedGFCanalysis");
- ((mergedFileNameCurrentCycleGFC+=(type.Data()))+=counterGFC/cycle)+=(".root");
- gfcFileMerger->OutputFile(mergedFileNameCurrentCycleGFC);
+ fileCounterGFC++;
+ fileMergerGFC->AddFile(fileNameGFC.Data());
- TString mergedFileNamePreviousCycleGFC("mergedGFCanalysis");
- ((mergedFileNamePreviousCycleGFC+=(type.Data()))+=(counterGFC/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleGFC.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- gfcFileMerger->AddFile(mergedFileNamePreviousCycleGFC.Data());
- }
+ fileMergerForSubsetsGFC[(fileCounterGFC-1) % nSubsets].AddFile(fileNameGFC.Data());
+ if(fileCounterGFC % nSubsets == 0)
+ {
+ fileCounterLastSubsetGFC++;
+ }
+ }
- Bool_t gfcMerged = kFALSE;
- if(gfcFileMerger)
- {
- gfcMerged = gfcFileMerger->Merge();
- gfcFileMerger->Reset();
- }
+ // global merging:
+ if(fileCounterGFC % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
+ (*mergedFileForPreviousCycleGFC)+=type.Data();
+ (*mergedFileForPreviousCycleGFC)+=(fileCounterGFC/cycle - 1);
+ (*mergedFileForPreviousCycleGFC)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleGFC->Data(),kFileExists)))
+ {
+ fileMergerGFC->AddFile(mergedFileForPreviousCycleGFC->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleGFC->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleGFC = new TString("mergedGFCanalysis");
+ (*mergedFileForCurrentCycleGFC)+=type.Data();
+ (*mergedFileForCurrentCycleGFC)+=(fileCounterGFC/cycle);
+ (*mergedFileForCurrentCycleGFC)+=".root";
+
+ fileMergerGFC->OutputFile(mergedFileForCurrentCycleGFC->Data());
+ fileMergerGFC->Merge();
+ fileMergerGFC->Reset();
+
+ delete mergedFileForPreviousCycleGFC;
+ delete mergedFileForCurrentCycleGFC;
+ } // end of if(fileCounterGFC % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetGFC > 0 && fileCounterLastSubsetGFC % cycle == 0 && fileCounterGFC % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetGFC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle - 1);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetGFC[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsGFC[i].AddFile(mergedFileForPreviousCycleForSubsetGFC[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetGFC[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetGFC[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetGFC[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle);
+ mergedFileForCurrentCycleForSubsetGFC[i]+=".root";
+
+ fileMergerForSubsetsGFC[i].OutputFile(mergedFileForCurrentCycleForSubsetGFC[i].Data());
+ fileMergerForSubsetsGFC[i].Merge();
+ fileMergerForSubsetsGFC[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetGFC % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameGFC.Data(),kFileExists)))
- if(gfcMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleGFC.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterGFC % cycle == 0)
-
- // QC:
- TString fileNameQC = presentDirName;
+ // QC:
+ TString fileNameQC = presentDirName;
((fileNameQC+="outputQCanalysis")+=type.Data())+=".root";
if(!(gSystem->AccessPathName(fileNameQC.Data(),kFileExists)))
{
- qcFileMerger->AddFile(fileNameQC.Data());
- counterQC++;
- } else
- {
- cout<<"WARNING: Couldn't find a file "<<fileNameQC.Data()<<". Merging will continue without this file."<<endl;
- }
-
- if(counterQC % cycle == 0)
- {
- maxCycleQC = counterQC/cycle;
- TString mergedFileNameCurrentCycleQC("mergedQCanalysis");
- ((mergedFileNameCurrentCycleQC+=(type.Data()))+=counterQC/cycle)+=(".root");
- qcFileMerger->OutputFile(mergedFileNameCurrentCycleQC);
+ fileCounterQC++;
+ fileMergerQC->AddFile(fileNameQC.Data());
- TString mergedFileNamePreviousCycleQC("mergedQCanalysis");
- ((mergedFileNamePreviousCycleQC+=(type.Data()))+=(counterQC/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleQC.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- qcFileMerger->AddFile(mergedFileNamePreviousCycleQC.Data());
- }
-
- Bool_t qcMerged = kFALSE;
- if(qcFileMerger)
- {
- qcMerged = qcFileMerger->Merge();
- qcFileMerger->Reset();
- }
+ fileMergerForSubsetsQC[(fileCounterQC-1) % nSubsets].AddFile(fileNameQC.Data());
+ if(fileCounterQC % nSubsets == 0)
+ {
+ fileCounterLastSubsetQC++;
+ }
+ }
- if(qcMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleQC.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterQC % cycle == 0)
+ // global merging:
+ if(fileCounterQC % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
+ (*mergedFileForPreviousCycleQC)+=type.Data();
+ (*mergedFileForPreviousCycleQC)+=(fileCounterQC/cycle - 1);
+ (*mergedFileForPreviousCycleQC)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleQC->Data(),kFileExists)))
+ {
+ fileMergerQC->AddFile(mergedFileForPreviousCycleQC->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleQC->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleQC = new TString("mergedQCanalysis");
+ (*mergedFileForCurrentCycleQC)+=type.Data();
+ (*mergedFileForCurrentCycleQC)+=(fileCounterQC/cycle);
+ (*mergedFileForCurrentCycleQC)+=".root";
+
+ fileMergerQC->OutputFile(mergedFileForCurrentCycleQC->Data());
+ fileMergerQC->Merge();
+ fileMergerQC->Reset();
+
+ delete mergedFileForPreviousCycleQC;
+ delete mergedFileForCurrentCycleQC;
+ } // end of if(fileCounterQC % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetQC > 0 && fileCounterLastSubsetQC % cycle == 0 && fileCounterQC % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetQC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle - 1);
+ mergedFileForPreviousCycleForSubsetQC[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetQC[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsQC[i].AddFile(mergedFileForPreviousCycleForSubsetQC[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetQC[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetQC[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetQC[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle);
+ mergedFileForCurrentCycleForSubsetQC[i]+=".root";
+
+ fileMergerForSubsetsQC[i].OutputFile(mergedFileForCurrentCycleForSubsetQC[i].Data());
+ fileMergerForSubsetsQC[i].Merge();
+ fileMergerForSubsetsQC[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetQC % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameQC.Data(),kFileExists)))
- // FQD:
- TString fileNameFQD = presentDirName;
+ // FQD:
+ TString fileNameFQD = presentDirName;
((fileNameFQD+="outputFQDanalysis")+=type.Data())+=".root";
if(!(gSystem->AccessPathName(fileNameFQD.Data(),kFileExists)))
{
- fqdFileMerger->AddFile(fileNameFQD.Data());
- counterFQD++;
- } else
+ fileCounterFQD++;
+ fileMergerFQD->AddFile(fileNameFQD.Data());
+
+ if(devideOutputFilesInEqualSubsets)
+ {
+ fileMergerForSubsetsFQD[(fileCounterFQD-1) % nSubsets].AddFile(fileNameFQD.Data());
+ if(fileCounterFQD % nSubsets == 0)
{
- cout<<"WARNING: Couldn't find a file "<<fileNameFQD.Data()<<". Merging will continue without this file."<<endl;
- }
+ fileCounterLastSubsetFQD++;
+ }
+ }
+
+ // global merging:
+ if(fileCounterFQD % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
+ (*mergedFileForPreviousCycleFQD)+=type.Data();
+ (*mergedFileForPreviousCycleFQD)+=(fileCounterFQD/cycle - 1);
+ (*mergedFileForPreviousCycleFQD)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleFQD->Data(),kFileExists)))
+ {
+ fileMergerFQD->AddFile(mergedFileForPreviousCycleFQD->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleFQD->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleFQD = new TString("mergedFQDanalysis");
+ (*mergedFileForCurrentCycleFQD)+=type.Data();
+ (*mergedFileForCurrentCycleFQD)+=(fileCounterFQD/cycle);
+ (*mergedFileForCurrentCycleFQD)+=".root";
- if(counterFQD % cycle == 0)
+ fileMergerFQD->OutputFile(mergedFileForCurrentCycleFQD->Data());
+ fileMergerFQD->Merge();
+ fileMergerFQD->Reset();
+
+ delete mergedFileForPreviousCycleFQD;
+ delete mergedFileForCurrentCycleFQD;
+ } // end of if(fileCounterFQD % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetFQD > 0 && fileCounterLastSubsetFQD % cycle == 0 && fileCounterFQD % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetFQD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle - 1);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetFQD[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsFQD[i].AddFile(mergedFileForPreviousCycleForSubsetFQD[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetFQD[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetFQD[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetFQD[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle);
+ mergedFileForCurrentCycleForSubsetFQD[i]+=".root";
+
+ fileMergerForSubsetsFQD[i].OutputFile(mergedFileForCurrentCycleForSubsetFQD[i].Data());
+ fileMergerForSubsetsFQD[i].Merge();
+ fileMergerForSubsetsFQD[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetFQD % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameFQD.Data(),kFileExists)))
+
+ // LYZ1SUM:
+ TString fileNameLYZ1SUM = presentDirName;
+ ((fileNameLYZ1SUM+="outputLYZ1SUManalysis")+=type.Data())+=".root";
+ if(!(gSystem->AccessPathName(fileNameLYZ1SUM.Data(),kFileExists)))
{
- maxCycleFQD = counterFQD/cycle;
- TString mergedFileNameCurrentCycleFQD("mergedFQDanalysis");
- ((mergedFileNameCurrentCycleFQD+=(type.Data()))+=counterFQD/cycle)+=(".root");
- fqdFileMerger->OutputFile(mergedFileNameCurrentCycleFQD);
+ fileCounterLYZ1SUM++;
+ fileMergerLYZ1SUM->AddFile(fileNameLYZ1SUM.Data());
- TString mergedFileNamePreviousCycleFQD("mergedFQDanalysis");
- ((mergedFileNamePreviousCycleFQD+=(type.Data()))+=(counterFQD/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleFQD.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- fqdFileMerger->AddFile(mergedFileNamePreviousCycleFQD.Data());
- }
-
- Bool_t fqdMerged = kFALSE;
- if(fqdFileMerger)
- {
- fqdMerged = fqdFileMerger->Merge();
- fqdFileMerger->Reset();
- }
+ fileMergerForSubsetsLYZ1SUM[(fileCounterLYZ1SUM-1) % nSubsets].AddFile(fileNameLYZ1SUM.Data());
+ if(fileCounterLYZ1SUM % nSubsets == 0)
+ {
+ fileCounterLastSubsetLYZ1SUM++;
+ }
+ }
- if(fqdMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleFQD.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterFQD % cycle == 0)
-
- // LYZ1:
- TString fileNameLYZ1 = presentDirName;
- ((fileNameLYZ1+="outputLYZ1analysis")+=type.Data())+=".root";
- if(!(gSystem->AccessPathName(fileNameLYZ1.Data(),kFileExists)))
- {
- lyz1FileMerger->AddFile(fileNameLYZ1.Data());
- counterLYZ1++;
- } else
+ // global merging:
+ if(fileCounterLYZ1SUM % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle - 1);
+ (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1SUM->Data(),kFileExists)))
{
- cout<<"WARNING: Couldn't find a file "<<fileNameLYZ1.Data()<<". Merging will continue without this file."<<endl;
- }
+ fileMergerLYZ1SUM->AddFile(mergedFileForPreviousCycleLYZ1SUM->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1SUM->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileForCurrentCycleLYZ1SUM)+=type.Data();
+ (*mergedFileForCurrentCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle);
+ (*mergedFileForCurrentCycleLYZ1SUM)+=".root";
+
+ fileMergerLYZ1SUM->OutputFile(mergedFileForCurrentCycleLYZ1SUM->Data());
+ fileMergerLYZ1SUM->Merge();
+ fileMergerLYZ1SUM->Reset();
+
+ delete mergedFileForPreviousCycleLYZ1SUM;
+ delete mergedFileForCurrentCycleLYZ1SUM;
+ } // end of if(fileCounterLYZ1SUM % cycle == 0)
- if(counterLYZ1 % cycle == 0)
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetLYZ1SUM > 0 && fileCounterLastSubsetLYZ1SUM % cycle == 0 && fileCounterLYZ1SUM % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetLYZ1SUM[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle - 1);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsLYZ1SUM[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle);
+ mergedFileForCurrentCycleForSubsetLYZ1SUM[i]+=".root";
+
+ fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZ1SUM[i].Data());
+ fileMergerForSubsetsLYZ1SUM[i].Merge();
+ fileMergerForSubsetsLYZ1SUM[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetLYZ1SUM % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameLYZ1SUM.Data(),kFileExists)))
+
+ // LYZ1PROD:
+ TString fileNameLYZ1PROD = presentDirName;
+ ((fileNameLYZ1PROD+="outputLYZ1PRODanalysis")+=type.Data())+=".root";
+ if(!(gSystem->AccessPathName(fileNameLYZ1PROD.Data(),kFileExists)))
{
- maxCycleLYZ1 = counterLYZ1/cycle;
- TString mergedFileNameCurrentCycleLYZ1("mergedLYZ1analysis");
- ((mergedFileNameCurrentCycleLYZ1+=(type.Data()))+=counterLYZ1/cycle)+=(".root");
- lyz1FileMerger->OutputFile(mergedFileNameCurrentCycleLYZ1);
+ fileCounterLYZ1PROD++;
+ fileMergerLYZ1PROD->AddFile(fileNameLYZ1PROD.Data());
- TString mergedFileNamePreviousCycleLYZ1("mergedLYZ1analysis");
- ((mergedFileNamePreviousCycleLYZ1+=(type.Data()))+=(counterLYZ1/cycle-1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleLYZ1.Data(),kFileExists)))
+ if(devideOutputFilesInEqualSubsets)
{
- lyz1FileMerger->AddFile(mergedFileNamePreviousCycleLYZ1.Data());
- }
-
- Bool_t lyz1Merged = kFALSE;
- if(lyz1FileMerger)
- {
- lyz1Merged = lyz1FileMerger->Merge();
- lyz1FileMerger->Reset();
- }
+ fileMergerForSubsetsLYZ1PROD[(fileCounterLYZ1PROD-1) % nSubsets].AddFile(fileNameLYZ1PROD.Data());
+ if(fileCounterLYZ1PROD % nSubsets == 0)
+ {
+ fileCounterLastSubsetLYZ1PROD++;
+ }
+ }
- if(lyz1Merged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleLYZ1.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- } // end of if(counterLYZ1 % cycle == 0)
-
- counter++;
-
- } // end of for(Int_t iDir=0;iDir<nDirs;++iDir)
-
- // last cycle MCEP:
- if(counterMCEP % cycle != 0)
- {
- TString mergedFileNameCurrentCycleMCEP("mergedMCEPanalysis");
- ((mergedFileNameCurrentCycleMCEP+=(type.Data()))+=(maxCycleMCEP+1))+=(".root");
- mcepFileMerger->OutputFile(mergedFileNameCurrentCycleMCEP);
+ // global merging:
+ if(fileCounterLYZ1PROD % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle - 1);
+ (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1PROD->Data(),kFileExists)))
+ {
+ fileMergerLYZ1PROD->AddFile(mergedFileForPreviousCycleLYZ1PROD->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1PROD->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileForCurrentCycleLYZ1PROD)+=type.Data();
+ (*mergedFileForCurrentCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle);
+ (*mergedFileForCurrentCycleLYZ1PROD)+=".root";
+
+ fileMergerLYZ1PROD->OutputFile(mergedFileForCurrentCycleLYZ1PROD->Data());
+ fileMergerLYZ1PROD->Merge();
+ fileMergerLYZ1PROD->Reset();
+
+ delete mergedFileForPreviousCycleLYZ1PROD;
+ delete mergedFileForCurrentCycleLYZ1PROD;
+ } // end of if(fileCounterLYZ1PROD % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetLYZ1PROD > 0 && fileCounterLastSubsetLYZ1PROD % cycle == 0 && fileCounterLYZ1PROD % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetLYZ1PROD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle - 1);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsLYZ1PROD[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle);
+ mergedFileForCurrentCycleForSubsetLYZ1PROD[i]+=".root";
+
+ fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZ1PROD[i].Data());
+ fileMergerForSubsetsLYZ1PROD[i].Merge();
+ fileMergerForSubsetsLYZ1PROD[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetLYZ1PROD % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameLYZ1PROD.Data(),kFileExists)))
- TString mergedFileNamePreviousCycleMCEP("mergedMCEPanalysis");
- ((mergedFileNamePreviousCycleMCEP+=(type.Data()))+=(maxCycleMCEP))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleMCEP.Data(),kFileExists)))
+ // LYZEP:
+ TString fileNameLYZEP = presentDirName;
+ ((fileNameLYZEP+="outputLYZEPanalysis")+=type.Data())+=".root";
+ if(!(gSystem->AccessPathName(fileNameLYZEP.Data(),kFileExists)))
{
- mcepFileMerger->AddFile(mergedFileNamePreviousCycleMCEP.Data());
- }
+ fileCounterLYZEP++;
+ fileMergerLYZEP->AddFile(fileNameLYZEP.Data());
- Bool_t mcepMerged = kFALSE;
- if(mcepFileMerger)
- {
- mcepMerged = mcepFileMerger->Merge();
- mcepFileMerger->Reset();
- }
+ if(devideOutputFilesInEqualSubsets)
+ {
+ fileMergerForSubsetsLYZEP[(fileCounterLYZEP-1) % nSubsets].AddFile(fileNameLYZEP.Data());
+ if(fileCounterLYZEP % nSubsets == 0)
+ {
+ fileCounterLastSubsetLYZEP++;
+ }
+ }
- if(mcepMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleMCEP.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleMCEP++;
- } // end of if(counterMCEP % cycle != 0)
+ // global merging:
+ if(fileCounterLYZEP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileForPreviousCycleLYZEP)+=type.Data();
+ (*mergedFileForPreviousCycleLYZEP)+=(fileCounterLYZEP/cycle - 1);
+ (*mergedFileForPreviousCycleLYZEP)+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZEP->Data(),kFileExists)))
+ {
+ fileMergerLYZEP->AddFile(mergedFileForPreviousCycleLYZEP->Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZEP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ TString *mergedFileForCurrentCycleLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileForCurrentCycleLYZEP)+=type.Data();
+ (*mergedFileForCurrentCycleLYZEP)+=(fileCounterLYZEP/cycle);
+ (*mergedFileForCurrentCycleLYZEP)+=".root";
+
+ fileMergerLYZEP->OutputFile(mergedFileForCurrentCycleLYZEP->Data());
+ fileMergerLYZEP->Merge();
+ fileMergerLYZEP->Reset();
+
+ delete mergedFileForPreviousCycleLYZEP;
+ delete mergedFileForCurrentCycleLYZEP;
+ } // end of if(fileCounterLYZEP % cycle == 0)
+
+ // merging for subsets:
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetLYZEP > 0 && fileCounterLastSubsetLYZEP % cycle == 0 && fileCounterLYZEP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
+ TString mergedFileForCurrentCycleForSubsetLYZEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle - 1);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
+
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),kFileExists)))
+ {
+ fileMergerForSubsetsLYZEP[i].AddFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data());
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+ }
+
+ mergedFileForCurrentCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
+ mergedFileForCurrentCycleForSubsetLYZEP[i]+=(i+1);
+ mergedFileForCurrentCycleForSubsetLYZEP[i]+=type.Data();
+ mergedFileForCurrentCycleForSubsetLYZEP[i]+="CycleNo";
+ mergedFileForCurrentCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle);
+ mergedFileForCurrentCycleForSubsetLYZEP[i]+=".root";
+
+ fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileForCurrentCycleForSubsetLYZEP[i].Data());
+ fileMergerForSubsetsLYZEP[i].Merge();
+ fileMergerForSubsetsLYZEP[i].Reset();
+
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of if(fileCounterLastSubsetLYZEP % cycle == 0)
+ } // end of if(devideOutputFilesInEqualSubsets)
+ } // end of if(!(gSystem->AccessPathName(fileNameLYZEP.Data(),kFileExists)))
- // renaming the final merged output for MCEP:
- TString finalMergedFileNameMCEP("mergedMCEPanalysis");
- ((finalMergedFileNameMCEP+=(type.Data()))+=maxCycleMCEP)+=(".root");
- TSystemFile *finalMergedFileMCEP = new TSystemFile(finalMergedFileNameMCEP.Data(),gSystem->pwd());
- TString defaultMergedFileNameMCEP("mergedMCEPanalysis");
- (defaultMergedFileNameMCEP+=(type.Data()))+=(".root");
- if(finalMergedFileMCEP) finalMergedFileMCEP->Rename(defaultMergedFileNameMCEP.Data());
+ } // end of for(Int_t iFile=0;iFile<nFiles;iFile++)
- // last cycle SP:
- if(counterSP % cycle != 0)
- {
- TString mergedFileNameCurrentCycleSP("mergedSPanalysis");
- ((mergedFileNameCurrentCycleSP+=(type.Data()))+=(maxCycleSP+1))+=(".root");
- spFileMerger->OutputFile(mergedFileNameCurrentCycleSP);
-
- TString mergedFileNamePreviousCycleSP("mergedSPanalysis");
- ((mergedFileNamePreviousCycleSP+=(type.Data()))+=(maxCycleSP))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleSP.Data(),kFileExists)))
- {
- spFileMerger->AddFile(mergedFileNamePreviousCycleSP.Data());
- }
-
- Bool_t spMerged = kFALSE;
- if(spFileMerger)
- {
- spMerged = spFileMerger->Merge();
- spFileMerger->Reset();
- }
-
- if(spMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleSP.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleSP++;
- } // end of if(counterSP % cycle != 0)
- // renaming the final merged output for SP:
- TString finalMergedFileNameSP("mergedSPanalysis");
- ((finalMergedFileNameSP+=(type.Data()))+=maxCycleSP)+=(".root");
- TSystemFile *finalMergedFileSP = new TSystemFile(finalMergedFileNameSP.Data(),gSystem->pwd());
- TString defaultMergedFileNameSP("mergedSPanalysis");
- (defaultMergedFileNameSP+=(type.Data()))+=(".root");
- if(finalMergedFileSP) finalMergedFileSP->Rename(defaultMergedFileNameSP.Data());
+ //=================================================================================================
- // last cycle GFC:
- if(counterGFC % cycle != 0)
- {
- TString mergedFileNameCurrentCycleGFC("mergedGFCanalysis");
- ((mergedFileNameCurrentCycleGFC+=(type.Data()))+=(maxCycleGFC+1))+=(".root");
- gfcFileMerger->OutputFile(mergedFileNameCurrentCycleGFC);
-
- TString mergedFileNamePreviousCycleGFC("mergedGFCanalysis");
- ((mergedFileNamePreviousCycleGFC+=(type.Data()))+=(maxCycleGFC))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleGFC.Data(),kFileExists)))
+
+ // global merging at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ // MCEP:
+ if(fileCounterMCEP < cycle)
+ {
+ TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileFinalMCEP)+=type.Data();
+ (*mergedFileFinalMCEP)+=".root";
+ fileMergerMCEP->OutputFile(mergedFileFinalMCEP->Data());
+ fileMergerMCEP->Merge();
+ delete mergedFileFinalMCEP;
+ } else if (fileCounterMCEP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileForPreviousCycleMCEP)+=type.Data();
+ (*mergedFileForPreviousCycleMCEP)+=(fileCounterMCEP/cycle);
+ (*mergedFileForPreviousCycleMCEP)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleMCEP->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileFinalMCEP)+=type.Data();
+ (*mergedFileFinalMCEP)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleMCEP->Data(),mergedFileFinalMCEP->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileForPreviousCycleMCEP)+=type.Data();
+ (*mergedFileForPreviousCycleMCEP)+=((Int_t)fileCounterMCEP/cycle);
+ (*mergedFileForPreviousCycleMCEP)+=".root";
+
+ fileMergerMCEP->AddFile(mergedFileForPreviousCycleMCEP->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleMCEP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalMCEP = new TString("mergedMCEPanalysis");
+ (*mergedFileFinalMCEP)+=type.Data();
+ (*mergedFileFinalMCEP)+=".root";
+ fileMergerMCEP->OutputFile(mergedFileFinalMCEP->Data());
+ fileMergerMCEP->Merge();
+
+ delete mergedFileForPreviousCycleMCEP;
+ delete mergedFileFinalMCEP;
+ }
+
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- gfcFileMerger->AddFile(mergedFileNamePreviousCycleGFC.Data());
- }
-
- Bool_t gfcMerged = kFALSE;
- if(gfcFileMerger)
- {
- gfcMerged = gfcFileMerger->Merge();
- gfcFileMerger->Reset();
- }
+ if(fileCounterLastSubsetMCEP < cycle)
+ {
+ TString mergedFileFinalForSubsetMCEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetMCEP[i]="subset";
+ mergedFileFinalForSubsetMCEP[i]+=(i+1);
+ mergedFileFinalForSubsetMCEP[i]+="/";
+ mergedFileFinalForSubsetMCEP[i]+="mergedMCEPanalysis";
+ mergedFileFinalForSubsetMCEP[i]+=type.Data();
+ mergedFileFinalForSubsetMCEP[i]+=".root";
+
+ fileMergerForSubsetsMCEP[i].OutputFile(mergedFileFinalForSubsetMCEP[i].Data());
+ fileMergerForSubsetsMCEP[i].Merge();
+ fileMergerForSubsetsMCEP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetMCEP % cycle == 0 && fileCounterMCEP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
+ TString mergedFileFinalForSubsetMCEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=(fileCounterLastSubsetMCEP/cycle);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedMCEPanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetMCEP[nSubsets];
+ TString mergedFileFinalForSubsetMCEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetMCEP[i]="mergedMCEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetMCEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=((Int_t)fileCounterLastSubsetMCEP/cycle);
+ mergedFileForPreviousCycleForSubsetMCEP[i]+=".root";
+
+ fileMergerForSubsetsMCEP[i].AddFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetMCEP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetMCEP[i]="subset";
+ mergedFileFinalForSubsetMCEP[i]+=(i+1);
+ mergedFileFinalForSubsetMCEP[i]+="/";
+ mergedFileFinalForSubsetMCEP[i]+="mergedMCEPanalysis";
+ mergedFileFinalForSubsetMCEP[i]+=type.Data();
+ mergedFileFinalForSubsetMCEP[i]+=".root";
+
+ fileMergerForSubsetsMCEP[i].OutputFile(mergedFileFinalForSubsetMCEP[i].Data());
+
+ fileMergerForSubsetsMCEP[i].Merge();
+ fileMergerForSubsetsMCEP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
- if(gfcMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleGFC.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleGFC++;
- } // end of if(counterGFC % cycle != 0)
+ // SP:
+ if(fileCounterSP < cycle)
+ {
+ TString *mergedFileFinalSP = new TString("mergedSPanalysis");
+ (*mergedFileFinalSP)+=type.Data();
+ (*mergedFileFinalSP)+=".root";
+ fileMergerSP->OutputFile(mergedFileFinalSP->Data());
+ fileMergerSP->Merge();
+ delete mergedFileFinalSP;
+ } else if (fileCounterSP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
+ (*mergedFileForPreviousCycleSP)+=type.Data();
+ (*mergedFileForPreviousCycleSP)+=(fileCounterSP/cycle);
+ (*mergedFileForPreviousCycleSP)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleSP->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalSP = new TString("mergedSPanalysis");
+ (*mergedFileFinalSP)+=type.Data();
+ (*mergedFileFinalSP)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleSP->Data(),mergedFileFinalSP->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleSP = new TString("mergedSPanalysis");
+ (*mergedFileForPreviousCycleSP)+=type.Data();
+ (*mergedFileForPreviousCycleSP)+=((Int_t)fileCounterSP/cycle);
+ (*mergedFileForPreviousCycleSP)+=".root";
+
+ fileMergerSP->AddFile(mergedFileForPreviousCycleSP->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleSP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalSP = new TString("mergedSPanalysis");
+ (*mergedFileFinalSP)+=type.Data();
+ (*mergedFileFinalSP)+=".root";
+ fileMergerSP->OutputFile(mergedFileFinalSP->Data());
+ fileMergerSP->Merge();
+
+ delete mergedFileForPreviousCycleSP;
+ delete mergedFileFinalSP;
+ }
- // renaming the final merged output for GFC:
- TString finalMergedFileNameGFC("mergedGFCanalysis");
- ((finalMergedFileNameGFC+=(type.Data()))+=maxCycleGFC)+=(".root");
- TSystemFile *finalMergedFileGFC = new TSystemFile(finalMergedFileNameGFC.Data(),gSystem->pwd());
- TString defaultMergedFileNameGFC("mergedGFCanalysis");
- (defaultMergedFileNameGFC+=(type.Data()))+=(".root");
- if(finalMergedFileGFC) finalMergedFileGFC->Rename(defaultMergedFileNameGFC.Data());
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetSP < cycle)
+ {
+ TString mergedFileFinalForSubsetSP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetSP[i]="subset";
+ mergedFileFinalForSubsetSP[i]+=(i+1);
+ mergedFileFinalForSubsetSP[i]+="/";
+ mergedFileFinalForSubsetSP[i]+="mergedSPanalysis";
+ mergedFileFinalForSubsetSP[i]+=type.Data();
+ mergedFileFinalForSubsetSP[i]+=".root";
+
+ fileMergerForSubsetsSP[i].OutputFile(mergedFileFinalForSubsetSP[i].Data());
+ fileMergerForSubsetsSP[i].Merge();
+ fileMergerForSubsetsSP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetSP % cycle == 0 && fileCounterSP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
+ TString mergedFileFinalForSubsetSP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=(fileCounterLastSubsetSP/cycle);
+ mergedFileForPreviousCycleForSubsetSP[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedSPanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetSP[nSubsets];
+ TString mergedFileFinalForSubsetSP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetSP[i]="mergedSPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetSP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetSP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetSP[i]+=((Int_t)fileCounterLastSubsetSP/cycle);
+ mergedFileForPreviousCycleForSubsetSP[i]+=".root";
+
+ fileMergerForSubsetsSP[i].AddFile(mergedFileForPreviousCycleForSubsetSP[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetSP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetSP[i]="subset";
+ mergedFileFinalForSubsetSP[i]+=(i+1);
+ mergedFileFinalForSubsetSP[i]+="/";
+ mergedFileFinalForSubsetSP[i]+="mergedSPanalysis";
+ mergedFileFinalForSubsetSP[i]+=type.Data();
+ mergedFileFinalForSubsetSP[i]+=".root";
+
+ fileMergerForSubsetsSP[i].OutputFile(mergedFileFinalForSubsetSP[i].Data());
+ fileMergerForSubsetsSP[i].Merge();
+ fileMergerForSubsetsSP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
+
+ // GFC:
+ if(fileCounterGFC < cycle)
+ {
+ TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
+ (*mergedFileFinalGFC)+=type.Data();
+ (*mergedFileFinalGFC)+=".root";
+ fileMergerGFC->OutputFile(mergedFileFinalGFC->Data());
+ fileMergerGFC->Merge();
+ delete mergedFileFinalGFC;
+ } else if (fileCounterGFC % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
+ (*mergedFileForPreviousCycleGFC)+=type.Data();
+ (*mergedFileForPreviousCycleGFC)+=(fileCounterGFC/cycle);
+ (*mergedFileForPreviousCycleGFC)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleGFC->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
+ (*mergedFileFinalGFC)+=type.Data();
+ (*mergedFileFinalGFC)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleGFC->Data(),mergedFileFinalGFC->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleGFC = new TString("mergedGFCanalysis");
+ (*mergedFileForPreviousCycleGFC)+=type.Data();
+ (*mergedFileForPreviousCycleGFC)+=((Int_t)fileCounterGFC/cycle);
+ (*mergedFileForPreviousCycleGFC)+=".root";
+
+ fileMergerGFC->AddFile(mergedFileForPreviousCycleGFC->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleGFC->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalGFC = new TString("mergedGFCanalysis");
+ (*mergedFileFinalGFC)+=type.Data();
+ (*mergedFileFinalGFC)+=".root";
+ fileMergerGFC->OutputFile(mergedFileFinalGFC->Data());
+ fileMergerGFC->Merge();
+
+ delete mergedFileForPreviousCycleGFC;
+ delete mergedFileFinalGFC;
+ }
- // last cycle QC:
- if(counterQC % cycle != 0)
- {
- TString mergedFileNameCurrentCycleQC("mergedQCanalysis");
- ((mergedFileNameCurrentCycleQC+=(type.Data()))+=(maxCycleQC+1))+=(".root");
- qcFileMerger->OutputFile(mergedFileNameCurrentCycleQC);
-
- TString mergedFileNamePreviousCycleQC("mergedQCanalysis");
- ((mergedFileNamePreviousCycleQC+=(type.Data()))+=(maxCycleQC))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleQC.Data(),kFileExists)))
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- qcFileMerger->AddFile(mergedFileNamePreviousCycleQC.Data());
- }
-
- Bool_t qcMerged = kFALSE;
- if(qcFileMerger)
- {
- qcMerged = qcFileMerger->Merge();
- qcFileMerger->Reset();
- }
-
- if(qcMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleQC.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleQC++;
- } // end of if(counterQC % cycle != 0)
+ if(fileCounterLastSubsetGFC < cycle)
+ {
+ TString mergedFileFinalForSubsetGFC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetGFC[i]="subset";
+ mergedFileFinalForSubsetGFC[i]+=(i+1);
+ mergedFileFinalForSubsetGFC[i]+="/";
+ mergedFileFinalForSubsetGFC[i]+="mergedGFCanalysis";
+ mergedFileFinalForSubsetGFC[i]+=type.Data();
+ mergedFileFinalForSubsetGFC[i]+=".root";
+
+ fileMergerForSubsetsGFC[i].OutputFile(mergedFileFinalForSubsetGFC[i].Data());
+ fileMergerForSubsetsGFC[i].Merge();
+ fileMergerForSubsetsGFC[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetGFC % cycle == 0 && fileCounterGFC % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
+ TString mergedFileFinalForSubsetGFC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=(fileCounterLastSubsetGFC/cycle);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedGFCanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetGFC[nSubsets];
+ TString mergedFileFinalForSubsetGFC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetGFC[i]="mergedGFCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetGFC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetGFC[i]+=((Int_t)fileCounterLastSubsetGFC/cycle);
+ mergedFileForPreviousCycleForSubsetGFC[i]+=".root";
+
+ fileMergerForSubsetsGFC[i].AddFile(mergedFileForPreviousCycleForSubsetGFC[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetGFC[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetGFC[i]="subset";
+ mergedFileFinalForSubsetGFC[i]+=(i+1);
+ mergedFileFinalForSubsetGFC[i]+="/";
+ mergedFileFinalForSubsetGFC[i]+="mergedGFCanalysis";
+ mergedFileFinalForSubsetGFC[i]+=type.Data();
+ mergedFileFinalForSubsetGFC[i]+=".root";
+
+ fileMergerForSubsetsGFC[i].OutputFile(mergedFileFinalForSubsetGFC[i].Data());
+ fileMergerForSubsetsGFC[i].Merge();
+ fileMergerForSubsetsGFC[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
+
+ // QC:
+ if(fileCounterQC < cycle)
+ {
+ TString *mergedFileFinalQC = new TString("mergedQCanalysis");
+ (*mergedFileFinalQC)+=type.Data();
+ (*mergedFileFinalQC)+=".root";
+ fileMergerQC->OutputFile(mergedFileFinalQC->Data());
+ fileMergerQC->Merge();
+ delete mergedFileFinalQC;
+ } else if (fileCounterQC % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
+ (*mergedFileForPreviousCycleQC)+=type.Data();
+ (*mergedFileForPreviousCycleQC)+=(fileCounterQC/cycle);
+ (*mergedFileForPreviousCycleQC)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleQC->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalQC = new TString("mergedQCanalysis");
+ (*mergedFileFinalQC)+=type.Data();
+ (*mergedFileFinalQC)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleQC->Data(),mergedFileFinalQC->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleQC = new TString("mergedQCanalysis");
+ (*mergedFileForPreviousCycleQC)+=type.Data();
+ (*mergedFileForPreviousCycleQC)+=((Int_t)fileCounterQC/cycle);
+ (*mergedFileForPreviousCycleQC)+=".root";
+
+ fileMergerQC->AddFile(mergedFileForPreviousCycleQC->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleQC->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalQC = new TString("mergedQCanalysis");
+ (*mergedFileFinalQC)+=type.Data();
+ (*mergedFileFinalQC)+=".root";
+ fileMergerQC->OutputFile(mergedFileFinalQC->Data());
+ fileMergerQC->Merge();
+
+ delete mergedFileForPreviousCycleQC;
+ delete mergedFileFinalQC;
+ }
- // renaming the final merged output for QC:
- TString finalMergedFileNameQC("mergedQCanalysis");
- ((finalMergedFileNameQC+=(type.Data()))+=maxCycleQC)+=(".root");
- TSystemFile *finalMergedFileQC = new TSystemFile(finalMergedFileNameQC.Data(),gSystem->pwd());
- TString defaultMergedFileNameQC("mergedQCanalysis");
- (defaultMergedFileNameQC+=(type.Data()))+=(".root");
- if(finalMergedFileQC) finalMergedFileQC->Rename(defaultMergedFileNameQC.Data());
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetQC < cycle)
+ {
+ TString mergedFileFinalForSubsetQC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetQC[i]="subset";
+ mergedFileFinalForSubsetQC[i]+=(i+1);
+ mergedFileFinalForSubsetQC[i]+="/";
+ mergedFileFinalForSubsetQC[i]+="mergedQCanalysis";
+ mergedFileFinalForSubsetQC[i]+=type.Data();
+ mergedFileFinalForSubsetQC[i]+=".root";
+
+ fileMergerForSubsetsQC[i].OutputFile(mergedFileFinalForSubsetQC[i].Data());
+ fileMergerForSubsetsQC[i].Merge();
+ fileMergerForSubsetsQC[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetQC % cycle == 0 && fileCounterQC % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
+ TString mergedFileFinalForSubsetQC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=(fileCounterLastSubsetQC/cycle);
+ mergedFileForPreviousCycleForSubsetQC[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedQCanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetQC[nSubsets];
+ TString mergedFileFinalForSubsetQC[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetQC[i]="mergedQCanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetQC[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetQC[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetQC[i]+=((Int_t)fileCounterLastSubsetQC/cycle);
+ mergedFileForPreviousCycleForSubsetQC[i]+=".root";
+
+ fileMergerForSubsetsQC[i].AddFile(mergedFileForPreviousCycleForSubsetQC[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetQC[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetQC[i]="subset";
+ mergedFileFinalForSubsetQC[i]+=(i+1);
+ mergedFileFinalForSubsetQC[i]+="/";
+ mergedFileFinalForSubsetQC[i]+="mergedQCanalysis";
+ mergedFileFinalForSubsetQC[i]+=type.Data();
+ mergedFileFinalForSubsetQC[i]+=".root";
+
+ fileMergerForSubsetsQC[i].OutputFile(mergedFileFinalForSubsetQC[i].Data());
+ fileMergerForSubsetsQC[i].Merge();
+ fileMergerForSubsetsQC[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
+
+ // FQD:
+ if(fileCounterFQD < cycle)
+ {
+ TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
+ (*mergedFileFinalFQD)+=type.Data();
+ (*mergedFileFinalFQD)+=".root";
+ fileMergerFQD->OutputFile(mergedFileFinalFQD->Data());
+ fileMergerFQD->Merge();
+ delete mergedFileFinalFQD;
+ } else if (fileCounterFQD % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
+ (*mergedFileForPreviousCycleFQD)+=type.Data();
+ (*mergedFileForPreviousCycleFQD)+=(fileCounterFQD/cycle);
+ (*mergedFileForPreviousCycleFQD)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleFQD->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
+ (*mergedFileFinalFQD)+=type.Data();
+ (*mergedFileFinalFQD)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleFQD->Data(),mergedFileFinalFQD->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleFQD = new TString("mergedFQDanalysis");
+ (*mergedFileForPreviousCycleFQD)+=type.Data();
+ (*mergedFileForPreviousCycleFQD)+=((Int_t)fileCounterFQD/cycle);
+ (*mergedFileForPreviousCycleFQD)+=".root";
+
+ fileMergerFQD->AddFile(mergedFileForPreviousCycleFQD->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleFQD->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalFQD = new TString("mergedFQDanalysis");
+ (*mergedFileFinalFQD)+=type.Data();
+ (*mergedFileFinalFQD)+=".root";
+ fileMergerFQD->OutputFile(mergedFileFinalFQD->Data());
+ fileMergerFQD->Merge();
+
+ delete mergedFileForPreviousCycleFQD;
+ delete mergedFileFinalFQD;
+ }
- // last cycle FQD:
- if(counterFQD % cycle != 0)
- {
- TString mergedFileNameCurrentCycleFQD("mergedFQDanalysis");
- ((mergedFileNameCurrentCycleFQD+=(type.Data()))+=(maxCycleFQD+1))+=(".root");
- fqdFileMerger->OutputFile(mergedFileNameCurrentCycleFQD);
-
- TString mergedFileNamePreviousCycleFQD("mergedFQDanalysis");
- ((mergedFileNamePreviousCycleFQD+=(type.Data()))+=(maxCycleFQD))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleFQD.Data(),kFileExists)))
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- fqdFileMerger->AddFile(mergedFileNamePreviousCycleFQD.Data());
- }
-
- Bool_t fqdMerged = kFALSE;
- if(fqdFileMerger)
- {
- fqdMerged = fqdFileMerger->Merge();
- fqdFileMerger->Reset();
- }
+ if(fileCounterLastSubsetFQD < cycle)
+ {
+ TString mergedFileFinalForSubsetFQD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetFQD[i]="subset";
+ mergedFileFinalForSubsetFQD[i]+=(i+1);
+ mergedFileFinalForSubsetFQD[i]+="/";
+ mergedFileFinalForSubsetFQD[i]+="mergedFQDanalysis";
+ mergedFileFinalForSubsetFQD[i]+=type.Data();
+ mergedFileFinalForSubsetFQD[i]+=".root";
+
+ fileMergerForSubsetsFQD[i].OutputFile(mergedFileFinalForSubsetFQD[i].Data());
+ fileMergerForSubsetsFQD[i].Merge();
+ fileMergerForSubsetsFQD[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetFQD % cycle == 0 && fileCounterFQD % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
+ TString mergedFileFinalForSubsetFQD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=(fileCounterLastSubsetFQD/cycle);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedFQDanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetFQD[nSubsets];
+ TString mergedFileFinalForSubsetFQD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetFQD[i]="mergedFQDanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetFQD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetFQD[i]+=((Int_t)fileCounterLastSubsetFQD/cycle);
+ mergedFileForPreviousCycleForSubsetFQD[i]+=".root";
+
+ fileMergerForSubsetsFQD[i].AddFile(mergedFileForPreviousCycleForSubsetFQD[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetFQD[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetFQD[i]="subset";
+ mergedFileFinalForSubsetFQD[i]+=(i+1);
+ mergedFileFinalForSubsetFQD[i]+="/";
+ mergedFileFinalForSubsetFQD[i]+="mergedFQDanalysis";
+ mergedFileFinalForSubsetFQD[i]+=type.Data();
+ mergedFileFinalForSubsetFQD[i]+=".root";
+
+ fileMergerForSubsetsFQD[i].OutputFile(mergedFileFinalForSubsetFQD[i].Data());
+ fileMergerForSubsetsFQD[i].Merge();
+ fileMergerForSubsetsFQD[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
+
+ // LYZ1SUM:
+ if(fileCounterLYZ1SUM < cycle)
+ {
+ TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileFinalLYZ1SUM)+=type.Data();
+ (*mergedFileFinalLYZ1SUM)+=".root";
+ fileMergerLYZ1SUM->OutputFile(mergedFileFinalLYZ1SUM->Data());
+ fileMergerLYZ1SUM->Merge();
+ delete mergedFileFinalLYZ1SUM;
+ } else if (fileCounterLYZ1SUM % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1SUM)+=(fileCounterLYZ1SUM/cycle);
+ (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1SUM->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileFinalLYZ1SUM)+=type.Data();
+ (*mergedFileFinalLYZ1SUM)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleLYZ1SUM->Data(),mergedFileFinalLYZ1SUM->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileForPreviousCycleLYZ1SUM)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1SUM)+=((Int_t)fileCounterLYZ1SUM/cycle);
+ (*mergedFileForPreviousCycleLYZ1SUM)+=".root";
+
+ fileMergerLYZ1SUM->AddFile(mergedFileForPreviousCycleLYZ1SUM->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1SUM->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalLYZ1SUM = new TString("mergedLYZ1SUManalysis");
+ (*mergedFileFinalLYZ1SUM)+=type.Data();
+ (*mergedFileFinalLYZ1SUM)+=".root";
+ fileMergerLYZ1SUM->OutputFile(mergedFileFinalLYZ1SUM->Data());
+ fileMergerLYZ1SUM->Merge();
+
+ delete mergedFileForPreviousCycleLYZ1SUM;
+ delete mergedFileFinalLYZ1SUM;
+ }
+
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetLYZ1SUM < cycle)
+ {
+ TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetLYZ1SUM[i]="subset";
+ mergedFileFinalForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileFinalForSubsetLYZ1SUM[i]+="/";
+ mergedFileFinalForSubsetLYZ1SUM[i]+="mergedLYZ1SUManalysis";
+ mergedFileFinalForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileFinalForSubsetLYZ1SUM[i]+=".root";
+
+ fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileFinalForSubsetLYZ1SUM[i].Data());
+ fileMergerForSubsetsLYZ1SUM[i].Merge();
+ fileMergerForSubsetsLYZ1SUM[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetLYZ1SUM % cycle == 0 && fileCounterLYZ1SUM % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
+ TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(fileCounterLastSubsetLYZ1SUM/cycle);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedLYZ1SUManalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1SUM[nSubsets];
+ TString mergedFileFinalForSubsetLYZ1SUM[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]="mergedLYZ1SUManalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=((Int_t)fileCounterLastSubsetLYZ1SUM/cycle);
+ mergedFileForPreviousCycleForSubsetLYZ1SUM[i]+=".root";
+
+ fileMergerForSubsetsLYZ1SUM[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1SUM[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetLYZ1SUM[i]="subset";
+ mergedFileFinalForSubsetLYZ1SUM[i]+=(i+1);
+ mergedFileFinalForSubsetLYZ1SUM[i]+="/";
+ mergedFileFinalForSubsetLYZ1SUM[i]+="mergedLYZ1SUManalysis";
+ mergedFileFinalForSubsetLYZ1SUM[i]+=type.Data();
+ mergedFileFinalForSubsetLYZ1SUM[i]+=".root";
+
+ fileMergerForSubsetsLYZ1SUM[i].OutputFile(mergedFileFinalForSubsetLYZ1SUM[i].Data());
+ fileMergerForSubsetsLYZ1SUM[i].Merge();
+ fileMergerForSubsetsLYZ1SUM[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
- if(fqdMerged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleFQD.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleFQD++;
- } // end of if(counterFQD % cycle != 0)
+ // LYZ1PROD:
+ if(fileCounterLYZ1PROD < cycle)
+ {
+ TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileFinalLYZ1PROD)+=type.Data();
+ (*mergedFileFinalLYZ1PROD)+=".root";
+ fileMergerLYZ1PROD->OutputFile(mergedFileFinalLYZ1PROD->Data());
+ fileMergerLYZ1PROD->Merge();
+ delete mergedFileFinalLYZ1PROD;
+ } else if (fileCounterLYZ1PROD % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1PROD)+=(fileCounterLYZ1PROD/cycle);
+ (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZ1PROD->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileFinalLYZ1PROD)+=type.Data();
+ (*mergedFileFinalLYZ1PROD)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleLYZ1PROD->Data(),mergedFileFinalLYZ1PROD->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileForPreviousCycleLYZ1PROD)+=type.Data();
+ (*mergedFileForPreviousCycleLYZ1PROD)+=((Int_t)fileCounterLYZ1PROD/cycle);
+ (*mergedFileForPreviousCycleLYZ1PROD)+=".root";
+
+ fileMergerLYZ1PROD->AddFile(mergedFileForPreviousCycleLYZ1PROD->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZ1PROD->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalLYZ1PROD = new TString("mergedLYZ1PRODanalysis");
+ (*mergedFileFinalLYZ1PROD)+=type.Data();
+ (*mergedFileFinalLYZ1PROD)+=".root";
+ fileMergerLYZ1PROD->OutputFile(mergedFileFinalLYZ1PROD->Data());
+ fileMergerLYZ1PROD->Merge();
+
+ delete mergedFileForPreviousCycleLYZ1PROD;
+ delete mergedFileFinalLYZ1PROD;
+ }
+
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
+ {
+ if(fileCounterLastSubsetLYZ1PROD < cycle)
+ {
+ TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetLYZ1PROD[i]="subset";
+ mergedFileFinalForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileFinalForSubsetLYZ1PROD[i]+="/";
+ mergedFileFinalForSubsetLYZ1PROD[i]+="mergedLYZ1PRODanalysis";
+ mergedFileFinalForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileFinalForSubsetLYZ1PROD[i]+=".root";
+
+ fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileFinalForSubsetLYZ1PROD[i].Data());
+ fileMergerForSubsetsLYZ1PROD[i].Merge();
+ fileMergerForSubsetsLYZ1PROD[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetLYZ1PROD % cycle == 0 && fileCounterLYZ1PROD % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
+ TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(fileCounterLastSubsetLYZ1PROD/cycle);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedLYZ1PRODanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZ1PROD[nSubsets];
+ TString mergedFileFinalForSubsetLYZ1PROD[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]="mergedLYZ1PRODanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=((Int_t)fileCounterLastSubsetLYZ1PROD/cycle);
+ mergedFileForPreviousCycleForSubsetLYZ1PROD[i]+=".root";
+
+ fileMergerForSubsetsLYZ1PROD[i].AddFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZ1PROD[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetLYZ1PROD[i]="subset";
+ mergedFileFinalForSubsetLYZ1PROD[i]+=(i+1);
+ mergedFileFinalForSubsetLYZ1PROD[i]+="/";
+ mergedFileFinalForSubsetLYZ1PROD[i]+="mergedLYZ1PRODanalysis";
+ mergedFileFinalForSubsetLYZ1PROD[i]+=type.Data();
+ mergedFileFinalForSubsetLYZ1PROD[i]+=".root";
+
+ fileMergerForSubsetsLYZ1PROD[i].OutputFile(mergedFileFinalForSubsetLYZ1PROD[i].Data());
+ fileMergerForSubsetsLYZ1PROD[i].Merge();
+ fileMergerForSubsetsLYZ1PROD[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
- // renaming the final merged output for FQD:
- TString finalMergedFileNameFQD("mergedFQDanalysis");
- ((finalMergedFileNameFQD+=(type.Data()))+=maxCycleFQD)+=(".root");
- TSystemFile *finalMergedFileFQD = new TSystemFile(finalMergedFileNameFQD.Data(),gSystem->pwd());
- TString defaultMergedFileNameFQD("mergedFQDanalysis");
- (defaultMergedFileNameFQD+=(type.Data()))+=(".root");
- if(finalMergedFileFQD) finalMergedFileFQD->Rename(defaultMergedFileNameFQD.Data());
+ // LYZEP:
+ if(fileCounterLYZEP < cycle)
+ {
+ TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileFinalLYZEP)+=type.Data();
+ (*mergedFileFinalLYZEP)+=".root";
+ fileMergerLYZEP->OutputFile(mergedFileFinalLYZEP->Data());
+ fileMergerLYZEP->Merge();
+ delete mergedFileFinalLYZEP;
+ } else if (fileCounterLYZEP % cycle == 0)
+ {
+ TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileForPreviousCycleLYZEP)+=type.Data();
+ (*mergedFileForPreviousCycleLYZEP)+=(fileCounterLYZEP/cycle);
+ (*mergedFileForPreviousCycleLYZEP)+=".root";
+ if(!(gSystem->AccessPathName(mergedFileForPreviousCycleLYZEP->Data(),kFileExists)))
+ {
+ TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileFinalLYZEP)+=type.Data();
+ (*mergedFileFinalLYZEP)+=".root";
+ gSystem->Rename(mergedFileForPreviousCycleLYZEP->Data(),mergedFileFinalLYZEP->Data());
+ }
+ } else
+ {
+ TString *mergedFileForPreviousCycleLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileForPreviousCycleLYZEP)+=type.Data();
+ (*mergedFileForPreviousCycleLYZEP)+=((Int_t)fileCounterLYZEP/cycle);
+ (*mergedFileForPreviousCycleLYZEP)+=".root";
+
+ fileMergerLYZEP->AddFile(mergedFileForPreviousCycleLYZEP->Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleLYZEP->Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ TString *mergedFileFinalLYZEP = new TString("mergedLYZEPanalysis");
+ (*mergedFileFinalLYZEP)+=type.Data();
+ (*mergedFileFinalLYZEP)+=".root";
+ fileMergerLYZEP->OutputFile(mergedFileFinalLYZEP->Data());
+ fileMergerLYZEP->Merge();
+
+ delete mergedFileForPreviousCycleLYZEP;
+ delete mergedFileFinalLYZEP;
+ }
- // last cycle LYZ1:
- if(counterLYZ1 % cycle != 0)
- {
- TString mergedFileNameCurrentCycleLYZ1("mergedLYZ1analysis");
- ((mergedFileNameCurrentCycleLYZ1+=(type.Data()))+=(maxCycleLYZ1+1))+=(".root");
- lyz1FileMerger->OutputFile(mergedFileNameCurrentCycleLYZ1);
-
- TString mergedFileNamePreviousCycleLYZ1("mergedLYZ1analysis");
- ((mergedFileNamePreviousCycleLYZ1+=(type.Data()))+=(maxCycleLYZ1))+=(".root");
- if(!(gSystem->AccessPathName(mergedFileNamePreviousCycleLYZ1.Data(),kFileExists)))
+ // merging for subsets at the end of the day:
+ gSystem->cd(baseDirPath->Data());
+ if(devideOutputFilesInEqualSubsets)
{
- lyz1FileMerger->AddFile(mergedFileNamePreviousCycleLYZ1.Data());
- }
-
- Bool_t lyz1Merged = kFALSE;
- if(lyz1FileMerger)
- {
- lyz1Merged = lyz1FileMerger->Merge();
- lyz1FileMerger->Reset();
- }
-
- if(lyz1Merged)
- {
- TSystemFile *previousCycle = new TSystemFile(mergedFileNamePreviousCycleLYZ1.Data(),gSystem->pwd());
- if(previousCycle) previousCycle->Delete();
- delete previousCycle;
- }
- maxCycleLYZ1++;
- } // end of if(counterLYZ1 % cycle != 0)
+ if(fileCounterLastSubsetLYZEP < cycle)
+ {
+ TString mergedFileFinalForSubsetLYZEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileFinalForSubsetLYZEP[i]="subset";
+ mergedFileFinalForSubsetLYZEP[i]+=(i+1);
+ mergedFileFinalForSubsetLYZEP[i]+="/";
+ mergedFileFinalForSubsetLYZEP[i]+="mergedLYZEPanalysis";
+ mergedFileFinalForSubsetLYZEP[i]+=type.Data();
+ mergedFileFinalForSubsetLYZEP[i]+=".root";
+
+ fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileFinalForSubsetLYZEP[i].Data());
+ fileMergerForSubsetsLYZEP[i].Merge();
+ fileMergerForSubsetsLYZEP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else if (fileCounterLastSubsetLYZEP % cycle == 0 && fileCounterLYZEP % cycle == 0)
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
+ TString mergedFileFinalForSubsetLYZEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=(fileCounterLastSubsetLYZEP/cycle);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
+ // move and rename this file to subdirectory subset*:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
+ TString *subdir = new TString("subset");
+ (*subdir)+=(i+1);
+ (*subdir)+="/";
+ (*subdir)+="mergedLYZEPanalysis";
+ (*subdir)+=type.Data();
+ (*subdir)+=".root";
+ file->Move(subdir->Data());
+ delete file;
+ delete subdir;
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } else
+ {
+ TString mergedFileForPreviousCycleForSubsetLYZEP[nSubsets];
+ TString mergedFileFinalForSubsetLYZEP[nSubsets];
+ for(Int_t i=0;i<nSubsets;i++)
+ {
+ mergedFileForPreviousCycleForSubsetLYZEP[i]="mergedLYZEPanalysisForSubsetNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=(i+1);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=type.Data();
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+="CycleNo";
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=((Int_t)fileCounterLastSubsetLYZEP/cycle);
+ mergedFileForPreviousCycleForSubsetLYZEP[i]+=".root";
+
+ fileMergerForSubsetsLYZEP[i].AddFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data());
+
+ // delete merged output from previous cycle:
+ TSystemFile *file = new TSystemFile(mergedFileForPreviousCycleForSubsetLYZEP[i].Data(),gSystem->pwd());
+ file->Delete();
+ delete file;
+
+ mergedFileFinalForSubsetLYZEP[i]="subset";
+ mergedFileFinalForSubsetLYZEP[i]+=(i+1);
+ mergedFileFinalForSubsetLYZEP[i]+="/";
+ mergedFileFinalForSubsetLYZEP[i]+="mergedLYZEPanalysis";
+ mergedFileFinalForSubsetLYZEP[i]+=type.Data();
+ mergedFileFinalForSubsetLYZEP[i]+=".root";
+
+ fileMergerForSubsetsLYZEP[i].OutputFile(mergedFileFinalForSubsetLYZEP[i].Data());
+ fileMergerForSubsetsLYZEP[i].Merge();
+ fileMergerForSubsetsLYZEP[i].Reset();
+ } // end of for(Int_t i=0;i<nSubsets;i++)
+ } // end of last else
+ } // end of if(devideOutputFilesInEqualSubsets)
- // renaming the final merged output for LYZ1:
- TString finalMergedFileNameLYZ1("mergedLYZ1analysis");
- ((finalMergedFileNameLYZ1+=(type.Data()))+=maxCycleLYZ1)+=(".root");
- TSystemFile *finalMergedFileLYZ1 = new TSystemFile(finalMergedFileNameLYZ1.Data(),gSystem->pwd());
- TString defaultMergedFileNameLYZ1("mergedLYZ1analysis");
- (defaultMergedFileNameLYZ1+=(type.Data()))+=(".root");
- if(finalMergedFileLYZ1) finalMergedFileLYZ1->Rename(defaultMergedFileNameLYZ1.Data());
+ delete dirNameSubset;
+ delete baseDirPath;
+ delete baseDir;
-} // end of void mergeOutput(TString type="", const Int_t nRuns=-1, Int_t mode=mLocal)
+} // end of void mergeOutput(TString type="", Int_t mode=mLocal)
-void LoadSpreadLibrariesMO(const libModes mode) {
+void LoadLibrariesMO(const libModes mode) {
//--------------------------------------
// Load the needed libraries most of them already loaded by aliroot
} // end of else if (mode==mLocalSource)
-} // end of void LoadSpreadLibrariesMO(const libModes mode)
-
-
+} // end of void LoadLibrariesMO(const libModes mode)
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff