HistMan.cc

Go to the documentation of this file.

#include "HistMan/HistMan.h"

#include <TSystem.h>
#include <TKey.h>
#include <TROOT.h>
#include <TFile.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TTree.h>

#include <string>
#include <vector>
#include <iostream>
#include <cassert>
#include <algorithm>
using namespace std;

//const char baseName[] = "HistMan";  
const char baseName[] = "stats";  

vector<string> parse_path(const char* path)
{
    vector<string> vs;
    string p(path);
    string::iterator it1=p.begin(), it2, done=p.end();
    for (it2=find(p.begin(),done,'/'); it2 != done; it2=find(it1,done,'/')) {
        if (it1==it2) {
            ++it1;
            continue;
        }
        string dir(it1,it2);
        if (dir != ".")
            vs.push_back(dir);
        it1 = it2+1;
    }
    if (it1 != it2) {
        string dir(it1,it2);
        if (dir != ".")
            vs.push_back(string(it1,it2));
    }
    return vs;
}

TFolder& mkdir_p(TFolder& top, const char* path)
{
    if (!path || path[0] == '\0') return top;

    vector<string> vp = parse_path(path);
    TFolder* folder = &top;
    for (unsigned int ind=0; ind < vp.size(); ++ind) {
        const char* name = vp[ind].c_str();
        TFolder* tmp = dynamic_cast<TFolder*>(folder->FindObject(name));
        if (tmp) folder = tmp;
        else folder = folder->AddFolder(name,name);
    }
    return *folder;
}

static int histcount = 0;
HistMan::HistMan(TFolder* folder, bool own)
    : fFolder(folder)
    , fOwn(own)
{
    if (!fFolder) {
        fFolder = new TFolder(Form("HistFolder%d",histcount),
                              Form("Histogram Folder #%d",histcount));
    }
    fFolder->SetOwner(true);
}

HistMan::HistMan(const char* base_directory)
{
    fFolder = &this->BaseFolder();
    fFolder = &mkdir_p(*fFolder,base_directory);
    fOwn = false;
    fFolder->SetOwner(true);
}

static TFolder* directory_to_folder(TDirectory& directory)
{
    TFolder* folder = new TFolder(directory.GetName(),directory.GetName());

    TList *l = directory.GetListOfKeys();
    if (!l) return folder;

    TIter it(l->MakeIterator());
    TObject *obj=0;
    while ( (obj=it()) ) {
        TKey* key = dynamic_cast<TKey*>(obj);
        assert(key);
        obj = directory.Get(key->GetName());
        TDirectory* dir = dynamic_cast<TDirectory*>(obj);
        if (dir) {
            TFolder* fol = directory_to_folder(*dir);
            //cerr << "Adding folder " << fol->GetName()
            //<< " to folder " << folder->GetName()
            //<< " from directory " << dir->GetName() << endl;
            folder->Add(fol);
        }
        else {
            //cerr << "Adding object " << obj->GetName()
            //<< " to folder " << folder->GetName() << endl;
            folder->Add(obj);
        }
    }
    return folder;
}



HistMan::HistMan(TFile& file, bool attach)
{
    TDirectory* dir = dynamic_cast<TDirectory*>(file.Get(baseName));
    if (!dir) {
      //cerr << "Failed to find HistMan folder in " << file.GetName() << endl;
        fFolder = &this->BaseFolder();
        fFolder = &mkdir_p(*fFolder,"");
        fOwn = false;
        fFolder->SetOwner(true);
        return;
    }
    fFolder = directory_to_folder(*dir);
    if (attach) {
        fOwn = false;
        gROOT->Add(fFolder);
    }
}

