geant4/source/analysis/g4tools/include/tools/rroot/rall

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.

#ifndef tools_rroot_rall
#define tools_rroot_rall

#include "streamers"
#include "fac"
#include "tree"

#define TOOLS_RROOT_NOT_OSC

#ifndef TOOLS_RROOT_NOT_OSC
#include "osc"
#endif

namespace tools {
namespace rroot {

inline TDirectory* find_dir(directory& a_dir,const std::string& a_name) {
  std::ostream& out = a_dir.file().out();
  key* k = a_dir.find_key(a_name);
  if(!k) {
    //out << "tools::rroot::find_dir :"
    //    << " " << a_name << " not a key."
    //    << std::endl;
    return 0;
  }

  if(k->object_class()!=TDirectory_cls()) {
    out << "tools::rroot::find_dir :"
        << " key " << a_name << " not a TDirectory."
        << std::endl;
    return 0;
  }
  uint32 sz;
  char* buf = k->get_object_buffer(a_dir.file(),sz); //we don't have ownership of buf.
  if(!buf) {
    out  << "tools::rroot::find_dir :"
         << " can't get directory data buffer."
         << std::endl;
    return 0;
  }
  buffer b(out,a_dir.file().byte_swap(),sz,buf,k->key_length(),false);
  TDirectory* tdir = new TDirectory(a_dir.file());
  if(!tdir) return 0;
  if(!tdir->stream(b)) {
    out << "tools::rroot::find_dir :"
        << " can't stream TDirectory."
        << std::endl;
    return 0;
  }
  return tdir;
}

inline bool read_key(std::ostream& a_out,ifile& a_file,key& a_key,bool a_dump){
  unsigned int sz;    
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    a_out << "tools::rroot::read_key :"
          << " can't get data buffer of " << a_key.object_name() << "."
          << std::endl;
    return false;
  }

  //a_out << "tools::rroot::read_key :"
  //      << " get data buffer size " << sz << "."
  //      << std::endl;

  buffer b(a_out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);

