plug-ins/include/SSummedVar.icc

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
// $Id: SSummedVar.icc 179 2010-06-30 09:36:19Z krasznaa $
/***************************************************************************
 * @Project: SFrame - ROOT-based analysis framework for ATLAS
 * @Package: Plug-ins
 *
 * @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_PLUGINS_SSummedVar_ICC
#define SFRAME_PLUGINS_SSummedVar_ICC

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

// STL include(s):
#include <vector>

// ROOT include(s):
#include <TCollection.h>
#include <TList.h>

// SFrame include(s):
#include "core/include/ISCycleBaseHist.h"
#include "core/include/SLogger.h"

template< class Type >
std::vector< Type > operator+( const std::vector< Type >& left,
                               const std::vector< Type >& right ) {

   // Create the result vector:
   std::vector< Type > result;

   // Check that the summation can be performed:
   if( left.size() != right.size() ) {
      const char* type_name = typeid( left ).name();
      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;
      }
      SLogger m_logger( real_type_name ); // Name given like this on purpose...
      REPORT_ERROR( "Couldn't perform summation on type: " << real_type_name );
      REPORT_ERROR( "The results will not be correct!" );
      ::free( real_type_name );
      return result;
   }

   // Peform the summation:
   result.resize( left.size() );
   for( typename std::vector< Type >::size_type i = 0; i < left.size(); ++i ) {
      result[ i ] = left[ i ] + right[ i ];
   }

   return result;
}

template< class KeyType, class ValueType >
std::map< KeyType, ValueType > operator+( const std::map< KeyType, ValueType >& left,
                                          const std::map< KeyType, ValueType >& right ) {

   // Create the result map:
   std::map< KeyType, ValueType > result;

   // Check that the summation can be performed:
   if( left.size() != right.size() ) {
      const char* type_name = typeid( left ).name();
      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;
      }
      SLogger m_logger( real_type_name ); // Name given like this on purpose...
      REPORT_ERROR( "Couldn't perform summation on type: " << real_type_name );
      REPORT_ERROR( "The results will not be correct!" );
      ::free( real_type_name );
      return result;
   }

   // Perform the summation:
   typename std::map< KeyType, ValueType >::const_iterator left_itr = left.begin();
   typename std::map< KeyType, ValueType >::const_iterator left_end = left.end();
   typename std::map< KeyType, ValueType >::const_iterator right_itr = right.begin();
   typename std::map< KeyType, ValueType >::const_iterator right_end = right.end();
   for( ; left_itr != left_end && right_itr != right_end; ++left_itr, ++right_itr ) {
      // Check that we have the corresponding elements selected:
      if( left_itr->first != right_itr->first ) {
         const char* type_name = typeid( left ).name();
         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;
         }
         SLogger m_logger( real_type_name );
         REPORT_ERROR( "Couldn't perform summation on type: " << real_type_name );
         REPORT_ERROR( "The results will not be correct!" );
         ::free( real_type_name );
         return result;
      }
      // Add the two values:
      result[ left_itr->first ] = left_itr->second + right_itr->second;
   }

   return result;
}

//                                                                //
//          Implementation of the ProofSummedVar class            //
//                                                                //

template< class Type >
ProofSummedVar< Type >::ProofSummedVar( const char* name,
                                        const char* title )
   : TNamed( name, title ), m_member() {

}

template< class Type >
Int_t ProofSummedVar< Type >::Merge( TCollection* coll ) {

   SLogger m_logger( this->ClassName() );

   //
   // Return right away if the input is flawed:
   //
   if( ! coll ) return 0;
   if( coll->IsEmpty() ) return 0;

   //
   // Select the elements from the collection that can actually be merged:
   //
   TIter next( coll );
   TObject* obj = 0;
   while( ( obj = next() ) ) {

      //
      // See if it is an SCycleOutput object itself:
      //
      ProofSummedVar< Type >* pobj = dynamic_cast< ProofSummedVar< Type >* >( obj );
      if( ! pobj ) {
         REPORT_ERROR( "Trying to merge \"" << obj->ClassName()
                       << "\" object into \"" << this->ClassName() << "\"" );
         continue;
      }

      //
      // If everything is fine, add its contents to this object.
      // I perform the summation in this non-optimal way to be able to use
      // the overloaded operator defined at the top of this file...
      //
      m_member = m_member + pobj->m_member;

   }

   m_logger << DEBUG << "Merged objects with name \"" << GetName()
            << "\"" << SLogger::endmsg;

   return 1;
}

//                                                                //
//            Implementation of the SSummedVar class              //
//                                                                //

template< class Type >
SSummedVar< Type >::SSummedVar( const char* name, ISCycleBaseHist* parent )
   : m_objName( name ), m_parent( parent ), m_object( 0 ) {

}

template< class Type >
SSummedVar< Type >::operator Type&() {

   return GetReference();
}

template< class Type >
SSummedVar< Type >::operator const Type&() const {

   return GetReference();
}

template< class Type >
Type& SSummedVar< Type >::operator*() {

   return GetReference();
}

template< class Type >
Type* SSummedVar< Type >::operator->() {

   return GetPointer();
}

template< class Type >
Type& SSummedVar< Type >::GetReference() {

   return GetObject()->m_member;
}

template< class Type >
Type* SSummedVar< Type >::GetPointer() {

   return &( GetObject()->m_member );
}

template< class Type >
const Type& SSummedVar< Type >::operator*() const {

   return GetReference();
}

template< class Type >
const Type* SSummedVar< Type >::operator->() const {

   return GetPointer();
}

template< class Type >
const Type& SSummedVar< Type >::GetReference() const {

   return GetObject()->m_member;
}

template< class Type >
const Type* SSummedVar< Type >::GetPointer() const {

   return &( GetObject()->m_member );
}

template< class Type >
ProofSummedVar< Type >* SSummedVar< Type >::GetObject() const throw( SError ) {

   //
   // Try to get an already existing object from the output list:
   //
   ProofSummedVar< Type >* pobj =
      dynamic_cast< ProofSummedVar< Type >* >( m_parent->GetHistOutput()->FindObject( m_objName ) );

   if( pobj ) {
      //
      // Check if we have this object cached already. If it's a different object, then
      // we delete the cached one.
      //
      if( m_object ) {
         if( m_object != pobj ) {
            delete m_object;
            m_object = pobj;
         }
      } else {
         m_object = pobj;
      }
   } else {
      //
      // Construct a logger with a meaningful source. It has to be this compilated
      // since SSummedVar does not inherit from TObject.
      //
      const char* type_name = typeid( *this ).name();
      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;
      }
      SLogger m_logger( real_type_name );
      free( real_type_name );

      //
      // Create a new object and add it to the output list:
      //
      REPORT_VERBOSE( "Creating new object with name \""
                      << m_objName << "\"" );
      m_object = new ProofSummedVar< Type >( m_objName, "Internal SFrame object" );
      m_parent->GetHistOutput()->Add( m_object );
   }

   return m_object;

}

#endif // SFRAME_PLUGINS_SSummedVar_ICC