core/include/SCycleBaseNTuple.icc

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
// $Id: SCycleBaseNTuple.icc 333 2012-11-21 09:19:50Z krasznaa $
/***************************************************************************
 * @Project: SFrame - ROOT-based analysis framework for ATLAS
 * @Package: Core
 *
 * @author Stefan Ask       <Stefan.Ask@cern.ch>           - Manchester
 * @author David Berge      <David.Berge@cern.ch>          - CERN
 * @author Johannes Haller  <Johannes.Haller@cern.ch>      - Hamburg
 * @author A. Krasznahorkay <Attila.Krasznahorkay@cern.ch> - CERN/Debrecen
 *
 ***************************************************************************/

#ifndef SFRAME_CORE_SCycleBaseNTuple_ICC
#define SFRAME_CORE_SCycleBaseNTuple_ICC

// System include(s):
#include <string.h>
#include <cxxabi.h>
#include <cstdlib>

// STL include(s):
#include <sstream>
#include <typeinfo>

// ROOT include(s):
#include <TTree.h>
#include <TBranch.h>
#include <TLeaf.h>
#include <TString.h>

// Local include(s):
#include "SPointer.h"

template< typename T >
bool SCycleBaseNTuple::ConnectVariable( const char* treeName, const char* branchName,
                                        T& variable ) throw ( SError ) {

   REPORT_VERBOSE( "Called with treeName = \"" << treeName
                   << "\", branchName = \"" << branchName << "\"" );

   // Access the TTree. The function will throw an exception if unsuccessful
   TTree* tree = GetInputTree( treeName );
   TBranch* br = 0;

   // Check if the branch actually exists:
   TBranch* branch_info;
   if( ! ( branch_info = tree->GetBranch( branchName ) ) ) {
      REPORT_ERROR( "Branch \"" << branchName << "\" doesn't exist in TTree \""
                    << treeName << "\"" );
      return false;
   }

   //
   // Detect what kind of variable we're dealing with:
   //
   const char* type_name = typeid( variable ).name();
   REPORT_VERBOSE( "Type ID: " << type_name );
   if( strlen( type_name ) == 1 ) {

      // Check whether the branch matches the type of the variable given to this
      // function:
      REPORT_VERBOSE( "Type of the variable held by the branch: "
                      << branch_info->GetTitle() );

      // Try to determine if the user is trying to connect a variable of the correct
      // type to the branch. Let's first assume that there is only one leaf, which
      // is called the same as the branch. This is the ATLAS convention.
      TLeaf* leaf = branch_info->GetLeaf( branchName );
      Bool_t simple_branch = kFALSE;
      if( ! leaf ) {
         // If there isn't a leaf with the name of the branch, try to look for all the
         // leaves. It could be that there is a single leaf with some other name, or that
         // there are a number of leaves.
         std::vector< TLeaf* > leaves;
         TObjArray* tleaves = branch_info->GetListOfLeaves();
         for( Int_t i = 0; i < tleaves->GetSize(); ++i ) {
            // In my experience not all objects in the array are actual TLeaf
            // objects...
            TLeaf* local_leaf = dynamic_cast< TLeaf* >( tleaves->At( i ) );
            if( local_leaf ) {
               leaves.push_back( local_leaf );
            }
         }
         // If there is a single leaf, then the type checking can continue:
         if( leaves.size() == 1 ) {
            leaf = leaves[ 0 ];
            simple_branch = kTRUE;
         }
         // If there are multiple leaves, then we'll have to skip the type checking:
         else if( leaves.size() > 1 ) {
            simple_branch = kFALSE;
         }
         // If we didn't find any leaves, then something is definitely wrong:
         else {
            REPORT_ERROR( "Couldn't interrogate branch: " << branchName );
            REPORT_ERROR( "Are you trying to connect a primitive to a branch describing "
                          "an object?" );
            throw SError( "Couldn't interrogate branch: " + TString( branchName ),
                          SError::SkipFile );
         }
      } else {
         simple_branch = kTRUE;
      }
      //
      // Only do the type checking if there is a single leaf:
      //
      if( simple_branch ) {
         REPORT_VERBOSE( "Leaf type: " << leaf->GetTypeName() );

         // Now check if the leaf has the correct type:
         if( strcmp( type_name, TypeidType( leaf->GetTypeName() ) ) ) {
            REPORT_ERROR( "Trying to connect a wrong type of primitive to the branch: "
                          << branchName );
            REPORT_ERROR( "  Use variable of type: " << leaf->GetTypeName() );
            throw SError( "Wrong variable type given for branch: " + TString( branchName ),
                          SError::SkipCycle );
         } else {
            REPORT_VERBOSE( "The branch and variable types seem to match" );
         }
      } else {
         // Let the user know that we can't do any type checking...
         m_logger << INFO << "Connecting to a branch with multiple leaves."
                  << "Type correctness can't be checked!" << SLogger::endmsg;
      }

      // For primitive types nothing fancy needs to be done
      REPORT_VERBOSE( "The supplied variable is a \"primitive\"" );
      tree->SetBranchStatus( branchName, 1 );
      tree->SetBranchAddress( branchName, &variable, &br );

   } else {

      throw SError( "ConnectVariable(...) called with an unknown variable type",
                    SError::SkipCycle );

   }

#if ROOT_VERSION_CODE >= ROOT_VERSION( 5, 26, 0 )
   tree->AddBranchToCache( br, kTRUE );
#endif // ROOT_VERSION...
   this->RegisterInputBranch( br );
   m_logger << DEBUG << "Connected branch \"" << branchName << "\" in tree \""
            << treeName << "\"" << SLogger::endmsg;

   return true;
}

