core/src/SCycleBaseHist.cxx

Go to the documentation of this file.

// $Id: SCycleBaseHist.cxx 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
 *
 ***************************************************************************/

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

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

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

#ifndef DOXYGEN_IGNORE
ClassImp( SCycleBaseHist )
#endif // DOXYGEN_IGNORE

SCycleBaseHist::SCycleBaseHist()
   : SCycleBaseBase(), m_histoMap(), m_fileOutput(),
     m_proofOutput( 0 ), m_inputFile( 0 ) {

   REPORT_VERBOSE( "SCycleBaseHist constructed" );
}

void SCycleBaseHist::SetHistOutput( TList* output ) {

   m_proofOutput = output;
   m_histoMap.clear();
   return;
}

TList* SCycleBaseHist::GetHistOutput() const {

   return m_proofOutput;
}

void SCycleBaseHist::WriteObj( const TObject& obj,
                               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:
   const TString path = ( directory ? directory + TString( "/" ) : "" ) +
      TString( obj.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( obj.Clone(), path, directory );
      output->TList::AddLast( out );
   }

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

   return;
}

TH1* SCycleBaseHist::Hist( const char* name, const char* dir ) throw( SError ) {

   TH1* result;

   std::pair< std::string, std::string > this_pair( name, ( dir ? dir : "" ) );
   std::map< std::pair< std::string, std::string >, TH1* >::const_iterator it;
   if( ( it = m_histoMap.find( this_pair ) ) != m_histoMap.end() ) {
      result = it->second;
   } else {
      REPORT_VERBOSE( "Hist(): Using Retrieve for name \""
                      << name << "\" and dir \"" << ( dir ? dir : "" ) << "\"" );
      result = Retrieve< TH1 >( name, dir ); // This line can throw an exception...
      m_histoMap[ this_pair ] = result;
   }

   return result;
}

void SCycleBaseHist::SetHistInputFile( TDirectory* file ) {

   m_inputFile = file;
   return;
}

TDirectory* SCycleBaseHist::GetHistInputFile() const {

   return m_inputFile;
}

void SCycleBaseHist::WriteHistObjects( TDirectory* output ) {

   // Return right away if we don't have objects designated for in-file
   // merging:
   if( ! m_fileOutput.GetSize() ) return;

   // If the objects are added to the output file:
   if( output ) {

      // Remember which directory we were in:
      TDirectory* currDir = gDirectory;
      // Go to the output file's directory:
      output->cd();

      // Write out each object to the file:
      for( Int_t i = 0; i < m_fileOutput.GetSize(); ++i ) {
         m_fileOutput.At( i )->Write();
      }

      // Remove the in-memory objects:
      m_fileOutput.SetOwner( kTRUE );
      m_fileOutput.Clear();

      // Change back to the old directory:
      currDir->cd();
   }
   // If the objects have to be merged in memory after all:
   else {

      // Print a WARNING message, as this is probably not what the user
      // wanted:
      m_logger << WARNING << "Objects designated to be merged in-file will be"
               << SLogger::endmsg;
      m_logger << WARNING << "merged in-memory instead!" << SLogger::endmsg;

      // Add each object to the PROOF output list instead:
      for( Int_t i = 0; i < m_fileOutput.GetSize(); ++i ) {
         m_proofOutput->TList::AddLast( m_fileOutput.At( i ) );
      }

      // Make out private list forget about the objects:
      m_fileOutput.SetOwner( kFALSE );
      m_fileOutput.Clear();
   }

   return;
}

TDirectory* SCycleBaseHist::GetTempDir() const {

   static TDirectory* tempdir = 0;

   if( ! tempdir ) {
      gROOT->cd();
      tempdir = gROOT->mkdir( "SFrameTempDir" );
      if( ! tempdir ) {
         REPORT_ERROR( "Temporary directory could not be created" );
      }
   }

   return tempdir;
}