AthHistogramming.h

Go to the documentation of this file.

 
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
// AthHistogramming.h
// Header file for class AthHistogramming
// Author: Karsten Koeneke
#ifndef ATHENABASECOMPS_ATHHISTOGRAMMING_H
#define ATHENABASECOMPS_ATHHISTOGRAMMING_H 1
 
 
 
// Framework includes
#include "GaudiKernel/ServiceHandle.h"
#include "GaudiKernel/ITHistSvc.h"
#include "AthenaBaseComps/AthCheckMacros.h"
#include "CxxUtils/crc64.h"
#include "GaudiKernel/MsgStream.h"
 
// ROOT includes
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TEfficiency.h"
#include "TTree.h"
#include "TGraph.h"
 
// STL includes
#include <string>
#include <map>
 
 
 
 
class AthHistogramming
{

  // Public methods:
public:

  AthHistogramming( const std::string& name );
 

  virtual ~AthHistogramming();

  // Const methods:

  const ServiceHandle<ITHistSvc>& histSvc() const;
 
 

  // Public methods:
protected:

  StatusCode configAthHistogramming ( const ServiceHandle<ITHistSvc>& histSvc,
                                      const std::string& prefix,          const std::string& rootDir,
                                      const std::string& histNamePrefix,  const std::string& histNamePostfix,
                                      const std::string& histTitlePrefix, const std::string& histTitlePostfix );
 
  // -----------------------
  // For histogramming
  // -----------------------

  inline TH1* bookGetPointer( const TH1& hist, const std::string& tDir="", const std::string& stream="" );

  inline TH1* bookGetPointer( TH1* hist, const std::string& tDir="", const std::string& stream="" );

  TH1* bookGetPointer( TH1& histRef, std::string tDir="", std::string stream="" );
 

  inline StatusCode book( const TH1& hist, const std::string& tDir="", const std::string& stream="" );

  inline StatusCode book( TH1* hist, const std::string& tDir="", const std::string& stream="" );

  inline StatusCode book( TH1& histRef, const std::string& tDir="", const std::string& stream="" );
 

  TH1* hist( const std::string&  histName, const std::string& tDir="", const std::string& stream="" );

  inline TH2* hist2d( const std::string& histName, const std::string& tDir="", const std::string& stream="" );

  inline TH3* hist3d( const std::string& histName, const std::string& tDir="", const std::string& stream="" );
 
 
  // -----------------------
  // For TTrees
  // -----------------------

  TTree* bookGetPointer( const TTree& treeRef, std::string tDir="", std::string stream="" );

  inline StatusCode book( const TTree& treeRef, const std::string& tDir="", const std::string& stream="" );

  TTree* tree( const std::string& treeName, const std::string& tDir="", const std::string& stream="" );
 
 
  // -----------------------
  // For TGraphs
  // -----------------------

  TGraph* bookGetPointer( const TGraph& graphRef, std::string tDir="", std::string stream="" );

  inline StatusCode book( const TGraph& graphRef, const std::string& tDir="", const std::string& stream="" );

  TGraph* graph( const std::string& graphName, const std::string& tDir="", const std::string& stream="" );
 
 
  // -----------------------
  // For TEfficiency
  // -----------------------

  inline TEfficiency* bookGetPointer( const TEfficiency& eff, const std::string& tDir="", const std::string& stream="" );

  inline TEfficiency* bookGetPointer( TEfficiency* eff, const std::string& tDir="", const std::string& stream="" );

  TEfficiency* bookGetPointer( TEfficiency& effRef, std::string tDir="", std::string stream="" );
 

  inline StatusCode book( const TEfficiency& eff, const std::string& tDir="", const std::string& stream="" );

  inline StatusCode book( TEfficiency* eff, const std::string& tDir="", const std::string& stream="" );

  inline StatusCode book( TEfficiency& effRef, const std::string& tDir="", const std::string& stream="" );
 

  TEfficiency* efficiency( const std::string& effName, const std::string& tDir="", const std::string& stream="" );
 

  // Private methods:
private:
  typedef uint32_t hash_t;

  void buildBookingString( std::string& bookingString,
                           std::string& histName,
                           std::string& tDir,
                           std::string& stream,
               bool usePrefixPostfix = false);

  void myReplace( std::string& str,
                  const std::string& oldStr,
                  const std::string& newStr);

  hash_t hash( const std::string& histName ) const;
 
 

  // Private data:
private:

  ServiceHandle<ITHistSvc> m_histSvc;
 

  typedef std::map< const hash_t, TH1* > HistMap_t;

  HistMap_t m_histMap;
 

  typedef std::map< const hash_t, TEfficiency* > EffMap_t;

  EffMap_t m_effMap;
 

  typedef std::map< const hash_t, TTree* > TreeMap_t;

  TreeMap_t m_treeMap;
 

  typedef std::map< const hash_t, TGraph* > GraphMap_t;

  GraphMap_t m_graphMap;
 

  std::string m_streamName;

  std::string m_rootDir;

  std::string m_histNamePrefix;

  std::string m_histNamePostfix;

  std::string m_histTitlePrefix;

  std::string m_histTitlePostfix;
 