HistMan::HistMan(const char** file_list, const char** hist_list)
{
    fFolder = &this->BaseFolder();
    fFolder = &mkdir_p(*fFolder,"");
    fOwn = false;
    fFolder->SetOwner(true);
    //
    for (int ifile=0; file_list[ifile]; ++ifile){
        // check first if there the file exists, if not, print out a
        // warning message and continue with the other files        
        if (gSystem->AccessPathName(file_list[ifile])) {
            cout << "HistMan: Warning: file " <<  file_list[ifile]
                 << " does not exist!" << endl;
            continue;
        }
        TFile file(file_list[ifile]);  
        if (!file.IsOpen()) {
            cout << "HistMan: Warning: problems opening file "
                 <<  file_list[ifile] << endl;
            continue;
        }
        HistMan hm(file,false);
        for (int ihist=0; hist_list[ihist]; ++ihist){           
            // Get a pointer to the histogram in the old file
            TH1* hold = hm.Get<TH1>(hist_list[ihist]);
            if (!hold) {
                cout << "HistMan: Warning: histogram named "
                     << hist_list[ihist] << " does not exist in file "
                     <<  file_list[ifile] << endl;
                continue;
            }
            
            // try to get a pointer to the hitogram in the new
            // HistMan. If it exists, add the old histogram to it. I
            // it doesn't, adopt the old histo 
            TH1* hnew = this->Get<TH1>(hist_list[ihist]);
            if (hnew)
                hnew->Add(hold);            
            else{ 
                string hname_fullp(hist_list[ihist]);
                string::size_type pos = hname_fullp.rfind("/"); 
                string hname_path;
                if (pos < hname_fullp.length())
                    hname_path = hname_fullp.substr(0,pos);
                else
                    hname_path = "";

                this->Adopt(hname_path.c_str(),dynamic_cast<TH1*>(hold->Clone()));
            }
        }
        file.Close();
    }
}

HistMan::~HistMan()
{
    if (fOwn) {
        //cerr<< "HistMan::~HistMan: Deleting file\n";
        delete fFolder;
    }
    fFolder = 0;
}

TFolder& HistMan::BaseFolder()
{
    TFolder* folder = dynamic_cast<TFolder*>(gROOT->FindObjectAny(baseName));
    if (folder) return *folder;

    folder = new TFolder(baseName,"Base Histogram Manager Folder");
    gROOT->Add(folder);
    return *folder;
}
void HistMan::RegisterWithRoot()
{
    if (!fOwn) return;
    fOwn = false;

    TFolder& base = this->BaseFolder();
    base.Add(fFolder);
}

static void folder_to_directory(TFolder* folder, TDirectory& directory)
{
    TDirectory*& prevdir = gDirectory, *dir = 0;

    TObject* obj = directory.Get(folder->GetName());
    if (obj) {
        dir = dynamic_cast<TDirectory*>(obj);
        if (!dir) {
            cerr << "Non-directory object \"" << folder->GetName()
                 << "\" already in directory\n";
            return;
        }
    }
    else
        dir = directory.mkdir(folder->GetName());

    dir->cd();

    TCollection* sf = folder->GetListOfFolders();
    if (!sf) {
        prevdir->cd();
        return;
    }

    TIter it(sf->MakeIterator());
    obj=0;
    while ( (obj=it()) ) {
        TFolder *fol = dynamic_cast<TFolder*>(obj);
        if (fol) folder_to_directory(fol,*dir);
        else {
            dir->cd();
            obj->Write();
        }
    }
    prevdir->cd();
}

void HistMan::WriteOut(TFile& file)
{
    if (!fFolder) return;
    folder_to_directory(fFolder,file);
}
void HistMan::WriteOut(const char* filename)
{
    TFile f(filename,"recreate");
    this->WriteOut(f);
    f.Close();
}


