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 keys in a ROOT TDirectory and stores it on a vector.
   *
   * \param  dir        The ROOT directory
   * \param  buffer     Vector to store keys
   */
  void readDir(TDirectory*                         dir,
               std::vector<JGIZMO::JRootObjectID>& buffer) {
  
    TIter iter(dir->GetListOfKeys());
  
    for (TKey* key; (key = (TKey*) iter.Next()) != NULL; ) {

      if (key->IsFolder()){

        dir->cd(key->GetName());
      
        TDirectory *subdir = gDirectory;
        readDir(subdir, buffer);

        dir->cd();
      
      } else {

        JGIZMO::JRootObjectID objectID(MAKE_STRING(dir->GetPath() << key->GetName()));
        
        buffer.push_back(objectID);
      }
    }
  }
}


/**
 * \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;

  vector<JRootObjectID> objectIDs;
  readDir(f1,objectIDs);

  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;
    }
    
    const TRegexp regexp(name); 
    
    for (vector<JRootObjectID>::const_iterator objectID = objectIDs.cbegin() ; objectID != objectIDs.cend() ; ++objectID) {

      const TString& objectDir  = objectID->getDirectory();
      const TString& objectName = objectID->getFullObjectName();
      
      if ((objectName.Index(regexp) != -1) && (f2->Get(objectName))) {

        TObject* obj1 = (TObject*)f1->Get(objectName);
        TObject* obj2 = (TObject*)f2->Get(objectName);

        d[testID]->read(iss);
        d[testID]->test(obj1,obj2);

        if (out.GetDirectory(objectDir)==0) {
          out.mkdir(objectDir);
        }

        out.cd(objectDir);
        
        for (vector<JTestResult>::iterator r = d[testID]->results.begin() ; r != d[testID]->results.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]->results.cbegin(), d[testID]->results.cend(),
                                      make_predicate(&JTestResult::passed, true));
        
        npassed += Npass;
        nfailed += (d[testID]->results.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; 
}