LArQuickHistMerge.cxx File Reference

#include "CxxUtils/checker_macros.h"
#include "TSystem.h"
#include "TH1.h"
#include "TH2.h"
#include "TFile.h"
#include "TKey.h"
#include "TTree.h"
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include "DataQualityUtils/MonitoringFile.h"

Go to the source code of this file.

Classes
class	histCollection
class	histCollection::histPerDir_t
struct	histCollection::histDir_t

Macros
#define	MAXSKIPPEDFILES   10
#define	MAXSKIPPEDFILESFRACTION   0.1

Functions
TFile *	openWithRetry (const char *path, const unsigned nTrys=3)
template<class HIST >
void	defaultMerge (TObject *a, const TObject *b)
void weightedAverageTH1	ATLAS_NOT_THREAD_SAFE (TObject *a, const TObject *b)
void	identical (TObject *a, const TObject *b)
std::vector< std::string >	splitString (const std::string &in, const std::string &delim)
bool	readFromTextFile (const char *filename, std::vector< std::string > &out)
int	main (int argc, char **argv)

Variables
	ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Macro Definition Documentation

MAXSKIPPEDFILES

#define MAXSKIPPEDFILES   10

Definition at line 31 of file LArQuickHistMerge.cxx.

MAXSKIPPEDFILESFRACTION

#define MAXSKIPPEDFILESFRACTION   0.1

Definition at line 32 of file LArQuickHistMerge.cxx.

Function Documentation

ATLAS_NOT_THREAD_SAFE()

void lowerLB ATLAS_NOT_THREAD_SAFE	(	TObject *	a,
		const TObject *	b
	)

Definition at line 145 of file LArQuickHistMerge.cxx.

                                                                             {
  TH1* a1=(dynamic_cast<TH1*>(a));
  const TH1* b1=dynamic_cast<const TH1*>(b);
  if (!b1 || !a1)
    std::cout << "ERROR in weightedAverageTH1: Object not of type TH1" << std::endl;
  else
    dqutils::MonitoringFile::merge_weightedAverage(*a1,*b1);
  return;
}

defaultMerge()

template<class HIST >

void defaultMerge	(	TObject *	a,
		const TObject *	b
	)

Definition at line 140 of file LArQuickHistMerge.cxx.

                                                {
  ((HIST*)a)->Add((HIST*)b);
  return;
}

identical()

void identical	(	TObject *	a,
		const TObject *	b
	)