template< typename T, size_t size >
bool SCycleBaseNTuple::ConnectVariable( const char* treeName, const char* branchName,
                                        T ( &variable )[ size ] ) throw( SError ) {

   // Access the TTree. The function will throw an exception if unsuccessful
   TTree* tree = GetInputTree( treeName );
   TBranch* br = 0;

   // Check if the branch actually exists:
   if( ! tree->GetBranch( branchName ) ) {
      REPORT_ERROR( "Branch \"" << branchName << "\" doesn't exist in TTree \""
                    << treeName << "\"" );
      return false;
   }

   //
   // Print what kind of variable we're dealing with:
   //
   const char* type_name = typeid( variable ).name();
   REPORT_VERBOSE( "Type ID: " << type_name );

   REPORT_VERBOSE( "The supplied variable is a \"primitive array\"" );
   tree->SetBranchStatus( branchName, 1 );
   tree->SetBranchAddress( branchName, variable, &br );

#if ROOT_VERSION_CODE >= ROOT_VERSION( 5, 26, 0 )
   tree->AddBranchToCache( br, kTRUE );
#endif // ROOT_VERSION...
   this->RegisterInputBranch( br );
   m_logger << DEBUG << "Connected branch \"" << branchName << "\" in tree \""
            << treeName << "\"" << SLogger::endmsg;

   return true;
}

template< typename T >
bool SCycleBaseNTuple::ConnectVariable( const char* treeName, const char* branchName,
                                        T*& variable ) throw ( SError ) {

   // Access the TTree. The function will throw an exception if unsuccessful
   TTree* tree = GetInputTree( treeName );
   TBranch* br = 0;

   // Check if the branch actually exists:
   if( ! tree->GetBranch( branchName ) ) {
      REPORT_ERROR( "Branch \"" << branchName << "\" doesn't exist in TTree \""
                    << treeName << "\"" );
      return false;
   }

   // To make sure that typeid(...) will succeed. All classes that can be written out
   // by ROOT have to have a default constructor anyway...
   variable = new T();

   //
   // Detect what kind of variable we're dealing with:
   //
   const char* type_name = typeid( *variable ).name();
   REPORT_VERBOSE( "Type ID: " << type_name );
   delete variable; // now let's dispose of the object
   if( strlen( type_name ) == 1 ) {

      throw SError( "ConnectVariable(...) specialised for object pointers called "
                    "with a simple variable.", SError::SkipCycle );

   } else {

      // The object pointers have to be initialised to zero before
      // connecting them to the branches
      REPORT_VERBOSE( "The supplied variable is an object pointer" );
      variable = 0;
      tree->SetBranchStatus( TString( branchName ) + "*", 1 );
      tree->SetBranchAddress( branchName, &variable, &br );
      // Take ownership of this new object:
      m_inputVarPointers.push_back( new SPointer< T >( variable ) );

   }

#if ROOT_VERSION_CODE >= ROOT_VERSION( 5, 26, 0 )
   tree->AddBranchToCache( br, kTRUE );
#endif // ROOT_VERSION...
   this->RegisterInputBranch( br );
   m_logger << DEBUG << "Connected branch \"" << branchName << "\" in tree \""
            << treeName << "\"" << SLogger::endmsg;

   return true;
}

