| # Gaudi Framework, version v20r4
Generated: 8 Jan 2009

# GaudiHistos< PBASE > Class Template Reference

`#include <GaudiAlg/GaudiHistos.h>`

Collaboration diagram for GaudiHistos< PBASE >:

[legend]

List of all members.

## Detailed Description

### template<class PBASE>
class GaudiHistos< PBASE >

Templated base class providing common histogramming methods for GaudiAlgorithm and GaudiTool like classes.

Author:
  Chris Jones Christopher.Rob.Jones@cern.ch

  Vanya BELYAEV Ivan.Belyaev@itep.ru

Date:
  2005-08-08

Definition at line 50 of file GaudiHistos.h.

## Public Types
typedef GaudiAlg::HistoID | HistoID
| the actual type for histogram identifier
typedef GaudiAlg::Histo1DMapNumericID | Histo1DMapNumID
| the actual type for (Numeric ID)->(1D histogram) mapping
typedef GaudiAlg::Histo1DMapLiteralID | Histo1DMapLitID
| the actual type for (Literal ID)->(1D histogram) mapping
typedef GaudiAlg::Histo1DMapTitle | Histo1DMapTitle
| the actual type for title->(1D histogram) mapping
typedef GaudiAlg::Histo2DMapNumericID | Histo2DMapNumID
| the actual type for (Numeric ID)->(2D histogram) mapping
typedef GaudiAlg::Histo2DMapLiteralID | Histo2DMapLitID
| the actual type for (Literal ID)->(2D histogram) mapping
typedef GaudiAlg::Histo2DMapTitle | Histo2DMapTitle
| the actual type for title->(2D histogram) mapping
typedef GaudiAlg::Histo3DMapNumericID | Histo3DMapNumID
| the actual type for (Numeric ID)->(3D histogram) mapping
typedef GaudiAlg::Histo3DMapLiteralID | Histo3DMapLitID
| the actual type for (Literal ID)->(3D histogram) mapping
typedef GaudiAlg::Histo3DMapTitle | Histo3DMapTitle
| the actual type for title->(3D histogram) mapping
typedef GaudiAlg::Profile1DMapNumericID | Profile1DMapNumID
| the actual type for (Numeric ID)->(1D profile histogram) mapping
typedef GaudiAlg::Profile1DMapLiteralID | Profile1DMapLitID
| the actual type for (Literal ID)->(1D profile histogram) mapping
typedef GaudiAlg::Profile1DMapTitle | Profile1DMapTitle
| the actual type for title->(1D profile histogram) mapping
typedef GaudiAlg::Profile2DMapNumericID | Profile2DMapNumID
| the actual type for (Numeric ID)->(2D profile histogram) mapping
typedef GaudiAlg::Profile2DMapLiteralID | Profile2DMapLitID
| the actual type for (Literal ID)->(2D profile histogram) mapping
typedef GaudiAlg::Profile2DMapTitle | Profile2DMapTitle
| the actual type for title->(2D profile histogram) mapping
## Public Member Functions
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
| fill the 1D histogram (book on demand)
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)
AIDA::IHistogram1D * | plot (const double value, const Gaudi::Histo1DDef &hdef, const double weight=1.0) const
| fill the 1D histogram (book on demand)
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
| fill the 1D histogram with forced ID assignment (book on demand)
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)
AIDA::IHistogram1D * | plot (const double value, const HistoID &ID, const Gaudi::Histo1DDef &hdef, const double weight=1.0) const
| fill the 1D histogram with forced ID assignment (book on demand)
template<class FUNCTION, class OBJECT>
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
template<class FUNCTION, class OBJECT>
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
template<class FUNCTION, class OBJECT, class WEIGHT>
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
template<class FUNCTION, class OBJECT, class WEIGHT>
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 weight
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
| fill the 2D histogram (book on demand)
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
| fill the 2D histogram with forced ID assignment (book on demand)
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
| fill the 3D histogram (book on demand)
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
| fill the 3D histogram with forced ID assignment (book on demand)
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
| fill the 1D profile histogram (book on demand)
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
| fill the 1D profile histogram with forced ID assignment (book on demand)
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
| fill the 2D profile histogram (book on demand)
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
| fill the 2D profile histogram with forced ID assignment (book on demand)
AIDA::IHistogram1D * | book1D (const std::string &title, const double low=0, const double high=100, const unsigned long bins=100) const
| book the 1D histogram
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
AIDA::IHistogram1D * | book (const Gaudi::Histo1DDef &hdef) const
| book the 1D histogram
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
| book the 2D histogram
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
| book the 3D histogram
AIDA::IHistogram1D * | book1D (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
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
AIDA::IHistogram1D * | book (const HistoID &ID, const Gaudi::Histo1DDef &hdef) const
| book the 1D histogram with forced ID
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
| book the 2D histogram with forced ID
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
| book the 3D histogram with forced ID
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
| book the 1D profile histogram
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
| book the 1D profile histogram
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
| book the 2D profile histogram
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
| book the 2D profile histogram with forced ID
AIDA::IHistogram1D * | fill (AIDA::IHistogram1D *histo, const double value, const double weight, const std::string &title="") const
| fill the 1D histogram with the value and weight
AIDA::IHistogram2D * | fill (AIDA::IHistogram2D *histo, const double valueX, const double valueY, const double weight, const std::string &title="") const
| fill the 2D histogram with the value and weight
AIDA::IHistogram3D * | fill (AIDA::IHistogram3D *histo, const double valueX, const double valueY, const double valueZ, const double weight, const std::string &title="") const
| fill the 3D histogram with the value and weight
AIDA::IProfile1D * | fill (AIDA::IProfile1D *histo, const double valueX, const double valueY, const double weight, const std::string &title="") const
| fill the 1D profile histogram with the values and weight
AIDA::IProfile2D * | fill (AIDA::IProfile2D *histo, const double valueX, const double valueY, const double valueZ, const double weight, const std::string &title="") const
| fill the 2D profile histogram with the values and weight
AIDA::IHistogram1D * | histo1D (const std::string &title) const
| access the EXISTING 1D histogram by title return the pointer to existing 1D histogram or NULL
AIDA::IHistogram1D * | histo (const std::string &title) const
| access the EXISTING 1D histogram by title
AIDA::IHistogram2D * | histo2D (const std::string &title) const
| access the EXISTING 2D histogram by title return the pointer to existing 2D histogram or NULL
AIDA::IHistogram3D * | histo3D (const std::string &title) const
| access the EXISTING 3D histogram by title return the pointer to existing 3D histogram or NULL
AIDA::IProfile1D * | profile1D (const std::string &title) const
| access the EXISTING 1D profile histogram by title return the pointer to existing 1D profile histogram or NULL
AIDA::IProfile2D * | profile2D (const std::string &title) const
| access the EXISTING 2D profile histogram by title return the pointer to existing 2D profile histogram or NULL
AIDA::IHistogram1D * | histo1D (const HistoID &ID) const
| access the EXISTING 1D histogram by ID return the pointer to existing 1D histogram or NULL
AIDA::IHistogram1D * | histo (const HistoID &ID) const
| access the EXISTING 1D histogram by ID
AIDA::IHistogram2D * | histo2D (const HistoID &ID) const
| access the EXISTING 2D histogram by ID return the pointer to existing 2D histogram or NULL
AIDA::IHistogram3D * | histo3D (const HistoID &ID) const
| access the EXISTING 3D histogram by ID return the pointer to existing 3D histogram or NULL
AIDA::IProfile1D * | profile1D (const HistoID &ID) const
| access the EXISTING 1D profile histogram by ID return the pointer to existing 1D profile histogram or NULL
AIDA::IProfile2D * | profile2D (const HistoID &ID) const
| access the EXISTING 2D profile histogram by ID return the pointer to existing 2D profile histogram or NULL
bool | histoExists (const std::string &title) const
| check the existence AND validity of the histogram with given title
bool | histoExists (const HistoID &ID) const
| check the existence AND validity of the histogram with given title
unsigned int | totalNumberOfHistos () const
| Returns the total number of histograms (of all types) currently booked.
bool | produceHistos () const
| get the flag for histogram production (property "HistoProduce")
bool | fullDetail () const
| get flag to control output level of histograms
bool | checkForNaN () const
| get the flag for NaN checks (property "HistoCheckForNan")
bool | splitHistoDir () const
| get the flag for histogram path split (property "HistoSplitDir")
HistoID::NumericID | histoOffSet () const
| get the value for histogram offset (property "HistoOffSet")
const std::string & | histoTopDir () const
| get top-level histogram directory (property "HistoTopDir")
const std::string & | histoDir () const
| get histogram directory (property "HistoDir")
std::string | histoPath () const
| get the constructed histogram path
bool | histosPrint () const
| print histograms at finalization ?
bool | useNumericAutoIDs () const
| Use old style sequencial numerical automatically assigned IDs ?
int | printHistos (const MSG::Level level=MSG::ALWAYS) const
| perform the actual printout of histograms
const Histo1DMapTitle & | histo1DMapTitle () const
| get access to the map of all 1D histograms indexed via their title
const Histo1DMapNumID & | histo1DMapNumID () const
| get access to the map of 1D histograms index via a numeric ID
const Histo1DMapLitID & | histo1DMapLitID () const
| get access to the map of all 1D histograms index via a literal (string) ID
const Histo2DMapTitle & | histo2DMapTitle () const
| get access to the map of all 2D histograms indexed via their title
const Histo2DMapNumID & | histo2DMapNumID () const
| get access to the map of 2D histograms index via a numeric ID
const Histo2DMapLitID & | histo2DMapLitID () const
| get access to the map of all 2D histograms index via a literal (string) ID
const Histo3DMapTitle & | histo3DMapTitle () const
| get access to the map of all 3D histograms indexed via their title
const Histo3DMapNumID & | histo3DMapNumID () const
| get access to the map of 3D histograms index via a numeric ID
const Histo3DMapLitID & | histo3DMapLitID () const
| get access to the map of all 3D histograms index via a literal (string) ID
const Profile1DMapTitle & | profile1DMapTitle () const
| get access to the map of all 1D profile histograms indexed via their title
const Profile1DMapNumID & | profile1DMapNumID () const
| get access to the map of 1D profile histograms index via a numeric ID
const Profile1DMapLitID & | profile1DMapLitID () const
| get access to the map of 1D profile histograms index via a literal ID
const Profile2DMapTitle & | profile2DMapTitle () const
| get access to the map of all 2D profile histograms indexed via their title
const Profile2DMapNumID & | profile2DMapNumID () const
| get access to the map of 2D profile histograms index via a numeric ID
const Profile2DMapLitID & | profile2DMapLitID () const
| get access to the map of 2D profile histograms index via a literal ID
void | setProduceHistos (const bool val)
| set the flag for histogram production (property "HistoProduce")
void | setFullDetail (const bool val)
| set flag to control output level of histograms
void | setCheckForNaN (const bool val)
| set the flag for NaN checks (property "HistoCheckForNan")
void | setSplitHistoDir (const bool val)
| set the flag for histogram path split (property "HistoSplitDir")
void | setHistoOffSet (const HistoID::NumericID val)
| set a value for histogram offset (property "HistoOffSet"
void | setHistoTopDir (const std::string &val)
| set top-level histogram directory (property "HistoTopDir")
void | setHistoDir (const std::string &val)
| set histogram directory (property "HistoDir")
| GaudiHistos (const std::string &name, ISvcLocator *pSvcLocator)
| Algorithm constructor.
| GaudiHistos (const std::string &type, const std::string &name, const IInterface *parent)
| Tool constructor.
virtual | ~GaudiHistos ()
| Destructor.
## Protected Member Functions
virtual StatusCode | initialize ()
| standard initialization method
virtual StatusCode | finalize ()
| standard finalization method
std::string | convertTitleToID (const std::string &title) const
| Create an ID string from a title string.
## Private Member Functions
bool | noHistos () const
| Check if all histogram maps are empty.
void | initGaudiHistosConstructor ()
| Constructor initialisation and job options.
void | monitorHisto (const AIDA::IBaseHistogram *hist, const HistoID &ID) const
| Declare a histogram to the monitor service.
void | newHistoID (const std::string &title, HistoID &ID) const
| Create a new histogram ID using the given title.
void | stringSearchReplace (std::string &title, const std::string &A, const std::string &B) const
| Searches 'title' for all instancies of 'A' and replaces them with 'B'.
## Private Attributes
bool | m_produceHistos
| flag to SWITCH ON/SWITCH OFF the histogrm fillling and booking
bool | m_fullDetail
| flag to control output level of histograms
bool | m_checkForNaN
| flag to control check for Nan/Finite while filling the histogram
bool | m_splitHistoDir
| split histogram directory name (very useful for Hbook)
HistoID::NumericID | m_histoOffSet
| general histogram ID offset (only works for automatically assigned numeric IDs)
std::string | m_histoTopDir
| histogram top level directory
std::string | m_histoDir
| histogram directory
bool | m_histosPrint
| print histograms at finalization
bool | m_declareMoniHists
| Flag to turn on/off the registration of histograms to the Monitoring Service.
Histo1DMapTitle | m_histo1DMapTitle
| the actual storage/access of 1D histograms by unique title
Histo1DMapNumID | m_histo1DMapNumID
| the actual storage/access of 1D histograms by unique numeric ID
Histo1DMapLitID | m_histo1DMapLitID
| the actual storage/access of 1D histograms by unique literal ID
Histo2DMapTitle | m_histo2DMapTitle
| the actual storage/access of 2D histograms by unique title
Histo2DMapNumID | m_histo2DMapNumID
| the actual storage/access of 2D histograms by unique numeric ID
Histo2DMapLitID | m_histo2DMapLitID
| the actual storage/access of 2D histograms by unique literal ID
Histo3DMapTitle | m_histo3DMapTitle
| the actual storage/access of 3D histograms by unique title
Histo3DMapNumID | m_histo3DMapNumID
| the actual storage/access of 3D histograms by unique numeric ID
Histo3DMapLitID | m_histo3DMapLitID
| the actual storage/access of 3D histograms by unique literal ID
Profile1DMapTitle | m_profile1DMapTitle
| the actual storage/access of 1D profile histograms by unique title
Profile1DMapNumID | m_profile1DMapNumID
| the actual storage/access of 1D profile histograms by unique numeric ID
Profile1DMapLitID | m_profile1DMapLitID
| the actual storage/access of 1D profile histograms by unique literal ID
Profile2DMapTitle | m_profile2DMapTitle
| the actual storage/access of 2D profile histograms by unique title
Profile2DMapNumID | m_profile2DMapNumID
| the actual storage/access of 2D profile histograms by unique numeric ID
Profile2DMapLitID | m_profile2DMapLitID
| the actual storage/access of 2D profile histograms by unique literal ID
std::string | m_histo1DTableFormat
| format for printout of 1D-histograms as a table
std::string | m_histo1DTableFormatShort
| format for printout of 1D-histograms as a table
std::string | m_histo1DTableHeader
| the header for the table of 1-D historgrams
bool | m_useNumericAutoIDs
| Flag to switch back to the old style sequencial numerical automatic IDs.
std::map< std::string, std::string > | m_idReplaceInfo
| Map of strings to search and replace when using the title as the basis of automatically generated literal IDs.

## Member Typedef Documentation

template<class PBASE>

typedef GaudiAlg::HistoID GaudiHistos< PBASE >::HistoID

the actual type for histogram identifier

Reimplemented in HistoTool, GaudiTuples< GaudiHistoTool >, and GaudiTuples< GaudiHistoAlg >.

Definition at line 55 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo1DMapNumericID GaudiHistos< PBASE >::Histo1DMapNumID

the actual type for (Numeric ID)->(1D histogram) mapping

Definition at line 58 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo1DMapLiteralID GaudiHistos< PBASE >::Histo1DMapLitID

the actual type for (Literal ID)->(1D histogram) mapping

Definition at line 60 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo1DMapTitle GaudiHistos< PBASE >::Histo1DMapTitle

the actual type for title->(1D histogram) mapping

Definition at line 62 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo2DMapNumericID GaudiHistos< PBASE >::Histo2DMapNumID

the actual type for (Numeric ID)->(2D histogram) mapping

Definition at line 65 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo2DMapLiteralID GaudiHistos< PBASE >::Histo2DMapLitID

the actual type for (Literal ID)->(2D histogram) mapping

Definition at line 67 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo2DMapTitle GaudiHistos< PBASE >::Histo2DMapTitle

the actual type for title->(2D histogram) mapping

Definition at line 69 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo3DMapNumericID GaudiHistos< PBASE >::Histo3DMapNumID

the actual type for (Numeric ID)->(3D histogram) mapping

Definition at line 72 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo3DMapLiteralID GaudiHistos< PBASE >::Histo3DMapLitID

the actual type for (Literal ID)->(3D histogram) mapping

Definition at line 74 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Histo3DMapTitle GaudiHistos< PBASE >::Histo3DMapTitle

the actual type for title->(3D histogram) mapping

Definition at line 76 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile1DMapNumericID GaudiHistos< PBASE >::Profile1DMapNumID

the actual type for (Numeric ID)->(1D profile histogram) mapping

Definition at line 79 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile1DMapLiteralID GaudiHistos< PBASE >::Profile1DMapLitID

the actual type for (Literal ID)->(1D profile histogram) mapping

Definition at line 81 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile1DMapTitle GaudiHistos< PBASE >::Profile1DMapTitle

the actual type for title->(1D profile histogram) mapping

Definition at line 83 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile2DMapNumericID GaudiHistos< PBASE >::Profile2DMapNumID

the actual type for (Numeric ID)->(2D profile histogram) mapping

Definition at line 86 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile2DMapLiteralID GaudiHistos< PBASE >::Profile2DMapLitID

the actual type for (Literal ID)->(2D profile histogram) mapping

Definition at line 88 of file GaudiHistos.h.

template<class PBASE>

typedef GaudiAlg::Profile2DMapTitle GaudiHistos< PBASE >::Profile2DMapTitle

the actual type for title->(2D profile histogram) mapping

Definition at line 90 of file GaudiHistos.h.

## Constructor & Destructor Documentation

template<class PBASE>

GaudiHistos< PBASE >::GaudiHistos | ( | const std::string & | name,
|  | ISvcLocator * | pSvcLocator |
| ) |  |  |

Algorithm constructor.

template<class PBASE>

GaudiHistos< PBASE >::GaudiHistos | ( | const std::string & | type,
|  | const std::string & | name,
|  | const IInterface * | parent |
| ) |  |  |

Tool constructor.

template<class PBASE>

GaudiHistos< PBASE >::~GaudiHistos | ( |  | ) | `[inline, virtual]`

Destructor.

Definition at line 55 of file GaudiHistos.icpp.

    00055 {}

## Member Function Documentation

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::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]`

fill the 1D histogram (book on demand)

         const double mass = ... ;
         plot1D( mass , "Invariant Mass" , 2.5 , 3.5 , 100 )

This example illustrates the filling of the histogram titled `"InvariantMass"` with value `mass` .

If the histogram with given title does not exist yet it will be automatically booked with parameters `low` equal to 2.5, parameters `high` equal to 3.5 and `bins` equal to 100.

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

See also:
  AIDA::IHistogram1D

Parameters:

  | value | value to be filled
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | weight | weight

Returns:
  pointer to AIDA 1D histogram

Reimplemented in HistoTool.

Definition at line 1173 of file GaudiHistos.icpp.

    01179 {
    01180   AIDA::IHistogram1D * h(0);
    01181   if ( produceHistos() )
    01182   {
    01183     // retrieve or book the histogram
    01184     h = histo1D ( title ) ;
    01185     if ( 0 == h )     { h = book1D  ( title , low , high , bins ) ; }
    01186     // fill the histogram
    01187     h = fill ( h , value , weight , title );
    01188   }
    01189   return h;
    01190 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::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`[inline]`

fill the 1D histogram (book on demand)

Wrapper method for the equivalent plot1D method. Retained for backwards compatibility, please use plot1D instead.

Parameters:

  | value | value to be filled
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | weight | weight

Returns:
  pointer to AIDA 1D histogram

Definition at line 160 of file GaudiHistos.h.

    00166   {
    00167     return plot1D ( value, title, low, high, bins, weight );
    00168   }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::plot | ( | const double | value,
|  | const Gaudi::Histo1DDef & | hdef,
|  | const double | weight = `1.0` |
| ) |  |  | const`[inline]`

fill the 1D histogram (book on demand)

         const Gaudi::Histo1DDef& hdef = ... ;

         const double mass = ... ;
         plot ( mass , hdef ) ;

The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title.

The histogram descriptor comes e.g. from the component properties.

See also:
  AIDA::IHistogram1D

Parameters:

  | value | value to be filled
  | hdef | histogram descriptor
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | weight | weight

Returns:
  pointer to AIDA 1D histogram

Definition at line 1496 of file GaudiHistos.icpp.

    01499 {
    01500   return plot1D
    01501     ( value  ,
    01502       hdef.title() , hdef.lowEdge() , hdef.highEdge() , hdef.bins() ,
    01503       weight ) ;
    01504 }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::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]`

fill the 1D histogram with forced ID assignment (book on demand)

         const double mass = ... ;
         plot1D( mass , 15 , "Invariant Mass" , 2.5 , 3.5 , 100 )

This example illustrates the filling of the 1D histogram ID=15 titled `"Invariant Mass"` with value `mass` .

If the histogram with given ID does not exist yet it will be automatically booked with parameters `low` equal to 2.5, parameters `high` equal to 3.5 and `bins` equal to 100.

It is also possible to use literal IDs. For example :-

         const double mass = ... ;
         plot1D( mass , "mass" , "Invariant Mass" , 2.5 , 3.5 , 100 )

Will book the same histogram, using the id "mass".

It is also possible using literal IDs, to place histograms in sub-directories from the main histogram directory, using for example :-

         const double mass = ... ;
         plot1D( mass , "subdir/mass" , "Invariant Mass" , 2.5 , 3.5 , 100 )

Which will create the histogram "mass" in the sub-directory "subdir". Histograms can also be created in sub-directories with numeric IDs if IDs such as "subdir/1" are used.

Attention:
  If the histogram with given ID is already booked through automatic assignment of histogram ID, the error will not be detected. Therefore it is recommended to use non-trivial histogram ID offset (property "HistoOffSet") if one need to combine these techniques together. It is still desirable to use the unique histogram title to avoid a bad interference.

See also:
  AIDA::IHistogram1D

Parameters:

  | value | value to be filled
  | ID | histogram identifier
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | weight | weight

Returns:
  pointer to AIDA 1D histogram

Reimplemented in HistoTool.

Definition at line 1197 of file GaudiHistos.icpp.

    01204 {
    01205   AIDA::IHistogram1D* h(0);
    01206   if ( produceHistos() )
    01207   {
    01208     // retrieve or book the histogram
    01209     h = histo1D ( ID ) ;
    01210     if ( 0 == h ) {  h = book1D ( ID , title , low , high , bins ) ; }
    01211     // fill
    01212     h = fill ( h , value , weight , title ) ;
    01213   }
    01214   return h;
    01215 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::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`[inline]`

fill the 1D histogram with forced ID assignment (book on demand)

Wrapper method for the equivalent plot1D method. Retained for backwards compatibility, please use plot1D instead.

Parameters:

  | value | value to be filled
  | ID | histogram identifier
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | weight | weight

Returns:
  pointer to AIDA 1D histogram

Definition at line 291 of file GaudiHistos.h.

    00298   {
    00299     return plot1D ( value, ID, title, low, high, bins, weight );
    00300   }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::plot | ( | const double | value,
|  | const HistoID & | ID,
|  | const Gaudi::Histo1DDef & | hdef,
|  | const double | weight = `1.0` |
| ) |  |  | const`[inline]`

fill the 1D histogram with forced ID assignment (book on demand)

         // get the histogram descriptor
         const Gaudi::Histo1DDef& hdef = ... ;

         // get the histogram ID
         const HistoID ID = ... ;

         const double mass = ... ;
         plot ( mass , ID , hdef  )

See also:
  AIDA::IHistogram1D

The histogram descriptor comes e.g. from component properties

Parameters:

  | value | value to be filled
  | ID | histogram identifier
  | hdef | histogram descriptor

Returns:
  pointer to AIDA 1D histogram

Definition at line 1511 of file GaudiHistos.icpp.

    01515 {
    01516   return plot1D
    01517     ( value  , ID ,
    01518       hdef.title() , hdef.lowEdge() , hdef.highEdge() , hdef.bins() ,
    01519       weight ) ;
    01520 }

template<class PBASE>
template<class FUNCTION, class OBJECT>

AIDA::IHistogram1D* GaudiHistos< PBASE >::plot | ( | const FUNCTION & | func,
|  | OBJECT | first,
|  | OBJECT | last,
|  | const std::string & | title,
|  | const double | low,
|  | const double | high,
|  | const unsigned long | bins = `100` |
| ) |  |  | const`[inline]`

fill the 1D histogram with information from [first,last) sequence

      std::vector<double> v = ... ;

      plot( sin                 , // function
            v.begin() , v.end() , // sequence
            " bla-bla "         , // title
            -1. , 1.0           , // low and high limits
            100                 ) // number of bins

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

Sequence, objects and function can be non-trivial:

      Particles* p = ... ;

      plot( PT                  , // function
            p->begin()  , p->end() , // sequence
            " bla-bla "         , // title
            -1. , 1.0           , // low and high limits
            100                 ) ; // number of bins

where `PT` can be any function or function object for which the expression `PT(p)` , with `p` of type `Particle*` have some sense and can be evaluated to the values, which is convertible to `double`

Attention:
  These plot methods using iterator ranges are more efficient than the simplier "value" only methods, since the associated histogram only requires locating from internal storage once per loop, as opposed to once per fill for the simplier functions. It is recommended to use these whenever possible.

See also:
  AIDA::IHistogram1D

Parameters:

  | func | function to be plotted
  | first | begin of the sequence
  | last | end of the sequence
  | title | histogram title
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins for histogram

Definition at line 397 of file GaudiHistos.h.

    00404   {
    00405     AIDA::IHistogram1D* h(0);
    00406     if ( produceHistos() )
    00407     {
    00408       // retrieve or book the histogram
    00409       h = histo1D ( title ) ;
    00410       if ( 0 == h )     { h = book1D  ( title , low , high , bins ); }
    00411       // fill histogram
    00412       while( first != last && 0 != h  )
    00413       { h = fill ( h , func( *first ) , 1.0 , title  ) ; ++first ; }
    00414     }
    00415     return h ;
    00416   }

template<class PBASE>
template<class FUNCTION, class OBJECT>

AIDA::IHistogram1D* GaudiHistos< PBASE >::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`[inline]`

fill the 1D histogram with forced ID and information from [first,last) sequence

      std::vector<double> v = ... ;

      // Example with numeric ID
      plot( sin                 ,   // function
            v.begin() , v.end() ,   // sequence
            100 , " bla-bla "   ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 );  // number of bins

      // Example with literal ID
      plot( sin                 ,   // function
            v.begin() , v.end() ,   // sequence
            "sin" , " bla-bla " ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 );  // number of bins

Sequence, objects and function can be non-trivial:

      Particles* p = ... ;

      plot( PT                  ,   // function
            p->begin()   , p->end() , // sequence
            100 , " bla-bla "   ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 ) ; // number of bins

Attention:
  These plot methods using iterator ranges are more efficient than the simplier "value" only methods, since the associated histogram only requires locating from internal storage once per loop, as opposed to once per fill for the simplier functions. It is recommended to use these whenever possible.

See also:
  AIDA::IHistogram1D

Parameters:

  | func | function to be plotted
  | first | begin of the sequence
  | last | end of the sequence
  | ID | histogram identifier
  | title | histogram title
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins for histogram

Definition at line 475 of file GaudiHistos.h.

    00483   {
    00484     AIDA::IHistogram1D* h(0);
    00485     if ( produceHistos() )
    00486     {
    00487       // retrieve or book the histogram
    00488       h = histo1D ( ID ) ;
    00489       if ( 0 == h )     { h = book1D  ( ID , title , low , high , bins ); }
    00490       // fill histogram
    00491       while( first != last && 0 != h )
    00492       { h = fill( h , func( *first ) , 1.0 , title  ) ; ++first ; }
    00493     }
    00494     return h;
    00495   }

template<class PBASE>
template<class FUNCTION, class OBJECT, class WEIGHT>

AIDA::IHistogram1D* GaudiHistos< PBASE >::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`[inline]`

book and fill the 1D histogram with information from [first,last) sequence with given weight

      std::vector<double> v = ... ;

      plot( sin                 ,   // function
            v.begin() , v.end() ,   // sequence
            " bla-bla "         ,   // title
            -1. , 1.0           ,   // low and high limits
            100                 ,   // number of bins
            tanh                );  // weight function

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

Sequence, objects and function can be non-trivial:

      Particles* p = ... ;

      plot( PT                  ,  // function
            p->begin()  , p->end() , // sequence
            " bla-bla "         ,   // title
            -1. , 1.0           ,   // low and high limits
            100                 ,   // number of bins
            MASS                ) ; // weight function

where `PT` and `MASS` can be any function or function object for which the expressions `PT(p)` and `MASS` with `p` of type `Particle*` have some sense and can be evaluated to the values, which is convertible to `double`

Attention:
  These plot methods using iterator ranges are more efficient than the simplier "value" only methods, since the associated histogram only requires locating from internal storage once per loop, as opposed to once per fill for the simplier functions. It is recommended to use these whenever possible.

See also:
  AIDA::IHistogram1D

Parameters:

  | first | begin of the sequence
  | last | end of the sequence
  | title | histogram title
  | func | function to be plotted
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins for histogram
  | weight | weight function

Definition at line 567 of file GaudiHistos.h.

    00575   {
    00576     AIDA::IHistogram1D* h(0);
    00577     if ( produceHistos() )
    00578     {
    00579       // retrieve or book the histogram
    00580       h = histo1D ( title ) ;
    00581       if ( 0 == h ) { h = book1D  ( title , low , high , bins ); }
    00582       // fill histogram
    00583       while ( first != last && 0 != h )
    00584       { h = fill ( h                 ,
    00585                    func   ( *first ) ,
    00586                    weight ( *first ) , title  ) ; ++first ; }
    00587     }
    00588     return h;
    00589   }

template<class PBASE>
template<class FUNCTION, class OBJECT, class WEIGHT>

AIDA::IHistogram1D* GaudiHistos< PBASE >::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`[inline]`

book and fill the 1D histogram with forced ID and information from [first,last) sequence with given weight

      std::vector<double> v = ... ;

      // example with numerical ID
      plot( sin                 ,   // function
            v.begin() , v.end() ,   // sequence
            100 , " bla-bla "   ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 ,   // number of bins
            sinh                );  // weight function

      // example with literal ID
      plot( sin                 ,   // function
            v.begin() , v.end() ,   // sequence
            "sin" , " bla-bla "   ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 ,   // number of bins
            sinh                );  // weight function

Attention:
  no checks for NaN or Finite are performed!

Sequence, objects and function can be non-trivial:

      Particles* p = ... ;

      plot( PT                  ,   // function
            p->begin()   , p->end() , // sequence
            100 , " bla-bla "   ,   // ID and title
            -1. , 1.0           ,   // low and high limits
            100                 ,   // number of bins
            MASS                ) ; // weight function

where `PT` and `MASS` can be any function or function object for which the expressions `PT(p)` and `MASS` with `p` of type `Particle*` have some sense and can be evaluated to the values, which is convertible to `double`

Attention:
  These plot methods using iterator ranges are more efficient than the simplier "value" only methods, since the associated histogram only requires locating from internal storage once per loop, as opposed to once per fill for the simplier functions. It is recommended to use these whenever possible.

See also:
  AIDA::IHistogram1D

Parameters:

  | first | begin of the sequence
  | last | end of the sequence
  | ID | histogram identifier
  | title | histogram title
  | func | function to be plotted
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins for histogram
  | weight | weight function

Definition at line 659 of file GaudiHistos.h.

    00668   {
    00669     AIDA::IHistogram1D* h(0);
    00670     if ( produceHistos() )
    00671     {
    00672       // retrieve or book the histogram
    00673       h = histo1D ( ID ) ;
    00674       if ( 0 == h ) { h = book1D  ( ID , title , low , high , bins ); }
    00675       // fill histogram
    00676       while( first != last && 0 != h )
    00677       { h  = fill ( h                 ,
    00678                     func   ( *first ) ,
    00679                     weight ( *first ) , title  ) ; ++first ; }
    00680     }
    00681     return h ;
    00682   }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::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`[inline]`

fill the 2D histogram (book on demand)

         const double mass1 = ... ;
         const double mass2 = ... ;
         plot2D( mass1, mass2,
                "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 4.5, 5.5, 100, 200 );

This example illustrates the filling of the 2D histogram titled `"Invariant Mass2 versus Mass1"` with values `mass1` and `mass2` .

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `binsX` equal to 100 and `binsY` equal to 200.

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

See also:
  AIDA::IHistogram2D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | weight | weight

Returns:
  pointer to AIDA 2D histogram

Reimplemented in HistoTool.

Definition at line 1221 of file GaudiHistos.icpp.

    01231 {
    01232   AIDA::IHistogram2D * h(0);
    01233   if ( produceHistos() )
    01234   {
    01235     // retrieve or book the histogram
    01236     h = histo2D ( title ) ;
    01237     if ( 0 == h )
    01238     { h = book2D ( title , lowX , highX , binsX , lowY , highY , binsY ) ; }
    01239     // fill the histogram
    01240     h = fill ( h , valueX , valueY , weight , title ) ;
    01241   }
    01242   return h;
    01243 }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::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`[inline]`

fill the 2D histogram with forced ID assignment (book on demand)

         const double mass1 = ... ;
         const double mass2 = ... ;
         plot2D( mass1, mass2, 15,
                 "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 4.5, 5.5, 100, 200 );

This example illustrates the filling of the 2D histogram ID=15 titled `"Invariant Mass2 versus Mass1"` with values `mass1` and `mass2` .

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `binsX` equal to 100 and `binsY` equal to 200.

It is also possible to use literal IDs. For example :-

         const double mass1 = ... ;
         const double mass2 = ... ;
         plot2D( mass1, mass2, "mass",
                 "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 4.5, 5.5, 100, 200 );

Will book the same histogram, using the id "mass".

It is also possible using literal IDs, to place histograms in sub-directories from the main histogram directory, using for example :-

         const double mass1 = ... ;
         const double mass2 = ... ;
         plot2D( mass1, mass2, "subdir/mass",
                 "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 4.5, 5.5, 100, 200 );

Which will create the histogram "mass" in the sub-directory "subdir". Histograms can also be created in sub-directories with numeric IDs if IDs such as "subdir/1" are used.

Attention:
  If the histogram with given ID is already booked through automatic assignment of histogram ID, the error will not be detected. Therefore it is recommended to use non-trivial histogram ID offset (property "HistoOffSet") if one need to combine these techniques together It is still desirable to use the unique histogram title to avoid a bad interference

See also:
  AIDA::IHistogram2D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | ID | Histogram ID to use
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | weight | weight

Returns:
  pointer to AIDA 2D histogram

Reimplemented in HistoTool.

Definition at line 1249 of file GaudiHistos.icpp.

    01260 {
    01261   AIDA::IHistogram2D * h(0);
    01262   // produce histograms ?
    01263   if ( produceHistos() )
    01264   {
    01265     // retrieve or book the histogram
    01266     h = histo2D ( ID ) ;
    01267     if ( 0 == h ) { h = book2D ( ID   , title ,
    01268                                  lowX , highX , binsX ,
    01269                                  lowY , highY , binsY ) ; }
    01270     // fill the histogram
    01271     h = fill ( h , valueX , valueY , weight , title ) ;
    01272   }
    01273   return h;
    01274 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::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`[inline]`

fill the 3D histogram (book on demand)

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         plot3D( X, Y, Z, "Space Points" ,
                2.5 , 3.5 ,
                4.5 , 5.5 ,
                6.5 , 7.5 ,
                10, 20, 30 );

This example illustrates the filling of the 3D histogram titled `"Space Points"` with values `X`, `Y` and `Z`.

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `lowZ` equal to 6.5, `highZ` equal to 7.5, `binsX` equal to 10, `binsY` equal to 20 and `binsZ` equal to 30.

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

See also:
  AIDA::IHistogram3D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | valueZ | z value to be filled
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | lowZ | low z limit for histogram
  | highZ | high z limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | binsZ | number of bins in z
  | weight | weight

Returns:
  pointer to AIDA 3D histogram

Reimplemented in HistoTool.

Definition at line 1280 of file GaudiHistos.icpp.

    01294 {
    01295   AIDA::IHistogram3D * h(0);
    01296   if ( produceHistos() )
    01297   {
    01298     // retrieve or book the histogram
    01299     h = histo3D ( title ) ;
    01300     if ( 0 == h ) { h = book3D ( title ,
    01301                                  lowX , highX , binsX ,
    01302                                  lowY , highY , binsY ,
    01303                                  lowZ , highZ , binsZ ) ; }
    01304     // fill the histogram
    01305     h = fill ( h , valueX , valueY , valueZ , weight , title ) ;
    01306   }
    01307   return h;
    01308 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::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`[inline]`

fill the 3D histogram with forced ID assignment (book on demand)

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         plot3D( X, Y, Z,
                15 , "Space Points" ,
                 2.5 ,3.5, 4.5, 5.5, 6.5, 7.5, 10, 20, 30 );

This example illustrates the filling of the 3D histogram ID=15 titled `"Space Points"` with values `X`, `Y` and `Z`.

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `lowZ` equal to 6.5, `highZ` equal to 7.5, `binsX` equal to 10, `binsY` equal to 20 and `binsZ` equal to 30.

It is also possible to use literal IDs. For example :-

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         plot3D( X, Y, Z,
                "space", "Space Points" ,
                  2.5 ,3.5, 4.5, 5.5, 6.5, 7.5, 10, 20, 30 );

Will book the same histogram, using the id "space".

It is also possible using literal IDs, to place histograms in sub-directories from the main histogram directory, using for example :-

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         plot3D( X, Y, Z,
                 "subdir/space", "Space Points" ,
                 2.5 ,3.5, 4.5, 5.5, 6.5, 7.5, 10, 20, 30 );

Which will create the histogram "space" in the sub-directory "subdir". Histograms can also be created in sub-directories with numeric IDs if IDs such as "subdir/1" are used.

Attention:
  If the histogram with given ID is already booked through automatic assignment of histogram ID, the error will not be detected. Therefore it is recommended to use non-trivial histogram ID offset (property "HistoOffSet") if one need to combine these techniques together It is still desirable to use the unique histogram title to avoid a bad interference

See also:
  AIDA::IHistogram3D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | valueZ | z value to be filled
  | ID | Histogram ID to use
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | lowZ | low z limit for histogram
  | highZ | high z limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | binsZ | number of bins in z
  | weight | weight

Returns:
  pointer to AIDA 3D histogram

Reimplemented in HistoTool.

Definition at line 1314 of file GaudiHistos.icpp.

    01329 {
    01330   AIDA::IHistogram3D * h(0);
    01331   if ( produceHistos() )
    01332   {
    01333     // retrieve or book the histogram
    01334     h = histo3D ( ID ) ;
    01335     if ( 0 == h ) { h = book3D ( ID , title ,
    01336                                  lowX , highX , binsX ,
    01337                                  lowY , highY , binsY ,
    01338                                  lowZ , highZ , binsZ ) ; }
    01339     // fill the histogram
    01340     h = fill ( h , valueX , valueY , valueZ , weight , title ) ;
    01341   }
    01342   return h;
    01343 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::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`[inline]`

fill the 1D profile histogram (book on demand)

         const double mass1 = ... ;
         const double mass2 = ... ;
         profile1D( mass1, mass2, "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 100 );

This example illustrates the filling of the 1D profile histogram titled `"Invariant Mass2 versus Mass1"` with values `mass1` and `mass2` .

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `binsX` equal to 100

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

See also:
  AIDA::IProfile1D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | opt | the options, used for evaluation of errors
  | lowY | the min cut-off for y-values
  | highY | the max cut-off for y-values
  | weight | weight

Returns:
  pointer to AIDA 1D profile histogram

Definition at line 1349 of file GaudiHistos.icpp.

    01359 {
    01360   AIDA::IProfile1D * h(0);
    01361   if ( produceHistos() )
    01362   {
    01363     // retrieve or book the histogram
    01364     h = profile1D ( title ) ;
    01365     if ( 0 == h )
    01366     { h = bookProfile1D ( title , lowX , highX , binsX , opt , lowY , highY ) ; }
    01367     // fill the histogram
    01368     h = fill ( h , valueX , valueY , weight , title ) ;
    01369   }
    01370   return h;
    01371 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::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`[inline]`

fill the 1D profile histogram with forced ID assignment (book on demand)

         const double mass1 = ... ;
         const double mass2 = ... ;
         profile1D( mass1, mass2,
                 15, "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 100 );

This example illustrates the filling of the 1D profile histogram with ID=15 titled `"Invariant Mass2 versus Mass1"` with values `mass1` and `mass2` .

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `binsX` equal to 100

It is also possible to use literal IDs. For example :-

         const double mass1 = ... ;
         const double mass2 = ... ;
         profile1D( mass1, mass2,
                 "mass", "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 100 );

Will book the same histogram, using the id "mass".

It is also possible using literal IDs, to place histograms in sub-directories from the main histogram directory, using for example :-

         const double mass1 = ... ;
         const double mass2 = ... ;
         profile1D( mass1, mass2,
            "subdir/mass", "Invariant Mass2 versus Mass1" ,2.5 ,3.5, 100 );

Which will create the histogram "mass" in the sub-directory "subdir". Histograms can also be created in sub-directories with numeric IDs if IDs such as "subdir/1" are used.

See also:
  AIDA::IProfile1D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | ID | histogram identifier
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | opt | the options, used for evaluation of errors
  | lowY | the min cut-off for y-values
  | highY | the max cut-off for y-values
  | weight | weight

Returns:
  pointer to AIDA 1D profile histogram

Definition at line 1377 of file GaudiHistos.icpp.

    01388 {
    01389   AIDA::IProfile1D * h(0);
    01390   if ( produceHistos() )
    01391   {
    01392     // retrieve or book the histogram
    01393     h = profile1D ( ID ) ;
    01394     if ( 0 == h )
    01395     { h = bookProfile1D ( ID , title , lowX , highX , binsX , opt , lowY , highY ) ; }
    01396     // fill the histogram
    01397     h = fill ( h , valueX , valueY , weight , title ) ;
    01398   }
    01399   return h;
    01400 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::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`[inline]`

fill the 2D profile histogram (book on demand)

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         profile2D( X, Y, Z, "Space Points" ,2.5 ,3.5, 4.5, 5.5, 10, 20 );

This example illustrates the filling of the 2D profile histogram titled `"Space Points"` with values `X`, `Y` and `Z`.

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `binsX` equal to 10, `binsY` equal to 20.

Attention:
  The histogram will get a unique identifier automatically assigned which by default will be equal to the histogram title. An option exists to instead use numerical IDs. In this case the first histogram booked will be ID=1 the next ID=2 and so on. Note though this scheme is not recommended as it does NOT guarantee predictability of the ID a given histogram will be given when filled under conditional statements, since in these circumstances the order in which the histograms are first filled, and thus booked, will depend on the nature of the first few events read. This is particularly problematic when users submit many parallel 'sub-jobs' and then attempt to merge the final output ROOT (or HBOOK) files, since a given histogram could have different IDs in each of the sub-jobs. Consequently it is strongly recommended that users do not use numerical automatic IDs unless they are sure they understand what they are doing.

See also:
  AIDA::IProfile2D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | valueZ | z value to be filled
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | weight | weight

Returns:
  pointer to AIDA 2D profile histogram

Definition at line 1406 of file GaudiHistos.icpp.

    01417 {
    01418   AIDA::IProfile2D * h(0);
    01419   if ( produceHistos() )
    01420   {
    01421     // retrieve or book the histogram
    01422     h = profile2D ( title ) ;
    01423     if ( 0 == h ) { h = bookProfile2D ( title ,
    01424                                         lowX , highX , binsX ,
    01425                                         lowY , highY , binsY ) ; }
    01426     // fill the histogram
    01427     h = fill ( h , valueX , valueY , valueZ , weight , title ) ;
    01428   }
    01429   return h;
    01430 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::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`[inline]`

fill the 2D profile histogram with forced ID assignment (book on demand)

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         profile2D( X, Y, Z, 15, "Space Points" ,2.5 ,3.5, 4.5, 5.5, 10, 20 );

This example illustrates the filling of the 2D profile histogram with ID=15 titled `"Space Points"` with values `X`, `Y` and `Z`.

If the histogram with given title does not exist yet it will be automatically booked with parameters `lowX` equal to 2.5, `highX` equal to 3.5, `lowY` equal to 4.5, `highY` equal to 5.5, `binsX` equal to 10, `binsY` equal to 20.

It is also possible to use literal IDs. For example :-

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         profile2D( X, Y, Z, "space", "Space Points" ,2.5 ,3.5, 4.5, 5.5, 10, 20 );

Will book the same histogram, using the id "space".

It is also possible using literal IDs, to place histograms in sub-directories from the main histogram directory, using for example :-

         const double X = ... ;
         const double Y = ... ;
         const double Z = ... ;
         profile2D( X, Y, Z,
                    "subdir/space", "Space Points" ,2.5 ,3.5, 4.5, 5.5, 10, 20 );

Which will create the histogram "space" in the sub-directory "subdir". Histograms can also be created in sub-directories with numeric IDs if IDs such as "subdir/1" are used.

See also:
  AIDA::IProfile2D

Parameters:

  | valueX | x value to be filled
  | valueY | y value to be filled
  | valueZ | z value to be filled
  | ID | histogram identifier
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsX | number of bins in x
  | binsY | number of bins in y
  | weight | weight

Returns:
  pointer to AIDA 2D profile histogram

Definition at line 1436 of file GaudiHistos.icpp.

    01448 {
    01449   AIDA::IProfile2D * h(0);
    01450   if ( produceHistos() )
    01451   {
    01452     // retrieve or book the histogram
    01453     h = profile2D ( ID ) ;
    01454     if ( 0 == h ) { h = bookProfile2D ( ID , title ,
    01455                                         lowX , highX , binsX ,
    01456                                         lowY , highY , binsY ) ; }
    01457     // fill the histogram
    01458     h = fill ( h , valueX , valueY , valueZ , weight , title ) ;
    01459   }
    01460   return h;
    01461 }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::book1D | ( | const std::string & | title,
|  | const double | low = `0`,
|  | const double | high = `100`,
|  | const unsigned long | bins = `100` |
| ) |  |  | const`[inline]`

book the 1D histogram

The histogram will be assigned a unique identifier

See also:
  AIDA::IHistogram1D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA 1D histogram

Reimplemented in HistoTool.

Definition at line 465 of file GaudiHistos.icpp.

    00469 {
    00470   // exist?
    00471   AIDA::IHistogram1D* hist = histo1D ( title ) ;
    00472   // histogram is already booked
    00473   if( 0 != hist      )                           { return hist ; } // RETURN !!
    00474
    00475   // propose the histogram ID
    00476   HistoID ID;
    00477   newHistoID( title, ID );
    00478
    00479   // Create a new histogram and return
    00480   return this -> book1D ( ID, title, low, high, bins );
    00481 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::book | ( | const std::string & | title,
|  | const double | low = `0`,
|  | const double | high = `100`,
|  | const unsigned long | bins = `100` |
| ) |  |  | const`[inline]`

book the 1D histogram

Wrapper method for the equivalent book1D method. Retained for backwards compatibility, please use book1D instead.

See also:
  IHistogram1D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA 1D histogram

Definition at line 1334 of file GaudiHistos.h.

    01338   {
    01339     return book1D( title, low, high, bins );
    01340   }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::book | ( | const Gaudi::Histo1DDef & | hdef | ) | const`[inline]`

book the 1D histogram

The histogram will be assigned a unique identifier

See also:
  AIDA::IHistogram1D

Parameters:

  | hdef | histogram description/definition

Returns:
  pointer to AIDA 1D histogram

Definition at line 1468 of file GaudiHistos.icpp.

    01469 {
    01470   return book1D ( hdef.title    () ,
    01471                   hdef.lowEdge  () ,
    01472                   hdef.highEdge () ,
    01473                   hdef.bins     () ) ;
    01474 }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::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`[inline]`

book the 2D histogram

The histogram will be assigned a unique identifier

See also:
  IHistogram2D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsY | number of bins in y

Returns:
  pointer to AIDA 2D histogram

Reimplemented in HistoTool.

Definition at line 592 of file GaudiHistos.icpp.

    00599 {
    00600   // exist?
    00601   AIDA::IHistogram2D* hist = histo2D ( title ) ;
    00602   // histogram is already booked
    00603   if( 0 != hist      )                                { return hist ; } // RETURN !!
    00604
    00605   // propose the histogram ID
    00606   HistoID ID;
    00607   newHistoID( title, ID );
    00608
    00609   // Create a new histogram and return
    00610   return this -> book2D ( ID, title, lowX, highX, binsX, lowY, highY, binsY );
    00611 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::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`[inline]`

book the 3D histogram

The histogram will be assigned a unique identifier

See also:
  IHistogram3D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsY | number of bins in y
  | lowZ | low y limit for histogram
  | highZ | high y limit for histogram
  | binsZ | number of bins in y

Returns:
  pointer to AIDA 3D histogram

Reimplemented in HistoTool.

Definition at line 733 of file GaudiHistos.icpp.

    00743 {
    00744   // exist?
    00745   AIDA::IHistogram3D* hist = histo3D ( title ) ;
    00746   // histogram is already booked
    00747   if( 0 != hist      )                           { return hist ; } // RETURN !!
    00748
    00749   // propose the histogram ID
    00750   HistoID ID;
    00751   newHistoID( title, ID );
    00752
    00753   // Create a new histogram and return
    00754   return this -> book3D ( ID, title,
    00755                           lowX, highX, binsX,
    00756                           lowY, highY, binsY,
    00757                           lowZ, highZ, binsZ );
    00758 }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::book1D | ( | const HistoID & | ID,
|  | const std::string & | title,
|  | const double | low = `0`,
|  | const double | high = `100`,
|  | const unsigned long | bins = `100` |
| ) |  |  | const`[inline]`

book the 1D histogram with forced ID

See also:
  IHistogram1D

Parameters:

  | ID | unique histogram ID
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA histogram

Reimplemented in HistoTool.

Definition at line 487 of file GaudiHistos.icpp.

    00492 {
    00493   // Check ID
    00494   if (ID.undefined())
    00495   {
    00496     this->Error("Undefined Histogram ID : Title='"+title+"'");
    00497     return NULL;
    00498   }
    00499
    00500   // exist?
    00501   AIDA::IHistogram1D* hist = histo1D ( ID ) ;
    00502   // histogram is already booked
    00503   if ( 0 != hist       )                         { return hist ; } // RETURN !!
    00504
    00505   // Histogram title
    00506   const std::string & htitle =
    00507     ( title.empty() ? "Unnamed 1D Histogram ID="+ID.idAsString() : title ) ;
    00508
    00509   // book the histogram
    00510   if ( ID.numeric() )
    00511   {
    00512     hist = this->histoSvc() -> book ( histoPath()  ,
    00513                                       ID.numericID() ,
    00514                                       htitle       ,
    00515                                       bins         ,
    00516                                       low          ,
    00517                                       high         ) ;
    00518   }
    00519   else if ( ID.literal() )
    00520   {
    00521     hist = this->histoSvc() -> book ( histoPath()+"/"+
    00522                                       ID.literalID() ,
    00523                                       htitle         ,
    00524                                       bins           ,
    00525                                       low            ,
    00526                                       high         ) ;
    00527   }
    00528
    00529   // check OK
    00530   if( 0 == hist )
    00531   { this->Error( "IHistogram1D* points to NULL! ID='" + ID.idAsString() +
    00532                  "' title='"+htitle+"'" ) ; return 0; } // RETURN !!
    00533
    00534   // add histogram into histogram storages
    00535   if      ( ID.numeric() )
    00536   { m_histo1DMapNumID [ ID.numericID() ] = hist ; }
    00537   else if ( ID.literal() )
    00538   { m_histo1DMapLitID [ ID.literalID() ] = hist ; }
    00539   m_histo1DMapTitle [ title ] = hist ;
    00540
    00541   // Declare to monitoring service
    00542   monitorHisto( Gaudi::Utils::Histos::toBase ( hist ) , ID );
    00543
    00544   // Printout and return
    00545   if ( this->msgLevel(MSG::DEBUG) )
    00546   { this->debug() << "Booked 1D Histogram : ID='" << ID
    00547                   << "' Path=" << histoPath()
    00548                   << " Title='"
    00549                   << Gaudi::Utils::Histos::htitle ( hist )
    00550                   << "'" << endreq; }
    00551   return hist ;
    00552 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::book | ( | const HistoID & | ID,
|  | const std::string & | title,
|  | const double | low = `0`,
|  | const double | high = `100`,
|  | const unsigned long | bins = `100` |
| ) |  |  | const`[inline]`

book the 1D histogram with forced ID

Wrapper method for the equivalent book1D method. Retained for backwards compatibility, please use book1D instead.

See also:
  IHistogram1D

Parameters:

  | ID | unique histogram ID
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA histogram

Definition at line 1436 of file GaudiHistos.h.

    01441   {
    01442     return book1D( ID, title, low, high, bins );
    01443   }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::book | ( | const HistoID & | ID,
|  | const Gaudi::Histo1DDef & | hdef |
| ) |  |  | const`[inline]`

book the 1D histogram with forced ID

See also:
  IHistogram1D

Parameters:

  | ID | unique histogram ID
  | hdef | histogram descriptor

Returns:
  pointer to AIDA histogram

Definition at line 1481 of file GaudiHistos.icpp.

    01483 {
    01484   return book1D ( ID               ,
    01485                   hdef.title    () ,
    01486                   hdef.lowEdge  () ,
    01487                   hdef.highEdge () ,
    01488                   hdef.bins     () ) ;
    01489 }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::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`[inline]`

book the 2D histogram with forced ID

See also:
  IHistogram2D

Parameters:

  | ID | unique histogram ID
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA histogram

Reimplemented in HistoTool.

Definition at line 617 of file GaudiHistos.icpp.

    00625 {
    00626   // Check ID
    00627   if (ID.undefined())
    00628   {
    00629     this->Error("Undefined Histogram ID : Title='"+title+"'");
    00630     return NULL;
    00631   }
    00632
    00633   // exist?
    00634   AIDA::IHistogram2D* hist = histo2D( ID ) ;
    00635   // histogram is already booked
    00636   if( 0 != hist       )                         { return hist ; } // RETURN !!
    00637
    00638   // Histogram title
    00639   const std::string & htitle =
    00640     ( title.empty() ? "Unnamed 2D Histogram ID="+ID.idAsString() : title ) ;
    00641
    00642   // book the histogram
    00643   if ( ID.numeric() )
    00644   {
    00645     hist = this->histoSvc() -> book ( histoPath()  ,
    00646                                       ID.numericID() ,
    00647                                       htitle       ,
    00648                                       binsX        ,
    00649                                       lowX         ,
    00650                                       highX        ,
    00651                                       binsY        ,
    00652                                       lowY         ,
    00653                                       highY        ) ;
    00654   }
    00655   else if ( ID.literal() )
    00656   {
    00657     hist = this->histoSvc() -> book ( histoPath()+"/"+
    00658                                       ID.literalID() ,
    00659                                       htitle       ,
    00660                                       binsX        ,
    00661                                       lowX         ,
    00662                                       highX        ,
    00663                                       binsY        ,
    00664                                       lowY         ,
    00665                                       highY        ) ;
    00666   }
    00667
    00668   // Check OK
    00669   if( 0 == hist )
    00670   { this->Error( "IHistogram2D* points to NULL! ID='" + ID.idAsString() +
    00671                  "' title='"+htitle+"'" ) ; return 0; } // RETURN !!
    00672
    00673   // add histogram into histogram storages
    00674   if      ( ID.numeric() )
    00675   { m_histo2DMapNumID [ ID.numericID() ] = hist ; }
    00676   else if ( ID.literal() )
    00677   { m_histo2DMapLitID [ ID.literalID() ] = hist ; }
    00678   m_histo2DMapTitle [ title ] = hist ;
    00679
    00680   // Declare to monitoring service
    00681   monitorHisto( Gaudi::Utils::Histos::toBase ( hist) , ID );
    00682
    00683   // Printout and return
    00684   if ( this->msgLevel(MSG::DEBUG) )
    00685   { this->debug() << "Booked 2D Histogram : ID='"
    00686                   << ID << "' Path=" << histoPath()
    00687                   << " Title='"
    00688                   << Gaudi::Utils::Histos::htitle ( hist )
    00689                   << "'" << endreq; }
    00690   // return
    00691   return hist ;
    00692 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::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`[inline]`

book the 3D histogram with forced ID

See also:
  IHistogram3D

Parameters:

  | ID | unique histogram ID
  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsY | number of bins in y
  | lowZ | low y limit for histogram
  | highZ | high y limit for histogram
  | binsZ | number of bins in y

Returns:
  pointer to AIDA 3D histogram

Reimplemented in HistoTool.

Definition at line 764 of file GaudiHistos.icpp.

    00775 {
    00776   // Check ID
    00777   if (ID.undefined())
    00778   {
    00779     this->Error("Undefined Histogram ID : Title='"+title+"'");
    00780     return NULL;
    00781   }
    00782
    00783   // exist?
    00784   AIDA::IHistogram3D* hist = histo3D( ID ) ;
    00785   // histogram is already booked
    00786   if( 0 != hist       )                        { return hist ; } // RETURN !!
    00787
    00788   // Histogram title
    00789   const std::string & htitle =
    00790     ( title.empty() ? "Unnamed 3D Histogram ID="+ID.idAsString() : title ) ;
    00791
    00792   // book the histogram
    00793   if ( ID.numeric() )
    00794   {
    00795     hist = this->histoSvc() -> book ( histoPath()  ,
    00796                                       ID.numericID() ,
    00797                                       htitle       ,
    00798                                       binsX        ,
    00799                                       lowX         ,
    00800                                       highX        ,
    00801                                       binsY        ,
    00802                                       lowY         ,
    00803                                       highY        ,
    00804                                       binsZ        ,
    00805                                       lowZ         ,
    00806                                       highZ        ) ;
    00807   }
    00808   else if ( ID.literal() )
    00809   {
    00810     hist = this->histoSvc() -> book ( histoPath()+"/"+
    00811                                       ID.literalID() ,
    00812                                       htitle       ,
    00813                                       binsX        ,
    00814                                       lowX         ,
    00815                                       highX        ,
    00816                                       binsY        ,
    00817                                       lowY         ,
    00818                                       highY        ,
    00819                                       binsZ        ,
    00820                                       lowZ         ,
    00821                                       highZ        ) ;
    00822   }
    00823
    00824   // Check OK
    00825   if( 0 == hist )
    00826   { this->Error( "IHistogram3D* points to NULL! ID='" + ID.idAsString() +
    00827                  "' title='"+htitle+"'" ) ; return 0; } // RETURN !!
    00828
    00829   // add histogram into histogram storages
    00830   if      ( ID.numeric() )
    00831   { m_histo3DMapNumID [ ID.numericID() ] = hist ; }
    00832   else if ( ID.literal() )
    00833   { m_histo3DMapLitID [ ID.literalID() ] = hist ; }
    00834   m_histo3DMapTitle [ title ] = hist ;
    00835
    00836   // Declare to monitoring service
    00837   monitorHisto( Gaudi::Utils::Histos::toBase ( hist ) , ID );
    00838
    00839   // Printout and return
    00840   if ( this->msgLevel(MSG::DEBUG) )
    00841   { this->debug() << "Booked 3D Histogram : ID='"
    00842                   << ID << "' Path=" << histoPath()
    00843                   << " Title='"
    00844                   << Gaudi::Utils::Histos::htitle ( hist )
    00845                   << "'" << endreq; }
    00846   return hist ;
    00847 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::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`[inline]`

book the 1D profile histogram

The histogram will be assigned a unique identifier

See also:
  IHistogram1D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | opt | the options, used for evaluation of errors
  | lowY | the min cut-off for y-values
  | highY | the max cut-off for y-values

Returns:
  pointer to AIDA 1D profile histogram

Definition at line 891 of file GaudiHistos.icpp.

    00898 {
    00899   // exist?
    00900   AIDA::IProfile1D* hist = profile1D ( title ) ;
    00901   // histogram is already booked
    00902   if( 0 != hist      )                              { return hist ; } // RETURN !!
    00903
    00904   // propose the histogram ID
    00905   HistoID ID;
    00906   newHistoID( title, ID );
    00907
    00908   // Book the histo and return
    00909   return this -> bookProfile1D ( ID, title, low, high, bins , opt , lowY , highY );
    00910 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::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`[inline]`

book the 1D profile histogram

The histogram will be assigned a unique identifier

See also:
  IHistogram1D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins
  | opt | the options, used for evaluation of errors
  | lowY | the min cut-off for y-values
  | highY | the max cut-off for y-values

Returns:
  pointer to AIDA 1D profile histogram

Definition at line 916 of file GaudiHistos.icpp.

    00924 {
    00925   // Check ID
    00926   if (ID.undefined())
    00927   {
    00928     this->Error("Undefined Histogram ID : Title='"+title+"'");
    00929     return NULL;
    00930   }
    00931
    00932   // exist?
    00933   AIDA::IProfile1D* hist = profile1D ( ID ) ;
    00934   // histogram is already booked
    00935   if( 0 != hist       )                         { return hist ; } // RETURN !!
    00936
    00937   // Histogram title
    00938   const std::string & htitle =
    00939     ( title.empty() ?
    00940       "Unnamed 1D Profile Histogram ID="+ID.idAsString() : title ) ;
    00941
    00942   // book the histogram
    00943   if ( ID.numeric() )
    00944   {
    00945     hist = this->histoSvc() -> bookProf ( histoPath()  ,
    00946                                           ID.numericID() ,
    00947                                           htitle       ,
    00948                                           bins         ,
    00949                                           low          ,
    00950                                           high         ,
    00951                                           lowY         ,
    00952                                           highY        ,
    00953                                           opt          ) ;
    00954   }
    00955   else if ( ID.literal() )
    00956   {
    00957     hist = this->histoSvc() -> bookProf ( histoPath()+"/"+
    00958                                           ID.literalID() ,
    00959                                           htitle       ,
    00960                                           bins         ,
    00961                                           low          ,
    00962                                           high         ,
    00963                                           lowY         ,
    00964                                           highY        ,
    00965                                           opt          ) ;
    00966   }
    00967
    00968   // test ok
    00969   if( 0 == hist )
    00970   { this->Error( "IProfile1D* points to NULL! ID='" + ID.idAsString() +
    00971                  "' title='"+htitle+"'" ) ; return 0; } // RETURN !!
    00972
    00973   // add histogram into histogram storages
    00974   if      ( ID.numeric() )
    00975   { m_profile1DMapNumID [ ID.numericID() ] = hist ; }
    00976   else if ( ID.literal() )
    00977   { m_profile1DMapLitID [ ID.literalID() ] = hist ; }
    00978   m_profile1DMapTitle [ title ] = hist ;
    00979
    00980   // Declare to monitoring service
    00981   monitorHisto( Gaudi::Utils::Histos::toBase ( hist ) , ID );
    00982
    00983   // printout and return
    00984   if ( this->msgLevel(MSG::DEBUG) )
    00985   { this->debug() << "Booked 1D Profile Histogram : ID='"
    00986                   << ID << "' Path=" << histoPath()
    00987                   << " Title='"
    00988                   << Gaudi::Utils::Histos::htitle ( hist )
    00989                   << "'" << endreq; }
    00990   return hist ;
    00991 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::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`[inline]`

book the 2D profile histogram

The histogram will be assigned a unique identifier

See also:
  AIDA::IProfile2D

Parameters:

  | title | histogram title (must be unique within the algorithm)
  | lowX | low x limit for histogram
  | highX | high x limit for histogram
  | binsX | number of bins in x
  | lowY | low y limit for histogram
  | highY | high y limit for histogram
  | binsY | number of bins in y

Returns:
  pointer to AIDA 2D histogram

Definition at line 1030 of file GaudiHistos.icpp.

    01037 {
    01038   // exist?
    01039   AIDA::IProfile2D* hist = profile2D ( title ) ;
    01040   // histogram is already booked
    01041   if( 0 != hist      )                          { return hist ; } // RETURN !!
    01042
    01043   // propose the histogram ID
    01044   HistoID ID;
    01045   newHistoID( title, ID );
    01046
    01047   // book histogram and return
    01048   return this -> bookProfile2D ( ID, title, lowX, highX, binsX, lowY, highY, binsY );
    01049 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::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`[inline]`

book the 2D profile histogram with forced ID

See also:
  AIDA::IProfile2D

Parameters:

  | ID | unique histogram ID
  | title | histogram title (must be unique within the algorithm)
  | low | low limit for histogram
  | high | high limit for histogram
  | bins | number of bins

Returns:
  pointer to AIDA histogram

Definition at line 1055 of file GaudiHistos.icpp.

    01063 {
    01064   // Check ID
    01065   if (ID.undefined())
    01066   {
    01067     this->Error("Undefined Histogram ID : Title='"+title+"'");
    01068     return NULL;
    01069   }
    01070
    01071   // exist?
    01072   AIDA::IProfile2D* hist = profile2D ( ID ) ;
    01073   // histogram is already booked
    01074   if( 0 != hist )                               { return hist ; } // RETURN !!
    01075
    01076   // Histogram title
    01077   const std::string & htitle =
    01078     ( title.empty() ?
    01079       "Unnamed 2D Profile Histogram ID="+ID.idAsString() : title ) ;
    01080
    01081   // book the histogram
    01082   if ( ID.numeric() )
    01083   {
    01084     hist = this->histoSvc() -> bookProf ( histoPath() ,
    01085                                           ID.numericID() ,
    01086                                           htitle      ,
    01087                                           binsX       ,
    01088                                           lowX        ,
    01089                                           highX       ,
    01090                                           binsY       ,
    01091                                           lowY        ,
    01092                                           highY        ) ;
    01093   }
    01094   else if ( ID.literal() )
    01095   {
    01096     hist = this->histoSvc() -> bookProf ( histoPath()+"/"+
    01097                                           ID.literalID() ,
    01098                                           htitle      ,
    01099                                           binsX       ,
    01100                                           lowX        ,
    01101                                           highX       ,
    01102                                           binsY       ,
    01103                                           lowY        ,
    01104                                           highY        ) ;
    01105   }
    01106
    01107   // test OK
    01108   if( 0 == hist )
    01109   { this->Error( "IProfile2D* points to NULL! ID='" + ID.idAsString() +
    01110                  "' title='"+htitle+"'" ) ; return 0; } // RETURN !!
    01111
    01112   // add histogram into histogram storages
    01113   if      ( ID.numeric() )
    01114   { m_profile2DMapNumID [ ID.numericID() ] = hist ; }
    01115   else if ( ID.literal() )
    01116   { m_profile2DMapLitID [ ID.literalID() ] = hist ; }
    01117   m_profile2DMapTitle [ title ] = hist ;
    01118
    01119   // Declare to monitoring service
    01120   monitorHisto( Gaudi::Utils::Histos::toBase ( hist ) , ID );
    01121
    01122   // printout and return
    01123   if ( this->msgLevel(MSG::DEBUG) )
    01124   {  this->debug() << "Booked 2D Profile Histogram : ID='" << ID
    01125                    << "' Path=" << histoPath()
    01126                    << " Title='"
    01127                    << Gaudi::Utils::Histos::htitle ( hist )
    01128                    << "'" << endreq; }
    01129   return hist ;
    01130 }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::fill | ( | AIDA::IHistogram1D * | histo,
|  | const double | value,
|  | const double | weight,
|  | const std::string & | title = `""` |
| ) |  |  | const`[inline]`

fill the 1D histogram with the value and weight

Parameters:

  | histo | 1D histogram to be filled
  | value | value to be put into the histogram
  | weight | weight to be used
  | title | histogram title (to be used for error report)

Returns:
  pointer to AIDA 1D histogram

Reimplemented in HistoTool.

Definition at line 558 of file GaudiHistos.icpp.

    00562 {
    00563   if ( 0 != histo && produceHistos() )
    00564   {
    00565     if ( !checkForNaN() )
    00566     { Gaudi::Utils::Histos::fill ( histo , value , weight ) ; }
    00567     else if  ( lfin ( value ) && lfin ( weight ) )
    00568     { Gaudi::Utils::Histos::fill ( histo , value , weight ) ; }
    00569     else if  ( lnan ( value ) || lnan ( weight ) )
    00570     {
    00571       this -> Warning
    00572         ("fill():: 'NaN'      value is skipped from the histogram '"
    00573          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    00574     }
    00575     else
    00576     {
    00577       this -> Warning
    00578         ("fill():: 'Infinite' value is skipped from the histogram '"
    00579          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    00580     }
    00581   }
    00582   // return
    00583   return histo ;
    00584 }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::fill | ( | AIDA::IHistogram2D * | histo,
|  | const double | valueX,
|  | const double | valueY,
|  | const double | weight,
|  | const std::string & | title = `""` |
| ) |  |  | const`[inline]`

fill the 2D histogram with the value and weight

Parameters:

  | histo | 2D histogram to be filled
  | valueX | x value to be put into the histogram
  | valueY | y value to be put into the histogram
  | weight | weight to be used
  | title | histogram title (to be used for error report)

Returns:
  pointer to AIDA 2D histogram

Reimplemented in HistoTool.

Definition at line 698 of file GaudiHistos.icpp.

    00703 {
    00704   if ( 0 != histo && produceHistos() )
    00705   {
    00706     if ( !checkForNaN() )
    00707     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , weight ) ; }
    00708     else if  ( lfin ( valueX ) && lfin ( valueY ) && lfin ( weight ) )
    00709     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , weight ) ; }
    00710     else if  ( lnan ( valueX ) || lnan ( valueY ) || lnan ( weight ) )
    00711     {
    00712       this -> Warning
    00713         ("fill():: 'NaN'      value is skipped from the histogram '"
    00714          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    00715     }
    00716     else
    00717     {
    00718       this -> Warning
    00719         ("fill():: 'Infinite' value is skipped from the histogram '"
    00720          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    00721     }
    00722   }
    00723   // return
    00724   return histo ;
    00725 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::fill | ( | AIDA::IHistogram3D * | histo,
|  | const double | valueX,
|  | const double | valueY,
|  | const double | valueZ,
|  | const double | weight,
|  | const std::string & | title = `""` |
| ) |  |  | const`[inline]`

fill the 3D histogram with the value and weight

Parameters:

  | histo | 3D histogram to be filled
  | valueX | x value to be put into the histogram
  | valueY | y value to be put into the histogram
  | valueZ | z value to be put into the histogram
  | weight | weight to be used
  | title | histogram title (to be used for error report)

Returns:
  pointer to AIDA 3D histogram

Reimplemented in HistoTool.

Definition at line 853 of file GaudiHistos.icpp.

    00859 {
    00860   if ( 0 != histo && produceHistos() )
    00861   {
    00862     if ( !checkForNaN() )
    00863     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , valueZ , weight ) ; }
    00864     else if  ( lfin ( valueX ) && lfin ( valueY ) &&
    00865                lfin ( valueZ ) && lfin ( weight ) )
    00866     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , valueZ , weight ) ; }
    00867     else if  ( lnan ( valueX ) || lnan ( valueY ) ||
    00868                lnan ( valueZ ) || lnan ( weight ) )
    00869     {
    00870       this -> Warning
    00871         ("fill():: 'NaN'      value is skipped from the histogram '"
    00872          + Gaudi::Utils::Histos::htitle ( histo , title  ) + "'" ) ;
    00873     }
    00874     else
    00875     {
    00876       this -> Warning
    00877         ("fill():: 'Infinite' value is skipped from the histogram '"
    00878          + Gaudi::Utils::Histos::htitle ( histo , title  ) + "'" ) ;
    00879     }
    00880   }
    00881   // return
    00882   return histo ;
    00883 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::fill | ( | AIDA::IProfile1D * | histo,
|  | const double | valueX,
|  | const double | valueY,
|  | const double | weight,
|  | const std::string & | title = `""` |
| ) |  |  | const`[inline]`

fill the 1D profile histogram with the values and weight

Parameters:

  | histo | 1D profile histogram to be filled
  | valueX | x value to be put into the histogram
  | valueY | y value to be put into the histogram
  | weight | weight to be used
  | title | histogram title (to be used for error report)

Returns:
  pointer to AIDA 1D histogram

Definition at line 997 of file GaudiHistos.icpp.

    01002 {
    01003   if ( 0 != histo && produceHistos() )
    01004   {
    01005     if ( !checkForNaN() )
    01006     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , weight ); }
    01007     else if  ( lfin ( valueX ) && lfin ( valueY ) && lfin ( weight ) )
    01008     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , weight ); }
    01009     else if  ( lnan ( valueX ) || lnan ( valueY ) || lnan ( weight ) )
    01010     {
    01011       this -> Warning
    01012         ("fill():: 'NaN'      value is skipped from the histogram '"
    01013          + Gaudi::Utils::Histos::htitle ( histo , title  ) + "'" ) ;
    01014     }
    01015     else
    01016     {
    01017       this -> Warning
    01018         ("fill():: 'Infinite' value is skipped from the histogram '"
    01019          + Gaudi::Utils::Histos::htitle ( histo , title  ) + "'" ) ;
    01020     }
    01021   }
    01022   // return
    01023   return histo ;
    01024 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::fill | ( | AIDA::IProfile2D * | histo,
|  | const double | valueX,
|  | const double | valueY,
|  | const double | valueZ,
|  | const double | weight,
|  | const std::string & | title = `""` |
| ) |  |  | const`[inline]`

fill the 2D profile histogram with the values and weight

Parameters:

  | histo | 2D profile histogram to be filled
  | valueX | x value to be put into the histogram
  | valueY | y value to be put into the histogram
  | valueZ | z value to be put into the histogram
  | weight | weight to be used
  | title | histogram title (to be used for error report)

Returns:
  pointer to AIDA 1D histogram

Definition at line 1136 of file GaudiHistos.icpp.

    01142 {
    01143   if ( 0 != histo && produceHistos() )
    01144   {
    01145     if ( !checkForNaN() )
    01146     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , valueZ , weight ); }
    01147     else if  ( lfin ( valueX ) && lfin ( valueY ) &&
    01148                lfin ( valueZ ) && lfin ( weight ) )
    01149     { Gaudi::Utils::Histos::fill ( histo , valueX , valueY , valueZ , weight ); }
    01150     else if  ( lnan ( valueX ) || lnan ( valueY ) ||
    01151                lnan ( valueZ ) || lnan ( weight ) )
    01152     {
    01153       this -> Warning
    01154         ("fill():: 'NaN'      value is skipped from the histogram '"
    01155          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    01156     }
    01157     else
    01158     {
    01159       this -> Warning
    01160         ("fill():: 'Infinite' value is skipped from the histogram '"
    01161          + Gaudi::Utils::Histos::htitle ( histo , title ) + "'" ) ;
    01162     }
    01163   }
    01164   // return
    01165   return histo ;
    01166 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::histo1D | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 1D histogram by title return the pointer to existing 1D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1679 of file GaudiHistos.h.

    01680   {
    01681     Histo1DMapTitle::const_iterator found = histo1DMapTitle().find( title ) ;
    01682     return ( histo1DMapTitle().end() == found ? 0 : found->second );
    01683   }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::histo | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 1D histogram by title

Wrapper method for the equivalent histo1D method. Retained for backwards compatibility, please use histo1D instead.

return the pointer to existing 1D histogram or NULL

Definition at line 1692 of file GaudiHistos.h.

    01693   {
    01694     return histo1D( title );
    01695   }

template<class PBASE>

AIDA::IHistogram2D* GaudiHistos< PBASE >::histo2D | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 2D histogram by title return the pointer to existing 2D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1700 of file GaudiHistos.h.

    01701   {
    01702     Histo2DMapTitle::const_iterator found = histo2DMapTitle().find( title ) ;
    01703     return ( histo2DMapTitle().end() == found ? 0 : found->second );
    01704   }

template<class PBASE>

AIDA::IHistogram3D* GaudiHistos< PBASE >::histo3D | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 3D histogram by title return the pointer to existing 3D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1709 of file GaudiHistos.h.

    01710   {
    01711     Histo3DMapTitle::const_iterator found = histo3DMapTitle().find( title ) ;
    01712     return ( histo3DMapTitle().end() == found ? 0 : found->second );
    01713   }

template<class PBASE>

AIDA::IProfile1D* GaudiHistos< PBASE >::profile1D | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 1D profile histogram by title return the pointer to existing 1D profile histogram or NULL

Definition at line 1718 of file GaudiHistos.h.

    01719   {
    01720     Profile1DMapTitle::const_iterator found = profile1DMapTitle().find( title ) ;
    01721     return ( profile1DMapTitle().end() == found ? 0 : found->second );
    01722   }

template<class PBASE>

AIDA::IProfile2D* GaudiHistos< PBASE >::profile2D | ( | const std::string & | title | ) | const`[inline]`

access the EXISTING 2D profile histogram by title return the pointer to existing 2D profile histogram or NULL

Definition at line 1727 of file GaudiHistos.h.

    01728   {
    01729     Profile2DMapTitle::const_iterator found = profile2DMapTitle().find( title ) ;
    01730     return ( profile2DMapTitle().end() == found ? 0 : found->second );
    01731   }

template<class PBASE>

AIDA::IHistogram1D * GaudiHistos< PBASE >::histo1D | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 1D histogram by ID return the pointer to existing 1D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1525 of file GaudiHistos.icpp.

    01526 {
    01527   AIDA::IHistogram1D * h(0);
    01528   if ( ID.numeric() )
    01529   {
    01530     Histo1DMapNumID::const_iterator found =
    01531       histo1DMapNumID().find( ID.numericID() ) ;
    01532     h = ( histo1DMapNumID().end() == found ? 0 : found->second );
    01533   }
    01534   else
    01535   {
    01536     Histo1DMapLitID::const_iterator found =
    01537       histo1DMapLitID().find( ID.literalID() ) ;
    01538     h = ( histo1DMapLitID().end() == found ? 0 : found->second );
    01539   }
    01540   return h;
    01541 }

template<class PBASE>

AIDA::IHistogram1D* GaudiHistos< PBASE >::histo | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 1D histogram by ID

Wrapper method for the equivalent histo1D method. Retained for backwards compatibility, please use histo1D instead.

return the pointer to existing 1D histogram or NULL

Definition at line 1747 of file GaudiHistos.h.

    01748   {
    01749     return histo1D( ID );
    01750   }

template<class PBASE>

AIDA::IHistogram2D * GaudiHistos< PBASE >::histo2D | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 2D histogram by ID return the pointer to existing 2D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1546 of file GaudiHistos.icpp.

    01547 {
    01548   AIDA::IHistogram2D * h(0);
    01549   if ( ID.numeric() )
    01550   {
    01551     Histo2DMapNumID::const_iterator found =
    01552       histo2DMapNumID().find( ID.numericID() ) ;
    01553     h = ( histo2DMapNumID().end() == found ? 0 : found->second );
    01554   }
    01555   else
    01556   {
    01557     Histo2DMapLitID::const_iterator found =
    01558       histo2DMapLitID().find( ID.literalID() ) ;
    01559     h = ( histo2DMapLitID().end() == found ? 0 : found->second );
    01560   }
    01561   return h;
    01562 }

template<class PBASE>

AIDA::IHistogram3D * GaudiHistos< PBASE >::histo3D | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 3D histogram by ID return the pointer to existing 3D histogram or NULL

Reimplemented in HistoTool.

Definition at line 1567 of file GaudiHistos.icpp.

    01568 {
    01569   AIDA::IHistogram3D * h(0);
    01570   if ( ID.numeric() )
    01571   {
    01572     Histo3DMapNumID::const_iterator found =
    01573       histo3DMapNumID().find( ID.numericID() ) ;
    01574     h = ( histo3DMapNumID().end() == found ? 0 : found->second );
    01575   }
    01576   else
    01577   {
    01578     Histo3DMapLitID::const_iterator found =
    01579       histo3DMapLitID().find( ID.literalID() ) ;
    01580     h = ( histo3DMapLitID().end() == found ? 0 : found->second );
    01581   }
    01582   return h;
    01583 }

template<class PBASE>

AIDA::IProfile1D * GaudiHistos< PBASE >::profile1D | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 1D profile histogram by ID return the pointer to existing 1D profile histogram or NULL

Definition at line 1588 of file GaudiHistos.icpp.

    01589 {
    01590   AIDA::IProfile1D * h(0);
    01591   if ( ID.numeric() )
    01592   {
    01593     Profile1DMapNumID::const_iterator found =
    01594       profile1DMapNumID().find( ID.numericID() ) ;
    01595     h = ( profile1DMapNumID().end() == found ? 0 : found->second );
    01596   }
    01597   else
    01598   {
    01599     Profile1DMapLitID::const_iterator found =
    01600       profile1DMapLitID().find( ID.literalID() ) ;
    01601     h = ( profile1DMapLitID().end() == found ? 0 : found->second );
    01602   }
    01603   return h;
    01604 }

template<class PBASE>

AIDA::IProfile2D * GaudiHistos< PBASE >::profile2D | ( | const HistoID & | ID | ) | const`[inline]`

access the EXISTING 2D profile histogram by ID return the pointer to existing 2D profile histogram or NULL

Definition at line 1609 of file GaudiHistos.icpp.

    01610 {
    01611   AIDA::IProfile2D * h(0);
    01612   if ( ID.numeric() )
    01613   {
    01614     Profile2DMapNumID::const_iterator found =
    01615       profile2DMapNumID().find( ID.numericID() ) ;
    01616     h = ( profile2DMapNumID().end() == found ? 0 : found->second );
    01617   }
    01618   else
    01619   {
    01620     Profile2DMapLitID::const_iterator found =
    01621       profile2DMapLitID().find( ID.literalID() ) ;
    01622     h = ( profile2DMapLitID().end() == found ? 0 : found->second );
    01623   }
    01624   return h;
    01625 }

template<class PBASE>

bool GaudiHistos< PBASE >::histoExists | ( | const std::string & | title | ) | const`[inline]`

check the existence AND validity of the histogram with given title

Reimplemented in HistoTool.

Definition at line 1775 of file GaudiHistos.h.

    01776   {
    01777     return
    01778       ( 0 != histo     ( title ) ||
    01779         0 != histo2D   ( title ) ||
    01780         0 != histo3D   ( title ) ||
    01781         0 != profile1D ( title ) ||
    01782         0 != profile2D ( title ) );
    01783   }

template<class PBASE>

bool GaudiHistos< PBASE >::histoExists | ( | const HistoID & | ID | ) | const`[inline]`

check the existence AND validity of the histogram with given title

Reimplemented in HistoTool.

Definition at line 1786 of file GaudiHistos.h.

    01787   {
    01788     return
    01789       ( 0 != histo     ( ID ) ||
    01790         0 != histo2D   ( ID ) ||
    01791         0 != histo3D   ( ID ) ||
    01792         0 != profile1D ( ID ) ||
    01793         0 != profile2D ( ID ) );
    01794   }

template<class PBASE>

unsigned int GaudiHistos< PBASE >::totalNumberOfHistos | ( |  | ) | const`[inline]`

Returns the total number of histograms (of all types) currently booked.

Definition at line 1630 of file GaudiHistos.icpp.

    01631 {
    01632   const unsigned int n1D  = histo1DMapNumID().size()+histo1DMapLitID().size();
    01633   const unsigned int n2D  = histo2DMapNumID().size()+histo2DMapLitID().size();
    01634   const unsigned int n3D  = histo3DMapNumID().size()+histo3DMapLitID().size();
    01635   const unsigned int n1DP = profile1DMapNumID().size()+profile1DMapLitID().size();
    01636   const unsigned int n2DP = profile2DMapNumID().size()+profile2DMapLitID().size();
    01637   return n1D+n2D+n3D+n1DP+n2DP;
    01638 }

template<class PBASE>

bool GaudiHistos< PBASE >::produceHistos | ( |  | ) | const`[inline]`

get the flag for histogram production (property "HistoProduce")

Definition at line 1801 of file GaudiHistos.h.

    01801 { return m_produceHistos ; }

template<class PBASE>

bool GaudiHistos< PBASE >::fullDetail | ( |  | ) | const`[inline]`

get flag to control output level of histograms

Definition at line 1803 of file GaudiHistos.h.

    01803 { return m_fullDetail    ; }

template<class PBASE>

bool GaudiHistos< PBASE >::checkForNaN | ( |  | ) | const`[inline]`

get the flag for NaN checks (property "HistoCheckForNan")

Definition at line 1805 of file GaudiHistos.h.

    01805 { return m_checkForNaN   ; }

template<class PBASE>

bool GaudiHistos< PBASE >::splitHistoDir | ( |  | ) | const`[inline]`

get the flag for histogram path split (property "HistoSplitDir")

Definition at line 1807 of file GaudiHistos.h.

    01807 { return m_splitHistoDir ; }

template<class PBASE>

HistoID::NumericID GaudiHistos< PBASE >::histoOffSet | ( |  | ) | const`[inline]`

get the value for histogram offset (property "HistoOffSet")

Definition at line 1809 of file GaudiHistos.h.

    01809 { return m_histoOffSet ; }

template<class PBASE>

const std::string& GaudiHistos< PBASE >::histoTopDir | ( |  | ) | const`[inline]`

get top-level histogram directory (property "HistoTopDir")

Definition at line 1811 of file GaudiHistos.h.

    01811 { return m_histoTopDir   ; }

template<class PBASE>

const std::string& GaudiHistos< PBASE >::histoDir | ( |  | ) | const`[inline]`

get histogram directory (property "HistoDir")

Definition at line 1813 of file GaudiHistos.h.

    01813 { return m_histoDir      ; }

template<class PBASE>

std::string GaudiHistos< PBASE >::histoPath | ( |  | ) | const`[inline]`

get the constructed histogram path

Definition at line 1815 of file GaudiHistos.h.

    01816   {
    01817     const std::string path = histoTopDir() + histoDir();
    01818     return ( splitHistoDir() ? dirHbookName(path) : path );
    01819   }

template<class PBASE>

bool GaudiHistos< PBASE >::histosPrint | ( |  | ) | const`[inline]`

print histograms at finalization ?

Definition at line 1821 of file GaudiHistos.h.

    01821 { return m_histosPrint ; }

template<class PBASE>

bool GaudiHistos< PBASE >::useNumericAutoIDs | ( |  | ) | const`[inline]`

Use old style sequencial numerical automatically assigned IDs ?

Definition at line 1823 of file GaudiHistos.h.

    01823 { return m_useNumericAutoIDs; }

template<class PBASE>

int GaudiHistos< PBASE >::printHistos | ( | const MSG::Level | level = `MSG::ALWAYS` | ) | const`[inline]`

perform the actual printout of histograms

Parameters:

  | level | The message level to print at

Returns:
  number of active histograms

Definition at line 221 of file GaudiHistos.icpp.

    00222 {
    00223   // temporary storage
    00224   std::set<const AIDA::IBaseHistogram*> histos   ;
    00225   std::set<const AIDA::IBaseHistogram*> profiles ;
    00226
    00227   using namespace Gaudi::Utils::Histos ;
    00228
    00229   if ( noHistos() )
    00230   { if (this->msgLevel(MSG::DEBUG)) this->msgStream(level) << "No histograms are booked" << endreq ; }
    00231   else
    00232   {
    00233     MsgStream & msg = this->msgStream(level);
    00234
    00235     // Printout all histograms
    00236     // Note, each must appear in either the numeric or literal map
    00237
    00238     Gaudi::Utils::Histos::Table table
    00239       ( m_histo1DTableFormat ,
    00240         m_histo1DTableHeader ) ;
    00241
    00242     if ( !histo1DMapNumID().empty() || !histo1DMapLitID().empty() )
    00243     {
    00244       msg << "List of booked 1D histograms in directory         "
    00245           << "\"" << histoPath() << "\" :-"  ;
    00246
    00247       if ( !table.header().empty() )
    00248       {
    00249         msg << std::endl << Gaudi::Utils::Histos::format
    00250           ( "ID" , table.header() , m_histo1DTableFormatShort ) ;
    00251       }
    00252       {
    00253         for ( Histo1DMapNumID::const_iterator entry = histo1DMapNumID().begin() ;
    00254               histo1DMapNumID().end() != entry ; ++entry )
    00255         {
    00256           AIDA::IHistogram1D* aida = entry->second ;
    00257           if ( 0 == aida )
    00258           { this->error() << "IHistogram1D points to NULL" << endreq ; continue ; }
    00259           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00260           histos.insert ( toBase ( aida  ) ) ;
    00261           // format and print the row
    00262           msg << std::endl << table.toString
    00263             ( aida                      ,
    00264               HistoID ( entry->first )  ,
    00265               m_histo1DTableFormatShort ) ;
    00266         }
    00267       }
    00268       {
    00269         for ( Histo1DMapLitID::const_iterator entry = histo1DMapLitID().begin() ;
    00270               histo1DMapLitID().end() != entry ; ++entry )
    00271         {
    00272           AIDA::IHistogram1D* aida = entry->second ;
    00273           if ( 0 == aida )
    00274           { this->error() << "IHistogram1D points to NULL" << endreq ; continue ; }
    00275           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00276           histos.insert ( toBase ( aida  ) ) ;
    00277           // format and print the row
    00278           msg << std::endl << table.toString
    00279             ( aida                      ,
    00280               entry->first              ,
    00281               m_histo1DTableFormatShort ) ;
    00282         }
    00283       }
    00284       msg << endreq ;
    00285     }
    00286     if ( !histo2DMapNumID().empty() || !histo2DMapLitID().empty() )
    00287     {
    00288       msg << "List of booked 2D histograms in directory         "
    00289           << "\"" << histoPath() << "\" :-" ;
    00290       {
    00291         for ( Histo2DMapNumID::const_iterator entry = histo2DMapNumID().begin() ;
    00292               histo2DMapNumID().end() != entry ; ++entry )
    00293         {
    00294           AIDA::IHistogram2D* aida = entry->second ;
    00295           if ( 0 == aida )
    00296           { this->error() << "IHistogram2D points to NULL" << endreq ; continue ; }
    00297           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00298           histos.insert ( toBase ( aida  ) ) ;
    00299           msg << std::endl
    00300               << GaudiAlg::Print2D::toString ( aida , entry->first );
    00301         }
    00302       }
    00303       {
    00304         for ( Histo2DMapLitID::const_iterator entry = histo2DMapLitID().begin() ;
    00305               histo2DMapLitID().end() != entry ; ++entry )
    00306         {
    00307           AIDA::IHistogram2D* aida = entry->second ;
    00308           if ( 0 == aida )
    00309           { this->error() << "IHistogram2D points to NULL" << endreq ; continue ; }
    00310           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00311           histos.insert ( toBase ( aida  ) ) ;
    00312           msg << std::endl
    00313               << GaudiAlg::Print2D::toString ( aida , entry->first );
    00314         }
    00315       }
    00316       msg << endreq ;
    00317     }
    00318
    00319     if ( !histo3DMapNumID().empty() || !histo3DMapLitID().empty() )
    00320     {
    00321       msg << "List of booked 3D histograms in directory         "
    00322           << "\"" << histoPath() << "\" :-" ;
    00323       {
    00324         for ( Histo3DMapNumID::const_iterator entry = histo3DMapNumID().begin() ;
    00325               histo3DMapNumID().end() != entry ; ++entry )
    00326         {
    00327           AIDA::IHistogram3D* aida = entry->second ;
    00328           if ( 0 == aida )
    00329           { this->error() << "IHistogram3D points to NULL" << endreq ; continue ; }
    00330           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00331           histos.insert ( toBase ( aida  ) ) ;
    00332           msg << std::endl << GaudiAlg::Print3D::toString ( aida , entry->first );
    00333         }
    00334       }
    00335       {
    00336         for ( Histo3DMapLitID::const_iterator entry = histo3DMapLitID().begin() ;
    00337               histo3DMapLitID().end() != entry ; ++entry )
    00338         {
    00339           AIDA::IHistogram3D* aida = entry->second ;
    00340           if ( 0 == aida )
    00341           { this->error() << "IHistogram3D points to NULL" << endreq ; continue ; }
    00342           if ( histos.end() != histos.find( toBase ( aida ) ) ) { continue ; }
    00343           histos.insert ( toBase ( aida  ) ) ;
    00344           msg << std::endl << GaudiAlg::Print3D::toString ( aida , entry->first ) ;
    00345         }
    00346       }
    00347       msg << endreq ;
    00348     }
    00349     if ( !profile1DMapNumID().empty() || !profile1DMapLitID().empty() )
    00350     {
    00351       msg << "List of booked 1D profile histograms in directory "
    00352           << "\"" << histoPath() << "\" :-" ;
    00353       {
    00354         for ( Profile1DMapNumID::const_iterator entry = profile1DMapNumID().begin() ;
    00355               profile1DMapNumID().end() != entry ; ++entry )
    00356         {
    00357           AIDA::IProfile1D*   aida = entry->second ;
    00358           if ( 0 == aida )
    00359           { this->error() << "IProfile1D points to NULL" << endreq ; continue ; }
    00360           if ( profiles.end() != profiles.find( toBase ( aida ) ) ) { continue ; }
    00361           profiles.insert ( toBase ( aida  ) ) ;
    00362           msg << std::endl << GaudiAlg::Print1DProf::toString  ( aida , entry->first );
    00363         }
    00364       }
    00365       {
    00366         for ( Profile1DMapLitID::const_iterator entry = profile1DMapLitID().begin() ;
    00367               profile1DMapLitID().end() != entry ; ++entry )
    00368         {
    00369           AIDA::IProfile1D*   aida = entry->second ;
    00370           if ( 0 == aida )
    00371           { this->error() << "IProfile1D points to NULL" << endreq ; continue ; }
    00372           if ( profiles.end() != profiles.find( toBase ( aida ) ) ) { continue ; }
    00373           profiles.insert ( toBase ( aida  ) ) ;
    00374           msg << std::endl << GaudiAlg::Print1DProf::toString ( aida , entry->first );
    00375         }
    00376       }
    00377       msg << endreq ;
    00378     }
    00379     if ( !profile2DMapNumID().empty() || !profile2DMapLitID().empty() )
    00380     {
    00381       msg << "List of booked 2D profile histograms in directory "
    00382           << "\"" << histoPath() << "\" :-" ;
    00383       {
    00384         for ( Profile2DMapNumID::const_iterator entry = profile2DMapNumID().begin() ;
    00385               profile2DMapNumID().end() != entry ; ++entry )
    00386         {
    00387           AIDA::IProfile2D*   aida = entry->second ;
    00388           if ( 0 == aida )
    00389           { this->error() << "IProfile2D points to NULL" << endreq ; continue ; }
    00390           if ( profiles.end() != profiles.find( toBase ( aida ) ) ) { continue ; }
    00391           profiles.insert ( toBase ( aida  ) ) ;
    00392           msg << std::endl << GaudiAlg::Print2DProf::toString ( aida , entry->first );
    00393         }
    00394       }
    00395       {
    00396         for ( Profile2DMapLitID::const_iterator entry = profile2DMapLitID().begin() ;
    00397               profile2DMapLitID().end() != entry ; ++entry )
    00398         {
    00399           AIDA::IProfile2D*   aida = entry->second ;
    00400           if ( 0 == aida )
    00401           { this->error() << "IProfile2D points to NULL" << endreq ; continue ; }
    00402           if ( profiles.end() != profiles.find( toBase ( aida ) ) ) { continue ; }
    00403           profiles.insert ( toBase ( aida  ) ) ;
    00404           msg << std::endl << GaudiAlg::Print2DProf::toString ( aida , entry->first );
    00405         }
    00406       }
    00407       msg << endreq ;
    00408     }
    00409
    00410   }
    00411   return histos.size() + profiles.size() ;
    00412 }

template<class PBASE>

const Histo1DMapTitle& GaudiHistos< PBASE >::histo1DMapTitle | ( |  | ) | const`[inline]`

get access to the map of all 1D histograms indexed via their title

Using this method one can inspect e.g. a list of active histograms

      const Histo1DMapTitle& histos = histo1DMapTitle() ;
      // iterate over the map!
      for ( Histo1DMapTitle::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram title
            const std::string&   title = entry->first ;
            // histogram itself
            AIDA::IHistogram1D* hist  = entry->second ;
            if( 0 == hist )  { continue ; }                // ATTENTION!

            std::cout << " Histogram title " << title << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 1858 of file GaudiHistos.h.

    01858 { return m_histo1DMapTitle; }

template<class PBASE>

const Histo1DMapNumID& GaudiHistos< PBASE >::histo1DMapNumID | ( |  | ) | const`[inline]`

get access to the map of 1D histograms index via a numeric ID

Attention:
  This map only contains 1D histogram booked via a numeric ID, either forced or automatically assigned.

      const Histo1DMapNumID& histos = histo1DMapNumID() ;
      // iterate over the map!
      for ( Histo1DMapNumID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram1D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 1889 of file GaudiHistos.h.

    01889 { return m_histo1DMapNumID; }

template<class PBASE>

const Histo1DMapLitID& GaudiHistos< PBASE >::histo1DMapLitID | ( |  | ) | const`[inline]`

get access to the map of all 1D histograms index via a literal (string) ID

Attention:
  This map only contains 1D histogram booked via a literal ID.

      const Histo1DMapLitID& histos = histo1DMapLitID() ;
      // iterate over the map!
      for ( Histo1DMapLitID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram1D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 1919 of file GaudiHistos.h.

    01919 { return m_histo1DMapLitID; }

template<class PBASE>

const Histo2DMapTitle& GaudiHistos< PBASE >::histo2DMapTitle | ( |  | ) | const`[inline]`

get access to the map of all 2D histograms indexed via their title

Using this method one can inspect e.g. a list of active histograms

      const Histo2DMapTitle& histos = histo2DMapTitle() ;
      // iterate over the map!
      for ( Histo2DMapTitle::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram title
            const std::string&   title = entry->first ;
            // histogram itself
            AIDA::IHistogram2D* hist  = entry->second ;
            if( 0 == hist )  { continue ; }                // ATTENTION!

            std::cout << " Histogram title " << title << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 1948 of file GaudiHistos.h.

    01948 { return m_histo2DMapTitle ; }

template<class PBASE>

const Histo2DMapNumID& GaudiHistos< PBASE >::histo2DMapNumID | ( |  | ) | const`[inline]`

get access to the map of 2D histograms index via a numeric ID

Attention:
  This map only contains 2D histogram booked via a numeric ID, either forced or automatically assigned.

      const Histo2DMapNumID& histos = histo2DMapNumID() ;
      // iterate over the map!
      for ( Histo2DMapNumID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram2D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 1979 of file GaudiHistos.h.

    01979 { return m_histo2DMapNumID; }

template<class PBASE>

const Histo2DMapLitID& GaudiHistos< PBASE >::histo2DMapLitID | ( |  | ) | const`[inline]`

get access to the map of all 2D histograms index via a literal (string) ID

Attention:
  This map only contains 2D histogram booked via a literal ID.

      const Histo2DMapLitID& histos = histo2DMapLitID() ;
      // iterate over the map!
      for ( Histo2DMapLitID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram2D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2009 of file GaudiHistos.h.

    02009 { return m_histo2DMapLitID; }

template<class PBASE>

const Histo3DMapTitle& GaudiHistos< PBASE >::histo3DMapTitle | ( |  | ) | const`[inline]`

get access to the map of all 3D histograms indexed via their title

Using this method one can inspect e.g. a list of active histograms

      const Histo3DMapTitle& histos = histo3DMapTitle() ;
      // iterate over the map!
      for ( Histo3DMapTitle::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram title
            const std::string&   title = entry->first ;
            // histogram itself
            AIDA::IHistogram3D* hist  = entry->second ;
            if( 0 == hist )  { continue ; }                // ATTENTION!

            std::cout << " Histogram title " << title << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2038 of file GaudiHistos.h.

    02038 { return m_histo3DMapTitle ; }

template<class PBASE>

const Histo3DMapNumID& GaudiHistos< PBASE >::histo3DMapNumID | ( |  | ) | const`[inline]`

get access to the map of 3D histograms index via a numeric ID

Attention:
  This map only contains 3D histogram booked via a numeric ID, either forced or automatically assigned.

      const Histo3DMapNumID& histos = histo3DMapNumID() ;
      // iterate over the map!
      for ( Histo3DMapNumID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram3D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2069 of file GaudiHistos.h.

    02069 { return m_histo3DMapNumID; }

template<class PBASE>

const Histo3DMapLitID& GaudiHistos< PBASE >::histo3DMapLitID | ( |  | ) | const`[inline]`

get access to the map of all 3D histograms index via a literal (string) ID

Attention:
  This map only contains 3D histogram booked via a literal ID.

      const Histo3DMapLitID& histos = histo3DMapLitID() ;
      // iterate over the map!
      for ( Histo3DMapLitID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IHistogram3D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2099 of file GaudiHistos.h.

    02099 { return m_histo3DMapLitID; }

template<class PBASE>

const Profile1DMapTitle& GaudiHistos< PBASE >::profile1DMapTitle | ( |  | ) | const`[inline]`

get access to the map of all 1D profile histograms indexed via their title

Using this method one can inspect e.g. a list of active histograms

      const Profile1DMapTitle& histos = profile1DMapTitle() ;
      // iterate over the map!
      for ( Profile1DMapTitle::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram title
            const std::string&   title = entry->first ;
            // histogram itself
            AIDA::IProfile1D* hist  = entry->second ;
            if( 0 == hist )  { continue ; }                // ATTENTION!

            std::cout << " Histogram title " << title << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2128 of file GaudiHistos.h.

    02128 { return m_profile1DMapTitle; }

template<class PBASE>

const Profile1DMapNumID& GaudiHistos< PBASE >::profile1DMapNumID | ( |  | ) | const`[inline]`

get access to the map of 1D profile histograms index via a numeric ID

Attention:
  This map only contains 2D histogram booked via a numeric ID, either forced or automatically assigned.

      const Profile1DMapNumID& histos = profile1DMapNumID() ;
      // iterate over the map!
      for ( Profile1DMapNumID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IProfile1D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2159 of file GaudiHistos.h.

    02159 { return m_profile1DMapNumID; }

template<class PBASE>

const Profile1DMapLitID& GaudiHistos< PBASE >::profile1DMapLitID | ( |  | ) | const`[inline]`

get access to the map of 1D profile histograms index via a literal ID

Attention:
  This map only contains 2D histogram booked via a literal ID, either forced or automatically assigned.

      const Profile1DMapLitID& histos = profile1DMapLitID() ;
      // iterate over the map!
      for ( Profile1DMapLitID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IProfile1D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2190 of file GaudiHistos.h.

    02190 { return m_profile1DMapLitID; }

template<class PBASE>

const Profile2DMapTitle& GaudiHistos< PBASE >::profile2DMapTitle | ( |  | ) | const`[inline]`

get access to the map of all 2D profile histograms indexed via their title

Using this method one can inspect e.g. a list of active histograms

      const Profile2DMapTitle& histos = profile2DMapTitle() ;
      // iterate over the map!
      for ( Profile2DMapTitle::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram title
            const std::string&   title = entry->first ;
            // histogram itself
            AIDA::IProfile2D* hist  = entry->second ;
            if( 0 == hist )  { continue ; }                // ATTENTION!

            std::cout << " Histogram title " << title << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2219 of file GaudiHistos.h.

    02219 { return m_profile2DMapTitle; }

template<class PBASE>

const Profile2DMapNumID& GaudiHistos< PBASE >::profile2DMapNumID | ( |  | ) | const`[inline]`

get access to the map of 2D profile histograms index via a numeric ID

Attention:
  This map only contains 2D histogram booked via a numeric ID, either forced or automatically assigned.

      const Profile2DMapNumID& histos = profile2DMapNumID() ;
      // iterate over the map!
      for ( Profile2DMapNumID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IProfile2D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2250 of file GaudiHistos.h.

    02250 { return m_profile2DMapNumID; }

template<class PBASE>

const Profile2DMapLitID& GaudiHistos< PBASE >::profile2DMapLitID | ( |  | ) | const`[inline]`

get access to the map of 2D profile histograms index via a literal ID

Attention:
  This map only contains 2D histogram booked via a literal ID, either forced or automatically assigned.

      const Profile2DMapLitID& histos = profile2DMapLitID() ;
      // iterate over the map!
      for ( Profile2DMapLitID::const_iterator entry = histos.begin() ;
            histos.end() != entry ; ++entry  )
         {
            // histogram ID
            const HistoID        ID = entry->first ;
            // histogram itself
            AIDA::IProfile2D* h  = entry->second ;
            if ( 0 == h ) { continue ;}

            std::cout << " Histogram ID    " << ID
                      << " Histogram title " << h->title() << std::endl ;

         }

Attention:
  The map *COULD* contains NULL pointers, the check before use is mandatory!

Definition at line 2281 of file GaudiHistos.h.

    02281 { return m_profile2DMapLitID; }

template<class PBASE>

void GaudiHistos< PBASE >::setProduceHistos | ( | const bool | val | ) | `[inline]`

set the flag for histogram production (property "HistoProduce")

Definition at line 2286 of file GaudiHistos.h.

    02286 { m_produceHistos = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setFullDetail | ( | const bool | val | ) | `[inline]`

set flag to control output level of histograms

Definition at line 2288 of file GaudiHistos.h.

    02288 { m_fullDetail    = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setCheckForNaN | ( | const bool | val | ) | `[inline]`

set the flag for NaN checks (property "HistoCheckForNan")

Definition at line 2290 of file GaudiHistos.h.

    02290 { m_checkForNaN   = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setSplitHistoDir | ( | const bool | val | ) | `[inline]`

set the flag for histogram path split (property "HistoSplitDir")

Definition at line 2292 of file GaudiHistos.h.

    02292 { m_splitHistoDir = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setHistoOffSet | ( | const HistoID::NumericID | val | ) | `[inline]`

set a value for histogram offset (property "HistoOffSet"

Definition at line 2294 of file GaudiHistos.h.

    02295   { m_histoOffSet   = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setHistoTopDir | ( | const std::string & | val | ) | `[inline]`

set top-level histogram directory (property "HistoTopDir")

Definition at line 2298 of file GaudiHistos.h.

    02298 { m_histoTopDir   = val ; }

template<class PBASE>

void GaudiHistos< PBASE >::setHistoDir | ( | const std::string & | val | ) | `[inline]`

set histogram directory (property "HistoDir")

Definition at line 2301 of file GaudiHistos.h.

    02301 { m_histoDir      = val ; }

template<class PBASE>

StatusCode GaudiHistos< PBASE >::initialize | ( |  | ) | `[inline, protected, virtual]`

standard initialization method

Returns:
  status code

Reimplemented in GaudiHistoAlg, GaudiHistoTool, GaudiTupleAlg, GaudiTupleTool, GaudiTuples< GaudiHistoTool >, and GaudiTuples< GaudiHistoAlg >.

Definition at line 129 of file GaudiHistos.icpp.

    00130 {
    00131   // initialize base class
    00132   const StatusCode sc = PBASE::initialize();
    00133   if ( sc.isFailure() ) return sc;
    00134
    00135   // produce histograms?
    00136   if ( !produceHistos() )
    00137   {
    00138     this->debug() << "Histogram production is switched OFF" << endreq;
    00139     return sc;
    00140   }
    00141
    00142   // check the validity of histogram service
    00143   if ( 0 == this->histoSvc() )
    00144   { return this->Error("initialize():: IHistogramSvc* is invalid"); }
    00145
    00146   // Warn if the user has decided to use numerical automatic IDs
    00147   if ( useNumericAutoIDs() )
    00148   {
    00149     this ->
    00150       Warning( "Using numerical automatic IDs. These are not guaranteed to be totally deterministic. Use with care...",
    00151                StatusCode::SUCCESS );
    00152   }
    00153
    00154   // Finally, print the location histogram will be written to
    00155   Print
    00156     ( "The histogram path is set to be '" + histoPath() + "'",
    00157       StatusCode( StatusCode::SUCCESS, true )  , MSG::DEBUG );
    00158
    00159   return sc;
    00160 }

template<class PBASE>

StatusCode GaudiHistos< PBASE >::finalize | ( | void |  | ) | `[inline, protected, virtual]`

standard finalization method

Returns:
  status code

Reimplemented in GaudiHistoAlg, GaudiHistoTool, GaudiTupleAlg, GaudiTupleTool, GaudiTuples< GaudiHistoTool >, and GaudiTuples< GaudiHistoAlg >.

Definition at line 165 of file GaudiHistos.icpp.

    00166 {
    00167
    00168   if ( produceHistos() )
    00169   {
    00170
    00171     // Count how many histos of each type
    00172     if ( !noHistos() )
    00173     {
    00174       const unsigned int n1D  = histo1DMapNumID().size()+histo1DMapLitID().size();
    00175       const unsigned int n2D  = histo2DMapNumID().size()+histo2DMapLitID().size();
    00176       const unsigned int n3D  = histo3DMapNumID().size()+histo3DMapLitID().size();
    00177       const unsigned int n1DP = profile1DMapNumID().size()+profile1DMapLitID().size();
    00178       const unsigned int n2DP = profile2DMapNumID().size()+profile2DMapLitID().size();
    00179       const unsigned int total = n1D+n2D+n3D+n1DP+n2DP;
    00180       if ( total>0 )
    00181       {
    00182         this->always() << "Booked " << total << " Histogram(s) : ";
    00183         if ( n1D>0  ) this->always() << "1D=" << n1D << " ";
    00184         if ( n2D>0  ) this->always() << "2D=" << n2D << " ";
    00185         if ( n3D>0  ) this->always() << "3D=" << n3D << " ";
    00186         if ( n1DP>0 ) this->always() << "1DProf=" << n1DP << " ";
    00187         if ( n2DP>0 ) this->always() << "2DProf=" << n2DP << " ";
    00188         this->always() << endreq;
    00189       }
    00190     }
    00191
    00192     // detailed printing
    00193     if ( histosPrint() ) { printHistos() ; }
    00194
    00195   }
    00196
    00197   // clear all maps
    00198   m_histo1DMapTitle   .clear() ;
    00199   m_histo2DMapTitle   .clear() ;
    00200   m_histo3DMapTitle   .clear() ;
    00201   m_histo1DMapNumID   .clear() ;
    00202   m_histo1DMapLitID   .clear() ;
    00203   m_histo2DMapNumID   .clear() ;
    00204   m_histo2DMapLitID   .clear() ;
    00205   m_histo3DMapNumID   .clear() ;
    00206   m_histo3DMapLitID   .clear() ;
    00207   m_profile1DMapTitle .clear() ;
    00208   m_profile2DMapTitle .clear() ;
    00209   m_profile1DMapNumID .clear() ;
    00210   m_profile1DMapLitID .clear() ;
    00211   m_profile2DMapNumID .clear() ;
    00212   m_profile2DMapLitID .clear() ;
    00213
    00214   // finalize base class
    00215   return PBASE::finalize();
    00216 }

template<class PBASE>

bool GaudiHistos< PBASE >::noHistos | ( |  | ) | const`[inline, private]`

Check if all histogram maps are empty.

Definition at line 417 of file GaudiHistos.icpp.

    00418 {
    00419   return ( histo1DMapTitle()   .empty() &&
    00420            histo2DMapTitle()   .empty() &&
    00421            histo3DMapTitle()   .empty() &&
    00422            profile1DMapTitle() .empty() &&
    00423            profile2DMapTitle() .empty() &&
    00424            histo1DMapNumID()   .empty() &&
    00425            histo1DMapLitID()   .empty() &&
    00426            histo2DMapNumID()   .empty() &&
    00427            histo2DMapLitID()   .empty() &&
    00428            histo3DMapNumID()   .empty() &&
    00429            histo3DMapLitID()   .empty() &&
    00430            profile1DMapNumID() .empty() &&
    00431            profile1DMapLitID() .empty() &&
    00432            profile2DMapNumID() .empty() &&
    00433            profile2DMapLitID() .empty() );
    00434 }

template<class PBASE>

void GaudiHistos< PBASE >::initGaudiHistosConstructor | ( |  | ) | `[inline, private]`

Constructor initialisation and job options.

Definition at line 60 of file GaudiHistos.icpp.

    00061 {
    00062   // SWITCH ON/OFF the histograms
    00063   this->declareProperty
    00064     ( "HistoProduce"          ,
    00065       m_produceHistos = true  ,
    00066       "Swith on/off the production of histograms "   ) ;
    00067   // print the histograms at finalization
    00068   this->declareProperty
    00069     ( "HistoPrint"            ,
    00070       m_histosPrint   = false ,
    00071       "Switch on/off the printout of histograms at finalization"    ) ;
    00072   // check for NaN/Finite
    00073   this->declareProperty
    00074     ( "HistoCheckForNaN"      ,
    00075       m_checkForNaN   = true  ,
    00076       "Swicth on/off the checks for NaN and Infinity for histogram fill" ) ;
    00077   // for HBOOK persistency, 'true' can be useful
    00078   this->declareProperty
    00079     ( "HistoSplitDir"         ,
    00080       m_splitHistoDir = false ,
    00081       "Split long directory names into short pieces (suitable for HBOOK)" );
    00082   // general OffSet for histogram ID
    00083   this->declareProperty
    00084     ( "HistoOffSet"           ,
    00085       m_histoOffSet   =   0   ,
    00086       "OffSet for automatically assigned histogram numerical identifiers " ) ;
    00087   // top level histogram directory
    00088   this->declareProperty
    00089     ( "HistoTopDir"           ,
    00090       m_histoTopDir   =   ""  ,
    00091       "Top level histogram directory (take care that it ends with '/')" ) ;
    00092   // histogram directory
    00093   this->declareProperty
    00094     ( "HistoDir"             ,
    00095       m_histoDir      = this->name() ,
    00096       "Histogram Directory" ) ;
    00097   // control output level of histograms
    00098   this->declareProperty ( "FullDetail"            , m_fullDetail    = false ) ;
    00099   // monitor histograms
    00100   this->declareProperty ( "MonitorHistograms"     , m_declareMoniHists = true ) ;
    00101   // format for 1D-histograms printout
    00102   this->declareProperty
    00103     ( "FormatFor1DHistoTable" ,
    00104       m_histo1DTableFormat   = Gaudi::Utils::Histos::Formats::format () ,
    00105       "Format string for printout of 1D histograms"      ) ;
    00106   // "short" format for 1D-histograms printout
    00107   this->declareProperty
    00108     ( "ShortFormatFor1DHistoTable" ,
    00109       m_histo1DTableFormatShort   = " | %1$-25.25s %2%"  ,
    00110       "Format string for printout of 1D histograms"      ) ;
    00111   // the header for 1D-histogram tabkle
    00112   this->declareProperty
    00113     ( "HeaderFor1DHistoTable" ,
    00114       m_histo1DTableHeader   = Gaudi::Utils::Histos::Formats::header () ,
    00115       "The table header for printout of 1D histograms "  ) ;
    00116   this->declareProperty
    00117     ( "UseSequencialNumericAutoIDs", m_useNumericAutoIDs = false,
    00118       "Flag to allow users to switch back to the old style of creating numerical automatic IDs" );
    00119   m_idReplaceInfo.clear();
    00120   m_idReplaceInfo["/"] = "=SLASH=";
    00121   this->declareProperty
    00122     ( "AutoStringIDPurgeMap", m_idReplaceInfo,
    00123       "Map of strings to search and replace when using the title as the basis of automatically generated literal IDs" );
    00124 }

template<class PBASE>

void GaudiHistos< PBASE >::monitorHisto | ( | const AIDA::IBaseHistogram * | hist,
|  | const HistoID & | ID |
| ) |  |  | const`[inline, private]`

Declare a histogram to the monitor service.

Uses the histogram ID as the 'name' sent to the monitor service and the histogram title as the long description

Definition at line 442 of file GaudiHistos.icpp.

    00444 {
    00445   if ( hist && m_declareMoniHists )
    00446   {
    00447     if ( this->msgLevel(MSG::DEBUG) )
    00448     {
    00449       this->debug() << "Monitoring histogram '"
    00450                     << ID.idAsString() << "' desc = '"
    00451                     << Gaudi::Utils::Histos::htitle  ( hist ) << endreq;
    00452     }
    00453     this->declareInfo ( histoPath()+"/"+ID.idAsString() ,
    00454                         hist            ,
    00455                         Gaudi::Utils::Histos::htitle ( hist ) ) ;
    00456   }
    00457 }

template<class PBASE>

void GaudiHistos< PBASE >::newHistoID | ( | const std::string & | title,
|  | HistoID & | ID |
| ) |  |  | const`[inline, private]`

Create a new histogram ID using the given title.

Parameters:

  `[in]` | title | Histogram title
  `[out]` | ID | The ID to use for the new histogram

Definition at line 1643 of file GaudiHistos.icpp.

    01645 {
    01646   if ( useNumericAutoIDs() || title.empty() )
    01647   {
    01648     if ( !useNumericAutoIDs() )
    01649     {
    01650       this -> Warning( "Cannot generate automatic literal ID from an empty title ! Using numeric ID instead for histogram ID",
    01651                        StatusCode::SUCCESS );
    01652     }
    01653     // propose the histogram ID (always numeric)
    01654     ID = HistoID( totalNumberOfHistos() + 1 + histoOffSet() );
    01655     // adjust the proposed ID
    01656     while ( histoExists( ID ) ) { ++ID; }
    01657   }
    01658   else
    01659   {
    01660     // use the title to create a unique literal ID
    01661     ID = HistoID( this->convertTitleToID(title) );
    01662     // Just in case ...
    01663     while ( histoExists( ID ) ) { ID = HistoID(ID.idAsString()+"_"); }
    01664   }
    01665 }

template<class PBASE>

void GaudiHistos< PBASE >::stringSearchReplace | ( | std::string & | title,
|  | const std::string & | A,
|  | const std::string & | B |
| ) |  |  | const`[inline, private]`

Searches 'title' for all instancies of 'A' and replaces them with 'B'.

Definition at line 1685 of file GaudiHistos.icpp.

    01688 {
    01689   std::string::size_type slash = title.find_first_of ( A ) ;
    01690   while ( std::string::npos != slash )
    01691   {
    01692     title = title.substr(0,slash) + B + title.substr(slash+A.size());
    01693     slash = title.find_first_of( A );
    01694   }
    01695 }

template<class PBASE>

std::string GaudiHistos< PBASE >::convertTitleToID | ( | const std::string & | title | ) | const`[inline, protected]`

Create an ID string from a title string.

Definition at line 1670 of file GaudiHistos.icpp.

    01671 {
    01672   // clean up the ID string for all unwanted characters
    01673   std::string tmp_id = title;
    01674   for ( std::map<std::string,std::string>::const_iterator i = m_idReplaceInfo.begin();
    01675         i != m_idReplaceInfo.end(); ++i )
    01676   {
    01677     stringSearchReplace( tmp_id, i->first, i->second );
    01678   }
    01679   return tmp_id;
    01680 }

## Member Data Documentation

template<class PBASE>

bool GaudiHistos< PBASE >::m_produceHistos`[private]`

flag to SWITCH ON/SWITCH OFF the histogrm fillling and booking

Definition at line 2365 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_fullDetail`[private]`

flag to control output level of histograms

Definition at line 2367 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_checkForNaN`[private]`

flag to control check for Nan/Finite while filling the histogram

Definition at line 2369 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_splitHistoDir`[private]`

split histogram directory name (very useful for Hbook)

Definition at line 2371 of file GaudiHistos.h.

template<class PBASE>

HistoID::NumericID GaudiHistos< PBASE >::m_histoOffSet`[private]`

general histogram ID offset (only works for automatically assigned numeric IDs)

Definition at line 2373 of file GaudiHistos.h.

template<class PBASE>

std::string GaudiHistos< PBASE >::m_histoTopDir`[private]`

histogram top level directory

Definition at line 2375 of file GaudiHistos.h.

template<class PBASE>

std::string GaudiHistos< PBASE >::m_histoDir`[private]`

histogram directory

Definition at line 2377 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_histosPrint`[private]`

print histograms at finalization

Definition at line 2379 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_declareMoniHists`[private]`

Flag to turn on/off the registration of histograms to the Monitoring Service.

Definition at line 2381 of file GaudiHistos.h.

template<class PBASE>

Histo1DMapTitle GaudiHistos< PBASE >::m_histo1DMapTitle`[mutable, private]`

the actual storage/access of 1D histograms by unique title

Definition at line 2384 of file GaudiHistos.h.

template<class PBASE>

Histo1DMapNumID GaudiHistos< PBASE >::m_histo1DMapNumID`[mutable, private]`

the actual storage/access of 1D histograms by unique numeric ID

Definition at line 2386 of file GaudiHistos.h.

template<class PBASE>

Histo1DMapLitID GaudiHistos< PBASE >::m_histo1DMapLitID`[mutable, private]`

the actual storage/access of 1D histograms by unique literal ID

Definition at line 2388 of file GaudiHistos.h.

template<class PBASE>

Histo2DMapTitle GaudiHistos< PBASE >::m_histo2DMapTitle`[mutable, private]`

the actual storage/access of 2D histograms by unique title

Definition at line 2391 of file GaudiHistos.h.

template<class PBASE>

Histo2DMapNumID GaudiHistos< PBASE >::m_histo2DMapNumID`[mutable, private]`

the actual storage/access of 2D histograms by unique numeric ID

Definition at line 2393 of file GaudiHistos.h.

template<class PBASE>

Histo2DMapLitID GaudiHistos< PBASE >::m_histo2DMapLitID`[mutable, private]`

the actual storage/access of 2D histograms by unique literal ID

Definition at line 2395 of file GaudiHistos.h.

template<class PBASE>

Histo3DMapTitle GaudiHistos< PBASE >::m_histo3DMapTitle`[mutable, private]`

the actual storage/access of 3D histograms by unique title

Definition at line 2398 of file GaudiHistos.h.

template<class PBASE>

Histo3DMapNumID GaudiHistos< PBASE >::m_histo3DMapNumID`[mutable, private]`

the actual storage/access of 3D histograms by unique numeric ID

Definition at line 2400 of file GaudiHistos.h.

template<class PBASE>

Histo3DMapLitID GaudiHistos< PBASE >::m_histo3DMapLitID`[mutable, private]`

the actual storage/access of 3D histograms by unique literal ID

Definition at line 2402 of file GaudiHistos.h.

template<class PBASE>

Profile1DMapTitle GaudiHistos< PBASE >::m_profile1DMapTitle`[mutable, private]`

the actual storage/access of 1D profile histograms by unique title

Definition at line 2405 of file GaudiHistos.h.

template<class PBASE>

Profile1DMapNumID GaudiHistos< PBASE >::m_profile1DMapNumID`[mutable, private]`

the actual storage/access of 1D profile histograms by unique numeric ID

Definition at line 2407 of file GaudiHistos.h.

template<class PBASE>

Profile1DMapLitID GaudiHistos< PBASE >::m_profile1DMapLitID`[mutable, private]`

the actual storage/access of 1D profile histograms by unique literal ID

Definition at line 2409 of file GaudiHistos.h.

template<class PBASE>

Profile2DMapTitle GaudiHistos< PBASE >::m_profile2DMapTitle`[mutable, private]`

the actual storage/access of 2D profile histograms by unique title

Definition at line 2412 of file GaudiHistos.h.

template<class PBASE>

Profile2DMapNumID GaudiHistos< PBASE >::m_profile2DMapNumID`[mutable, private]`

the actual storage/access of 2D profile histograms by unique numeric ID

Definition at line 2414 of file GaudiHistos.h.

template<class PBASE>

Profile2DMapLitID GaudiHistos< PBASE >::m_profile2DMapLitID`[mutable, private]`

the actual storage/access of 2D profile histograms by unique literal ID

Definition at line 2416 of file GaudiHistos.h.

template<class PBASE>

std::string GaudiHistos< PBASE >::m_histo1DTableFormat`[private]`

format for printout of 1D-histograms as a table

Definition at line 2419 of file GaudiHistos.h.

template<class PBASE>

std::string GaudiHistos< PBASE >::m_histo1DTableFormatShort`[private]`

format for printout of 1D-histograms as a table

Definition at line 2421 of file GaudiHistos.h.

template<class PBASE>

std::string GaudiHistos< PBASE >::m_histo1DTableHeader`[private]`

the header for the table of 1-D historgrams

Definition at line 2423 of file GaudiHistos.h.

template<class PBASE>

bool GaudiHistos< PBASE >::m_useNumericAutoIDs`[private]`

Flag to switch back to the old style sequencial numerical automatic IDs.

Definition at line 2425 of file GaudiHistos.h.

template<class PBASE>

std::map<std::string,std::string> GaudiHistos< PBASE >::m_idReplaceInfo`[private]`

Map of strings to search and replace when using the title as the basis of automatically generated literal IDs.

Definition at line 2429 of file GaudiHistos.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiAlg/GaudiAlg/GaudiHistos.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v20r4/GaudiAlg/GaudiAlg/GaudiHistos.icpp