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

Collaboration diagram for CP::AsgxAODMetNTupleMakerAlg::ElementProcessor::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	process (const SG::AuxElement &element, 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.

Definition at line 138 of file AsgxAODMetNTupleMakerAlg.h.

Member Function Documentation

◆ process()

StatusCode CP::AsgxAODMetNTupleMakerAlg::ElementProcessor::BranchProcessor::process	(	const SG::AuxElement &	element,
		MsgStream &	msg
	)

Function processing the object, filling the variable.

This function is called by ElementProcessor, 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 529 of file AsgxAODMetNTupleMakerAlg.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::AsgxAODMetNTupleMakerAlg::ElementProcessor::BranchProcessor::setup	(	TTree &	tree,
		const std::string &	auxName,
		const std::string &	branchName,
		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 435 of file AsgxAODMetNTupleMakerAlg.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() );
       if( ! ti ) {
          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(), 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( ti->name() ) == 1 ) {
  
          // This is a "primitive" variable...
  
          // Get the type identifier for it that ROOT will understand.
          const char rType = rootType( ti->name()[ 0 ], msg );
          if( rType == '\0' ) {
             msg << MSG::ERROR << "Type not recognised for variable: "
                 << branchName << endmsg;
             return StatusCode::FAILURE;
          }
  
          // Construct the type description.
          std::ostringstream typeDesc;
          typeDesc << branchName << "/" << rType;
  
          // Create the primitive branch.
          br = tree.Branch( branchName.c_str(), m_data->toPtr(),
                            typeDesc.str().c_str() );
  
       } else {
  
          // This is an "object" variable...
  
          // Get a proper type name for the variable.
          const std::string typeName = SG::normalizedTypeinfoName( *ti );
  
          // Access the dictionary for the type.
          TClass* cl = TClass::GetClass( *ti );
          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( branchName.c_str(), cl->GetName(), &m_dataPtr );
  
       }
  
       // Check that the branch creation succeeded.
       if( ! br ) {
          msg << MSG::ERROR << "Failed to create branch: " << branchName
              << endmsg;
          return StatusCode::FAILURE;
       }
  
       // Return gracefully.
       return StatusCode::SUCCESS;
    }