AthHistogramming Class Reference

#include <AthHistogramming.h>

Inheritance diagram for AthHistogramming:

Collaboration diagram for AthHistogramming:

Public Member Functions
	AthHistogramming (const std::string &name)
	Constructor with parameters:
virtual	~AthHistogramming ()
	Destructor:
const ServiceHandle< ITHistSvc > &	histSvc () const
	The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.

Protected Member Functions
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)
	To be called to fill the internal configuration.
TH1 *	bookGetPointer (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
TH1 *	bookGetPointer (TH1 *hist, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
TH1 *	bookGetPointer (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
StatusCode	book (const TH1 &hist, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
StatusCode	book (TH1 *hist, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
StatusCode	book (TH1 &histRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of histograms.
TH1 *	hist (std::string_view histName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered histograms of any type.
TH2 *	hist2d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered 2-d histograms.
TH3 *	hist3d (std::string_view histName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered 3-d histograms.
TTree *	bookGetPointer (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TTrees.
StatusCode	book (const TTree &treeRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TTrees.
TTree *	tree (std::string_view treeName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered TTrees.
TGraph *	bookGetPointer (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TGraphs.
StatusCode	book (const TGraph &graphRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TGraphs.
TGraph *	graph (std::string_view graphName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered TGraphs.
TEfficiency *	bookGetPointer (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency *	bookGetPointer (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency *	bookGetPointer (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode	book (const TEfficiency &eff, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode	book (TEfficiency *eff, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
StatusCode	book (TEfficiency &effRef, std::string_view tDir="", std::string_view stream="")
	Simplify the booking and registering (into THistSvc) of TEfficiency.
TEfficiency *	efficiency (std::string_view effName, std::string_view tDir="", std::string_view stream="")
	Simplify the retrieval of registered TEfficiency.

Private Types
typedef uint32_t	hash_t
	typedef for the internal hash
typedef std::map< const hash_t, TH1 * >	HistMap_t
	Typedef for convenience.
typedef std::map< const hash_t, TEfficiency * >	EffMap_t
	Typedef for convenience.
typedef std::map< const hash_t, TTree * >	TreeMap_t
	Typedef for convenience.
typedef std::map< const hash_t, TGraph * >	GraphMap_t
	Typedef for convenience.

Private Member Functions
std::string	buildBookingString (std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix=false) const
	Method to build individual booking string.
hash_t	hash (std::string_view histName) const
	Method to calculate a 32-bit hash from a string.

Private Attributes
ServiceHandle< ITHistSvc >	m_histSvc
	Pointer to the THistSvc (event store by default).
HistMap_t	m_histMap
	The map of histogram names to their pointers.
EffMap_t	m_effMap
	The map of histogram names to their pointers.
TreeMap_t	m_treeMap
	The map of TTree names to their pointers.
GraphMap_t	m_graphMap
	The map of TGraph names to their pointers.
std::string	m_streamName
	Name of the ROOT output stream (file).
std::string	m_rootDir
	Name of the ROOT directory.
std::string	m_histNamePrefix
	The prefix for the histogram THx name.
std::string	m_histNamePostfix
	The postfix for the histogram THx name.
std::string	m_histTitlePrefix
	The prefix for the histogram THx title.
std::string	m_histTitlePostfix
	The postfix for the histogram THx title.
std::string	m_name
	Instance name.
MsgStream	m_msg
	Cached Message Stream.

Detailed Description

Definition at line 38 of file AthHistogramming.h.

Member Typedef Documentation

EffMap_t

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

private

Typedef for convenience.

Definition at line 199 of file AthHistogramming.h.

GraphMap_t

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

private

Typedef for convenience.

Definition at line 213 of file AthHistogramming.h.

hash_t

typedef uint32_t AthHistogramming::hash_t

private

typedef for the internal hash

Definition at line 171 of file AthHistogramming.h.

HistMap_t

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

private

Typedef for convenience.

Definition at line 192 of file AthHistogramming.h.

TreeMap_t

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

private

Typedef for convenience.

Definition at line 206 of file AthHistogramming.h.

Constructor & Destructor Documentation

AthHistogramming()

AthHistogramming::AthHistogramming

(

const std::string &

name

)

Constructor with parameters:

Definition at line 39 of file AthHistogramming.cxx.

                                                          :
  m_histSvc ( "THistSvc/THistSvc", name ),
  m_streamName(""),
  m_name ( name ),
  m_msg( Athena::getMessageSvc(), name )
{
}

~AthHistogramming()

AthHistogramming::~AthHistogramming ( )

virtual

Destructor:

Definition at line 52 of file AthHistogramming.cxx.

{
  //ATH_MSG_DEBUG ("Calling destructor of AthHistogramming");
  if ( m_msg.level() <= MSG::VERBOSE ) m_msg << MSG::DEBUG << "Calling destructor of AthHistogramming" << endmsg;
}

Member Function Documentation

book() [1/8]

StatusCode AthHistogramming::book ( const TEfficiency & eff, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 329 of file AthHistogramming.h.

{
  // 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 );
}

book() [2/8]

StatusCode AthHistogramming::book ( const TGraph & graphRef, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TGraphs.

book() [3/8]

StatusCode AthHistogramming::book ( const TH1 & hist, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 297 of file AthHistogramming.h.

{
  // 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 );
}

book() [4/8]

StatusCode AthHistogramming::book ( const TTree & treeRef, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 397 of file AthHistogramming.h.

{
  // 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;
    }
}

book() [5/8]

StatusCode AthHistogramming::book ( TEfficiency & effRef, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 350 of file AthHistogramming.h.

{
  // 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;
}

book() [6/8]

StatusCode AthHistogramming::book ( TEfficiency * eff, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 340 of file AthHistogramming.h.

{
  if ( !eff ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *eff, tDir, stream );
}

book() [7/8]

StatusCode AthHistogramming::book ( TH1 & histRef, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 318 of file AthHistogramming.h.

{
  // 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;
}

book() [8/8]

StatusCode AthHistogramming::book ( TH1 * hist, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 308 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1" << endmsg;
    return StatusCode::FAILURE;
  }
  return this->book( *hist, tDir, stream );
}

bookGetPointer() [1/8]

TEfficiency * AthHistogramming::bookGetPointer ( const TEfficiency & eff, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 275 of file AthHistogramming.h.

{
  // 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 );
 
}

bookGetPointer() [2/8]

TGraph * AthHistogramming::bookGetPointer ( const TGraph & graphRef, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the booking and registering (into THistSvc) of TGraphs.

Definition at line 374 of file AthHistogramming.cxx.

{
  // Get a pointer
  const TGraph* graphPointer = &graphRef;
 
  // Check that we got a valid pointer
  if ( !graphPointer )
    {
      m_msg << MSG::WARNING
            << "We got an invalid TGraph pointer in the BookGetPointer(TGraph*) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
 
  // Modify the name and title according to the prefixes of this classes instance
  std::string graphName  = graphPointer->GetName();
  const std::string graphTitle = graphPointer->GetTitle();
 
  // Check if the hash for this graphName already exists, i.e., if we have a hash collision
  const hash_t graphHash = this->hash(graphName);
  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
  if ( it != m_graphMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the TGraph with name=" << graphName
            << " already exists and points to a TGraph with name=" << it->second->GetName()
            << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Create a clone that has the new name
  TGraph* graphClone = dynamic_cast< TGraph* >( graphPointer->Clone((m_histNamePrefix+graphName+m_histNamePostfix).c_str()) );
  if( !graphClone )
    {
      m_msg << MSG::WARNING
            << "We couldn't clone the TGraph in the BookGetPointer(TGraph&) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
  graphClone->SetTitle ((m_histTitlePrefix+graphTitle+m_histTitlePostfix).c_str());
 
  // Massage the final string to book things
  std::string bookingString = buildBookingString( graphName, tDir, stream );
 
  // Register the TGraph into the THistSvc
  if ( !((histSvc()->regGraph(bookingString, graphClone)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering TGraph with name " << graphName
            << ", title " << graphTitle
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphClone ) );
 
  return graphClone;
}

bookGetPointer() [3/8]

TH1 * AthHistogramming::bookGetPointer ( const TH1 & hist, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 254 of file AthHistogramming.h.

{
  // 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 );
 
}

bookGetPointer() [4/8]

TTree * AthHistogramming::bookGetPointer ( const TTree & treeRef, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the booking and registering (into THistSvc) of TTrees.

Definition at line 268 of file AthHistogramming.cxx.

{
  // Get a pointer
  const TTree* treePointer = &treeRef;
 
  // Check that we got a valid pointer
  if ( !treePointer )
    {
      m_msg << MSG::WARNING
            << "We got an invalid TTree pointer in the BookGetPointer(TTree*) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
 
  // Modify the name and title according to the prefixes of this classes instance
  std::string treeName  = treePointer->GetName();
  const std::string treeTitle = treePointer->GetTitle();
 
  // Check if the hash for this treeName already exists, i.e., if we have a hash collision
  const hash_t treeHash = this->hash(treeName);
  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
  if ( it != m_treeMap.end() ) // It does exist!
    {
      m_msg << MSG::WARNING
            << "Detected a hash collision. The hash for the TTree with name=" << treeName
            << " already exists and points to a TTree with name=" << it->second->GetName()
            << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
      return NULL;
    }
 
  // Create a clone that has the new name
  TTree* treeClone = dynamic_cast< TTree* >( treePointer->Clone(treeName.c_str()) );
  if( !treeClone )
    {
      m_msg << MSG::WARNING
            << "We couldn't clone the TTree in the BookGetPointer(TTree&) method of the class" << m_name
            << "!" << endmsg;
      return NULL;
    }
  treeClone->SetTitle (treeTitle.c_str());
 
  // Massage the final string to book things
  std::string bookingString = buildBookingString( treeName, tDir, stream );
 
  // Register the TTree into the THistSvc
  if ( !((histSvc()->regTree(bookingString, treeClone)).isSuccess()) )
    {
      m_msg << MSG::WARNING
            << "Problem registering TTree with name " << treeName
            << ", title " << treeTitle
            << " in " << m_name << "!" << endmsg;
      return NULL;
    }
 
  // Also register it in the local map of string to pointer
  m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treeClone ) );
 
  return treeClone;
}

bookGetPointer() [5/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency & effRef, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 139 of file AthHistogramming.cxx.

{
  std::string originalName{effRef.GetName()};
  const auto effName = splitName(originalName).second;
  const std::string effTitle(effRef.GetTitle());
  std::string bookingString = buildBookingString(originalName, tDir, stream);
  std::string finalEffName{m_histNamePrefix};
  finalEffName += effName;
  finalEffName += m_histNamePostfix;
  effRef.SetTitle((m_histTitlePrefix + effTitle + m_histTitlePostfix).c_str());
  effRef.SetName(finalEffName.c_str());
 
  const hash_t effHash = this->hash(effName);
  EffMap_t::const_iterator it = m_effMap.find(effHash);
  if (it != m_effMap.end()) {
    m_msg << MSG::WARNING
          << "Detected a hash collision. The hash for the TEfficiency with name=" << effName
          << " already exists and points to a TEfficiency with name=" << it->second->GetName()
          << " NOT going to book the new TEfficiency and returning a NULL pointer!" << endmsg;
    return nullptr;
  }
 
  if (!histSvc()->regEfficiency(bookingString, &effRef).isSuccess()) {
    m_msg << MSG::WARNING
          << "Problem registering TEfficiency with name " << effName
          << ", name prefix " << m_histNamePrefix
          << ", title " << effTitle
          << ", title prefix " << m_histTitlePrefix
          << ", and title postfix " << m_histTitlePostfix
          << " in " << m_name << "!" << endmsg;
    return nullptr;
  }
 
  m_effMap.insert(m_effMap.end(), std::pair<const hash_t, TEfficiency*>(effHash, &effRef));
 
  return &effRef;
}

bookGetPointer() [6/8]

TEfficiency * AthHistogramming::bookGetPointer ( TEfficiency * eff, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of TEfficiency.

Definition at line 287 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TEfficiency in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}

bookGetPointer() [7/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 & histRef, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 97 of file AthHistogramming.cxx.

                                                                                          {
  
  const std::string originalName{histRef.GetName()};
  const auto histName = splitName(originalName).second;
  
  const std::string histTitle(histRef.GetTitle());
  std::string bookingString = buildBookingString(originalName, tDir, stream);
 
  std::string finalHistName{m_histNamePrefix};
  finalHistName += histName;
  finalHistName += m_histNamePostfix;
 
  histRef.SetTitle((m_histTitlePrefix + histTitle + m_histTitlePostfix).c_str());
  histRef.SetName(finalHistName.c_str());
 
  const hash_t histHash = this->hash(histName);
  HistMap_t::const_iterator it = m_histMap.find(histHash);
  if (it != m_histMap.end()) {
    m_msg << MSG::WARNING
          << "Detected a hash collision. The hash for the histogram with name=" << histName
          << " already exists and points to a histogram with name=" << it->second->GetName()
          << " NOT going to book the new histogram and returning a NULL pointer!" << endmsg;
    return nullptr;
  }
 
  if (!histSvc()->regHist(bookingString, &histRef).isSuccess()) {
    m_msg << MSG::WARNING
          << "Problem registering histogram with name " << histName
          << ", name prefix " << m_histNamePrefix
          << ", title " << histTitle
          << ", title prefix " << m_histTitlePrefix
          << ", and title postfix " << m_histTitlePostfix
          << " in " << m_name << "!" << endmsg;
    return nullptr;
  }
 
  m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, &histRef));
 
  return &histRef;
}

bookGetPointer() [8/8]

TH1 * AthHistogramming::bookGetPointer ( TH1 * hist, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the booking and registering (into THistSvc) of histograms.

Definition at line 266 of file AthHistogramming.h.

{
  if ( !hist ) {
    m_msg << MSG::ERROR << "Got a zero pointer to a TH1 in bookGetPointer" << endmsg;
    return 0;
  }
  return this->bookGetPointer( *hist, tDir, stream );
}

buildBookingString()

std::string AthHistogramming::buildBookingString ( std::string_view histName, std::string_view tDir, std::string_view stream, bool usePrefixPostfix = false ) const

private

Method to build individual booking string.

Definition at line 500 of file AthHistogramming.cxx.

                                                     {
  if (tDir.empty()) {
    tDir = m_rootDir;
  }
  if (stream.empty()) {
    stream = m_streamName;
  }
  const auto [histDir, baseName] = splitName(histName);
  std::string bookingString{"/"};
  bookingString += stream;
  bookingString += '/';
  bookingString += tDir;
  if (!histDir.empty()) {
    bookingString += '/';
    bookingString += histDir;
  }
  bookingString += '/';
  if (usePrefixPostfix) {
    bookingString += m_histNamePrefix;
  }
  bookingString += baseName;
  if (usePrefixPostfix) {
    bookingString += m_histNamePostfix;
  }
  const auto tail = std::ranges::unique(
    bookingString, [](char lhs, char rhs) { return lhs == '/' && rhs == '/'; });
  bookingString.erase(tail.begin(), tail.end());
  return bookingString;
}

configAthHistogramming()

StatusCode AthHistogramming::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 )

protected

To be called to fill the internal configuration.

Definition at line 64 of file AthHistogramming.cxx.

{
  m_histSvc          = histSvc;
  m_streamName       = prefix;
  m_rootDir          = rootDir;
  m_histNamePrefix   = histNamePrefix;
  m_histNamePostfix  = histNamePostfix;
  m_histTitlePrefix  = histTitlePrefix;
  m_histTitlePostfix = histTitlePostfix;
 
  return StatusCode::SUCCESS;
}

efficiency()

TEfficiency * AthHistogramming::efficiency ( std::string_view effName, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the retrieval of registered TEfficiency.

Definition at line 214 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t effHash = this->hash(effName);
 
  // See if this entry exists in the map
  EffMap_t::const_iterator it = m_effMap.find( effHash );
  if ( it == m_effMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TEfficiency...
      // Massage the final string to book things
      std::string bookingString = buildBookingString(effName, tDir, stream ,false);
 
      TEfficiency* effPointer{};
      if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
        {
          // Book things
          std::string bookingString = buildBookingString( effName, tDir, stream, true );
 
          if ( !((histSvc()->getEfficiency(bookingString, effPointer)).isSuccess()) )
            {
              m_msg << MSG::WARNING
                    << "Problem retrieving the TEfficiency with name (including pre- and post-fixes) "
                    << bookingString
                    << " or with name " << effName
                    << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                    << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
              return NULL;
            }
          // If we get to here, we actually found the TEfficiency in the THistSvc.
          // So let's add it to the local cache map and return its pointer
          m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
          return effPointer;
        }
      // If we get to here, we actually found the TEfficiency in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_effMap.insert( m_effMap.end(), std::pair< const hash_t, TEfficiency* >( effHash, effPointer ) );
      return effPointer;
    }
 
  // Return the pointer to the TEfficiency that we got from the local cache map
  return it->second;
}

graph()

TGraph * AthHistogramming::graph ( std::string_view graphName, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the retrieval of registered TGraphs.

Definition at line 438 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t graphHash = this->hash(graphName);
 
  // See if this entry exists in the map
  GraphMap_t::const_iterator it = m_graphMap.find( graphHash );
  if ( it == m_graphMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TGraph...
 
      // Massage the final string to book things
      std::string bookingString = buildBookingString( graphName, tDir, stream, false);
 
      TGraph* graphPointer(nullptr);
      if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
        {
          // Massage the final string to book things
          std::string bookingString = buildBookingString( graphName, tDir, stream, true );
 
          if ( !((histSvc()->getGraph(bookingString, graphPointer)).isSuccess()) )
            {
              m_msg << MSG::WARNING
                    << "Problem retrieving the TGraph with name (including pre- and post-fixes) "
                    << bookingString
                    << " or with name " << graphName
                    << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                    << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
              return nullptr;
            }
          // If we get to here, we actually found the TGraph in the THistSvc.
          // So let's add it to the local cache map and return its pointer
          m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
          return graphPointer;
        }
      // If we get to here, we actually found the TGraph in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_graphMap.insert( m_graphMap.end(), std::pair< const hash_t, TGraph* >( graphHash, graphPointer ) );
      return graphPointer;
    }
 
 
  // Return the pointer to the TGraph that we got from the local cache map
  return it->second;
}

hash()

AthHistogramming::hash_t AthHistogramming::hash ( std::string_view histName ) const

inlineprivate

Method to calculate a 32-bit hash from a string.

Definition at line 422 of file AthHistogramming.h.

{
  const uint64_t hash64 = CxxUtils::crc64( std::string{histName} );
  return (hash_t)(hash64 & 0xFFFFFFFF);
}

hist()

TH1 * AthHistogramming::hist ( std::string_view histName, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the retrieval of registered histograms of any type.

Definition at line 182 of file AthHistogramming.cxx.

                       {
 
  const auto histBaseName = splitName(histName).second;
  std::string bookingString = buildBookingString(histName, tDir, stream, false);
 
  const hash_t histHash = this->hash(histBaseName);
 
  HistMap_t::const_iterator it = m_histMap.find(histHash);
  if (it == m_histMap.end()) {
    TH1* histPointer(nullptr);
 
    if (!histSvc()->getHist(bookingString, histPointer).isSuccess()) {
      std::string prefixedBookingString = buildBookingString(histName, tDir, stream, true);
      if (!histSvc()->getHist(prefixedBookingString, histPointer).isSuccess()) {
        m_msg << MSG::WARNING
              << "Problem retrieving the histogram with name (including pre- and post-fixes) "
              << prefixedBookingString
              << " or with name " << histName
              << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
              << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
        return nullptr;
      }
    }
 
    m_histMap.insert(m_histMap.end(), std::pair<const hash_t, TH1*>(histHash, histPointer));
    return histPointer;
  }
 
  return it->second;
}

hist2d()

TH2 * AthHistogramming::hist2d ( std::string_view histName, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the retrieval of registered 2-d histograms.

Definition at line 363 of file AthHistogramming.h.

{
  // 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 );
}

hist3d()

TH3 * AthHistogramming::hist3d ( std::string_view histName, std::string_view tDir = "", std::string_view stream = "" )

inlineprotected

Simplify the retrieval of registered 3-d histograms.

Definition at line 380 of file AthHistogramming.h.

{
  // 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 );
}

histSvc()

const ServiceHandle< ITHistSvc > & AthHistogramming::histSvc ( ) const

inline

The standard THistSvc (for writing histograms and TTrees and more to a root file) Returns (kind of) a pointer to the THistSvc.

Definition at line 415 of file AthHistogramming.h.

{
  return m_histSvc;
}

tree()

TTree * AthHistogramming::tree ( std::string_view treeName, std::string_view tDir = "", std::string_view stream = "" )

protected

Simplify the retrieval of registered TTrees.

Definition at line 333 of file AthHistogramming.cxx.

{
  // Build a 32 bit hash out of the name
  const hash_t treeHash = this->hash(treeName);
  // See if this entry exists in the map
  TreeMap_t::const_iterator it = m_treeMap.find( treeHash );
  if ( it == m_treeMap.end() ) // It doesn't exist!
    { // Let's see into the THistSvc if somebody else has registered the TTree...
      // Massage the final string to book things
      std::string bookingString = buildBookingString( treeName, tDir, stream);
 
      TTree* treePointer(NULL);
      if ( !((histSvc()->getTree(bookingString, treePointer)).isSuccess()) )
        {
          m_msg << MSG::WARNING
                << "Problem retrieving the TTree with name " << treeName
                << " in " << m_name << "... it doesn't exist, neither in the cached map nor in the THistSvc!"
                << " Will return an NULL pointer... you have to handle it correctly!" << endmsg;
          return NULL;
        }
      // If we get to here, we actually found the TTree in the THistSvc.
      // So let's add it to the local cache map and return its pointer
      m_treeMap.insert( m_treeMap.end(), std::pair< const hash_t, TTree* >( treeHash, treePointer ) );
      return treePointer;
    }
 
  // Return the pointer to the TTree that we got from the local cache map
  return it->second;
}

Member Data Documentation

m_effMap

EffMap_t AthHistogramming::m_effMap

private

The map of histogram names to their pointers.

Definition at line 202 of file AthHistogramming.h.

m_graphMap

GraphMap_t AthHistogramming::m_graphMap

private

The map of TGraph names to their pointers.

Definition at line 216 of file AthHistogramming.h.

m_histMap

HistMap_t AthHistogramming::m_histMap

private

The map of histogram names to their pointers.

Definition at line 195 of file AthHistogramming.h.

m_histNamePostfix

std::string AthHistogramming::m_histNamePostfix

private

The postfix for the histogram THx name.

Definition at line 229 of file AthHistogramming.h.

m_histNamePrefix

std::string AthHistogramming::m_histNamePrefix

private

The prefix for the histogram THx name.

Definition at line 226 of file AthHistogramming.h.

m_histSvc

ServiceHandle<ITHistSvc> AthHistogramming::m_histSvc

private

Pointer to the THistSvc (event store by default).

Definition at line 188 of file AthHistogramming.h.

m_histTitlePostfix

std::string AthHistogramming::m_histTitlePostfix

private

The postfix for the histogram THx title.

Definition at line 235 of file AthHistogramming.h.

m_histTitlePrefix

std::string AthHistogramming::m_histTitlePrefix

private

The prefix for the histogram THx title.

Definition at line 232 of file AthHistogramming.h.

m_msg

MsgStream AthHistogramming::m_msg

private

Cached Message Stream.

Definition at line 242 of file AthHistogramming.h.

m_name

std::string AthHistogramming::m_name

private

Instance name.

Definition at line 239 of file AthHistogramming.h.

m_rootDir

std::string AthHistogramming::m_rootDir

private

Name of the ROOT directory.

Definition at line 223 of file AthHistogramming.h.

m_streamName

std::string AthHistogramming::m_streamName

private

Name of the ROOT output stream (file).

Definition at line 220 of file AthHistogramming.h.

m_treeMap

TreeMap_t AthHistogramming::m_treeMap

private

The map of TTree names to their pointers.

Definition at line 209 of file AthHistogramming.h.

---

The documentation for this class was generated from the following files:

• AthHistogramming.h
• AthHistogramming.cxx