tools::rroot::ntuple Class Reference

Inheritance diagram for tools::rroot::ntuple:

Collaboration diagram for tools::rroot::ntuple:

Classes
class	column
class	column_element
class	column_element_ref
class	column_ref
class	column_string
class	column_string_ref
class	column_vector_string
class	column_vector_string_ref
class	std_vector_column_ref

Public Member Functions
virtual const std::string &	s_cls () const
virtual void	start ()
virtual bool	next ()
virtual read::icol *	find_icol (const std::string &a_name)
virtual const std::vector< read::icol * > &	columns () const
virtual const std::string &	title () const
virtual bool	number_of_entries (uint64 &a_value) const
	ntuple (tree &a_tree)
virtual	~ntuple ()
bool	initialize (std::ostream &a_out, const ntuple_binding &a_bd=ntuple_binding(), bool a_enforce_double=false)
bool	get_row () const
Public Member Functions inherited from tools::read::intuple
virtual	~intuple ()
virtual void	stop ()
size_t	number_of_columns () const
void	column_names (std::vector< std::string > &a_names) const
icol *	find_icol_case_insensitive (const std::string &a_name)
template<class T >
icolumn< T > *	find_column (const std::string &a_name)
template<class T >
bool	find_column (const std::string &a_name, icolumn< T > *&a_col, bool a_case_sensitive=true)
template<class T >
bool	column_is_of_type (const std::string &a_name, bool &a_is, bool a_case_sensitive=true)
template<class T >
bool	column_min (unsigned int a_col, T &a_value)
template<class T >
bool	column_max (unsigned int a_col, T &a_value)

Static Public Member Functions
static const std::string &	s_class ()
Static Public Member Functions inherited from tools::read::intuple
static const std::string &	s_class ()

Protected Member Functions
	ntuple (const ntuple &a_from)
ntuple &	operator= (const ntuple &)

Protected Attributes
tree &	m_tree
std::vector< read::icol * >	m_cols
int64	m_index

Detailed Description

Definition at line 28 of file ntuple.

Constructor & Destructor Documentation

ntuple() [1/2]

tools::rroot::ntuple::ntuple ( tree &  a_tree )

inline

