HanOutputFile_translation.cxx

Go to the documentation of this file.

/*
   Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
#include <iostream>           //input-output
#include <nlohmann/json.hpp>  //If you run this code as part of Athena
// Root libraries
#include <TFile.h>
#include <TFolder.h>
#include <TH1.h>
#include <TKey.h>
#include <TObjString.h>
#include <TROOT.h>   //To use gRoot
#include <unistd.h>  //To use usleep function
 
#include <chrono>   //To measure time
#include <cstring>  //to convert string to char array (to save json file as TObjString)
 
// Function, that checks, if the directory includes histogram in it or in any subdirectories
 
int include_hist(TObject* obj);
 
// Function, that defines the number of objects inside a directory
int number_of_objects_in_dir(TIter next);
 
// Function, that converts sequense, containing TDirectories and strings to JSON file
nlohmann::ordered_json to_JSON(TObject* obj);
 
// What to do if dir has no hist
int work_with_no_hist_dir(TObject* obj, TObject* destination_to_save);
 
// Results directory usually does not include any hists. In such a way, after conversion it usually represents JSON
// string
// However,there are some cases, when it includes histogram "Reference". In this case it will be saved as Tdirectory.
// The conversion should be done in such a way, that the type of "Results" object should be the same all the time.
// The simpliest way is to store hist in the higher level and store the "Results" as JSON all the time.
// The higher level is a hist_ TDirectory. However this directory also not always will contains Reference. In this
// regards, the histo_ directory will always be Tdirectory кegardless of whether it contains a link or not.
int work_with_results_dir(TObject* obj_in, TObject* obj_to);
 
// Converts from old format to new format
int convert_file(TObject* obj_in, TObject* obj_to);
 
int main(int argc, char* argv[]) {
  using namespace std;
  // ATLAS Data Quality space
  TString input_file_path = "/eos/atlas/atlascerngroupdisk/data-dqm/examples/han_output_translation_example/";
  TString input_file_name = "run_364030_lowStat_LB121-140_han.root";  // Example file
  TString output_file_path = "./";
 
  if (argc == 2) {
    input_file_name = argv[1];
  }
  if (argc == 3) {
    input_file_name = argv[1];
    output_file_path = argv[2];
  }
  if (argc == 4) {
    input_file_path = argv[1];
    input_file_name = argv[2];
    output_file_path = argv[3];
  }
 
  auto start = std::chrono::system_clock::now();  // Start time counting
  // Open file from which to convert
  TFile* f_input = new TFile(input_file_path + input_file_name);
  // Open file where to convert
  // Enter here the path where you want to store the iutput file
  TFile* f_output = new TFile(output_file_path + input_file_name, "recreate");
  // Counting time elapsed for the translation
  auto end = std::chrono::system_clock::now();  // Stop time counting
  std::chrono::duration<double> elapsed_seconds = end - start;
  std::cout << "elapsed time to open files: " << elapsed_seconds.count() << "s\n";
  start = std::chrono::system_clock::now();  // Start time counting
 
  // Convert from V1-->V2.3
  convert_file(f_input, f_output);
 
  // Add the version flag
 
  f_output->cd("HanMetadata_");
  TDirectory* version_dir = gDirectory->mkdir("File");
  version_dir->cd();
  TDirectory* version_sub_dir = gDirectory->mkdir("Version_name");
  version_sub_dir->cd();
  TObjString file_version;
  file_version.Write("V.2.3");
 
  end = std::chrono::system_clock::now();  // Stop time counting
  elapsed_seconds = end - start;
  std::cout << "elapsed time for algorythm implementation: " << elapsed_seconds.count() << "s\n";
  // From root forum
  // To reduce the time spent in the ‘garbage collection’ and assuming that you are 100% sure
  // that no pointer to the contained object is shared and assuming you explicitly delete the
  // TFile object, you can remove the TFile object from the list of files
  // “gROOT->GetListOfFiles()->Remove(myfile);”
 
  // This is a known problem with file with very large number of histograms in a file
  //(and in particular in a directory). You can work around the problem, if (and only if)
  // you are sure the same histogram is not shared between two directories:
  // TFile *outputFile = ..... ..... gROOT->GetListOfFiles()->Remove(outputFile); delete outputFile;
 
  // start = std::chrono::system_clock::now(); // Start time counting
  gROOT->GetListOfFiles()->Remove(f_input);  // removes the file from a list of “files to cleanup”, so that the objects
  //  they contain are not cleaned at the end.
  gROOT->GetListOfFiles()->Remove(f_output);
  f_output->Close();
  f_input->Close();  // Close the file
  delete f_input;
  delete f_output;
  end = std::chrono::system_clock::now();  // Stop time counting
  elapsed_seconds = end - start;
  std::cout << "elapsed time to close files: " << elapsed_seconds.count() << "s\n";
  return 0;
}
 
//---------Functions description--------------
int convert_file(TObject* obj_input, TObject* obj_outout) {
  TString obj_input_type = obj_input->ClassName();
  bool is_file;
 
  if (obj_input_type == "TFile") {
    is_file = true;
  } else {
    is_file = false;
  }
 
  TDirectory* dir;
  TDirectory* save_to = dynamic_cast<TDirectory*>(obj_outout);
  TString name = obj_input->GetName();
 
  if (dir = dynamic_cast<TDirectory*>(obj_input)) { // obj_input is a TDirectory
    TString name = dir->GetName();
    if (name == "Results") { // From Results folder should be extracted Reference histogrma (in an upper level), and
                             // Results --> JSON
      work_with_results_dir(dir, save_to);
    } else if (name == "Config") { // Config --> JSON
      work_with_no_hist_dir(dir, save_to);
    } else {
      // Treat as TDirectory
      // 1-st, lets create this dir
      TDirectory* copy_dir;
      if (is_file == false) {
        copy_dir = save_to->mkdir(name);
      } else {
        copy_dir = save_to;
      }
      // All files in this dir should be saved in the created one
      copy_dir->cd();
      // 2-nd, create iterator to iterate through the objects in the original dir
      TIter next(dir->GetListOfKeys());
      TKey* key;
      // 3-rd, Analyse, from which elements this dir consists of
      while ((key = (TKey*) next())) {
        TObject* next_level_obj;
        TString key_name = key->GetName();
        next_level_obj = dir->GetKey(key_name)->ReadObj();
        convert_file(next_level_obj, copy_dir);
      }
    }
  } else { // If the object is not a Tdirectory (a histogram or TObjsStrin)
           // just save it as it is where it should be
    save_to->cd();
    obj_input->Write(name);
  }
  return 1;
}
 
int work_with_results_dir(TObject* obj_input, TObject* obj_outout) {
  TDirectory* dir = (TDirectory*) obj_input;
  TDirectory* save_to = (TDirectory*) obj_outout;
 
  if (include_hist(dir)) {
    TKey* key;
    TString key_type;
    TString key_name;
    TIter next(dir->GetListOfKeys());
    while ((key = (TKey*) next())) {
      TObject* obj_inside;
      key_name = key->GetName();
      obj_inside = dir->GetKey(key_name)->ReadObj();
      key_type = obj_inside->ClassName();
      // If an element in "Results" directory is a hist, we will save it in higher level
      if (key_type == "TH1I" || key_type == "TH2I" || key_type == "TH1F" || key_type == "TH2F" ||
          key_type == "TProfile2D" || key_type == "TProfile" || key_type == "TGraphAsymmErrors" ||
          key_type == "TGraphErrors" || key_type == "TH1D" || key_type == "TH2S") {
        save_to->cd();
        obj_inside->Write(key_name);
      }
    }
    // Then we will work with this directory as with ones without hists
    work_with_no_hist_dir(obj_input, obj_outout);
  }
  // If "Results" has no histograms inside, we will work with it as with the usual directory
  else {
    work_with_no_hist_dir(obj_input, obj_outout);
  }
  return 1;
}
 
int work_with_no_hist_dir(TObject* obj, TObject* destination_to_save) {
  TDirectory* save_place = (TDirectory*) destination_to_save;
 
  // If directory has no hists in it, we convert it to JSON
  //  histogram_ Tdirectory is an exception. It will always be a Tdirectory
  save_place->cd();
  nlohmann::ordered_json j = to_JSON(obj);
  // Then, save JSON to file as TObjString
  // Convert json to string
  std::string string = j.dump(4);
  // Write JSON to rootFile
 
  TObjString string_to_tfile;
  // string_to_tfile.SetString(cstr);//Original
  if (j.is_null()) {
    string_to_tfile.SetString("{}");  // Content of a JSON string
  } else {
    string_to_tfile.SetString(string.data());  // Content of a JSON string
  }
  TString key_name = obj->GetName();
  string_to_tfile.Write(key_name);
  return 0;
}
 
int include_hist(TObject* obj) {
  using namespace std;
 
  TDirectory* dir = (TDirectory*) obj;
  TKey* key;
  TString key_type;
  TString key_name;
  // Look, what the directory stores
  dir->cd();
  TIter next(dir->GetListOfKeys());
  while ((key = (TKey*) next())) {
    TObject* obj_inside;
    key_name = key->GetName();
    obj_inside =
      dir->GetKey(key_name)->ReadObj();  // Get the object. This procedure is better, since it is able to read
    //  names with "/"
    key_type = obj_inside->ClassName();
    // If the object is histogram
    if (key_type == "TH1I" || key_type == "TH2I" || key_type == "TH1F" || key_type == "TH2F" ||
        key_type == "TProfile2D" || key_type == "TProfile" || key_type == "TGraphAsymmErrors" ||
        key_type == "TGraphErrors" || key_type == "TH1D" || key_type == "TH2S") {
      return 1;
    }
    // Also check all the subdirectories
    if (key_type == "TDirectoryFile") {
      if (include_hist(obj_inside) == 1) {
        return 1;
      }
    }
  }
  return 0;
}
 
int number_of_objects_in_dir(TIter next) {
  const TCollection* next_coll = next.GetCollection();
  Int_t level_size = next_coll->Capacity();
 
  return level_size;
}
 
nlohmann::ordered_json to_JSON(TObject* obj) {
  using json = nlohmann::ordered_json;
  TString obj_type = obj->ClassName();
  json j;
 
  if (obj_type == "TObjString") { // If the object type, that were passed to this function is TObjString (should be
                                  //  impossible), this means, that there is a TObjString, that is not a single file in
                                  // a
                                  //  directory (not a usual case)
    std::cout << "WARNING: Strange case: TObjString is not a single object in a dir" << std::endl;
  } else if (obj_type != "TDirectoryFile" && obj_type != "TFile") { // No other type than TDirectory or TFile should be
                                                                    //  passed to this function normally
    std::cout << "WARNING: Strange type: " << obj_type << std::endl;
  }
 
  TDirectory* dir = (TDirectory*) obj;
  TString dir_name = dir->GetName();
  TIter next(dir->GetListOfKeys());
  TKey* key;
  TString key_name;
 
  int size_next = number_of_objects_in_dir(next);
 
  // We should write to JSON all the objects
  while ((key = (TKey*) next())) {
    TObject* next_level_obj;
    key_name = key->GetName();
    next_level_obj =
      dir->GetKey(key_name)->ReadObj();  // Get object. This procedure is better, since it is able to read
    //  names with "/"
    TString key_type = next_level_obj->ClassName();
 
    if (size_next == 1 && key_type == "TObjString") { // If this is a directory just before the leaf (the TObjString
                                                      //  file)
      j = key_name;  // This is the leaf
      if (key_name == dir_name) {
        std::cout << "WARNING: The names of Directory and TObjstring inside this directory are the same: " << dir_name
                  << std::endl;
      }
    }
    // We will ignore Hists in "Results" directory, since we have already written them in a higher level
    else if ((dir_name == "Results") &&
             (key_type == "TH1I" || key_type == "TH2I" || key_type == "TH1F" || key_type == "TH2F" ||
              key_type == "TProfile2D" || key_type == "TProfile" || key_type == "TGraphAsymmErrors" ||
              key_type == "TGraphErrors" || key_type == "TH1D" || key_type == "TH2S")) {
      continue;
    }
    // If inside this directory other subdirrectory
    else { // Write Directory_names as keys and content of the dirrectories as a values
           // Convert TString to string
      std::string key_name_string(key_name.Data());
      // Write JSON to rootFile
      j.emplace(key_name_string, to_JSON(next_level_obj));
    }
  }
  return j;
}