Athena::RootBranchAddress Class Reference

A simple class to hold the buffer of a TBranch from a TTree. More...

#include <RootBranchAddress.h>

Inheritance diagram for Athena::RootBranchAddress:

Collaboration diagram for Athena::RootBranchAddress:

Public Member Functions
	RootBranchAddress ()
	Default constructor:
	RootBranchAddress (const RootBranchAddress &rhs)
	Copy constructor:
RootBranchAddress &	operator= (const RootBranchAddress &rhs)
	Assignment operator:
	RootBranchAddress (long svc, const CLID &clid, const std::string &p1="", const std::string &p2="", unsigned long ip1=0, unsigned long ip2=0)
	Constructor with parameters:
virtual	~RootBranchAddress ()
	Destructor:
void	setBranchAddress (const RootType &t)
	setup the ROOT TTree internal address for the branch.
TTree *	ttree ()
	the TTree whose branch we proxy

Public Attributes
RootType	m_type
	the buffer for the TBranch
void *	m_ptr
TBranch *	m_branch
	the branch we are connected to.

Detailed Description

A simple class to hold the buffer of a TBranch from a TTree.

Definition at line 31 of file RootBranchAddress.h.

Constructor & Destructor Documentation

RootBranchAddress() [1/3]

Athena::RootBranchAddress::RootBranchAddress

(

)

Default constructor:

Definition at line 35 of file RootBranchAddress.cxx.

                                     :
  GenericAddress(),
  m_ptr    (),
  m_branch (NULL)
{}

RootBranchAddress() [2/3]

Athena::RootBranchAddress::RootBranchAddress

(

const RootBranchAddress &

rhs

)

Copy constructor:

Definition at line 42 of file RootBranchAddress.cxx.

                                                                   :
  GenericAddress(rhs),
  m_ptr    (rhs.m_ptr),
  m_branch (rhs.m_branch)
{}

RootBranchAddress() [3/3]

Athena::RootBranchAddress::RootBranchAddress	(	long	svc,
		const CLID &	clid,
		const std::string &	p1 = "",
		const std::string &	p2 = "",
		unsigned long	ip1 = 0,
		unsigned long	ip2 = 0 )

Constructor with parameters:

Definition at line 61 of file RootBranchAddress.cxx.

                                                        :
  GenericAddress(svc, clid, p1, p2, ip1, ip2),
  m_ptr    (),
  m_branch (NULL)
{
  // std::cerr << "::RBA::+RBA... (this=" << this << ") br=[" 
  //           << this->par()[1] << "]\n";
}

~RootBranchAddress()

Athena::RootBranchAddress::~RootBranchAddress ( )

virtual

Destructor:

Definition at line 76 of file RootBranchAddress.cxx.

{
  // std::cerr << "::RBA::~RBA... (this=" << this << ") br=["
  //           << this->par()[1] << "]\n";
}

Member Function Documentation

operator=()

RootBranchAddress & Athena::RootBranchAddress::operator=

(

const RootBranchAddress &

rhs

)

Assignment operator:

Definition at line 50 of file RootBranchAddress.cxx.

{
  if (this != &rhs) {
    GenericAddress::operator=(rhs);
    m_ptr    = rhs.m_ptr;
    m_branch = rhs.m_branch;
  }
  return *this;
}

setBranchAddress()

void Athena::RootBranchAddress::setBranchAddress

(

const RootType &

t

)

setup the ROOT TTree internal address for the branch.

as a side-effect, this will load the data from the tree for this branch and entry.

Parameters

t	additional RootType hint (we check the consistency) FIXME: should the TBranch::GetEntry be lifted into its own method ? for the moment, that doesn't seem necessary, as setBranchAddress is only used in one place (LeafCnv) where the intent is to load the data anyway...

Definition at line 92 of file RootBranchAddress.cxx.