Definition at line 488 of file ntuple.

                      :m_tree(a_tree),m_index(-1){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

~ntuple()

virtual tools::rroot::ntuple::~ntuple ( )

inlinevirtual

Definition at line 493 of file ntuple.

                    {
    safe_clear<read::icol>(m_cols);
#ifdef TOOLS_MEM
    mem::decrement(s_class().c_str());
#endif
  }

ntuple() [2/2]

tools::rroot::ntuple::ntuple ( const ntuple &  a_from )

inlineprotected

Definition at line 500 of file ntuple.

  :parent(a_from),m_tree(a_from.m_tree){
#ifdef TOOLS_MEM
    mem::increment(s_class().c_str());
#endif
  }

Member Function Documentation

columns()

virtual const std::vector<read::icol*>& tools::rroot::ntuple::columns ( ) const

inlinevirtual

Implements tools::read::intuple.

Definition at line 46 of file ntuple.

{return m_cols;}

find_icol()

virtual read::icol* tools::rroot::ntuple::find_icol ( const std::string &  a_name )

inlinevirtual

Implements tools::read::intuple.

Definition at line 43 of file ntuple.

                                                      {
    return find_named<read::icol>(m_cols,a_name);
  }

get_row()

bool tools::rroot::ntuple::get_row ( ) const

inline

Definition at line 720 of file ntuple.

                       {
    bool status = true;
    tools_vforcit(read::icol*,m_cols,it) {
      if(!(*it)->fetch_entry()) {
        m_tree.out() << "tools::rroot::ntuple::get_row : fetch_entry() failed for leaf " << (*it)->name() << std::endl;
        status = false;
      }
    }
    return status;
  }

initialize()

bool tools::rroot::ntuple::initialize ( std::ostream &  a_out, const ntuple_binding &  a_bd = ntuple_binding(), bool  a_enforce_double = false  )

inline

Definition at line 508 of file ntuple.

                                                                                                                 {
    safe_clear<read::icol>(m_cols);
 
    std::vector<base_leaf*> leaves;
    m_tree.find_leaves(leaves);
    tools_vforcit(base_leaf*,leaves,it) {
      base_leaf* bl = (*it);
      if(find_named<read::icol>(m_cols,bl->name())) {
        a_out << "tools::rroot::ntuple::initialize :"
              << " column with name " << sout(bl->name())
              << " already exists."
              << std::endl;
        safe_clear<read::icol>(m_cols);
        return false;
      }
      branch* _branch = m_tree.find_leaf_branch(*bl);
      if(!_branch) {
        a_out << "tools::rroot::ntuple::initialize :"
              << " can't find branch of leaf " << sout(bl->name()) << "."
              << std::endl;
        safe_clear<read::icol>(m_cols);
        return false;
      }
 
      //a_out << "tools::rroot::ntuple::initialize :"
      //      << " branch " << _branch->name()
      //      << ", entries " << _branch->entry_number() << "."
      //      << std::endl;
 
#define TOOLS_RROOT_NTUPLE_CREATE_COL(a__type) \
      if(leaf<a__type>* lf_##a__type = safe_cast<base_leaf, leaf<a__type> >(*bl) ){\
        cid user_cid;void* user_obj;\
        a_bd.find_user_obj(bl->name(),user_cid,user_obj);\
        typedef leaf<a__type> leaf_t;\
        if(!user_obj) {\
          if(a_enforce_double) {\
            column<double,leaf_t>* col = new column<double,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index);\
            m_cols.push_back(col);\
          } else {\
            column<a__type,leaf_t>* col = new column<a__type,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index);\
            m_cols.push_back(col);\
          }\
        } else {\
          const base_leaf* lfc = bl->leaf_count();\
          if(lfc) {\
            /*::printf("debug : ntuple : create col leaf count : %s\n",bl->name().c_str());*/\
            if(user_cid!=_cid_std_vector<a__type>()) {\
              a_out << "tools::rroot::ntuple::initialize :"\
                    << " for leaf with name " << sout(bl->name())\
                    << ", user variable type is not a std::vector of " << #a__type << "."\
                    << std::endl;\
              safe_clear<read::icol>(m_cols);\
              return false;\
            }\
            std::vector<a__type>* user_var = (std::vector<a__type>*)user_obj;\
            std_vector_column_ref<a__type>* col = new std_vector_column_ref<a__type>\
          (m_tree.file(),*_branch,*lf_##a__type,m_index,*user_var);\
            m_cols.push_back(col);\
          } else {\
            /*::printf("debug : ntuple : create col : %s\n",bl->name().c_str());*/\
            if(user_cid!=_cid(a__type())) {\
              a_out << "tools::rroot::ntuple::initialize :"\
                    << " for leaf with name " << sout(bl->name())\
                    << ", user variable type is not a " << #a__type << "."\
                    << std::endl;\
              safe_clear<read::icol>(m_cols);\
              return false;\
            }\
            a__type* user_var = (a__type*)user_obj;\
            column_ref<a__type,leaf_t>* col =\
              new column_ref<a__type,leaf_t>(m_tree.file(),*_branch,*lf_##a__type,m_index,*user_var);\
            m_cols.push_back(col);\
          }\
    }\
      }
 
      //below types are in sync with wroot/ntuple.
 
           TOOLS_RROOT_NTUPLE_CREATE_COL(char)
      else TOOLS_RROOT_NTUPLE_CREATE_COL(short)
      else TOOLS_RROOT_NTUPLE_CREATE_COL(int)
      else TOOLS_RROOT_NTUPLE_CREATE_COL(float)
      else TOOLS_RROOT_NTUPLE_CREATE_COL(double)
 
      else if(leaf_string* ls = safe_cast<base_leaf, leaf_string >(*bl) ){
        char sep = '\n';
        cid user_cid;void* user_obj;
        if(!a_bd.find_user_obj(bl->name(),user_cid,user_obj)) {
          column_vector_string* col = new column_vector_string(m_tree.file(),*_branch,*ls,m_index,sep);
          m_cols.push_back(col);
    } else if(user_cid==_cid_std_vector<std::string>()) {
          std::vector<std::string>* user_var = (std::vector<std::string>*)user_obj;
          if(user_var) {
            column_vector_string_ref* col = new column_vector_string_ref(m_tree.file(),*_branch,*ls,m_index,*user_var,sep);
            m_cols.push_back(col);
      } else {
        column_vector_string* col = new column_vector_string(m_tree.file(),*_branch,*ls,m_index,sep);
            m_cols.push_back(col);
          }
        } else if(user_cid==_cid(std::string())) {
          std::string* user_var = (std::string*)user_obj;
          if(user_var) {
            column_string_ref* col = new column_string_ref(m_tree.file(),*_branch,*ls,m_index,*user_var);
            m_cols.push_back(col);
      } else {
        column_string* col = new column_string(m_tree.file(),*_branch,*ls,m_index);
            m_cols.push_back(col);
          }
    } else {
          a_out << "tools::rroot::ntuple::initialize :"
                << " for leaf with name " << sout(ls->name())
                << ", user variable type is not a std::string or a std::vector<std::string>."
                << ". It's class id is " << user_cid << "."
                << std::endl;
          safe_clear<read::icol>(m_cols);
          return false;
    }
 
      } else if(leaf_element* le = safe_cast<base_leaf,leaf_element>(*bl) ){
 
        branch_element* be = safe_cast<branch,branch_element>(*_branch);
        if(!be) {
          a_out << "tools::rroot::ntuple::initialize : branch is not a branch_element." << std::endl;
          safe_clear<read::icol>(m_cols);
          return false;
        }
 
#define TOOLS_RROOT_NTUPLE_CREATE_VEC_COL(a__name,a__type) \
        if(be->class_name()==a__name) {\
          /*::printf("debug : ntuple : create vec col : %s\n",bl->name().c_str());*/\
          typedef a__type el_t;\
          std::vector<el_t>* user_var = a_bd.find_vector_variable<el_t>(bl->name());\
          if(user_var) {\
            typedef column_element_ref< stl_vector<el_t> , std::vector<el_t> > ce_t;\
            ce_t* col = new ce_t(m_tree.file(),*be,*le,m_index,*user_var);\
            m_cols.push_back(col);\
      } else {\
            typedef column_element< stl_vector<el_t> , std::vector<el_t> > ce_t;\
            ce_t* col = new ce_t(m_tree.file(),*be,*le,m_index);\
            m_cols.push_back(col);\
      }\
    }
 
             TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<char>",char)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<short>",short)
      //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned short>",unsigned short)
      //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned int>",unsigned int)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<int>",int)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<float>",float)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<double>",double)
 
      //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<string>",std::string)
      //else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<unsigned long>",uint64) //beurk
 
        // WARNING : take care of the space in "> >".
    /* VisualC++ : the below does not compile.
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<unsigned short> >",std::vector<unsigned short>)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<short> >",std::vector<short>)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<unsigned int> >",std::vector<unsigned int>)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<int> >",std::vector<short>)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<float> >",std::vector<float>)
        else TOOLS_RROOT_NTUPLE_CREATE_VEC_COL("vector<vector<double> >",std::vector<double>)
        */
 
        else {
          a_out << "tools::rroot::ntuple::initialize :"
                << " WARNING : leaf element"
                << " with name " << sout(bl->name())
                << ",title " << sout(bl->title())
                << " br_elem class name " << be->class_name() << "."
                << " entries " << be->entry_number() << "."
                << std::endl;
        }
 
      } else {
        a_out << "tools::rroot::ntuple::initialize :"
              << " WARNING : column type not yet handled for leaf"
              << " with name " << sout(bl->name())
              << " and title " << sout(bl->title()) << "."
              << " s_cls() is " << sout(bl->s_cls()) << "."
              << " Not fatal."
              << std::endl;
      }
 
    }
 
#undef TOOLS_RROOT_NTUPLE_CREATE_VEC_COL
#undef TOOLS_RROOT_NTUPLE_CREATE_COL
 
    size_t num = m_cols.size();
    if(!num) {
      a_out << "tools::rroot::ntuple::initialize :"
            << " zero columns."
            << std::endl;
      return false;
    }
 
   {tools_vforcit(column_binding,a_bd.columns(),it) {
      if(!find_named<read::icol>(m_cols,(*it).name())) {
        a_out << "tools::rroot::ntuple::initialize :"
              << " warning : for column binding with name " << sout((*it).name()) << ", no ntuple column found."
              << std::endl;
      }
    }}
 
    //a_out << "tools::rroot::ntuple::initialize :"
    //      << " number of columns " << num << "."
    //      << std::endl;
 
    return true;
  }

