D3PD::RootD3PD Class Reference

Root-based D3PD tree. More...

#include <RootD3PD.h>

Inheritance diagram for D3PD::RootD3PD:

Collaboration diagram for D3PD::RootD3PD:

Public Types
typedef unsigned int	Dim_t
	Currently unimplemented — see design note.

Public Member Functions
	RootD3PD (TTree *tree, const std::string &master, const std::vector< std::string > &allowedNames=std::vector< std::string >(), const std::vector< std::string > &vetoedNames=std::vector< std::string >(), int basketSize=-1, int entryOffsetLen=-1)
	Constructor.
	~RootD3PD ()
	Destructor.
virtual StatusCode	addVariable (const std::string &name, const std::type_info &ti, void *&ptr, const std::string &docstring="", const void *defval=0) override
	Add a variable to the tuple.
virtual StatusCode	addDimensionedVariable (const std::string &name, const std::type_info &ti, void *&ptr, const std::string &dim, const std::string &docstring="", const void *defval=0) override
	Add a variable to the tuple.
virtual StatusCode	capture () override
	Capture the current state of all variables and write to the tuple.
virtual StatusCode	clear () override
	Clear all the tuple variables.
virtual StatusCode	redim (const Dim_t *ptr) override
	Currently unimplemented — see design note.
const TTree *	tree () const
	Return the underlying root tree.
TTree *	tree ()
const std::string &	master () const
	Return the name of the master tree.
virtual StatusCode	addMetadata (const std::string &key, const void *obj, const std::type_info &ti) override
	Add a new piece of metadata to the tuple.
void	setPoolFile (const std::string &poolFile)
	Set the name of a pool file to which we should attach.
StatusCode	attachPoolFile ()
	Try to attach to a pool file, if we haven't yet done so.
template<class T>
StatusCode	addMetadata (const std::string &key, const T *obj)
	Add a new piece of metadata to the tuple.
template<class T>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring="")
	Add a variable to the tuple.
template<class T, class U>
StatusCode	addVariable (const std::string &name, T *&ptr, const std::string &docstring, const U &defval)
	Add a variable to the tuple.
template<class T>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring="")
	Add a variable to the tuple.
template<class T, class U>
StatusCode	addDimensionedVariable (const std::string &name, T *&ptr, const std::string &dim, const std::string &docstring, const U &defval)
	Add a variable to the tuple.

Private Member Functions
TClass *	getClass (const std::type_info &ti)
	Try to convert from a std::type_info to a TClass.
bool	isAllowed (const std::string &name)
	Decide if a given variable name is allowed.
StatusCode	addFakeVariable (const std::string &name, const std::type_info &ti, void *&ptr)
	Create a variable in memory only.
	RootD3PD (const RootD3PD &)=delete
RootD3PD &	operator= (const RootD3PD &)=delete

Private Attributes
TTree *	m_tree
	The underlying root tree.
std::string	m_master
	The name of the master tree.
int	m_basketSize
	Specified basket size.
int	m_entryOffsetLen
	Specified entry offset buffer length.
Root::Cleartable *	m_cleartable
	Helper to clear variables.
std::vector< std::string >	m_allowedNames
	List of names/regular expressions allowed to be put into the output tree.
std::vector< std::string >	m_vetoedNames
	List of names/regular expressions not allowed to be put into the output tree.
std::map< std::string, FakeProxy * >	m_fakeVars
	"Fake" variables, only kept in memory
std::string	m_poolFile
	If set, the name of a pool data file to which we should attach ourself.

Detailed Description

Root-based D3PD tree.

This provides an ID3PD interface for a Root tree. The tree is passed to the constructor. Ownership of the tree remains with Root.

If there are several trees being made, one may be designated as the master; the other trees will be made friends of it. (For AANT, this is generally CollectionTree.)

Definition at line 50 of file RootD3PD.h.

Member Typedef Documentation

Dim_t

typedef unsigned int D3PD::ID3PD::Dim_t

inherited

Currently unimplemented — see design note.

Definition at line 52 of file ID3PD.h.

Constructor & Destructor Documentation

RootD3PD() [1/2]

D3PD::RootD3PD::RootD3PD	(	TTree *	tree,
		const std::string &	master,
		const std::vector< std::string > &	allowedNames = std::vector< std::string >(),
		const std::vector< std::string > &	vetoedNames = std::vector< std::string >(),
		int	basketSize = -1,
		int	entryOffsetLen = -1 )

Constructor.

Parameters