template < class T >
TBranch* SCycleBaseNTuple::DeclareVariable( T& obj, const char* name,
                                            const char* treeName ) throw( SError ) {

   TTree*   tree = 0;
   TBranch* branch = 0;

   //
   // Find the pointer to the output tree:
   //
   if( treeName ) {

      // Consider both "normal" and metadata trees:
      try {
         tree = GetOutputTree( treeName );
      } catch( const SError& error ) {
         if( error.request() <= SError::SkipFile ) {
            // Try to find a metadata tree if a regular tree is not found
            // with this name:
            REPORT_VERBOSE( "Output tree with name \"" << name
                            << "\" not found. Trying to find a metadata tree "
                            << "instead." );
            tree = GetOutputMetadataTree( treeName );
         } else {
            REPORT_ERROR( "Exception message caught with message: "
                          << error.what() );
            throw;
         }
      }

   } else {

      if( m_outputTrees.size() != 1 ) {
         SError error( SError::SkipInputData );
         error << "There can't be other than 1 output tree defined in order not to\n";
         error << "define a tree name in SCycleBaseNTuple::DeclareVariable(...)!";
         throw error;
      }

      tree = m_outputTrees.front();

   }

   //
   // Check if the tree has been found:
   //
   if( ! tree ) {
      SError error( SError::SkipInputData );
      if( treeName ) {
         error << "Couldn't find output tree with name: " << treeName;
      } else {
         error << "Couldn't find default output tree";
      }
      throw error;
   }

   REPORT_VERBOSE( "Found output tree with name: " << tree->GetName() );

   // Check if the branch exists already:
   branch = tree->GetBranch( name );
   if( ! branch ) {

      //
      // This branch doesn't exist yet. We have to (try to) create it.
      //
      m_logger << DEBUG << "Creating new output branch with name: " << name
               << SLogger::endmsg;

      // First of all, lets figure out what kind of object we're dealing with
      const char* type_name = typeid( obj ).name();

      if( strlen( type_name ) == 1 ) {

         //
         // This is a simple variable:
         //
         REPORT_VERBOSE( "The supplied variable is a \"primitive\"" );

         std::ostringstream leaflist;
         leaflist << name << "/" << RootType( type_name );
         branch = tree->Branch( name, &obj, leaflist.str().c_str() );

      } else {

         //
         // This is an object:
         //
         REPORT_VERBOSE( "The supplied variable is an object" );

         int status;
         char* real_type_name = abi::__cxa_demangle( type_name, 0, 0, &status );
         if( status ) {
            SError error( SError::StopExecution );
            error << "Couldn't demangle type name: " << type_name;
            throw error;
         }

         REPORT_VERBOSE( "Mangled name of object: " << type_name );
         REPORT_VERBOSE( "De-mangled name of object: " << real_type_name );

         //
         // Then try to add the object to the TTree. We have to do it in such a weird way,
         // since the "pointer" variable is going to disappear at the end of this function
         // so giving "&pointer" to TTree::Bronch would cause quite a crash when you're
         // writing out the event. (Trust me, I *know*... :-)) I'm storing the pointers
         // in an std::list, since lists don't move their elements around.
         // (vectors are allowed to do that. This one I've just read... :-))
         //
         T* pointer = &obj;
         m_outputVarPointers.push_back( pointer );
         branch = tree->Bronch( name, real_type_name, &m_outputVarPointers.back() );

         free( real_type_name );

      }

      if( ! branch ) {
         SError error( SError::SkipInputData );
         error << "Couldn't create branch with name: " << name;
         throw error;
      }

      REPORT_VERBOSE( "Successfully added branch" );

   } else {

      m_logger << WARNING << "A branch with the name \"" << name << "\" already exists"
               << SLogger::endmsg;
      m_logger << WARNING << "New object not added to tree!" << SLogger::endmsg;

   }

   return branch;
}

#endif // SFRAME_CORE_SCycleBaseNTuple_ICC