  if(a_key.object_class()==TH1F_cls()) {
    tools::histo::h1d* h = TH1F_stream(b);
    if(!h) {
      a_out << "tools::rroot::read_key :"
            << " TH1F streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==TH1D_cls()) {
    tools::histo::h1d* h = TH1D_stream(b);
    if(!h) {
      a_out << "tools::rroot::read_key :"
            << " TH1D streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==TH2F_cls()) {
    tools::histo::h2d* h = TH2F_stream(b);
    if(!h) {
      a_out << "tools::rroot::read_key :"
            << " TH2F streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==TH2D_cls()) {
    tools::histo::h2d* h = TH2D_stream(b); //we get ownership of h.
    if(!h) {
      a_out << "tools::rroot::read_key :"
            << " TH2D streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==TH3D_cls()) {
    tools::histo::h3d* h = TH3D_stream(b); //we get ownership of h.
    if(!h) {
      a_out << "tools::rroot::read_key :"
            << " TH3D streaming failed"
            << std::endl;
    } else {
      if(a_dump) h->hprint(a_out);
    }
    delete h;

  } else if(a_key.object_class()==TProfile_cls()) {
    tools::histo::p1d* p = TProfile_stream(b);
    if(!p) {
      a_out << "tools::rroot::read_key :"
            << " TProfile streaming failed"
            << std::endl;
    } else {
      if(a_dump) p->hprint(a_out);
    }
    delete p;

  } else if(a_key.object_class()==TProfile2D_cls()) {
    tools::histo::p2d* p = TProfile2D_stream(b);
    if(!p) {
      a_out << "tools::rroot::read_key :"
            << " TProfile2D streaming failed"
            << std::endl;
    } else {
      if(a_dump) p->hprint(a_out);
    }
    delete p;

  } else if(a_key.object_class()==TTree_cls()) {
   
    fac _fac(a_out);
    tree tree(a_file,_fac);
    if(!tree.stream(b)) {
      a_out << "tools::rroot::read_key :"
            << " TTree streaming failed"
            << std::endl;
    } else {
      //tree->dump(a_out);
      if(a_dump) {
        tree.dump(a_out,"","  ");

        uint64 entries = tree.entries();  

       /*
       {for(uint32 j=0;j<10;j++){ //to test memory.
        for(uint32 i=0;i<entries;i++){
          uint32 n;
          if(!tree.find_entry(i,n)) {
            a_out << " can't find entry " << i
                  << std::endl;
          }       
        }
        }}
        */
  
       {for(uint32 i=0;i<5;i++){
          if(!tree.show(a_out,i)) {
            a_out << " show failed for entry " << i
                  << std::endl;
          }       
        }}
       {for(uint64 i=mx<int64>(5,entries-5);i<entries;i++){
          if(!tree.show(a_out,(uint32)i)) {
            a_out << " show failed for entry " << i
                  << std::endl;
          }
        }}
 
      }
    }
	
#ifndef TOOLS_RROOT_NOT_OSC
  } else if(a_key.object_class()==tools::osc::s_h1d()) {

    tools::histo::h1d h("",10,0,1);
    if(!from_osc(b,tools::osc::s_h1d(),h)) {
      a_out << "tools::rroot::read_key :"
            << " " << tools::osc::s_h1d() << " streaming failed"
            << std::endl;
    } else {
      if(a_dump) h.hprint(a_out);
    }

  } else if(a_key.object_class()==tools::osc::s_h2d()) {

    tools::histo::h2d h("",10,0,1,10,0,1);
    if(!from_osc(b,tools::osc::s_h2d(),h)) {
      a_out << "tools::rroot::read_key :"
            << " " << tools::osc::s_h2d() << " streaming failed"
            << std::endl;
    } else {
      if(a_dump) h.hprint(a_out);
    }

  } else if(a_key.object_class()==tools::osc::s_h3d()) {

    tools::histo::h3d h("",10,0,1,10,0,1,10,0,1);
    if(!from_osc(b,tools::osc::s_h3d(),h)) {
      a_out << "tools::rroot::read_key :"
            << " " << tools::osc::s_h3d() << " streaming failed"
            << std::endl;
    } else {
      if(a_dump) h.hprint(a_out);
    }

  } else if(a_key.object_class()==tools::osc::s_p1d()) {

    tools::histo::p1d h("",10,0,1);
    if(!from_osc(b,tools::osc::s_p1d(),h)) {
      a_out << "tools::rroot::read_key :"
            << " " << tools::osc::s_p1d() << " streaming failed"
            << std::endl;
    } else {
      if(a_dump) h.hprint(a_out);
    }

  } else if(a_key.object_class()==tools::osc::s_p2d()) {

    tools::histo::p2d h("",10,0,1,10,0,1);
    if(!from_osc(b,tools::osc::s_p2d(),h)) {
      a_out << "tools::rroot::read_key :"
            << " " << tools::osc::s_p2d() << " streaming failed"
            << std::endl;
    } else {
      if(a_dump) h.hprint(a_out);
    }
#endif

  } else if(a_key.object_class()==TDirectory_cls()) {

    //we should not pass here.

  } else {
    a_out << "tools::rroot::read_key :"
          << " dont't know how to read key with object class "
          << tools::sout(a_key.object_class())
          << std::endl;
  }
  return true;
}

inline tools::histo::h1d* key_to_h1d(ifile& a_file,key& a_key){
  std::ostream& out = a_key.out();
  if((a_key.object_class()!=TH1D_cls())&&
     (a_key.object_class()!=TH1F_cls())
  ) {
    out << "tools::rroot::key_to_h1d :"
        << " key not a TH1D and not a TH1F."
        << std::endl;
    return 0;
  }
  unsigned int sz;
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_h1d :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  if(a_key.object_class()==TH1D_cls()) {
    return TH1D_stream(b);
  } else {
    return TH1F_stream(b);
  }
}

inline tools::histo::h2d* key_to_h2d(ifile& a_file,key& a_key){
  std::ostream& out = a_key.out();
  if(a_key.object_class()!=TH2D_cls()) {
    out << "tools::rroot::key_to_h2d :"
        << " key not a TH2D."
        << std::endl;
    return 0;
  }
  unsigned int sz;
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_h2d :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  return TH2D_stream(b);
}

inline tools::histo::h3d* key_to_h3d(ifile& a_file,key& a_key){
  std::ostream& out = a_key.out();
  if(a_key.object_class()!=TH3D_cls()) {
    out << "tools::rroot::key_to_h3d :"
        << " key not a TH3D."
        << std::endl;
    return 0;
  }
  unsigned int sz;
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_h3d :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  return TH3D_stream(b);
}

inline tools::histo::p1d* key_to_p1d(ifile& a_file,key& a_key){
  std::ostream& out = a_key.out();
  if(a_key.object_class()!=TProfile_cls()) {
    out << "tools::rroot::key_to_p1d :"
        << " key not a TProfile."
        << std::endl;
    return 0;
  }
  unsigned int sz;
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_p1d :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  return TProfile_stream(b);
}

inline tools::histo::p2d* key_to_p2d(ifile& a_file,key& a_key){
  std::ostream& out = a_key.out();
  if(a_key.object_class()!=TProfile2D_cls()) {
    out << "tools::rroot::key_to_p2d :"
        << " key not a TProfile2D."
        << std::endl;
    return 0;
  }
  unsigned int sz;
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_p2d :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  return TProfile2D_stream(b);
}

inline tree* key_to_tree(ifile& a_file,ifac& a_fac,key& a_key) {
  std::ostream& out = a_key.out();
  if(a_key.object_class()!=TTree_cls()) {
    out << "tools::rroot::key_to_tree :"
        << " key not a TTree."
        << std::endl;
    return 0;
  }
  unsigned int sz;    
  char* buf = a_key.get_object_buffer(a_file,sz); //we don't have ownership of buf.
  if(!buf) {
    out << "tools::rroot::key_to_tree :"
        << " can't get data buffer of " << a_key.object_name() << "."
        << std::endl;
    return 0;
  }
  buffer b(out,a_file.byte_swap(),sz,buf,a_key.key_length(),false);
  tree* _tree = new tree(a_file,a_fac);
  if(!_tree->stream(b)) {
    out << "tools::rroot::key_to_tree :"
        << " TTree streaming failed"
        << std::endl;
    delete _tree;
    return 0;
  }
  return _tree;
}	

inline void read(std::ostream& a_out,
                 ifile& a_file,
                 const std::vector<key*>& a_keys,
                 bool a_recursive,
                 bool a_ls,
                 bool a_dump,
                 unsigned int a_spaces) {

 {std::vector<key*>::const_iterator it;
  for(it=a_keys.begin();it!=a_keys.end();++it) {
    key& k = *(*it);
    if(k.object_class()!=TDirectory_cls()) {
      if(a_ls||a_dump) {
        {for(unsigned int index=0;index<a_spaces;index++) a_out << " ";}
        std::string label = k.object_name();
        a_out << "object : " << sout(label)
              << ", class : " << k.object_class()
              << std::endl;
        //k.dump(a_out);
      }
      if(!read_key(a_out,a_file,k,a_dump)) return;
    }
  }}

 {std::vector<key*>::const_iterator it;
  for(it=a_keys.begin();it!=a_keys.end();++it) {
    key& k = *(*it);
    if(k.object_class()==TDirectory_cls()) {

      if(a_ls||a_dump) {
        {for(unsigned int index=0;index<a_spaces;index++) a_out << " ";}
        std::string label = k.object_name();
        a_out << "directory : " << label << std::endl;
      }

      if(!a_recursive) continue;

      tools::uint32 sz;    
      char* buf = k.get_object_buffer(a_file,sz); 
      if(!buf) {
        a_out  << "read :"
               << " can't get directory data buffer."
               << std::endl;
      } else {
        buffer b(a_out,a_file.byte_swap(),sz,buf,k.key_length(),false);
        TDirectory dir(a_file);
        if(!dir.stream(b)) {
          a_out << "read :"
                << " can't stream TDirectory."
                << std::endl;
        } else {
          const std::vector<key*>& keys = dir.keys();
          read(a_out,a_file,keys,a_recursive,a_ls,a_dump,a_spaces+1);
        }
      }
    }
  }}
}

}}

#endif