tree	The underlying Root tree.
master	The name of the master tree. Null if no master.
allowedNames	Names allowed to be put into the output tree
vetoedNames	Names not allowed to end up in the output tree
basketSize	The branch basket size. -1 to use Root default.
entryOffsetLen	The branch entry offset buffer size. -1 to use Root default.
tree	The underlying Root tree.
master	The name of the master tree. Null if no master.
basketSize	The branch basket size. -1 to use Root default.
entryOffsetLen	The branch entry offset buffer size. -1 to use Root default.

Definition at line 439 of file RootD3PD.cxx.

  : m_tree (tree),
    m_master (master),
    m_basketSize (basketSize),
    m_entryOffsetLen (entryOffsetLen),
    m_cleartable (new Root::Cleartable),
    m_allowedNames (allowedNames),
    m_vetoedNames (vetoedNames),
    m_fakeVars()
{
}

~RootD3PD()

D3PD::RootD3PD::~RootD3PD

(

)

Destructor.

Definition at line 460 of file RootD3PD.cxx.

{
  delete m_cleartable;
  std::map< std::string, FakeProxy* >::iterator itr = m_fakeVars.begin();
  std::map< std::string, FakeProxy* >::iterator end = m_fakeVars.end();
  for( ; itr != end; ++itr ) {
     delete itr->second;
  }
}

RootD3PD() [2/2]

D3PD::RootD3PD::RootD3PD ( const RootD3PD & )

privatedelete

Member Function Documentation

addDimensionedVariable() [1/3]

template<class T, class U>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring, const U & defval )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Only works for basic types.

If called from the constructor, the only effect is to clear ptr.

addDimensionedVariable() [2/3]

template<class T>

StatusCode D3PD::IAddVariable::addDimensionedVariable ( const std::string & name, T *& ptr, const std::string & dim, const std::string & docstring = "" )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.

If called from the constructor, the only effect is to clear ptr.

addDimensionedVariable() [3/3]

StatusCode D3PD::RootD3PD::addDimensionedVariable ( const std::string & name, const std::type_info & ti, void *& ptr, const std::string & dim, const std::string & docstring = "", const void * defval = 0 )

overridevirtual

Add a variable to the tuple.

Parameters

name	The name of the variable.
type	The type of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
dim	Dimension for the variable. (Presently unimplemented!)
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Null for no default (generally means to fill with zeros). Of the type given by ti. Only works for basic types.

Implements D3PD::IAddVariable.

Definition at line 605 of file RootD3PD.cxx.

{
  REPORT_MESSAGE (MSG::ERROR)
    << "addDimensionedVariable not yet implemented.";
  return StatusCode::FAILURE;
}

addFakeVariable()

StatusCode D3PD::RootD3PD::addFakeVariable ( const std::string & name, const std::type_info & ti, void *& ptr )

private

Create a variable in memory only.

Definition at line 838 of file RootD3PD.cxx.

{
   // Check if this variable already exists:
   std::map< std::string, FakeProxy* >::const_iterator itr =
      m_fakeVars.find( name );
   if( itr != m_fakeVars.end() ) {
      REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "RootD3PD" )
         << "\"Fake\" variable with name \"" << name << "\" already created";
      return StatusCode::FAILURE;
   }
 
   // Check if we have a dictionary for this type:
   ::TClass* cls = FakeProxy::getClass( ti );
   if( cls ) {
      // Create and store the new object:
      ptr = cls->New();
      m_fakeVars[ name ] = new FakeProxy( ptr, ti );
      return StatusCode::SUCCESS;
   }
 
   // If not, then try to see if it's a primitive type:
   ptr = FakeProxy::newPrimitive( ti );
   if( ptr ) {
      m_fakeVars[ name ] = new FakeProxy( ptr, ti );
      return StatusCode::SUCCESS;
   }
 
   // If both of these failed, then let's bail:
   REPORT_MESSAGE_WITH_CONTEXT( MSG::FATAL, "RootD3PD" )
      << "Couldn't create \"fake\" variable of type: " << ti.name();
   return StatusCode::FAILURE;
}

addMetadata() [1/2]

template<class T>

StatusCode D3PD::ID3PD::addMetadata ( const std::string & key, const T * obj )

inherited

Add a new piece of metadata to the tuple.

Parameters

key	- The key for this object. Any existing object will be overwritten.
obj	- Pointer to the object to write.

The interpretation of the key parameter is up to the concrete D3PD implementation. However, a key name with a trailing slash NAME/ indicates that all metadata items with this name should be grouped together in a collection called NAME (for example, in a Root directory with that name).

addMetadata() [2/2]

