core/include/SCycleBaseHist.icc

Go to the documentation of this file.

// Dear emacs, this is -*- c++ -*-
// $Id: SCycleBaseHist.icc 335 2012-11-21 14:11:47Z 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_SCycleBaseHist_ICC
#define SFRAME_CORE_SCycleBaseHist_ICC

// ROOT include(s):
#include <TROOT.h>
#include <TH1.h>
#include <TList.h>
#include <TDirectory.h>
#include <TKey.h>

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

template< class T >
T* SCycleBaseHist::Book( const T& histo,
                         const char* directory,
                         Bool_t inFile ) throw( SError ) {

   // Put the object into our temporary directory in memory:
   GetTempDir()->cd();

   // Construct a full path name for the object:
   TString path = ( directory ? directory + TString( "/" ) : "" ) +
      TString( histo.GetName() );

   // Decide which TList to store the object in:
   TList* output = ( inFile ? &m_fileOutput : m_proofOutput );

   // Check if the object was already added:
   SCycleOutput* out =
      dynamic_cast< SCycleOutput* >( output->FindObject( path ) );

   // If not, add it now:
   if( ! out ) {
      out = new SCycleOutput( histo.Clone(), path, directory );
      output->TList::AddLast( out );
      REPORT_VERBOSE( "Added new object with name \"" << histo.GetName()
                      << "\" in directory \"" << ( directory ? directory : "" )
                      << "\"" );
   }

   // Get the pointer to the created object:
   T* ret = dynamic_cast< T* >( out->GetObject() );

   gROOT->cd(); // So that the temporary objects would be
                // created in a general memory space.

   // Calculate the statistical uncertainties correctly for
   // weighted histograms:
   TH1* hist = dynamic_cast< TH1* >( ret );
   if( hist ) {
      if( ( ! TH1::GetDefaultSumw2() ) && ( ! hist->GetSumw2N() ) ) {
         hist->Sumw2();
      }
   }

   // Return the object pointer:
   return ret;
}

template< class T >
T* SCycleBaseHist::Retrieve( const char* name,
                             const char* directory,
                             Bool_t outputOnly ) throw( SError ) {

   // Just to make sure that we're in the default directory in
   // memory:
   gROOT->cd();

   // Construct a path name from the specified parameters:
   const TString path = ( directory ? directory + TString( "/" ) : "" ) +
      TString( name );

   // Pointer to the requested object:
   T* result = 0;

   //
   // Try to find this object in the output PROOF list:
   //
   SCycleOutput* out =
      dynamic_cast< SCycleOutput* >( m_proofOutput->FindObject( path ) );
   if( out ) {
      result = dynamic_cast< T* >( out->GetObject() );
      if( ! result ) {
         REPORT_ERROR( "Output object with name \"" << name << "\" found in "
                       << "directory \"" << ( directory ? directory : "" )
                       << "\" but is not of the requested type" );
         SError error( SError::SkipCycle );
         error << "No object found in the holder with name: " << name
               << " in directory: " << directory;
         throw error;
      }
      return result;
   }

   //
   // Try to find this object in our private object list:
   //
   out = dynamic_cast< SCycleOutput* >( m_fileOutput.FindObject( path ) );
   if( out ) {
      result = dynamic_cast< T* >( out->GetObject() );
      if( ! result ) {
         REPORT_ERROR( "Output object with name \"" << name << "\" found in "
                       << "directory \"" << ( directory ? directory : "" )
                       << "\" but is not of the requested type" );
         SError error( SError::SkipCycle );
         error << "No object found in the holder with name: " << name
               << " in directory: " << directory;
         throw error;
      }
      return result;
   }

   // Return gracefully if the input should not be checked:
   if( outputOnly ) {
      REPORT_VERBOSE( "Object not found in output: " << path );
      return 0;
   }

   // Check that we have an input file already specified:
   if( ! m_inputFile ) {
      REPORT_ERROR( "No input file defined, and requested object "
                    "not found in output list" );
      throw SError( "No input file defined, and requested object "
                    "not found in output list", SError::SkipCycle );
   }

   //
   // Try to find this object inside the input file:
   //
   result = dynamic_cast< T* >( m_inputFile->Get( path ) );
   if( ! result ) {
      REPORT_ERROR( "Couldn't access object with path: " << path );
      SError error( SError::SkipCycle );
      error << "Couldn't access object with name: " << name
            << " in directory: " << directory;
      throw error;
   }

   return result;
}

template< class T >
std::vector< T* >
SCycleBaseHist::RetrieveAll( const char* name,
                             const char* directory ) throw( SError ) {

   // The result object:
   std::vector< T* > result;

   // Decide which directory to search in:
   TDirectory* dir = m_inputFile;
   if( directory ) {
      dir = dynamic_cast< TDirectory* >( m_inputFile->Get( directory ) );
      // If the requestested directory doesn't exist that's not necessariy an
      // error condition:
      if( ! dir ) {
         m_logger << DEBUG << "Directory \"" << directory
                  << "\" doesn't exist in the input file" << SLogger::endmsg;
         return result;
      }
   }

   // Get a list of all keys from the directory:
   TList* keyList = dir->GetListOfKeys();
   // Search for objects of the specified name:
   for( Int_t i = 0; i < keyList->GetEntries(); ++i ) {
      // Convert object to a TKey:
      TKey* key = dynamic_cast< TKey* >( keyList->At( i ) );
      if( ! key ) {
         REPORT_ERROR( "Couldn't cast to TKey. "
                       "There is some problem in the code" );
         throw SError( "Couldn't cast to TKey. "
                       "There is some problem in the code",
                       SError::StopExecution );
      }
      // Check if the object has the right name:
      if( strcmp( key->GetName(), name ) ) continue;
      // Check if this object is of the right type:
      T* obj =
         dynamic_cast< T* >( dir->Get( TString( key->GetName() ) + ";" +
                                       TString::Format( "%hi",
                                                        key->GetCycle() ) ) );
      if( ! obj ) continue;
      // Add it to our output:
      result.push_back( obj );
   }

   // Return the full list:
   return result;
}

#endif // SFRAME_CORE_SCycleBaseHist_ICC