Definition at line 215 of file LArQuickHistMerge.cxx.

                                             {
   TH1* a1=(dynamic_cast<TH1*>(a));
   const TH1* b1=dynamic_cast<const TH1*>(b);
   TH2* c1=(dynamic_cast<TH2*>(a));
   const TH2* d1=dynamic_cast<const TH2*>(b);
   if (a1 and b1){
     dqutils::MonitoringFile::merge_identical(*a1,*b1);
   } else if (c1 and d1){
     dqutils::MonitoringFile::merge_identical(*c1,*d1);
   } else {
     std::cout << "ERROR in identical: Object not of type THist" << std::endl;
     std::cout << a1 << " " << b1 << " " << c1 << " " <<d1 <<std::endl;
   }
   return;
}

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 472 of file LArQuickHistMerge.cxx.

                                {
 
  if (argc<2 || (argc>1 && (!strcmp(argv[1],"-h") || !strcmp(argv[1],"--help")))) {
    std::cout << "Syntax:\n" << argv[0] << " [-v ] [-i inputTextFile] [-d directroy] <outfile> <infile1> <infile2> .... " << std::endl;
    std::cout << "  -v verbose " << std::endl;
    return -1;
  }
 
  bool debug=false;
  std::string outFileName;
  std::vector<std::string> inFileNames;
  std::vector<std::string> baseDirs;
 
  for(int iArg=1;iArg<argc;++iArg) {
    if (!strcmp(argv[iArg],"-v")) {
      debug=true;
      continue;
    }
 
    if (!strcmp(argv[iArg],"-d")) {
      ++iArg;
      if (argc<=iArg) {
    std::cout << "ERROR: Expected a parameter (directory name) after '-d'" << std::endl;
    return -1;
      }
      baseDirs.push_back(std::string(argv[iArg]));
      continue;
    }
    
 
    if (!strcmp(argv[iArg],"-i")) {
      ++iArg;
      if (argc<=iArg) {
    std::cout << "ERROR: Expected text file name after '-i'" << std::endl;
    return -1;
      }
      readFromTextFile(argv[iArg],inFileNames);
      continue;
    }
    if (outFileName.empty())
      outFileName=argv[iArg];
    else
      inFileNames.push_back(std::string(argv[iArg]));
  }//end loop over arguments
  
  
  if (outFileName.empty()) {
    std::cout << "ERROR: No output file name given!" << std::endl;
    return -1;
  }
 
  if (!gSystem->AccessPathName(outFileName.c_str())) {
    std::cout << "ERROR: Output file " << outFileName << " exists already!" << std::endl;
    return -1;
  }
 
  if (inFileNames.empty()) {
    std::cout << "WARNING: No input files given! Will produce empty output file" << std::endl;
  }
 
 
  std::cout << "Number of input files: " << inFileNames.size() << std::endl;
  std::cout << "Output file: " << outFileName << std::endl;
  
  if (baseDirs.empty()) {
    baseDirs.push_back("LAr");
    baseDirs.push_back("CaloMonitoring/LArCellMon_NoTrigSel");
    baseDirs.push_back("CaloTopoClusters/CalBAR");
    baseDirs.push_back("CaloTopoClusters/CalECA");
    baseDirs.push_back("CaloTopoClusters/CalECC");
    baseDirs.push_back("CaloTopoClusters/CalEMBAR");
    baseDirs.push_back("CaloTopoClusters/CalEMECA");
    baseDirs.push_back("CaloTopoClusters/CalEMECC");
 
  }
  else {
    //clean superfluos slash characters
    for (size_t i=0;i<baseDirs.size();++i) {
      std::vector<std::string> dirtok=splitString(baseDirs[i],std::string("/"));
      if (dirtok.empty()) {
    baseDirs[i].clear();
    continue;
      }
      baseDirs[i]=dirtok[0];
      for (size_t j=1;j<dirtok.size();++j) {
    baseDirs[i]+="/"+dirtok[j];
      }//eld loop over dir tokens
    }//end loop over directories
  }
 
  // Keeping track of which directories we found
  std::vector<std::string> foundDirs;
 
  histCollection listOfHists(debug);
  listOfHists.addExclusion("/CaloMonitoring/LArCellMon_NoTrigSel/Sporadic");
 
  TFile* in1=nullptr;
  std::string runDir("/");
  size_t fileIndex=0;
  unsigned nSkippedFiles=0;
 
  const size_t nFiles=inFileNames.size(); 
 
  //Loop to find the first non-empty file
  //for (;fileIndex<nFiles && runDir.size()==1;++fileIndex) {
  for (;fileIndex<nFiles && foundDirs.size()!=baseDirs.size() ;++fileIndex) {
    //in1=TFile::Open(inFileNames[fileIndex].c_str(),"READ");
    in1=openWithRetry(inFileNames[fileIndex].c_str());
    if (!in1) {
      std::cout << "ERROR: Could not open first file " << inFileNames[fileIndex] << "after all attempts" << std::endl;
      if (nSkippedFiles>MAXSKIPPEDFILES) {
    std::cout << "Failed to read " << nSkippedFiles << " input files. Abort job ..." << std::endl;
    return -1;
      }
      if (nSkippedFiles>nFiles*MAXSKIPPEDFILESFRACTION) {
    std::cout << "Failed to read " << 100.0*nSkippedFiles/nFiles << "% of input files. Abort job ..." << std::endl;
    return -1;
      }
      ++nSkippedFiles;
      std::cout << "Continue without this file. Skipped " << nSkippedFiles << " input files so far." << std::endl;
      continue;
    }
 
    std::cout << "First loop: Working on file " << inFileNames[fileIndex] <<std::endl;
    //Get run_XXXX directory name
    TIter next(in1->GetListOfKeys() );
    TKey* key;
    while((key=(TKey*)next()))  {
      const char* name=key->GetName();
      if (!strncmp(name,"run_",4)) {
    if (runDir.size()>1) {
      std::cout << "ERROR More than one run_XXX directory found! Ignoring " <<  name << std::endl;
    }
    else
      runDir.append(name);
      }
    }
 
    if (runDir.size()==1) {
      std::cout << "WARNING: No run_XXXX directory found. Empty File? Ignored." << std::endl;
      in1->Close();
      continue;
    }
 
    //Collect histogram directories
    std::vector<std::string>::const_iterator dIt=baseDirs.begin();
    std::vector<std::string>::const_iterator dIt_e=baseDirs.end();
 
    for (;dIt!=dIt_e;++dIt) {
      std::string dirName=runDir+"/"+(*dIt);
      // In case we are looping over more files to find the directory
 
      TDirectory* dir=dynamic_cast<TDirectory*>(in1->Get(dirName.c_str()));
      if (!dir) {
    std::cout << "Did not find directory " << dirName <<" in file "<<inFileNames[fileIndex].c_str()<<" !" << std::endl;
    continue;
      }
      if (std::find(foundDirs.begin(), foundDirs.end(), dirName) != foundDirs.end())
    {
      std::cout<<"Already found "<<dirName<<" before"<<std::endl;
      //continue;
    }else{
    foundDirs.push_back(dirName);
      }
      if (debug) std::cout << "Found directory " << dirName <<" in file "<<inFileNames[fileIndex].c_str()<<" !" << std::endl;
      listOfHists.addDirectory(dir,dirName);
    }
 
    std::cout << "Number of directories: " << listOfHists.size() << std::endl;
    std::cout<<"SIZE "<< listOfHists.size() <<std::endl;
 
    if (debug) listOfHists.print();
    
    //std::cout << "Closing first file" << std::endl;
    //in1->Close("R");
    //delete in1;
  }//end loop to find first non-empty file
 
  for (;fileIndex<nFiles;++fileIndex) { // Loop over remaining files
    const char* filename=inFileNames[fileIndex].c_str();
    //TFile* in=TFile::Open(filename,"READ");
    TFile* in=openWithRetry(filename);
    if (!in) {
      std::cout << "ERROR: Could not open file " << filename << "after all attempts" << std::endl;
      if (nSkippedFiles>MAXSKIPPEDFILES) {
    std::cout << "Failed to read " << nSkippedFiles << " input files. Abort job ..." << std::endl;
    return -1;
      }
      if (nSkippedFiles>nFiles*MAXSKIPPEDFILESFRACTION) {
    std::cout << "Failed to read " << 100.0*nSkippedFiles/nFiles << "% of input files. Abort job ..." << std::endl;
    return -1;
      }
      ++nSkippedFiles;
      std::cout << "Continue without this file. Skipped " << nSkippedFiles << " input files so far." << std::endl;
      continue;
    }
    std::cout << "Working on file " << filename << std::endl;
    TObject* dirObj=in->Get(runDir.c_str()+1);
    if (!dirObj) {
      std::cout << "Directory " << runDir << " not found. Ignoring apprently empty file" << std::endl;
    }
    else
      listOfHists.addFile(in);
    in->Close();
    delete in;
  }
 
  TFile* out=new TFile(outFileName.c_str(),"NEW");
  if (!out || !out->IsOpen()) {
    std::cout << "ERROR: Failed to open output file " << outFileName << " for writing" << std::endl;
    return -1;
  }
  listOfHists.write(out);
  out->Close();
  delete out;
 
  if (in1 && in1->IsOpen()) {
    in1->Close();
    delete in1;
  }
 
  if (nSkippedFiles>0) {
    std::cout << "WARNING: Skipped " << nSkippedFiles << " input file(s)." << std::endl;
  }
 
  return 0;
}