{
  const std::string& br_name = this->par()[1];
  //const unsigned long* ipar = this->ipar();
  TTree *tree = this->ttree();
  Long64_t ientry = tree->GetReadEntry();
 
  // std::cerr << "::RBA::setBA(" << this << ") -- tree_nbr=" << tree_nbr << "|"
  //           << " ientry=" << ientry
  //           << "\tname=[" << br_name << "]"
  //           << " addr=" << m_ptr
  //           << "\n";
  if (m_branch && m_ptr != 0) {
    m_branch->GetEntry(ientry);
    return;
  }
 
  // activate branch...
  tree->SetBranchStatus(br_name.c_str(), 1);
 
  // --- inspired from pyroot/src/Pythonize.cxx ---
  // search for branch first (typical for objects)
  TBranch *branch = tree->GetBranch(br_name.c_str());
  if (!branch) {
    //ATH_MSG_INFO("-- branch [" << br_name << "] =0 -> trying a subbranch");
    // for benefit of naming of sub-branches, 
    // the actual name may have a trailing '.'
    branch = tree->GetBranch((br_name+".").c_str());
  }
 
  m_branch = branch;
  if (branch) {
    Long64_t bentry = branch->GetReadEntry();
    if ( bentry != ientry || ientry < 0) {
      // std::cerr << "::RBA:: -- ientry=" << ientry << " bentry="
      //           << bentry 
      //           << "\tname=[" << br_name << "]"
      //           << "\n";
      /*Long64_t nnn =*/ branch->GetEntry(ientry);
      bentry = branch->GetReadEntry();
      // std::cerr << "::RBA:: -- ientry=" << ientry << " bentry="
      //           << bentry 
      //           << "\tname=[" << br_name << "]"
      //           << " --> " << nnn
      //           << "\n";
 
    }
 
    //ATH_MSG_INFO("-- branch [" << br_name << "] = OK");
    // found a branched object, wrap its address for the object it represents
    TClass *cls = TClass::GetClass(branch->GetClassName());
    if (cls) {
      if (!branch->GetAddress()) {
        branch->GetEntry(ientry);
      }
      if (branch->GetAddress()) {
        //ATH_MSG_INFO("-- branch [" << br_name << "] cls: [" << cls->GetName() << "]");
        void* addr = *(char**)branch->GetAddress();
        RootType t = RootType(*cls->GetTypeInfo());
        if (t != rflx_type && !t.Id()) {
            t = rflx_type;
        }
        m_type = std::move(t);
        m_ptr = addr;
        return;
 
      } else {
        //ATH_MSG_INFO("-- branch [" << br_name << "] cls: [" << cls << "]");
      }
    } else {
      //ATH_MSG_INFO("-- branch [" << br_name << "] cls: [" << cls << "]");
    }
 
  }
 
  // if not, try a leaf
  TLeaf *leaf = tree->GetLeaf(br_name.c_str());
  //ATH_MSG_INFO("-- leaf [" << br_name << "] ??");
  if (branch && !leaf) {
    leaf = branch->GetLeaf(br_name.c_str());
    if (!leaf) {
      TObjArray *leaves = branch->GetListOfLeaves();
      if (leaves->GetSize() && (leaves->First() == leaves->Last())) {
        // i.e., if unambiguously only this one
        leaf = (TLeaf*)leaves->At(0);
      }
    }
  }
 
  if (leaf) {
    //ATH_MSG_INFO("-- leaf [" << br_name << "] = OK");
    // found a leaf, extract value and wrap
    if ( 1 < leaf->GetLenStatic() || leaf->GetLeafCount() ) {
      // array types --- FIXME
      //ATH_MSG_INFO("-- leaf [" << br_name << "] => array...");
      std::string tname = leaf->GetTypeName();
      void *addr = (void*)leaf->GetValuePointer();
      RootType t = RootType(tname+"*");
      if (t != rflx_type && !t.Id()) {
        t = rflx_type;
      }
      m_type = std::move(t);
      m_ptr = &addr;
      return;
 
    } else {
      // value types
      std::string tname = leaf->GetTypeName();
      // std::cerr << "-- leaf [" << br_name << "] => value-type("
      //           << tname << ")...\n";
      void *addr = (void*)leaf->GetValuePointer();
      RootType t = RootType(tname);
      if (t != rflx_type && !t.Id()) {
        t = rflx_type;
      }
      m_type = std::move(t);
      m_ptr = addr;
      // std::cerr << "-->ptr: [" << m_type.Name() << "]\n";
    }
  }
 
}

ttree()

TTree * Athena::RootBranchAddress::ttree

(

)

the TTree whose branch we proxy

Definition at line 217 of file RootBranchAddress.cxx.

{
  return reinterpret_cast<TTree*>(reinterpret_cast<unsigned long*>(this->ipar()[0]));  
}

Member Data Documentation

m_branch

TBranch* Athena::RootBranchAddress::m_branch

the branch we are connected to.

Definition at line 92 of file RootBranchAddress.h.

m_ptr

void* Athena::RootBranchAddress::m_ptr

Definition at line 89 of file RootBranchAddress.h.

m_type

RootType Athena::RootBranchAddress::m_type

the buffer for the TBranch

Definition at line 88 of file RootBranchAddress.h.

---

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

• RootBranchAddress.h
• RootBranchAddress.cxx