JZebraMantis.cc

Go to the documentation of this file.

#include <iostream>
#include <fstream>
 
#include "TString.h"
#include "TRegexp.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TFile.h"
#include "TKey.h"
 
#include "Jeep/JParser.hh"
 
#include "JSupport/JMeta.hh"
 
#include "JLang/JPredicate.hh"
 
#include "JCompareHistograms/JTest_t.hh"
#include "JCompareHistograms/JTestDictionary.hh"
 
#include "JGizmo/JRootObjectID.hh"
 
namespace {
  
  /*
   * Gets list of ROOT object identifiers in a ROOT TDirectory and stores it in a vector.
   * Note: Subdirectories are searched recursively.
   *
   * \param  dir        The ROOT directory
   */
  std::vector<JGIZMO::JRootObjectID> readDir(TDirectory* dir) {
 
    using namespace std;
    using namespace JPP;
 
    vector<JRootObjectID> buffer1;    
  
    TIter iter(dir->GetListOfKeys());
  
    for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {
 
      if (key->IsFolder()){
      
        TDirectory *subdir = dir->GetDirectory(key->GetName());
        
        vector<JRootObjectID> buffer2 = readDir(subdir);
 
        buffer1.insert(buffer1.end(), buffer2.begin(), buffer2.end());
      
      } else {
 
        const string fullName = MAKE_STRING(dir->GetPath()                    <<
                                            JRootObjectID::PATHNAME_SEPARATOR <<
                                            key->GetName());
 
        JRootObjectID objectID(fullName);
        
        buffer1.push_back(objectID);
      }
    }
 
    return buffer1;
  }
}
 
 
/**
 * \file
 *
 * Program to compare histograms in root files that have same directory structure,\n
 * and where the histograms have the same names.
 * The input histograms and the test to be applied for each histogram are specified\n
 * in an ASCII formatted steering file which is passed by the command line.\n\n
 * 
 * Each row of the steering file should have multiple columns.\n\n
 * 
 * Column  1 is the name of the histogram to be compared (including the full path inside the root file)\n
 * Column  2 is an integer value that indicates the test to be performed. See JTestDictionary()\n
 * Columns 3..n are reserved for the different parameters of the test.\n\n
 *
 * \author rgruiz, bjung
 */
int main(int argc, char** argv) {
 
  using namespace JPP;
  using namespace std;
 
  string         steeringFile;
  
  string         file1;
  string         file2;
  
  string         output;
  string         ascii;
 
  vector<string> keys;
  
  bool           onlyFailures;
 
  int            debug;
 
  const array_type<string>& listOfKeys = get_keys(JTestSummary().getProperties());
  
  try {
 
    const string& keysExplainer = MAKE_STRING("Terminal output:" << endl << listOfKeys);
    
    JParser<> zap("\nProgram to compare histograms in root files that have the same directory structure. See the link below this usage for further details.\n");
    
    zap['s'] = make_field(steeringFile , "ASCII steering file with list of histograms and tests");
    zap['a'] = make_field(file1        , "input file 1");
    zap['b'] = make_field(file2        , "input file 2");
    zap['o'] = make_field(output       , "output file root") = "zebramantis.root";
    zap['t'] = make_field(ascii        , "output file txt" ) = "zebramantis.txt";
    zap['k'] = make_field(keys         ,  keysExplainer )    = JPARSER::initialised();
    zap['w'] = make_field(onlyFailures , "write only failed tests" );
    zap['d'] = make_field(debug)                                                                = 2;
    
    zap(argc,argv);
  }
  catch(const exception &error) {
    ERROR(error.what() << endl);
  }
 
  if (keys.empty()) {
    keys = listOfKeys;
  }
  
  TFile* f1 = TFile::Open(file1.c_str());
  TFile* f2 = TFile::Open(file2.c_str());
  
  TFile out(output.c_str(),"recreate");
 
  ofstream results;
  results.open (ascii);
  results << "# " << listOfKeys << endl;
 
  const vector<JRootObjectID> objectIDs = readDir(f1);
 
  std::ifstream infile(steeringFile);
 
  JTestDictionary d;
 
  size_t npassed = 0;
  size_t nfailed = 0;
    
  for (string line; getline(infile, line); ) {
      
    istringstream iss(line);
 
    TString       name;
    int           testID;
    
    if (!(iss >> name >> testID)) {
      continue;
    }
 
    DEBUG("Input: " << name << ' ' << testID << endl);
    
    const TRegexp regexp(name); 
    
    for (vector<JRootObjectID>::const_iterator objectID = objectIDs.cbegin() ; objectID != objectIDs.cend() ; ++objectID) {
 
      const TString& dirName  = objectID->getDirectory();
      const TString& fullName = objectID->getFullObjectName();
 
      DEBUG("Key: " << fullName << " match = " << fullName.Contains(regexp) << endl);
      
      if ((fullName.Index(regexp) != -1)) {
 
        TObject* obj1 = (TObject*)f1->Get(fullName);
        TObject* obj2 = (TObject*)f2->Get(fullName);
 
        if (!obj1 || !obj2) {
          DEBUG("Could not retrieve " << fullName << endl);
          continue;
        }
 
        d[testID]->read(iss);
        d[testID]->test(obj1,obj2);
 
        if (dirName.Length() > 0 && !out.GetDirectory(dirName)) {
          
          if (dirName[0] == JRootObjectID::PATHNAME_SEPARATOR) { // Remove leading forward slash
            out.mkdir(TString(dirName(1, dirName.Length() - 1))); 
          } else {
            out.mkdir(dirName);
          }
        }
 
        out.cd(dirName);
        
        for (vector<JTestResult>::iterator r = d[testID]->begin() ; r != d[testID]->end() ; ++r) {
 
          if (onlyFailures && r->passed) {
            continue;
          }
 
          print(cout,    *r, keys.cbegin(),       keys.cend(),       ' ', false);
          print(results, *r, listOfKeys.cbegin(), listOfKeys.cend(), ' ', true);
 
          r->obj->Write();
        }
 
        const size_t Npass = count_if(d[testID]->cbegin(), d[testID]->cend(),
                                      make_predicate(&JTestResult::passed, true));
        
        npassed += Npass;
        nfailed += (d[testID]->size() - Npass);
 
        d[testID]->clear();
      }
    }
  }
    
  infile.close();
 
  results << WHITE << "# PASSED: " << npassed << " " << " FAILED: " << nfailed << " FAILURE FRACTION: " << float (nfailed)/(nfailed+npassed) << endl;
 
  putObject(&out, JMeta(argc, argv));
  JMeta::copy(file1.c_str(), out);
  JMeta::copy(file2.c_str(), out);
 
  results.close();
  out    .Close();
  
  return 0; 
}