StatusCode D3PD::RootD3PD::addMetadata ( const std::string & key, const void * obj, const std::type_info & ti )

overridevirtual

Add a new piece of metadata to the tuple.

Parameters

key	- The key for this object. Any existing object will be overwritten.
obj	- Pointer to the object to write.
ti	- Type of the object to write.

The interpretation of the key parameter is up to the concrete D3PD implementation. However, a key name with a trailing slash NAME/ indicates that all metadata items with this name should be grouped together in a collection called NAME (for example, in a Root directory with that name).

Implements D3PD::ID3PD.

Definition at line 709 of file RootD3PD.cxx.

{
  TObjString ostmp;
 
  TClass* cls = getClass (ti);
  if (!cls)
    return StatusCode::RECOVERABLE;
 
  if (ti == typeid(TString)) {
    ostmp.String() = *reinterpret_cast<const TString*> (obj);
    obj = &ostmp;
    cls = gROOT->GetClass ("TObjString");
  }
  else if (ti == typeid(std::string)) {
    ostmp.String() = *reinterpret_cast<const std::string*> (obj);
    obj = &ostmp;
    cls = gROOT->GetClass ("TObjString");
  }
 
  std::string metaname;
  TDirectory* dir = m_tree->GetDirectory();
  std::string thekey = key;
 
  if (key.size() > 0 && key[key.size()-1] == '/') {
    // Go to the root directory of the file.
    while (dynamic_cast<TDirectoryFile*> (dir) != 0 &&
           dir->GetMotherDir())
      dir = dir->GetMotherDir();
 
    metaname = key.substr (0, key.size()-1);
    thekey = m_tree->GetName();
  }
  else {
    metaname = m_tree->GetName();
    metaname += "Meta";
  }
 
  TDirectory::TContext ctx (dir);
  TDirectory* metadir = dir->GetDirectory (metaname.c_str());
  if (!metadir) {
    metadir = dir->mkdir (metaname.c_str());
    if (!metadir) {
      REPORT_MESSAGE (MSG::ERROR)
        << "Can't create metadata dir " << metaname
        << "in dir " << dir->GetName();
      return StatusCode::RECOVERABLE;
    }
  }
 
  // If we're writing in a common directory, make sure name is unique.
  if (key.size() > 0 && key[key.size()-1] == '/') {
    int i = 1;
    while (metadir->FindObject (thekey.c_str())) {
      ++i;
      std::ostringstream ss;
      ss << m_tree->GetName() << "-" << i;
      thekey = ss.str();
    }
  }
 
  if (metadir->WriteObjectAny (obj, cls, thekey.c_str(), "overwrite") == 0) {
    REPORT_MESSAGE (MSG::ERROR)
      << "Can't write metadata object " << thekey
      << " for tree " << m_tree->GetName();
    return StatusCode::RECOVERABLE;
  }
 
  return StatusCode::SUCCESS;
}

addVariable() [1/3]

template<class T, class U>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring, const U & defval )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Only works for basic types.

If called from the constructor, the only effect is to clear ptr.

addVariable() [2/3]

template<class T>

StatusCode D3PD::IAddVariable::addVariable ( const std::string & name, T *& ptr, const std::string & docstring = "" )

inherited

Add a variable to the tuple.

Parameters

name	The name of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
docstring	Documentation string for this variable.

If called from the constructor, the only effect is to clear ptr.

addVariable() [3/3]

StatusCode D3PD::RootD3PD::addVariable ( const std::string & name, const std::type_info & ti, void *& ptr, const std::string & docstring = "", const void * defval = 0 )

overridevirtual

Add a variable to the tuple.

Parameters

name	The name of the variable.
type	The type of the variable.
ptr	Pointer to the type of the variable. The pointer need not be initialized; the D3PD software will set the pointer prior to calling fill().
docstring	Documentation string for this variable.
defval	Pointer to the default value to use for this variable. Null for no default (generally means to fill with zeros). Of the type given by ti. Only works for basic types.

Implements D3PD::IAddVariable.

Definition at line 485 of file RootD3PD.cxx.