openWithRetry()

TFile* openWithRetry	(	const char *	path,
		const unsigned	nTrys = 3
	)

Definition at line 33 of file LArQuickHistMerge.cxx.

                                                               {
  TFile* f=nullptr;
  unsigned iTry=0;
  unsigned sleepSeconds=30;
  while (!f && iTry<nTrys) {
    f=TFile::Open(path,"READ");
    if (!f || !(f->IsOpen())) {
      ++iTry;
      std::cout << "WARNING: Failed to open file " << path << " on " << iTry << ". attempt." << std::endl;
      if (iTry<nTrys) {
    std::cout << "Will re-try after " << sleepSeconds << " seconds..." << std::endl;
    sleep(sleepSeconds);
    f=nullptr;
    sleepSeconds*=2;
      }
      else {//no more attempts
    std::cout << "No more retrys" << std::endl;
      }
    }//end if file not open
  }// end while
  return f;
}

readFromTextFile()

bool readFromTextFile	(	const char *	filename,
		std::vector< std::string > &	out
	)

Definition at line 447 of file LArQuickHistMerge.cxx.

                                                                       {
  std::ifstream ifs (filename, std::ifstream::in );
  if (!ifs.good()) {
    std::cout << "Failed to open file " << filename << " for reading." << std::endl;
    return false;
  }
  while (ifs.good()) {
    std::string line;
    getline(ifs,line);
    //Bit of cleaning and splitting:
    const std::vector<std::string> linetok=splitString(line," ,;\t\n");
    std::vector<std::string>::const_iterator it=linetok.begin();
    std::vector<std::string>::const_iterator it_e=linetok.end();
    for(;it!=it_e;++it) {
      if ((*it)[0]=='#') break; //ingore all characters behind '#'
      out.push_back(*it);
    }
    //if (!line.size()) continue;
    //out.push_back(line);
  }
  ifs.close();
  return true;
}

splitString()

std::vector<std::string> splitString	(	const std::string &	in,
		const std::string &	delim
	)

Definition at line 434 of file LArQuickHistMerge.cxx.

                                                                              {
  std::vector<std::string> retvec;
  size_t pos1=0,pos2=0;
  while (pos2!=std::string::npos) {
    pos2=in.find_first_of(delim,pos1);
    const std::string sub=in.substr(pos1,pos2-pos1);
    if (!sub.empty())
      retvec.push_back(sub);
    pos1=pos2+1;
  }
  return retvec;
}

Variable Documentation

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

ATLAS_NO_CHECK_FILE_THREAD_SAFETY

Definition at line 7 of file LArQuickHistMerge.cxx.