CP::TreeBranchHelpers::ElementBranchProcessor Class Reference

Class writing one variable from an xAOD object into a branch. More...

#include <TreeBranchHelpers.h>

Inheritance diagram for CP::TreeBranchHelpers::ElementBranchProcessor:

Collaboration diagram for CP::TreeBranchHelpers::ElementBranchProcessor:

Public Member Functions
StatusCode	setup (TTree &tree, const BranchConfig &branchConfig, OutputBranchData &outputData, MsgStream &msg)
	Function setting up the object, and the branch.
StatusCode	process (const SG::AuxElement &element, MsgStream &msg)
	Function processing the object, filling the variable.

Public Attributes
std::string	m_branchName
	Name of the branch being written.
std::unique_ptr< SG::TypelessConstAccessor >	m_acc
	Object accessing the variable in question.
const SG::IAuxTypeVectorFactory *	m_factory = nullptr
	Pointer to the helper object that handles this variable.
std::unique_ptr< SG::IAuxTypeVector >	m_data
	The object managing the memory of the written variable.
void *	m_dataPtr = nullptr
	Helper variable, pointing at the object to be written.

Detailed Description

Class writing one variable from an xAOD object into a branch.

It is used for both setting up the branch in the outut TTree during the setup of the tree, and then to fill the "output variable" with the right payload during the event processing.

Note that since we may have a lot of such objects, I didn't want to make it inherit from asg::AsgMessaging. Which means that all of the class's functions need to receive its parent's message stream object to be able to log error messages "nicely".

Also note that since this is very much an internal class, all of its members are public. Since the owner of such objects should know perfectly well how they behave.

Definition at line 218 of file TreeBranchHelpers.h.

Member Function Documentation

process()

StatusCode CP::TreeBranchHelpers::ElementBranchProcessor::process	(	const SG::AuxElement &	element,
		MsgStream &	msg )

Function processing the object, filling the variable.

This function is called by ElementProcessorRegular, to extract one variable from the standalone object, and move its payload into the memory address from which the output tree is writing its branch.

Parameters

element	The standalone object to get the auxiliary variable from
msg	Reference to the parent's MsgStream object

Returns

The usual StatusCode values

Definition at line 683 of file TreeBranchHelpers.cxx.

                                                           {
 
      // A security check.
      if( ( ! m_acc ) || ( ! m_factory ) || ( ! m_data ) ) {
        msg << MSG::FATAL << "Internal logic error detected" << endmsg;
        return StatusCode::FAILURE;
      }
 
      // Get the data out of the xAOD object.
      //const void* auxData = ( *m_acc )( element );
 
      // Copy it into the output variable.
      TempInterface dstiface (m_data->size(), m_acc->auxid(), m_data->toPtr());
      m_factory->copy( m_acc->auxid(), dstiface, 0,
                      *element.container(), element.index(), 1 );
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

setup()

StatusCode CP::TreeBranchHelpers::ElementBranchProcessor::setup	(	TTree &	tree,
		const BranchConfig &	branchConfig,
		OutputBranchData &	outputData,
		MsgStream &	msg )

Function setting up the object, and the branch.

This is pretty much the constructor of the class. I just decided to implement it as a regular function and not a "real" constructor, to be able to return a StatusCode value from the call. Since the setup of the object may very well fail.

Parameters

tree	The tree to set up the new branch in
auxName	The name of the auxiliary variable to create a branch from
branchName	Name of the branch to create in the tree
msg	Reference to the parent's MsgStream object

Returns

The usual StatusCode values

Definition at line 599 of file TreeBranchHelpers.cxx.

                                                                                                         {
 
      // Remember the branch name.
      m_branchName = outputData.branchName;
 
      // Create the accessor.
      m_acc.reset( new SG::TypelessConstAccessor( *branchConfig.auxType, outputData.auxName ) );
 
      // Get a pointer to the vector factory.
      m_factory = branchConfig.auxFactory;
 
      // Create the data object.
      m_data = m_factory->create( m_acc->auxid(), 1, 1, false );
 
      // Pointer to the branch, to be created.
      TBranch* br = nullptr;
 
      // Decide whether we're dealing with a "primitive" or an "object" branch.
      if( strlen( branchConfig.auxType->name() ) == 1 ) {
 
        // This is a "primitive" variable...
 
        // Get the type identifier for it that ROOT will understand.
        const char rType = rootType( branchConfig.auxType->name()[ 0 ], msg );
        if( rType == '\0' ) {
            msg << MSG::ERROR << "Type not recognised for variable: "
                << outputData.branchName << endmsg;
            return StatusCode::FAILURE;
        }
 
        // Construct the type description.
        std::ostringstream typeDesc;
        typeDesc << outputData.branchName << "/" << rType;
 
        // Create the primitive branch.
        br = tree.Branch( outputData.branchName.c_str(), m_data->toPtr(),
                          typeDesc.str().c_str() );
        if (branchConfig.basketSize.has_value())
          br->SetBasketSize(branchConfig.basketSize.value());
 
      } else {
 
        // This is an "object" variable...
 
        // Get a proper type name for the variable.
        const std::string typeName = SG::normalizedTypeinfoName( *branchConfig.auxType );
 
        // Access the dictionary for the type.
        TClass* cl = TClass::GetClass( *branchConfig.auxType );
        if( ! cl ) {
            cl = TClass::GetClass( typeName.c_str() );
        }
        if( ! cl ) {
            msg << MSG::ERROR << "Couldn't find dictionary for type: "
                << typeName << endmsg;
            return StatusCode::FAILURE;
        }
        if( ! cl->GetStreamerInfo() ) {
            msg << MSG::ERROR << "No streamer info available for type: "
                << cl->GetName() << endmsg;
            return StatusCode::FAILURE;
        }
 
        // Create the object branch.
        m_dataPtr = m_data->toPtr();
        br = tree.Branch( outputData.branchName.c_str(), cl->GetName(), &m_dataPtr );
        if (branchConfig.basketSize.has_value())
          br->SetBasketSize(branchConfig.basketSize.value());
 
      }
 
      // Check that the branch creation succeeded.
      if( ! br ) {
        msg << MSG::ERROR << "Failed to create branch: " << outputData.branchName
            << endmsg;
        return StatusCode::FAILURE;
      }
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

Member Data Documentation

m_acc

std::unique_ptr< SG::TypelessConstAccessor > CP::TreeBranchHelpers::ElementBranchProcessor::m_acc

Object accessing the variable in question.

Definition at line 255 of file TreeBranchHelpers.h.

m_branchName

std::string CP::TreeBranchHelpers::ElementBranchProcessor::m_branchName

Name of the branch being written.

Definition at line 253 of file TreeBranchHelpers.h.

m_data

std::unique_ptr< SG::IAuxTypeVector > CP::TreeBranchHelpers::ElementBranchProcessor::m_data

The object managing the memory of the written variable.

Definition at line 259 of file TreeBranchHelpers.h.

m_dataPtr

void* CP::TreeBranchHelpers::ElementBranchProcessor::m_dataPtr = nullptr

Helper variable, pointing at the object to be written.

Definition at line 261 of file TreeBranchHelpers.h.

m_factory

const SG::IAuxTypeVectorFactory* CP::TreeBranchHelpers::ElementBranchProcessor::m_factory = nullptr

Pointer to the helper object that handles this variable.

Definition at line 257 of file TreeBranchHelpers.h.

---

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

• TreeBranchHelpers.h
• TreeBranchHelpers.cxx