{
  TBranch* br = 0;
 
  // If the variable is not to be put into the output tree, let's
  // just create it in memory:
  if( ! isAllowed( name ) ) {
     CHECK( addFakeVariable( name, ti, ptr ) );
     return StatusCode::SUCCESS;
  }
 
  // Make sure that there's not already a branch with this name.
  if (m_tree->GetBranch (name.c_str()) != 0) {
    REPORT_MESSAGE (MSG::ERROR) << "Duplicate branch name " << name
                                << " in tree " << m_tree->GetName();
    return StatusCode::FAILURE;
  }
 
  char* defcopied = 0;
  size_t defsize = 0;
 
  // See if it's a basic type.
  char typecode = find_typecode (ti);
  if (typecode != '\0') {
    // Yes.  Make a simple branch for it.
    br = m_tree->Branch (name.c_str(), 0, (name + '/' + typecode).c_str());
    if (!br)
      return StatusCode::FAILURE;
 
    // Find the (single) leaf for the branch.
    TLeaf* leaf = br->GetLeaf (name.c_str());
    if (!leaf)
      return StatusCode::FAILURE;
 
    // Set the pointer.
    ptr = leaf->GetValuePointer();
 
    if (defval) {
      EDataType dt = TDataType::GetType (ti);
      TDataType* tdt = gROOT->GetType (TDataType::GetTypeName (dt));
      assert (tdt != 0);
      defsize = tdt->Size();
      defcopied = new char[defsize];
      std::memcpy (defcopied, defval, defsize);
    }
  }
  else {
 
    // Default value not supported for class types.
    if (defval) {
      REPORT_MESSAGE (MSG::ERROR)
        << "Requested a default value for variable " << name
        << " of type " << System::typeinfoName (ti)
        << "; but default values are only supported for basic types.";
      return StatusCode::FAILURE;
    }
 
    // A class type.  Try to find the class.
    TClass* cls = getClass (ti);
    if (!cls)
      return StatusCode::FAILURE;
 
    // Create the branch.
    br = m_tree->Bronch (name.c_str(), cls->GetName(), 0);
    if (!br)
      return StatusCode::FAILURE;
 
    TBranchElement* bre = dynamic_cast<TBranchElement*> (br);
    if (!bre) {
      REPORT_MESSAGE (MSG::ERROR) << "Unexpected branch type created for "
                                  << name;
      return StatusCode::FAILURE;
    }
 
    // Set the pointer.
    ptr = bre->GetObject();
  }
 
  // Set the branch docstring.
  br->SetTitle (docstring.c_str());
 
  // Set the branch buffer sizes as requested.
  if (m_basketSize != -1)
    br->SetBasketSize (m_basketSize);
 
  if (m_entryOffsetLen != -1)
    br->SetEntryOffsetLen (m_entryOffsetLen);
 
  CHECK( m_cleartable->add (br, defcopied, defsize) );
 
  // If we're extending an already-started tuple, then we need
  // to write the correct number of blank entries at the start.
  for (Long64_t i = 0; i < m_tree->GetEntries(); i++)
    br->Fill();
 
  return StatusCode::SUCCESS;
}

attachPoolFile()

StatusCode D3PD::RootD3PD::attachPoolFile

(

)

Try to attach to a pool file, if we haven't yet done so.

Definition at line 635 of file RootD3PD.cxx.

{
  if (!m_poolFile.empty()) {
    TIter next (gROOT->GetListOfFiles());
    while (TFile* f = dynamic_cast<TFile*>(next())) {
      if (std::string(f->GetName()) == m_poolFile) {
        m_tree->SetDirectory (f);
        m_poolFile.clear();
        break;
      }
    }
    if (!m_poolFile.empty()) {
      REPORT_MESSAGE (MSG::ERROR) << "Can't find root file " << m_poolFile
                                  << " to attach tree " << m_tree->GetName();
      return StatusCode::FAILURE;
    }
  }
  return StatusCode::SUCCESS;
}

capture()

StatusCode D3PD::RootD3PD::capture ( )

overridevirtual

Capture the current state of all variables and write to the tuple.

Implements D3PD::ID3PD.

Definition at line 621 of file RootD3PD.cxx.

{
  // Handle pending pool file association.
  CHECK( attachPoolFile() );
 
  if (m_tree->Fill() < 0)
    return StatusCode::FAILURE;
  return StatusCode::SUCCESS;
}

clear()

StatusCode D3PD::RootD3PD::clear ( )

overridevirtual

Clear all the tuple variables.

Implements D3PD::ID3PD.

Definition at line 659 of file RootD3PD.cxx.

{
  m_cleartable->clear();
  return StatusCode::SUCCESS;
}

getClass()

TClass * D3PD::RootD3PD::getClass ( const std::type_info & ti )

private

Try to convert from a std::type_info to a TClass.

On failure, write an error and return null.

Parameters

ti	The type to convert.

On failure, write an error and return null.

Definition at line 788 of file RootD3PD.cxx.