  std::string m_name;

  MsgStream m_msg;
 
};
 
 
 
 

// Inline methods:
 
inline TH1* AthHistogramming::bookGetPointer( const TH1& hist, const std::string& tDir, const std::string& stream )
{
  // We need to create a non-const clone
  TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TH1 clone in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *histClone, tDir, stream );
 
}
 
inline TH1* AthHistogramming::bookGetPointer( TH1* hist, const std::string& tDir, const std::string& stream )
{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}
 
inline TEfficiency* AthHistogramming::bookGetPointer( const TEfficiency& hist, const std::string& tDir, const std::string& stream )
{
  // We need to create a non-const clone
  TEfficiency* histClone = dynamic_cast< TEfficiency* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *histClone, tDir, stream );
 
}
 
inline TEfficiency* AthHistogramming::bookGetPointer( TEfficiency* hist, const std::string& tDir, const std::string& stream )
{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}
 
 
inline StatusCode AthHistogramming::book( const TH1& hist, const std::string& tDir, const std::string& stream )
{
  // We need to create a non-const clone
  TH1* histClone = dynamic_cast< TH1* >( hist.Clone() );
  if ( !histClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TH1 clone" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *histClone, tDir, stream );
}
 
inline StatusCode AthHistogramming::book( TH1* hist, const std::string& tDir, const std::string& stream )
{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *hist, tDir, stream );
}
 
// Simplify the booking and registering (into THistSvc) of histograms
inline StatusCode AthHistogramming::book( TH1& histRef, const std::string& tDir, const std::string& stream )
{
  // Call the other Book method and see if it returns a valid pointer
  TH1* histPointer = this->bookGetPointer( histRef, tDir, stream );
  if ( !histPointer ) {
    m_msg << MSG::ERROR << "Couldn't book a TH1" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 
inline StatusCode AthHistogramming::book( const TEfficiency& eff, const std::string& tDir, const std::string& stream )
{
  // We need to create a non-const clone
  TEfficiency* effClone = dynamic_cast< TEfficiency* >( eff.Clone() );
  if ( !effClone ) {
    m_msg << MSG::ERROR << "Couldn't create a TEfficiency clone" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *effClone, tDir, stream );
}
 
inline StatusCode AthHistogramming::book( TEfficiency* eff, const std::string& tDir, const std::string& stream )
{
  if ( !eff ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *eff, tDir, stream );
}
 
// Simplify the booking and registering (into THistSvc) of TEfficiency
inline StatusCode AthHistogramming::book( TEfficiency& effRef, const std::string& tDir, const std::string& stream )
{
  // Call the other Book method and see if it returns a valid pointer
  TEfficiency* effPointer = this->bookGetPointer( effRef, tDir, stream );
  if ( !effPointer ) {
    m_msg << MSG::ERROR << "Couldn't book a TEfficiency" << endmsg;
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 
 
// Simplify the retrieval of registered 2-d histograms
inline TH2* AthHistogramming::hist2d( const std::string& histName, const std::string& tDir, const std::string& stream )
{
  // Get the TH1 pointer
  TH1* th1Pointer = this->hist(histName, tDir, stream);
  if ( !th1Pointer )
    {
      m_msg << MSG::ERROR
            << "Cannot get a 2-d histogram with name " << histName
            << "... will probably seg-fault!" << endmsg;
      return NULL;
    }
  // If the TH1 pointer is valid, simply return the dynamic_cast
  return dynamic_cast<TH2*>( th1Pointer );
}
 
 
// Simplify the retrieval of registered 3-d histograms
inline TH3* AthHistogramming::hist3d( const std::string& histName, const std::string& tDir, const std::string& stream )
{
  // Get the TH1 pointer
  TH1* th1Pointer = this->hist(histName, tDir, stream);
  if ( !th1Pointer )
    {
      m_msg << MSG::ERROR
            << "Cannot get a 3-d histogram with name " << histName
            << "... will probably seg-fault!" << endmsg;
      return NULL;
    }
  // If the TH1 pointer is valid, simply return the dynamic_cast
  return dynamic_cast<TH3*>( th1Pointer );
}
 
 
// Simplify the booking and registering (into THistSvc) of TTrees
inline StatusCode AthHistogramming::book( const TTree& treeRef, const std::string& tDir, const std::string& stream )
{
  // Call the other Book method and see if it returns a valid pointer
  TTree* treePointer = this->bookGetPointer( treeRef, tDir, stream );
  if ( treePointer )
    {
      return StatusCode::SUCCESS;
    }
  else
    {
      return StatusCode::FAILURE;
    }
}
 
 
 
 
// For the THistSvc
inline const ServiceHandle<ITHistSvc>& AthHistogramming::histSvc() const
{
  return m_histSvc;
}
 
 
// Create a 32-bit hash out of the histogram name
inline AthHistogramming::hash_t AthHistogramming::hash( const std::string& histName ) const
{
  const uint64_t hash64 = CxxUtils::crc64( histName );
  return (hash_t)(hash64 & 0xFFFFFFFF);
}
 
 
#endif //> !ATHENABASECOMPS_ATHHISTOGRAMMINGTOOL_H