TObject* HistMan::Adopt(const char* dirpath, TObject* obj)
{
    TH1* hist = dynamic_cast<TH1*>(obj);
    if (hist)
        hist->SetDirectory(0);
    TTree* tree = dynamic_cast<TTree*>(obj);
    if (tree)
        tree->SetDirectory(0);
    TFolder* folder = &mkdir_p(*fFolder,dirpath);
    if (folder->FindObject(obj->GetName())) { // FindObject(Object*) not implemented!
        cerr << "Object: " << dirpath << "/" 
             << obj->GetName() << " already exists\n";
        delete obj;
        return 0;
    }
    folder->Add(obj);

    return obj;
}
bool HistMan::Fill1d(const char* pathname, Axis_t x, Stat_t w)
{
    TObject* o = fFolder->FindObject(pathname);
    if (!o) o = fFolder->FindObjectAny(pathname);
    TH1* h = dynamic_cast<TH1*>(o);
    if (!h) {
        cerr << "Fill1d(\""<<pathname<<"\") failed lookup\n";
        return false;
    }
    h->Fill(x,w);
    return true;
}
bool HistMan::Fill2d(const char* pathname, Axis_t x, Axis_t y, Stat_t w)
{
    TObject* o = fFolder->FindObject(pathname);
    if (!o) o = fFolder->FindObjectAny(pathname);
    TH2* h = dynamic_cast<TH2*>(o);
    if (!h) {
        cerr << "Fill2d(\""<<pathname<<"\") failed lookup\n";
        return false;
    }
    h->Fill(x,y,w);
    return true;
}

bool HistMan::FillProfile(const char* pathname, Axis_t x, Axis_t y, Stat_t w)
{
    TObject* o = fFolder->FindObject(pathname);
    if (!o) o = fFolder->FindObjectAny(pathname);
    TProfile* h = dynamic_cast<TProfile*>(o);
    if (!h) {
        cerr << "FillProfile(\""<<pathname<<"\") failed lookup\n";
        return false;
    }
    h->Fill(x,y,w);
    return true;
}


TObject* HistMan::GetObject(const char* pathname){
  TObject* obj = GetObjectOrFolder(pathname);
  if(!obj) return 0;
  // Don't return folders
  TFolder* f = dynamic_cast<TFolder*>(obj);
  if ( f ) return 0;
  return obj;
}

TFolder* HistMan::GetFolder(const char* pathname){
  TObject* obj = GetObjectOrFolder(pathname);
  if(!obj) return 0;
  // Only return folders
  TFolder* f = dynamic_cast<TFolder*>(obj);
  if ( !f ) return 0;
  return f;
}

TObject* HistMan::GetObjectOrFolder(const char* pathname)
{
    if (!fFolder) return 0;
    vector<string> path = parse_path(pathname);
    TFolder* folder = fFolder;
    for (size_t ind=0; ind < path.size(); ++ind) {
        //cerr << "Checking " << path[ind] << endl;
        TObject* obj = folder->FindObject(path[ind].c_str());
        if( !obj ) return 0;
        if( ind == (path.size()-1) ) return obj;
        TFolder* f = dynamic_cast<TFolder*>(obj);
        if ( !f ) return 0;
        folder = f;
    }
    return folder;
}

vector<TObject*> HistMan::GetObjects(const char* pathname){
  // Return the list of Objects (non-folders) in this folder
  vector<TObject*> objects;
  TFolder* currentFolder = this->GetFolder(pathname);
  if(!currentFolder) return objects;
  TCollection* contents = currentFolder->GetListOfFolders();
  TIter next(contents);
  TObject* obj = 0;
  while( (obj = next()) ){
    TFolder* folder = dynamic_cast<TFolder*>(obj);
    if(folder) continue; // Ignore sub-folders
    objects.push_back(obj);
  }
  return objects;
}

vector<TFolder*> HistMan::GetSubFolders(const char* pathname){
  // Return the list of sub-folders in this folder
  vector<TFolder*> folders;
  TFolder* currentFolder = this->GetFolder(pathname);
  if(!currentFolder) return folders;
  TCollection* contents = currentFolder->GetListOfFolders();
  TIter next(contents);
  TObject* obj = 0;
  while( (obj = next()) ){
    TFolder* folder = dynamic_cast<TFolder*>(obj);
    if(!folder) continue; // Ignore non-folders
    folders.push_back(folder);
  }
  return folders;
}