CP::TreeBranchHelpers::ContainerBranchProcessor Class Reference

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

#include <TreeBranchHelpers.h>

Inheritance diagram for CP::TreeBranchHelpers::ContainerBranchProcessor:

Collaboration diagram for CP::TreeBranchHelpers::ContainerBranchProcessor:

Public Member Functions
StatusCode	setup (TTree &tree, const BranchConfig &branchConfig, OutputBranchData &outputData, MsgStream &msg)
	Function setting up the object, and the branch.
StatusCode	resize (size_t size, MsgStream &msg)
	Function (re)sizing the variable for a new event.
StatusCode	process (const SG::AuxElement &element, size_t index, 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.

Finally, note that it is more complicated than the ElementBranchProcessor class. Since in this case we need to explicitly deal with std::vector types, which we need to fill explicitly when extracting the variables from the xAOD objects.

Definition at line 288 of file TreeBranchHelpers.h.

Member Function Documentation

process()

StatusCode CP::TreeBranchHelpers::ContainerBranchProcessor::process	(	const SG::AuxElement &	element,
		size_t	index,
		MsgStream &	msg )

Function processing the object, filling the variable.

Definition at line 771 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, index,
                      *element.container(), element.index(), 1 );
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

resize()

StatusCode CP::TreeBranchHelpers::ContainerBranchProcessor::resize	(	size_t	size,
		MsgStream &	msg )

Function (re)sizing the variable for a new event.

Definition at line 754 of file TreeBranchHelpers.cxx.

                                          {
 
      // A security check.
      if( ! m_data ) {
        msg << MSG::FATAL << "Internal logic error detected" << endmsg;
        return StatusCode::FAILURE;
      }
 
      // Do the deed.
      m_data->resize( 0 );
      m_data->resize( size );
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

setup()

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

Function setting up the object, and the branch.

Definition at line 704 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(), 0, 0, false );
 
      // Get a proper type name for the variable.
      const std::string typeName = SG::normalizedTypeinfoName( *branchConfig.auxVecType );
 
      // Access the dictionary for the type.
      TClass* cl = TClass::GetClass( *branchConfig.auxVecType );
      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 branch.
      m_dataPtr = m_data->toVector();
      TBranch* br = tree.Branch( outputData.branchName.c_str(), cl->GetName(),
                                &m_dataPtr );
      if( ! br ) {
        msg << MSG::ERROR << "Failed to create branch: " << outputData.branchName
            << endmsg;
        return StatusCode::FAILURE;
      }
      if (branchConfig.basketSize.has_value())
        br->SetBasketSize(branchConfig.basketSize.value());
 
      // Return gracefully.
      return StatusCode::SUCCESS;
    }

Member Data Documentation

m_acc

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

Object accessing the variable in question.

Definition at line 302 of file TreeBranchHelpers.h.

m_branchName

std::string CP::TreeBranchHelpers::ContainerBranchProcessor::m_branchName

Name of the branch being written.

Definition at line 300 of file TreeBranchHelpers.h.

m_data

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

The object managing the memory of the written variable.

Definition at line 306 of file TreeBranchHelpers.h.

m_dataPtr

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

Helper variable, pointing at the object to be written.

Definition at line 308 of file TreeBranchHelpers.h.

m_factory

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

Pointer to the helper object that handles this variable.

Definition at line 304 of file TreeBranchHelpers.h.

---

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

• TreeBranchHelpers.h
• TreeBranchHelpers.cxx