next()

virtual bool tools::rroot::ntuple::next ( )

inlinevirtual

Implements tools::read::intuple.

Definition at line 38 of file ntuple.

                      {
    m_index++;
    if((uint64)m_index>=m_tree.entries()) return false;
    return true;
  }

number_of_entries()

virtual bool tools::rroot::ntuple::number_of_entries ( uint64 &  a_value ) const

inlinevirtual

Implements tools::read::intuple.

Definition at line 48 of file ntuple.

{a_value = m_tree.entries();return true;}

operator=()

ntuple& tools::rroot::ntuple::operator= ( const ntuple &  )

inlineprotected

Definition at line 506 of file ntuple.

{return *this;}

s_class()

static const std::string& tools::rroot::ntuple::s_class ( )

inlinestatic

Definition at line 31 of file ntuple.

                                    {
    static const std::string s_v("tools::rroot::ntuple");
    return s_v;
  }

s_cls()

virtual const std::string& tools::rroot::ntuple::s_cls ( ) const

inlinevirtual

Reimplemented in tools::rroot::fac_tree_ntuple.

Definition at line 35 of file ntuple.

{return s_class();}

start()

virtual void tools::rroot::ntuple::start ( )

inlinevirtual

Implements tools::read::intuple.

Definition at line 37 of file ntuple.

{m_index = -1;}

title()

virtual const std::string& tools::rroot::ntuple::title ( ) const

inlinevirtual

Implements tools::read::intuple.

Definition at line 47 of file ntuple.

{return m_tree.title();}

Member Data Documentation

m_cols

std::vector<read::icol*> tools::rroot::ntuple::m_cols

protected

Definition at line 732 of file ntuple.

m_index

int64 tools::rroot::ntuple::m_index

protected

Definition at line 733 of file ntuple.

m_tree

tree& tools::rroot::ntuple::m_tree

protected

Definition at line 731 of file ntuple.

---

The documentation for this class was generated from the following file:

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/rroot/ntuple