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

Collaboration diagram for CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor:

Public Member Functions
StatusCode	setup (TTree &tree, const std::string &auxName, const std::string &branchName, MsgStream &msg)
	Function setting up the object, and the branch. More...

StatusCode	resize (size_t size, MsgStream &msg)
	Function (re)sizing the variable for a new event. More...

StatusCode	process (const SG::AuxElement &element, size_t index, MsgStream &msg)
	Function processing the object, filling the variable. More...

Public Attributes
std::string	m_branchName
	Name of the branch being written. More...

std::unique_ptr< SG::AuxElement::TypelessConstAccessor >	m_acc
	Object accessing the variable in question. More...

const SG::IAuxTypeVectorFactory *	m_factory = nullptr
	Pointer to the helper object that handles this variable. More...

std::unique_ptr< SG::IAuxTypeVector >	m_data
	The object managing the memory of the written variable. More...

void *	m_dataPtr = nullptr
	Helper variable, pointing at the object to be written. More...

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 ElementProcessor::BranchProcessor 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 301 of file AsgxAODNTupleMakerAlg.h.

Member Function Documentation

◆ process()

StatusCode CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::process	(	const SG::AuxElement &	element,
		size_t	index,
		MsgStream &	msg
	)

Function processing the object, filling the variable.

Definition at line 1010 of file AsgxAODNTupleMakerAlg.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::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::resize	(	size_t	size,
		MsgStream &	msg
	)

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

Definition at line 993 of file AsgxAODNTupleMakerAlg.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::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::setup	(	TTree &	tree,
		const std::string &	auxName,
		const std::string &	branchName,
		MsgStream &	msg
	)

Function setting up the object, and the branch.

Definition at line 930 of file AsgxAODNTupleMakerAlg.cxx.

                                                         {
  
       // Remember the branch name.
       m_branchName = branchName;
  
       // Create the accessor.
       m_acc.reset( new SG::AuxElement::TypelessConstAccessor( auxName ) );
  
       // Get a pointer to the vector factory.
       const SG::AuxTypeRegistry& reg = SG::AuxTypeRegistry::instance();
       const std::type_info* ti    = reg.getType( m_acc->auxid() );
       const std::type_info* vecTi = reg.getVecType( m_acc->auxid() );
       if( ( ! ti ) || ( ! vecTi ) ) {
          msg << MSG::ERROR
              << "No std::type_info available for auxiliary variable: "
              << auxName << endmsg;
          return StatusCode::FAILURE;
       }
       m_factory = reg.getFactory( m_acc->auxid() );
       if( ! m_factory ) {
          msg << MSG::ERROR << "No factory found for auxiliary variable: "
              << auxName << endmsg;
          return StatusCode::FAILURE;
       }
  
       // 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( *vecTi );
  
       // Access the dictionary for the type.
       TClass* cl = TClass::GetClass( *vecTi );
       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( branchName.c_str(), cl->GetName(),
                                  &m_dataPtr );
       if( ! br ) {
          msg << MSG::ERROR << "Failed to create branch: " << branchName
              << endmsg;
          return StatusCode::FAILURE;
       }
  
       // Return gracefully.
       return StatusCode::SUCCESS;
    }

Member Data Documentation

◆ m_acc

std::unique_ptr< SG::AuxElement::TypelessConstAccessor > CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::m_acc

Object accessing the variable in question.

Definition at line 317 of file AsgxAODNTupleMakerAlg.h.

◆ m_branchName

std::string CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::m_branchName

Name of the branch being written.

Definition at line 315 of file AsgxAODNTupleMakerAlg.h.

◆ m_data

std::unique_ptr< SG::IAuxTypeVector > CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::m_data

The object managing the memory of the written variable.

Definition at line 321 of file AsgxAODNTupleMakerAlg.h.

◆ m_dataPtr

void* CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::m_dataPtr = nullptr

Helper variable, pointing at the object to be written.

Definition at line 323 of file AsgxAODNTupleMakerAlg.h.

◆ m_factory

const SG::IAuxTypeVectorFactory* CP::AsgxAODNTupleMakerAlg::ContainerProcessor::BranchProcessor::m_factory = nullptr

Pointer to the helper object that handles this variable.

Definition at line 319 of file AsgxAODNTupleMakerAlg.h.

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

Public Member Functions

Public Attributes