d7/df0/_gaudi_histos_8h_source.html

 /***********************************************************************************\
 * (c) Copyright 1998-2019 CERN for the benefit of the LHCb and ATLAS collaborations *
 *                                                                                   *
 * This software is distributed under the terms of the Apache version 2 licence,     *
 * copied verbatim in the file "LICENSE".                                            *
 *                                                                                   *
 * In applying this licence, CERN does not waive the privileges and immunities       *
 * granted to it by virtue of its status as an Intergovernmental Organization        *
 * or submit itself to any jurisdiction.                                             *
 \***********************************************************************************/
 #ifndef GAUDIALG_GAUDIHISTOS_H
 #define GAUDIALG_GAUDIHISTOS_H 1
 // ============================================================================
 /* @file GaudiHistos.h
  *
  *  Header file for class : GaudiHistos
  *
  *  @author Chris Jones   Christopher.Rob.Jones@cern.ch
  *  @author Vanya BELYAEV Ivan.Belyaev@itep.ru
  *  @date   2005-08-08
  */
 // ============================================================================
 // Include files#
 // ============================================================================
 // STD& STL
 // ============================================================================
 #include <boost/algorithm/string/replace.hpp>
 #include <limits>
 #include <type_traits>
 #include <vector>
 // ============================================================================
 // GaudiUtils
 // ============================================================================
 #include "GaudiUtils/HistoTableFormat.h"
 // ============================================================================
 // GaudiAlg
 // ============================================================================
 #include "GaudiAlg/GaudiAlgorithm.h"
 #include "GaudiAlg/GaudiTool.h"
 #include "GaudiAlg/Maps.h"
 // ============================================================================
 // GaudiKernel
 // ============================================================================
 #include "GaudiKernel/HistoProperty.h"
 // ============================================================================
 // Forward declarations
 namespace AIDA {
   class IHistogram1D;
   class IHistogram2D;
   class IHistogram3D;
   class IProfile1D;
   class IProfile2D;
 } // namespace AIDA
 // ============================================================================
 template <class PBASE>
 class GAUDI_API GaudiHistos : public PBASE {
 public:
   // ==========================================================================
   typedef GaudiAlg::HistoID HistoID;
   // ==========================================================================
   typedef GaudiAlg::Histo1DMapID Histo1DMapID;
   typedef GaudiAlg::Histo1DMapTitle Histo1DMapTitle;
   // ==========================================================================
   typedef GaudiAlg::Histo2DMapID Histo2DMapID;
   typedef GaudiAlg::Histo2DMapTitle Histo2DMapTitle;
   // ==========================================================================
   typedef GaudiAlg::Histo3DMapID Histo3DMapID;
   typedef GaudiAlg::Histo3DMapTitle Histo3DMapTitle;
   // ==========================================================================
   typedef GaudiAlg::Profile1DMapID Profile1DMapID;
   typedef GaudiAlg::Profile1DMapTitle Profile1DMapTitle;
   // ==========================================================================
   typedef GaudiAlg::Profile2DMapID Profile2DMapID;
   typedef GaudiAlg::Profile2DMapTitle Profile2DMapTitle;
   // ==========================================================================
   typedef GaudiAlg::HistoBinEdges HistoBinEdges;
   // ==========================================================================
 public:
   // ==========================================================================
   // ================================= 1D Histograms ==========================
   // ================================= Fixed Binning ==========================
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const std::string& title, const double low, const double high,
                               const unsigned long bins = 100, const double weight = 1.0 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* plot( const double value, const std::string& title, const double low, const double high,
                                    const unsigned long bins = 100, const double weight = 1.0 ) const {
     return plot1D( value, title, low, high, bins, weight );
   }
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const Gaudi::Histo1DDef& hdef, const double weight = 1.0 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* plot( const double value, const Gaudi::Histo1DDef& hdef,
                                    const double weight = 1.0 ) const {
     return plot1D( value, hdef, weight );
   }
   // ==========================================================================
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const HistoID& ID, const std::string& title, const double low,
                               const double high, const unsigned long bins = 100, const double weight = 1.0 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* plot( const double value, const HistoID& ID, const std::string& title, const double low,
                                    const double high, const unsigned long bins = 100,
                                    const double weight = 1.0 ) const {
     return plot1D( value, ID, title, low, high, bins, weight );
   }
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const HistoID& ID, const Gaudi::Histo1DDef& hdef,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* plot( const double value, const HistoID& ID, const Gaudi::Histo1DDef& hdef,
                                    const double weight = 1.0 ) const {
     return plot1D( value, ID, hdef, weight );
   }
   template <class FUNCTION, class OBJECT>
   inline AIDA::IHistogram1D* plot( const FUNCTION& func, OBJECT first, OBJECT last, const std::string& title,
                                    const double low, const double high, const unsigned long bins = 100 ) const {
     AIDA::IHistogram1D* h = nullptr;
     if ( produceHistos() ) {
       // retrieve or book the histogram
       h = histo1D( title );
       if ( !h ) { h = book1D( title, low, high, bins ); }
       // fill histogram
       while ( first != last && h ) {
         h = fill( h, func( *first ), 1.0, title );
         ++first;
       }
     }
     return h;
   }
   // ==========================================================================
   template <class FUNCTION, class OBJECT>
   inline AIDA::IHistogram1D* plot( const FUNCTION& func, OBJECT first, OBJECT last, const HistoID& ID,
                                    const std::string& title, const double low, const double high,
                                    const unsigned long bins = 100 ) const {
     AIDA::IHistogram1D* h( 0 );
     if ( produceHistos() ) {
       // retrieve or book the histogram
       h = histo1D( ID );
       if ( !h ) { h = book1D( ID, title, low, high, bins ); }
       // fill histogram
       while ( first != last && h ) {
         h = fill( h, func( *first ), 1.0, title );
         ++first;
       }
     }
     return h;
   }
   // ==========================================================================
   template <class FUNCTION, class OBJECT, class WEIGHT>
   inline AIDA::IHistogram1D* plot( const FUNCTION& func, OBJECT first, OBJECT last, const std::string& title,
                                    const double low, const double high, const unsigned long bins,
                                    const WEIGHT& weight ) const {
     AIDA::IHistogram1D* h = nullptr;
     if ( produceHistos() ) {
       // retrieve or book the histogram
       h = histo1D( title );
       if ( !h ) { h = book1D( title, low, high, bins ); }
       // fill histogram
       while ( first != last && h ) {
         h = fill( h, func( *first ), weight( *first ), title );
         ++first;
       }
     }
     return h;
   }
   // ==========================================================================
   template <class FUNCTION, class OBJECT, class WEIGHT>
   inline AIDA::IHistogram1D* plot( const FUNCTION& func, OBJECT first, OBJECT last, const HistoID& ID,
                                    const std::string& title, const double low, const double high,
                                    const unsigned long bins, const WEIGHT& weight ) const {
     AIDA::IHistogram1D* h = nullptr;
     if ( produceHistos() ) {
       // retrieve or book the histogram
       h = histo1D( ID );
       if ( !h ) { h = book1D( ID, title, low, high, bins ); }
       // fill histogram
       while ( first != last && h ) {
         h = fill( h, func( *first ), weight( *first ), title );
         ++first;
       }
     }
     return h;
   }
   // ==========================================================================
   // ================================= 1D Histograms ==========================
   // =============================== Variable Binning =========================
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const std::string& title, const HistoBinEdges& edges,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   // ==========================================================================
   AIDA::IHistogram1D* plot1D( const double value, const HistoID& ID, const std::string& title,
                               const HistoBinEdges& edges, const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 2D Histograms ==========================
   // ==========================================================================
   AIDA::IHistogram2D* plot2D( const double valueX, const double valueY, const std::string& title, const double lowX,
                               const double highX, const double lowY, const double highY, const unsigned long binsX = 50,
                               const unsigned long binsY = 50, const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IHistogram2D* plot2D( const double valueX, const double valueY, const HistoID& ID, const std::string& title,
                               const double lowX, const double highX, const double lowY, const double highY,
                               const unsigned long binsX = 50, const unsigned long binsY = 50,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 2D Histograms ==========================
   // =============================== Variable Binning =========================
   // ==========================================================================
   AIDA::IHistogram2D* plot2D( const double valueX, const double valueY, const std::string& title,
                               const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IHistogram2D* plot2D( const double valueX, const double valueY, const HistoID& ID, const std::string& title,
                               const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 3D Histograms ==========================
   // ==========================================================================
   AIDA::IHistogram3D* plot3D( const double valueX, const double valueY, const double valueZ, const std::string& title,
                               const double lowX, const double highX, const double lowY, const double highY,
                               const double lowZ, const double highZ, const unsigned long binsX = 10,
                               const unsigned long binsY = 10, const unsigned long binsZ = 10,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IHistogram3D* plot3D( const double valueX, const double valueY, const double valueZ, const HistoID& ID,
                               const std::string& title, const double lowX, const double highX, const double lowY,
                               const double highY, const double lowZ, const double highZ, const unsigned long binsX = 10,
                               const unsigned long binsY = 10, const unsigned long binsZ = 10,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 3D Histograms ==========================
   // =============================== Variable Binning =========================
   // ==========================================================================
   AIDA::IHistogram3D* plot3D( const double valueX, const double valueY, const double valueZ, const std::string& title,
                               const HistoBinEdges& edgesX, const HistoBinEdges& edgesY, const HistoBinEdges& edgesZ,
                               const double weight = 1.0 ) const;
   // ==========================================================================
   // ==========================================================================
   AIDA::IHistogram3D* plot3D( const double valueX, const double valueY, const double valueZ, const HistoID& ID,
                               const std::string& title, const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                               const HistoBinEdges& edgesZ, const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 1D Profile =============================
   // ================================= Fixed binning ==========================
   // ==========================================================================
   AIDA::IProfile1D* profile1D( const double valueX, const double valueY, const std::string& title, const double lowX,
                                const double highX, const unsigned long binsX = 100, const std::string& opt = "",
                                const double lowY   = -std::numeric_limits<double>::max(),
                                const double highY  = std::numeric_limits<double>::max(),
                                const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IProfile1D* profile1D( const double valueX, const double valueY, const HistoID& ID, const std::string& title,
                                const double lowX, const double highX, const unsigned long binsX = 100,
                                const std::string& opt = "", const double lowY = -std::numeric_limits<double>::max(),
                                const double highY  = std::numeric_limits<double>::max(),
                                const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 1D Profile =============================
   // ============================== Variable binning ==========================
   // ==========================================================================
   AIDA::IProfile1D* profile1D( const double valueX, const double valueY, const std::string& title,
                                const HistoBinEdges& edges, const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IProfile1D* profile1D( const double valueX, const double valueY, const HistoID& ID, const std::string& title,
                                const HistoBinEdges& edges, const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 2D Profile =============================
   // ==========================================================================
   AIDA::IProfile2D* profile2D( const double valueX, const double valueY, const double valueZ, const std::string& title,
                                const double lowX, const double highX, const double lowY, const double highY,
                                const unsigned long binsX = 50, const unsigned long binsY = 50,
                                const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IProfile2D* profile2D( const double valueX, const double valueY, const double valueZ, const HistoID& ID,
                                const std::string& title, const double lowX, const double highX, const double lowY,
                                const double highY, const unsigned long binsX = 50, const unsigned long binsY = 50,
                                const double weight = 1.0 ) const;
   // ==========================================================================
   // ================================= 2D Profile =============================
   // ============================== Variable binning ==========================
   // ==========================================================================
   AIDA::IProfile2D* profile2D( const double valueX, const double valueY, const double valueZ, const std::string& title,
                                const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                                const double weight = 1.0 ) const;
   // ==========================================================================
   AIDA::IProfile2D* profile2D( const double valueX, const double valueY, const double valueZ, const HistoID& ID,
                                const std::string& title, const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                                const double weight = 1.0 ) const;
   // ==========================================================================

 public: // 1D Fixed
         // ==========================================================================
   AIDA::IHistogram1D* book1D( const std::string& title, const double low = 0, const double high = 100,
                               const unsigned long bins = 100 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* book( const std::string& title, const double low = 0, const double high = 100,
                                    const unsigned long bins = 100 ) const {
     return book1D( title, low, high, bins );
   }
   // ==========================================================================
   AIDA::IHistogram1D* book( const Gaudi::Histo1DDef& hdef ) const;
   // ==========================================================================
   AIDA::IHistogram1D* book1D( const HistoID& ID, const std::string& title, const double low = 0,
                               const double high = 100, const unsigned long bins = 100 ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* book( const HistoID& ID, const std::string& title, const double low = 0,
                                    const double high = 100, const unsigned long bins = 100 ) const {
     return book1D( ID, title, low, high, bins );
   }
   // ==========================================================================
   inline AIDA::IHistogram1D* book( const HistoID& ID, const Gaudi::Histo1DDef& hdef ) const;
   // ==========================================================================

 public: // 1D Variable
         // ==========================================================================
   AIDA::IHistogram1D* book1D( const std::string& title, const HistoBinEdges& edges ) const;
   // ==========================================================================
   AIDA::IHistogram1D* book1D( const HistoID& ID, const std::string& title, const HistoBinEdges& edges ) const;
   // ==========================================================================

 public: // 2D Fixed
         // ==========================================================================
   AIDA::IHistogram2D* book2D( const std::string& title, const double lowX = 0, const double highX = 100,
                               const unsigned long binsX = 50, const double lowY = 0, const double highY = 100,
                               const unsigned long binsY = 50 ) const;
   // ==========================================================================
   AIDA::IHistogram2D* book2D( const HistoID& ID, const std::string& title, const double lowX = 0,
                               const double highX = 100, const unsigned long binsX = 50, const double lowY = 0,
                               const double highY = 100, const unsigned long binsY = 50 ) const;
   // ==========================================================================

 public: // 2D Variable
         // ==========================================================================
   AIDA::IHistogram2D* book2D( const std::string& title, const HistoBinEdges& edgesX,
                               const HistoBinEdges& edgesY ) const;
   // ==========================================================================
   AIDA::IHistogram2D* book2D( const HistoID& ID, const std::string& title, const HistoBinEdges& edgesX,
                               const HistoBinEdges& edgesY ) const;
   // ==========================================================================

 public: // 3D Fixed
         // ==========================================================================
   AIDA::IHistogram3D* book3D( const std::string& title, const double lowX = 0, const double highX = 100,
                               const unsigned long binsX = 10, const double lowY = 0, const double highY = 100,
                               const unsigned long binsY = 10, const double lowZ = 0, const double highZ = 100,
                               const unsigned long binsZ = 10 ) const;
   // ==========================================================================
   AIDA::IHistogram3D* book3D( const HistoID& ID, const std::string& title, const double lowX = 0,
                               const double highX = 100, const unsigned long binsX = 10, const double lowY = 0,
                               const double highY = 100, const unsigned long binsY = 10, const double lowZ = 0,
                               const double highZ = 100, const unsigned long binsZ = 10 ) const;
   // ==========================================================================

 public: // 3D Variable
         // ==========================================================================
   AIDA::IHistogram3D* book3D( const std::string& title, const HistoBinEdges& edgesX, const HistoBinEdges& edgesY,
                               const HistoBinEdges& edgesZ ) const;
   // ==========================================================================
   AIDA::IHistogram3D* book3D( const HistoID& ID, const std::string& title, const HistoBinEdges& edgesX,
                               const HistoBinEdges& edgesY, const HistoBinEdges& edgesZ ) const;
   // ==========================================================================

 public: // 1D Fixed Profiles
         // ==========================================================================
   AIDA::IProfile1D* bookProfile1D( const std::string& title, const double low = 0, const double high = 100,
                                    const unsigned long bins = 100, const std::string& opt = "",
                                    const double lowY  = -std::numeric_limits<double>::max(),
                                    const double highY = std::numeric_limits<double>::max() ) const;
   // ==========================================================================
   AIDA::IProfile1D* bookProfile1D( const HistoID& ID, const std::string& title, const double low = 0,
                                    const double high = 100, const unsigned long bins = 100, const std::string& opt = "",
                                    const double lowY  = -std::numeric_limits<double>::max(),
                                    const double highY = std::numeric_limits<double>::max() ) const;
   // ==========================================================================

 public: // 1D Variable Profiles
         // ==========================================================================
   AIDA::IProfile1D* bookProfile1D( const std::string& title, const HistoBinEdges& edges ) const;
   // ==========================================================================
   AIDA::IProfile1D* bookProfile1D( const HistoID& ID, const std::string& title, const HistoBinEdges& edges ) const;
   // ==========================================================================

 public: // 2D Profiles
         // ==========================================================================
   AIDA::IProfile2D* bookProfile2D( const std::string& title, const double lowX = 0, const double highX = 100,
                                    const unsigned long binsX = 50, const double lowY = 0, const double highY = 100,
                                    const unsigned long binsY = 50 ) const;
   // ==========================================================================
   AIDA::IProfile2D* bookProfile2D( const HistoID& ID, const std::string& title, const double lowX = 0,
                                    const double highX = 100, const unsigned long binsX = 50, const double lowY = 0,
                                    const double highY = 100, const unsigned long binsY = 50 ) const;
   // ==========================================================================

 public: // 2D Profiles
         // ==========================================================================
   AIDA::IProfile2D* bookProfile2D( const std::string& title, const HistoBinEdges& edgesX,
                                    const HistoBinEdges& edgesY ) const;
   // ==========================================================================
   AIDA::IProfile2D* bookProfile2D( const HistoID& ID, const std::string& title, const HistoBinEdges& edgesX,
                                    const HistoBinEdges& edgesY ) const;
   // ==========================================================================

 public:
   // ==========================================================================
   AIDA::IHistogram1D* fill( AIDA::IHistogram1D* histo, const double value, const double weight,
                             const std::string& title = "" ) const;
   // ==========================================================================
   AIDA::IHistogram2D* fill( AIDA::IHistogram2D* histo, const double valueX, const double valueY, const double weight,
                             const std::string& title = "" ) const;
   // ==========================================================================
   AIDA::IHistogram3D* fill( AIDA::IHistogram3D* histo, const double valueX, const double valueY, const double valueZ,
                             const double weight, const std::string& title = "" ) const;
   // ==========================================================================
   AIDA::IProfile1D* fill( AIDA::IProfile1D* histo, const double valueX, const double valueY, const double weight,
                           const std::string& title = "" ) const;
   // ==========================================================================
   AIDA::IProfile2D* fill( AIDA::IProfile2D* histo, const double valueX, const double valueY, const double valueZ,
                           const double weight, const std::string& title = "" ) const;
   // ==========================================================================
 public:
   // ==========================================================================
   inline AIDA::IHistogram1D* histo1D( const std::string& title ) const {
     auto found = histo1DMapTitle().find( title );
     return found != histo1DMapTitle().end() ? found->second : nullptr;
   }
   // ==========================================================================
   inline AIDA::IHistogram1D* histo( const std::string& title ) const { return histo1D( title ); }
   // ==========================================================================
   inline AIDA::IHistogram2D* histo2D( const std::string& title ) const {
     auto found = histo2DMapTitle().find( title );
     return histo2DMapTitle().end() != found ? found->second : nullptr;
   }
   // ==========================================================================
   inline AIDA::IHistogram3D* histo3D( const std::string& title ) const {
     auto found = histo3DMapTitle().find( title );
     return histo3DMapTitle().end() != found ? found->second : nullptr;
   }
   // ==========================================================================
   inline AIDA::IProfile1D* profile1D( const std::string& title ) const {
     auto found = profile1DMapTitle().find( title );
     return profile1DMapTitle().end() != found ? found->second : nullptr;
   }
   // ==========================================================================
   inline AIDA::IProfile2D* profile2D( const std::string& title ) const {
     auto found = profile2DMapTitle().find( title );
     return profile2DMapTitle().end() != found ? found->second : nullptr;
   }
   // ==========================================================================
 public:
   // ==========================================================================
   AIDA::IHistogram1D* histo1D( const HistoID& ID ) const;
   // ==========================================================================
   inline AIDA::IHistogram1D* histo( const HistoID& ID ) const { return histo1D( ID ); }
   // ==========================================================================
   AIDA::IHistogram2D* histo2D( const HistoID& ID ) const;
   // ==========================================================================
   AIDA::IHistogram3D* histo3D( const HistoID& ID ) const;
   // ==========================================================================
   AIDA::IProfile1D* profile1D( const HistoID& ID ) const;
   // ==========================================================================
   AIDA::IProfile2D* profile2D( const HistoID& ID ) const;
   // ==========================================================================
 public:
   // ==========================================================================
   inline bool histoExists( const std::string& title ) const {
     return ( 0 != histo( title ) || 0 != histo2D( title ) || 0 != histo3D( title ) || 0 != profile1D( title ) ||
              0 != profile2D( title ) );
   }
   // ==========================================================================
   inline bool histoExists( const HistoID& ID ) const {
     return ( 0 != histo( ID ) || 0 != histo2D( ID ) || 0 != histo3D( ID ) || 0 != profile1D( ID ) ||
              0 != profile2D( ID ) );
   }
   unsigned int totalNumberOfHistos() const;
   // ==========================================================================
 public: // trivial & non-trivial accessors
   // ==========================================================================
   inline bool produceHistos() const { return m_produceHistos; }
   inline bool fullDetail() const { return m_fullDetail; }
   inline bool checkForNaN() const { return m_checkForNaN; }
   inline bool splitHistoDir() const { return m_splitHistoDir; }
   inline HistoID::NumericID histoOffSet() const { return m_histoOffSet; }
   inline const std::string& histoTopDir() const { return m_histoTopDir; }
   inline const std::string& histoDir() const { return m_histoDir; }
   std::string histoPath() const;
   inline bool histosPrint() const { return m_histosPrint; }
   inline bool histoCountersPrint() const { return m_histoCountersPrint; }
   inline bool useNumericAutoIDs() const { return m_useNumericAutoIDs; }
   // ==========================================================================
   int printHistos( const MSG::Level level = MSG::ALWAYS ) const;
   // ==========================================================================
   const Histo1DMapTitle& histo1DMapTitle() const { return m_histo1DMapTitle; }
   // ==========================================================================
   const Histo1DMapID& histo1DMapID() const { return m_histo1DMapID; }
   // ==========================================================================
   const Histo2DMapTitle& histo2DMapTitle() const { return m_histo2DMapTitle; }
   // ==========================================================================
   const Histo2DMapID& histo2DMapID() const { return m_histo2DMapID; }
   // ==========================================================================
   const Histo3DMapTitle& histo3DMapTitle() const { return m_histo3DMapTitle; }
   // ==========================================================================
   const Histo3DMapID& histo3DMapID() const { return m_histo3DMapID; }
   // ==========================================================================
   const Profile1DMapTitle& profile1DMapTitle() const { return m_profile1DMapTitle; }
   // ==========================================================================
   const Profile1DMapID& profile1DMapID() const { return m_profile1DMapID; }
   // ==========================================================================
   const Profile2DMapTitle& profile2DMapTitle() const { return m_profile2DMapTitle; }
   // ==========================================================================
   const Profile2DMapID& profile2DMapID() const { return m_profile2DMapID; }
   // ==========================================================================
 public: // trivial setters
   // ==========================================================================
   inline void setProduceHistos( const bool val ) { m_produceHistos = val; }
   inline void setFullDetail( const bool val ) { m_fullDetail = val; }
   inline void setCheckForNaN( const bool val ) { m_checkForNaN = val; }
   inline void setSplitHistoDir( const bool val ) { m_splitHistoDir = val; }
   inline void setHistoOffSet( const HistoID::NumericID val ) { m_histoOffSet = val; }
   // ==========================================================================
   inline void setHistoTopDir( const std::string& val ) { m_histoTopDir = val; }
   // ==========================================================================
   inline void setHistoDir( const std::string& val ) { m_histoDir = val; }
   // ==========================================================================
 public:
   // FIXME: due to a bug in gcc7, the following two cannot be replaced with
   // using PBASE::PBASE...
   // ==========================================================================
   template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<Gaudi::Algorithm, PBASE>, U>>
   GaudiHistos( const std::string& name, ISvcLocator* pSvcLocator ) : PBASE( name, pSvcLocator ) {}
   // ==========================================================================
   template <typename U = PBASE, typename = std::enable_if_t<std::is_base_of_v<GaudiTool, PBASE>, U>>
   GaudiHistos( const std::string& type, const std::string& name, const IInterface* parent )
       : PBASE( type, name, parent ) {}
   // ==========================================================================
 protected:
   // ==========================================================================
   StatusCode initialize() override
 #ifdef __ICC
   {
     return i_ghInitialize();
   }
   StatusCode i_ghInitialize()
 #endif
       ;
   // ==========================================================================
   StatusCode finalize() override
 #ifdef __ICC
   {
     return i_ghFinalize();
   }
   StatusCode i_ghFinalize()
 #endif
       ;
   // ==========================================================================
 private:
   // ==========================================================================
   bool noHistos() const;
   // ===========================================unsigned===============================
   void monitorHisto( const AIDA::IBaseHistogram* hist, const HistoID& ID ) const;
   // ==========================================================================
   void newHistoID( const std::string& title, HistoID& ID ) const;
   // ==========================================================================
 protected:
   // ==========================================================================
   std::string convertTitleToID( std::string title ) const;
   // ==========================================================================
 private:
   Gaudi::Property<bool> m_produceHistos{this, "HistoProduce", true, "Switch on/off the production of histograms"};
   Gaudi::Property<bool> m_histosPrint{this, "HistoPrint", false,
                                       [this]( const auto& ) {
                                         // no action if not yet initialized
                                         if ( this->FSMState() >= Gaudi::StateMachine::INITIALIZED &&
                                              this->histosPrint() )
                                           this->printHistos( MSG::ALWAYS );
                                       },
                                       "Switch on/off the printout of histograms at finalization"};
   Gaudi::Property<bool> m_histoCountersPrint{this, "HistoCountersPrint", true,
                                              "Switch on/off the printout of histogram counters at finalization"};
   Gaudi::Property<bool> m_checkForNaN{this, "HistoCheckForNaN", true,
                                       "Switch on/off the checks for NaN and Infinity for histogram fill"};
   Gaudi::Property<bool> m_splitHistoDir{this, "HistoSplitDir", false,
                                         "Split long directory names into short pieces (suitable for HBOOK)"};
   Gaudi::Property<HistoID::NumericID> m_histoOffSet{
       this, "HistoOffSet", 0, "OffSet for automatically assigned histogram numerical identifiers "};
   Gaudi::Property<std::string> m_histoTopDir{this, "HistoTopDir", "",
                                              "Top level histogram directory (take care that it ends with '/')"};
   Gaudi::Property<std::string> m_histoDir{
       this, "HistoDir", boost::algorithm::replace_all_copy( this->name(), ":", "_" ), "Histogram Directory"};
   Gaudi::Property<bool>        m_fullDetail{this, "FullDetail", false};
   Gaudi::Property<bool>        m_declareMoniHists{this, "MonitorHistograms", true};
   Gaudi::Property<std::string> m_histo1DTableFormat{this, "FormatFor1DHistoTable",
                                                     Gaudi::Utils::Histos::Formats::format(),
                                                     "Format string for printout of 1D histograms"};
   Gaudi::Property<std::string> m_histo1DTableFormatShort{this, "ShortFormatFor1DHistoTable", " | %1$-25.25s %2%",
                                                          "Format string for printout of 1D histograms"};
   Gaudi::Property<std::string> m_histo1DTableHeader{this, "HeaderFor1DHistoTable",
                                                     Gaudi::Utils::Histos::Formats::header(),
                                                     "The table header for printout of 1D histograms "};
   Gaudi::Property<bool>        m_useNumericAutoIDs{
       this, "UseSequencialNumericAutoIDs", false,
       "Flag to allow users to switch back to the old style of creating numerical automatic IDs"};
   Gaudi::Property<std::map<std::string, std::string>> m_idReplaceInfo{
       this,
       "AutoStringIDPurgeMap",
       {{"/", "=SLASH="}},
       "Map of strings to search and replace when using the title "
       "as the basis of automatically generated literal IDs"};
   // ==========================================================================
   mutable Histo1DMapTitle m_histo1DMapTitle;
   mutable Histo1DMapID m_histo1DMapID;
   // ==========================================================================
   mutable Histo2DMapTitle m_histo2DMapTitle;
   mutable Histo2DMapID m_histo2DMapID;
   // ==========================================================================
   mutable Histo3DMapTitle m_histo3DMapTitle;
   mutable Histo3DMapID m_histo3DMapID;
   // ==========================================================================
   mutable Profile1DMapTitle m_profile1DMapTitle;
   mutable Profile1DMapID m_profile1DMapID;
   // ==========================================================================
   mutable Profile2DMapTitle m_profile2DMapTitle;
   mutable Profile2DMapID m_profile2DMapID;
   // ==========================================================================
 };
 // ============================================================================
 // The END
 // ============================================================================
 #endif // GAUDIALG_GAUDIHISTOS_H
GaudiHistos::setFullDetail
void setFullDetail(const bool val)
set flag to control output level of histograms
Definition: GaudiHistos.h:2667

GaudiHistos::histoTopDir
const std::string & histoTopDir() const
get top-level histogram directory (property "HistoTopDir")
Definition: GaudiHistos.h:2391

GaudiHistos::histo
AIDA::IHistogram1D * histo(const std::string &title) const
access the EXISTING 1D histogram by title
Definition: GaudiHistos.h:2292

Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:25

GaudiHistos::Histo3DMapID
GaudiAlg::Histo3DMapID Histo3DMapID
the actual type for (ID)->(3D histogram) mapping
Definition: GaudiHistos.h:82

GaudiHistos::histo2DMapTitle
const Histo2DMapTitle & histo2DMapTitle() const
get access to the map of all 2D histograms indexed via their title
Definition: GaudiHistos.h:2485

GaudiTool.h
Header file for class GaudiAlgorithm.

GaudiHistos::histo3DMapID
const Histo3DMapID & histo3DMapID() const
get access to the map of all 3D histograms index via a ID
Definition: GaudiHistos.h:2558

GaudiHistos::Histo1DMapTitle
GaudiAlg::Histo1DMapTitle Histo1DMapTitle
the actual type for title->(1D histogram) mapping
Definition: GaudiHistos.h:74

ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:35

GaudiHistos::histo3DMapTitle
const Histo3DMapTitle & histo3DMapTitle() const
get access to the map of all 3D histograms indexed via their title
Definition: GaudiHistos.h:2535

GaudiHistos::plot
AIDA::IHistogram1D * plot(const double value, const std::string &title, const double low, const double high, const unsigned long bins=100, const double weight=1.0) const
fill the 1D histogram (book on demand)
Definition: GaudiHistos.h:162

gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:52

Gaudi::Histos::book
GAUDI_API AIDA::IHistogram1D * book(IHistogramSvc *svc, const std::string &path, const Gaudi::Histo1DDef &hist)
helper function to book 1D-histogram
Definition: HistoDef.cpp:97

GaudiAlg::HistoBinEdges
std::vector< double > HistoBinEdges
Type for bin edges for variable binning histograms.
Definition: HistoID.h:41

GaudiHistos::m_profile1DMapID
Profile1DMapID m_profile1DMapID
the actual storage/access of 1D profile histograms by unique ID
Definition: GaudiHistos.h:2805

GaudiHistos::Profile1DMapTitle
GaudiAlg::Profile1DMapTitle Profile1DMapTitle
the actual type for title->(1D profile histogram) mapping
Definition: GaudiHistos.h:89

Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:370

GaudiHistos::profile2DMapID
const Profile2DMapID & profile2DMapID() const
get access to the map of 2D profile histograms index via a ID
Definition: GaudiHistos.h:2660

GaudiHistos::plot
AIDA::IHistogram1D * plot(const FUNCTION &func, OBJECT first, OBJECT last, const HistoID &ID, const std::string &title, const double low, const double high, const unsigned long bins, const WEIGHT &weight) const
book and fill the 1D histogram with forced ID and information from [first,last) sequence with given w...
Definition: GaudiHistos.h:645

Histos::HistoID
GaudiAlg::ID HistoID
The actual type for histogram identifier.
Definition: HistoID.h:32

GaudiHistos::HistoID
GaudiAlg::HistoID HistoID
the actual type for histogram identifier
Definition: GaudiHistos.h:69

GaudiHistos::profile1D
AIDA::IProfile1D * profile1D(const std::string &title) const
access the EXISTING 1D profile histogram by title return the pointer to existing 1D profile histogram...
Definition: GaudiHistos.h:2313

GaudiHistos::fullDetail
bool fullDetail() const
get flag to control output level of histograms
Definition: GaudiHistos.h:2383

GaudiAlgorithm.h
Header file for class GaudiAlgorithm.

GaudiHistos::m_histo1DMapID
Histo1DMapID m_histo1DMapID
the actual storage/access of 1D histograms by unique ID
Definition: GaudiHistos.h:2790

GaudiAlg::ID::NumericID
int NumericID
type for internal numeric ID
Definition: GaudiHistoID.h:57

HistoTableFormat.h

GaudiHistos::m_histo3DMapTitle
Histo3DMapTitle m_histo3DMapTitle
the actual storage/access of 3D histograms by unique title
Definition: GaudiHistos.h:2798

HistoProperty.h

Gaudi::Utils::Histos::fill
GAUDI_API void fill(AIDA::IHistogram1D *histo, const double value, const double weight=1.0)
simple function to fill AIDA::IHistogram1D objects
Definition: Fill.cpp:45

GaudiHistos::histoDir
const std::string & histoDir() const
get histogram directory (property "HistoDir")
Definition: GaudiHistos.h:2393

GaudiHistos::setHistoOffSet
void setHistoOffSet(const HistoID::NumericID val)
set a value for histogram offset (property "HistoOffSet"
Definition: GaudiHistos.h:2673

GaudiHistos::plot
AIDA::IHistogram1D * plot(const FUNCTION &func, OBJECT first, OBJECT last, const std::string &title, const double low, const double high, const unsigned long bins=100) const
fill the 1D histogram with information from [first,last) sequence
Definition: GaudiHistos.h:403

GaudiHistos::Histo3DMapTitle
GaudiAlg::Histo3DMapTitle Histo3DMapTitle
the actual type for title->(3D histogram) mapping
Definition: GaudiHistos.h:84

GaudiHistos::Profile2DMapID
GaudiAlg::Profile2DMapID Profile2DMapID
the actual type for (ID)->(2D profile histogram) mapping
Definition: GaudiHistos.h:92

GaudiHistos::Profile1DMapID
GaudiAlg::Profile1DMapID Profile1DMapID
the actual type for (ID)->(1D profile histogram) mapping
Definition: GaudiHistos.h:87

GaudiHistos::HistoBinEdges
GaudiAlg::HistoBinEdges HistoBinEdges
Edges for variable binning.
Definition: GaudiHistos.h:97

GaudiHistos::m_histo2DMapTitle
Histo2DMapTitle m_histo2DMapTitle
the actual storage/access of 2D histograms by unique title
Definition: GaudiHistos.h:2793

Gaudi::Utils::Histos::Formats::header
GAUDI_API std::string header(const int ID=Default)
get the recommended header by enum
Definition: HistoTableFormat.cpp:197

AIDA
GaudiKernel.
Definition: Fill.h:20

GaudiHistos::setProduceHistos
void setProduceHistos(const bool val)
set the flag for histogram production (property "HistoProduce")
Definition: GaudiHistos.h:2665

GaudiHistos::profile1DMapID
const Profile1DMapID & profile1DMapID() const
get access to the map of 1D profile histograms index via a ID
Definition: GaudiHistos.h:2610

GaudiHistos::Profile2DMapTitle
GaudiAlg::Profile2DMapTitle Profile2DMapTitle
the actual type for title->(2D profile histogram) mapping
Definition: GaudiHistos.h:94

std::string
STL class.

GaudiHistos::setCheckForNaN
void setCheckForNaN(const bool val)
set the flag for NaN checks (property "HistoCheckForNan")
Definition: GaudiHistos.h:2669

GaudiHistos::histo
AIDA::IHistogram1D * histo(const HistoID &ID) const
access the EXISTING 1D histogram by ID
Definition: GaudiHistos.h:2340

GaudiHistos::histosPrint
bool histosPrint() const
print histograms at finalization ?
Definition: GaudiHistos.h:2397

GaudiHistos::plot
AIDA::IHistogram1D * plot(const FUNCTION &func, OBJECT first, OBJECT last, const std::string &title, const double low, const double high, const unsigned long bins, const WEIGHT &weight) const
book and fill the 1D histogram with information from [first,last) sequence with given weight
Definition: GaudiHistos.h:561

MSG::Level
Level
Definition: IMessageSvc.h:25

GaudiHistos::m_profile1DMapTitle
Profile1DMapTitle m_profile1DMapTitle
the actual storage/access of 1D profile histograms by unique title
Definition: GaudiHistos.h:2803

GaudiHistos::histoExists
bool histoExists(const std::string &title) const
check the existence AND validity of the histogram with given title
Definition: GaudiHistos.h:2365

GaudiHistos::plot
AIDA::IHistogram1D * plot(const double value, const HistoID &ID, const Gaudi::Histo1DDef &hdef, const double weight=1.0) const
fill the 1D histogram (book on demand)
Definition: GaudiHistos.h:335

GaudiHistos::histo1D
AIDA::IHistogram1D * histo1D(const std::string &title) const
access the EXISTING 1D histogram by title return the pointer to existing 1D histogram or NULL
Definition: GaudiHistos.h:2280

GaudiHistos::profile2D
AIDA::IProfile2D * profile2D(const std::string &title) const
access the EXISTING 2D profile histogram by title return the pointer to existing 2D profile histogram...
Definition: GaudiHistos.h:2321

GaudiPluginService.cpluginsvc.func
func
Definition: cpluginsvc.py:222

StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:61

IInterface
Definition of the basic interface.
Definition: IInterface.h:254

gaudirun.type
type
Definition: gaudirun.py:154

Gaudi::Utils::Histos::Formats::format
GAUDI_API std::string format(const int ID=Default)
get the format by enum
Definition: HistoTableFormat.cpp:164

GaudiHistos::plot
AIDA::IHistogram1D * plot(const double value, const HistoID &ID, const std::string &title, const double low, const double high, const unsigned long bins=100, const double weight=1.0) const
fill the 1D histogram with forced ID assignment (book on demand)
Definition: GaudiHistos.h:290

Gaudi::Histo1DDef
Simple helper class for description of 1D-histogram The class is targeted to act as the primary "hist...
Definition: HistoDef.h:41

GaudiHistos::GaudiHistos
GaudiHistos(const std::string &type, const std::string &name, const IInterface *parent)
Tool constructor - SFINAE-ed to insure this constructor is only defined if PBASE derives from GaudiTo...
Definition: GaudiHistos.h:2693

GaudiHistos::histoOffSet
HistoID::NumericID histoOffSet() const
get the value for histogram offset (property "HistoOffSet")
Definition: GaudiHistos.h:2389

GaudiHistos::Histo1DMapID
GaudiAlg::Histo1DMapID Histo1DMapID
the actual type for (ID)->(1D histogram) mapping
Definition: GaudiHistos.h:72

GaudiHistos::histoCountersPrint
bool histoCountersPrint() const
print histogram counters at finalization ?
Definition: GaudiHistos.h:2399

GaudiHistos::histo2D
AIDA::IHistogram2D * histo2D(const std::string &title) const
access the EXISTING 2D histogram by title return the pointer to existing 2D histogram or NULL
Definition: GaudiHistos.h:2297

GaudiHistos::m_profile2DMapID
Profile2DMapID m_profile2DMapID
the actual storage/access of 2D profile histograms by unique ID
Definition: GaudiHistos.h:2810

GaudiHistos::histoExists
bool histoExists(const HistoID &ID) const
check the existence AND validity of the histogram with given title
Definition: GaudiHistos.h:2371

GaudiHistos::plot
AIDA::IHistogram1D * plot(const FUNCTION &func, OBJECT first, OBJECT last, const HistoID &ID, const std::string &title, const double low, const double high, const unsigned long bins=100) const
fill the 1D histogram with forced ID and information from [first,last) sequence
Definition: GaudiHistos.h:475

GaudiHistos::Histo2DMapTitle
GaudiAlg::Histo2DMapTitle Histo2DMapTitle
the actual type for title->(2D histogram) mapping
Definition: GaudiHistos.h:79

Maps.h

GaudiHistos::setSplitHistoDir
void setSplitHistoDir(const bool val)
set the flag for histogram path split (property "HistoSplitDir")
Definition: GaudiHistos.h:2671

GaudiHistos::checkForNaN
bool checkForNaN() const
get the flag for NaN checks (property "HistoCheckForNan")
Definition: GaudiHistos.h:2385

std::vector< double >

GaudiHistos::GaudiHistos
GaudiHistos(const std::string &name, ISvcLocator *pSvcLocator)
Algorithm constructor - the SFINAE constraint below ensures that this is constructor is only defined ...
Definition: GaudiHistos.h:2688

GaudiHistos::profile1DMapTitle
const Profile1DMapTitle & profile1DMapTitle() const
get access to the map of all 1D profile histograms indexed via their title
Definition: GaudiHistos.h:2587

GaudiHistos::m_histo1DMapTitle
Histo1DMapTitle m_histo1DMapTitle
the actual storage/access of 1D histograms by unique title
Definition: GaudiHistos.h:2788

GaudiHistos::histo3D
AIDA::IHistogram3D * histo3D(const std::string &title) const
access the EXISTING 3D histogram by title return the pointer to existing 3D histogram or NULL
Definition: GaudiHistos.h:2305

GaudiHistos::m_profile2DMapTitle
Profile2DMapTitle m_profile2DMapTitle
the actual storage/access of 2D profile histograms by unique title
Definition: GaudiHistos.h:2808

GaudiHistos::book
AIDA::IHistogram1D * book(const std::string &title, const double low=0, const double high=100, const unsigned long bins=100) const
book the 1D histogram
Definition: GaudiHistos.h:1859

GaudiHistos::setHistoTopDir
void setHistoTopDir(const std::string &val)
set top-level histogram directory (property "HistoTopDir")
Definition: GaudiHistos.h:2676

GaudiHistos::Histo2DMapID
GaudiAlg::Histo2DMapID Histo2DMapID
the actual type for (ID)->(2D histogram) mapping
Definition: GaudiHistos.h:77

GaudiHistos::m_histo3DMapID
Histo3DMapID m_histo3DMapID
the actual storage/access of 3D histograms by unique ID
Definition: GaudiHistos.h:2800

GaudiHistos::plot
AIDA::IHistogram1D * plot(const double value, const Gaudi::Histo1DDef &hdef, const double weight=1.0) const
fill the 1D histogram (book on demand)
Definition: GaudiHistos.h:203

GaudiHistos::histo1DMapTitle
const Histo1DMapTitle & histo1DMapTitle() const
get access to the map of all 1D histograms indexed via their title
Definition: GaudiHistos.h:2434

GaudiHistos::splitHistoDir
bool splitHistoDir() const
get the flag for histogram path split (property "HistoSplitDir")
Definition: GaudiHistos.h:2387

GaudiUtils::HashMap
Common class providing an architecture-independent hash map.
Definition: HashMap.h:83

parent
const Gaudi::Algorithm & parent
Definition: HiveDataBroker.cpp:34

gaudirun.level
level
Definition: gaudirun.py:346

GaudiHistos::m_histo2DMapID
Histo2DMapID m_histo2DMapID
the actual storage/access of 2D histograms by unique ID
Definition: GaudiHistos.h:2795

GaudiHistos::histo1DMapID
const Histo1DMapID & histo1DMapID() const
get access to the map of all 1D histograms index via ID
Definition: GaudiHistos.h:2458

GaudiHistos::setHistoDir
void setHistoDir(const std::string &val)
set histogram directory (property "HistoDir")
Definition: GaudiHistos.h:2679

GaudiHistos
Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like cla...
Definition: GaudiHistos.h:65

GaudiHistos::profile2DMapTitle
const Profile2DMapTitle & profile2DMapTitle() const
get access to the map of all 2D profile histograms indexed via their title
Definition: GaudiHistos.h:2637

GaudiHistos::useNumericAutoIDs
bool useNumericAutoIDs() const
Use old style sequencial numerical automatically assigned IDs ?
Definition: GaudiHistos.h:2401

GaudiHistos::book
AIDA::IHistogram1D * book(const HistoID &ID, const std::string &title, const double low=0, const double high=100, const unsigned long bins=100) const
book the 1D histogram with forced ID
Definition: GaudiHistos.h:1900

GAUDI_API
#define GAUDI_API
Definition: Kernel.h:81

DataObject
A DataObject is the base class of any identifiable object on any data store.
Definition: DataObject.h:40

MSG::ALWAYS
Definition: IMessageSvc.h:25

GaudiAlg::ID
ID class for Histogram and Ntuples.
Definition: GaudiHistoID.h:53

GaudiHistos::produceHistos
bool produceHistos() const
get the flag for histogram production (property "HistoProduce")
Definition: GaudiHistos.h:2381

GaudiHistos::histo2DMapID
const Histo2DMapID & histo2DMapID() const
get access to the map of 2D histograms index via ID
Definition: GaudiHistos.h:2508

std::numeric_limits