{
  TClass* cls = gROOT->GetClass (ti);
  if (!cls) {
    // Can't do autoloading via type_info.
    // Try to convert back to a name...
    std::string tiname = System::typeinfoName (ti);
    cls = gROOT->GetClass (tiname.c_str());
  }
 
  if (!cls) {
    REPORT_MESSAGE (MSG::ERROR) << "Can't find class for typeinfo "
                                << ti.name();
  }
 
  return cls;
}

isAllowed()

bool D3PD::RootD3PD::isAllowed ( const std::string & name )

private

Decide if a given variable name is allowed.

This function is used to decide if a variable with a given name is allowed to be put into the output tree or not.

Parameters

name	The name of the variable

Returns

true if the variable should be put into the output, and false if it shouldn't

Definition at line 815 of file RootD3PD.cxx.

{
   // If the list of allowed names is not empty, the name has to match
   // one of them:
   if( m_allowedNames.size() ) {
      if( std::find_if( m_allowedNames.begin(), m_allowedNames.end(),
                        NameMatches( name ) ) == m_allowedNames.end() ) {
         return false;
      }
   }
 
   // Now check that the name doesn't appear on the veto list:
   if( std::find_if( m_vetoedNames.begin(), m_vetoedNames.end(),
                     NameMatches( name ) ) != m_vetoedNames.end() ) {
      return false;
   }
 
   // If all of these passed, then the variable is allowed to
   // be put into the output:
   return true;
}

master()

const std::string & D3PD::RootD3PD::master

(

)

const

Return the name of the master tree.

Definition at line 690 of file RootD3PD.cxx.

{
  return m_master;
}

operator=()

RootD3PD & D3PD::RootD3PD::operator= ( const RootD3PD & )

privatedelete

redim()

StatusCode D3PD::RootD3PD::redim ( const Dim_t * ptr )

overridevirtual

Currently unimplemented — see design note.

Implements D3PD::ID3PD.

Definition at line 667 of file RootD3PD.cxx.

{
  return StatusCode::FAILURE;
}

setPoolFile()

void D3PD::RootD3PD::setPoolFile

(

const std::string &

poolFile

)

Set the name of a pool file to which we should attach.

Parameters

poolFile

The name of the pool file to which we should attach.

If we want a D3PD tree to end up in a pool file, we can't in general do it from RootD3PDSvc::make, since the file usually won't have been opened yet. Instead, call this method to have the RootD3PD object remember the name of the pool file. On the first capture(), we'll look for the pool file in root's list of files and then associate the tree with it.

Definition at line 885 of file RootD3PD.cxx.

{
  m_poolFile = poolFile;
}

tree() [1/2]

TTree * D3PD::RootD3PD::tree

(

)

Definition at line 681 of file RootD3PD.cxx.

{
  return m_tree;
}

tree() [2/2]

const TTree * D3PD::RootD3PD::tree

(

)

const

Return the underlying root tree.

Definition at line 676 of file RootD3PD.cxx.

{
  return m_tree;
}

Member Data Documentation

m_allowedNames

std::vector< std::string > D3PD::RootD3PD::m_allowedNames

private

List of names/regular expressions allowed to be put into the output tree.

Definition at line 221 of file RootD3PD.h.

m_basketSize

int D3PD::RootD3PD::m_basketSize

private

Specified basket size.

Definition at line 211 of file RootD3PD.h.

m_cleartable

Root::Cleartable* D3PD::RootD3PD::m_cleartable

private

Helper to clear variables.

Definition at line 217 of file RootD3PD.h.

m_entryOffsetLen

int D3PD::RootD3PD::m_entryOffsetLen

private

Specified entry offset buffer length.

Definition at line 214 of file RootD3PD.h.

m_fakeVars

std::map< std::string, FakeProxy* > D3PD::RootD3PD::m_fakeVars

private

"Fake" variables, only kept in memory

Definition at line 228 of file RootD3PD.h.

m_master

std::string D3PD::RootD3PD::m_master

private

The name of the master tree.

Definition at line 208 of file RootD3PD.h.

m_poolFile

std::string D3PD::RootD3PD::m_poolFile

private

If set, the name of a pool data file to which we should attach ourself.

Definition at line 231 of file RootD3PD.h.

m_tree

TTree* D3PD::RootD3PD::m_tree

private

The underlying root tree.

Definition at line 205 of file RootD3PD.h.

m_vetoedNames

std::vector< std::string > D3PD::RootD3PD::m_vetoedNames

private

List of names/regular expressions not allowed to be put into the output tree.

Definition at line 225 of file RootD3PD.h.

---

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

• RootD3PD.h
• RootD3PD.cxx