| # Gaudi Framework, version v21r6 |

Home |  | Generated: 11 Nov 2009

# HistogramSvc Class Reference

`#include <HistogramSvc.h>`

Inheritance diagram for HistogramSvc:

[legend]
Collaboration diagram for HistogramSvc:

[legend]

List of all members.

## Detailed Description

HistogramSvc class definition.

Definition at line 49 of file HistogramSvc.h.

## Public Types
typedef std::map< std::string, Gaudi::Histo1DDef > | Histo1DMap
## Public Member Functions
| HistogramSvc (CSTR name, ISvcLocator *svc)
| Statndard Constructor.
virtual | ~HistogramSvc ()
| Destructor.
std::pair< std::string, std::string > | i_splitPath (CSTR full)
| Split full path into its components.
StatusCode | connectInput (CSTR ident)
| Connect input histogram file to the service.
std::string | _STR (int i)
template<class T>
T * | i_book (DataObject *pPar, CSTR rel, CSTR title, const std::pair< DataObject *, T * > &o)
H2D * | i_project (CSTR nameAndTitle, const H3D &h, CSTR dir)
| Helper for 2D projections.
virtual StatusCode | initialize ()
| Initialise the service.
virtual StatusCode | reinitialize ()
| Initialise the service.
virtual StatusCode | finalize ()
| finalize the service
virtual AIDA::IHistogramFactory * | histogramFactory ()
| Retrieve the AIDA HistogramFactory interface.
virtual H1D * | book (CSTR par, CSTR rel, CSTR title, DBINS(x))
| Book histogram and register it with the histogram data store.
virtual H1D * | book (CSTR par, int hID, CSTR title, DBINS(x))
virtual H1D * | book (DataObject *pPar, int hID, CSTR title, DBINS(x))
virtual H1D * | book (DataObject *pPar, CSTR rel, CSTR title, DBINS(x))
virtual H1D * | book (STRPAIR loc, CSTR title, DBINS(x))
virtual H1D * | book (CSTR full, CSTR title, DBINS(x))
virtual P1D * | bookProf (CSTR par, CSTR rel, CSTR title, DBINS(x), CSTR opt)
| Book histogram and register it with the histogram data store.
virtual P1D * | bookProf (CSTR par, int hID, CSTR title, DBINS(x), CSTR opt)
virtual P1D * | bookProf (DataObject *pPar, int hID, CSTR title, DBINS(x), CSTR opt)
virtual P1D * | bookProf (STRPAIR loc, CSTR title, DBINS(x), CSTR opt)
virtual P1D * | bookProf (CSTR full, CSTR title, DBINS(x), CSTR opt)
virtual P1D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), CSTR opt)
virtual P1D * | bookProf (CSTR par, CSTR rel, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual P1D * | bookProf (CSTR par, int hID, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual P1D * | bookProf (DataObject *pPar, int hID, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual P1D * | bookProf (STRPAIR loc, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual P1D * | bookProf (CSTR full, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual P1D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), double upper, double lower, CSTR opt)
virtual H1D * | book (CSTR par, int hID, CSTR title, Edges e)
| Book histogram and register it with the histogram data store.
virtual H1D * | book (DataObject *pPar, int hID, CSTR title, Edges e)
virtual H1D * | book (CSTR par, CSTR rel, CSTR title, Edges e)
virtual H1D * | book (STRPAIR loc, CSTR title, Edges e)
virtual H1D * | book (CSTR full, CSTR title, Edges e)
virtual H1D * | book (DataObject *pPar, CSTR rel, CSTR title, Edges e)
virtual P1D * | bookProf (CSTR full, CSTR title, Edges e)
| Book histogram and register it with the histogram data store.
virtual P1D * | bookProf (CSTR par, CSTR rel, CSTR title, Edges e)
virtual P1D * | bookProf (CSTR par, int hID, CSTR title, Edges e)
virtual P1D * | bookProf (DataObject *pPar, int hID, CSTR title, Edges e)
virtual P1D * | bookProf (STRPAIR loc, CSTR title, Edges e)
virtual P1D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, Edges e)
virtual P1D * | bookProf (CSTR full, CSTR title, Edges e, double upper, double lower)
virtual P1D * | bookProf (CSTR par, CSTR rel, CSTR title, Edges e, double upper, double lower)
virtual P1D * | bookProf (CSTR par, int hID, CSTR title, Edges e, double upper, double lower)
virtual P1D * | bookProf (DataObject *pPar, int hID, CSTR title, Edges e, double upper, double lower)
virtual P1D * | bookProf (STRPAIR loc, CSTR title, Edges e, double upper, double lower)
virtual P1D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, Edges e, double upper, double lower)
virtual H2D * | book (CSTR full, CSTR title, DBINS(x), DBINS(y))
| Book histogram and register it with the histogram data store.
virtual H2D * | book (CSTR par, CSTR rel, CSTR title, DBINS(x), DBINS(y))
virtual H2D * | book (CSTR par, int hID, CSTR title, DBINS(x), DBINS(y))
virtual H2D * | book (STRPAIR loc, CSTR title, DBINS(x), DBINS(y))
virtual H2D * | book (DataObject *pPar, int hID, CSTR title, DBINS(x), DBINS(y))
virtual H2D * | book (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (CSTR full, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
| Book histogram and register it with the histogram data store.
virtual P2D * | bookProf (CSTR par, CSTR rel, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
virtual P2D * | bookProf (STRPAIR loc, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
virtual P2D * | bookProf (CSTR par, int hID, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
virtual P2D * | bookProf (DataObject *pPar, int hID, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
virtual P2D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), DBINS(y), double upper, double lower)
virtual P2D * | bookProf (CSTR full, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (CSTR par, CSTR rel, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (STRPAIR loc, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (CSTR par, int hID, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (DataObject *pPar, int hID, CSTR title, DBINS(x), DBINS(y))
virtual P2D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), DBINS(y))
virtual H2D * | book (CSTR full, CSTR title, Edges x, Edges y)
| Book histogram and register it with the histogram data store.
virtual H2D * | book (CSTR par, CSTR rel, CSTR title, Edges x, Edges y)
virtual H2D * | book (CSTR par, int hID, CSTR title, Edges x, Edges y)
virtual H2D * | book (STRPAIR loc, CSTR title, Edges x, Edges y)
virtual H2D * | book (DataObject *pPar, int hID, CSTR title, Edges x, Edges y)
virtual H2D * | book (DataObject *pPar, CSTR rel, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (CSTR full, CSTR title, Edges x, Edges y)
| Book histogram and register it with the histogram data store.
virtual P2D * | bookProf (CSTR par, CSTR rel, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (CSTR par, int hID, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (DataObject *pPar, int hID, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (STRPAIR loc, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, Edges x, Edges y)
virtual P2D * | bookProf (CSTR full, CSTR title, Edges x, Edges y, double upper, double lower)
virtual P2D * | bookProf (CSTR par, CSTR rel, CSTR title, Edges x, Edges y, double upper, double lower)
virtual P2D * | bookProf (CSTR par, int hID, CSTR title, Edges x, Edges y, double upper, double lower)
virtual P2D * | bookProf (DataObject *pPar, int hID, CSTR title, Edges x, Edges y, double upper, double lower)
virtual P2D * | bookProf (STRPAIR loc, CSTR title, Edges x, Edges y, double upper, double lower)
virtual P2D * | bookProf (DataObject *pPar, CSTR rel, CSTR title, Edges x, Edges y, double upper, double lower)
virtual H3D * | book (CSTR full, CSTR title, DBINS(x), DBINS(y), DBINS(z))
| Book histogram and register it with the histogram data store.
virtual H3D * | book (CSTR par, CSTR rel, CSTR title, DBINS(x), DBINS(y), DBINS(z))
virtual H3D * | book (CSTR par, int hID, CSTR title, DBINS(x), DBINS(y), DBINS(z))
virtual H3D * | book (DataObject *pPar, int hID, CSTR title, DBINS(x), DBINS(y), DBINS(z))
virtual H3D * | book (STRPAIR loc, CSTR title, DBINS(x), DBINS(y), DBINS(z))
virtual H3D * | book (DataObject *pPar, CSTR rel, CSTR title, DBINS(x), DBINS(y), DBINS(z))
virtual H3D * | book (CSTR full, CSTR title, Edges x, Edges y, Edges z)
| Book histogram and register it with the histogram data store.
virtual H3D * | book (CSTR par, CSTR rel, CSTR title, Edges x, Edges y, Edges z)
virtual H3D * | book (CSTR par, int hID, CSTR title, Edges x, Edges y, Edges z)
virtual H3D * | book (DataObject *pPar, int hID, CSTR title, Edges x, Edges y, Edges z)
virtual H3D * | book (STRPAIR loc, CSTR title, Edges x, Edges y, Edges z)
virtual H3D * | book (DataObject *pPar, CSTR rel, CSTR title, Edges x, Edges y, Edges z)
virtual StatusCode | registerObject (CSTR parent, CSTR rel, Base *obj)
virtual StatusCode | registerObject (CSTR parent, int item, Base *obj)
virtual StatusCode | registerObject (Base *pPar, CSTR rel, Base *obj)
virtual StatusCode | registerObject (DataObject *pPar, int item, Base *obj)
virtual StatusCode | registerObject (Base *pPar, int item, Base *obj)
virtual StatusCode | registerObject (CSTR full, Base *obj)
virtual StatusCode | registerObject (DataObject *pPar, CSTR rel, Base *obj)
virtual StatusCode | unregisterObject (Base *obj)
virtual StatusCode | unregisterObject (Base *obj, CSTR objectPath)
virtual StatusCode | unregisterObject (Base *obj, int item)
virtual StatusCode | retrieveObject (IRegistry *pReg, CSTR path, H1D *&obj)
virtual StatusCode | retrieveObject (IRegistry *pReg, CSTR path, P1D *&obj)
virtual StatusCode | retrieveObject (IRegistry *pReg, CSTR path, H2D *&obj)
virtual StatusCode | retrieveObject (IRegistry *pReg, CSTR path, P2D *&obj)
virtual StatusCode | retrieveObject (IRegistry *pReg, CSTR path, H3D *&obj)
virtual StatusCode | retrieveObject (CSTR full, P1D *&obj)
virtual StatusCode | retrieveObject (CSTR full, P2D *&obj)
virtual StatusCode | retrieveObject (CSTR full, H1D *&obj)
virtual StatusCode | retrieveObject (CSTR full, H2D *&obj)
virtual StatusCode | retrieveObject (CSTR full, H3D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, CSTR rel, P1D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, CSTR rel, P2D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, CSTR rel, H1D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, CSTR rel, H2D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, CSTR rel, H3D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, int item, P1D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, int item, P2D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, int item, H1D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, int item, H2D *&obj)
virtual StatusCode | retrieveObject (CSTR parent, int item, H3D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, CSTR item, P1D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, CSTR item, P2D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, CSTR item, H1D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, CSTR item, H2D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, CSTR item, H3D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, int item, P1D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, int item, P2D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, int item, H1D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, int item, H2D *&obj)
virtual StatusCode | retrieveObject (DataObject *par, int item, H3D *&obj)
virtual StatusCode | retrieveObject (Base *par, int item, P1D *&obj)
virtual StatusCode | retrieveObject (Base *par, int item, P2D *&obj)
virtual StatusCode | retrieveObject (Base *par, int item, H1D *&obj)
virtual StatusCode | retrieveObject (Base *par, int item, H2D *&obj)
virtual StatusCode | retrieveObject (Base *par, int item, H3D *&obj)
virtual StatusCode | retrieveObject (Base *par, CSTR item, P1D *&obj)
virtual StatusCode | retrieveObject (Base *par, CSTR item, P2D *&obj)
virtual StatusCode | retrieveObject (Base *par, CSTR item, H1D *&obj)
virtual StatusCode | retrieveObject (Base *par, CSTR item, H2D *&obj)
virtual StatusCode | retrieveObject (Base *par, CSTR item, H3D *&obj)
virtual StatusCode | findObject (IRegistry *pReg, CSTR path, P1D *&obj)
virtual StatusCode | findObject (IRegistry *pReg, CSTR path, P2D *&obj)
virtual StatusCode | findObject (IRegistry *pReg, CSTR path, H1D *&obj)
virtual StatusCode | findObject (IRegistry *pReg, CSTR path, H2D *&obj)
virtual StatusCode | findObject (IRegistry *pReg, CSTR path, H3D *&obj)
virtual StatusCode | findObject (CSTR full, P1D *&obj)
virtual StatusCode | findObject (CSTR full, P2D *&obj)
virtual StatusCode | findObject (CSTR full, H1D *&obj)
virtual StatusCode | findObject (CSTR full, H2D *&obj)
virtual StatusCode | findObject (CSTR full, H3D *&obj)
virtual StatusCode | findObject (CSTR par, CSTR rel, P1D *&obj)
virtual StatusCode | findObject (CSTR par, CSTR rel, P2D *&obj)
virtual StatusCode | findObject (CSTR par, CSTR rel, H1D *&obj)
virtual StatusCode | findObject (CSTR par, CSTR rel, H2D *&obj)
virtual StatusCode | findObject (CSTR par, CSTR rel, H3D *&obj)
virtual StatusCode | findObject (CSTR par, int item, P1D *&obj)
virtual StatusCode | findObject (CSTR par, int item, P2D *&obj)
virtual StatusCode | findObject (CSTR par, int item, H1D *&obj)
virtual StatusCode | findObject (CSTR par, int item, H2D *&obj)
virtual StatusCode | findObject (CSTR par, int item, H3D *&obj)
virtual StatusCode | findObject (DataObject *par, int item, P1D *&obj)
virtual StatusCode | findObject (DataObject *par, int item, P2D *&obj)
virtual StatusCode | findObject (DataObject *par, int item, H1D *&obj)
virtual StatusCode | findObject (DataObject *par, int item, H2D *&obj)
virtual StatusCode | findObject (DataObject *par, int item, H3D *&obj)
virtual StatusCode | findObject (DataObject *par, CSTR item, P1D *&obj)
virtual StatusCode | findObject (DataObject *par, CSTR item, P2D *&obj)
virtual StatusCode | findObject (DataObject *par, CSTR item, H1D *&obj)
virtual StatusCode | findObject (DataObject *par, CSTR item, H2D *&obj)
virtual StatusCode | findObject (DataObject *par, CSTR item, H3D *&obj)
virtual StatusCode | findObject (Base *par, int item, P1D *&obj)
virtual StatusCode | findObject (Base *par, int item, P2D *&obj)
virtual StatusCode | findObject (Base *par, int item, H1D *&obj)
virtual StatusCode | findObject (Base *par, int item, H2D *&obj)
virtual StatusCode | findObject (Base *par, int item, H3D *&obj)
virtual StatusCode | findObject (Base *par, CSTR item, P1D *&obj)
virtual StatusCode | findObject (Base *par, CSTR item, P2D *&obj)
virtual StatusCode | findObject (Base *par, CSTR item, H1D *&obj)
virtual StatusCode | findObject (Base *par, CSTR item, H2D *&obj)
virtual StatusCode | findObject (Base *par, CSTR item, H3D *&obj)
virtual H1D * | projectionX (CSTR name, const H2D &h)
virtual H1D * | projectionY (CSTR name, const H2D &h)
virtual H1D * | sliceX (CSTR name, const H2D &h, int indexY)
virtual H1D * | sliceY (CSTR name, const H2D &h, int indexX)
virtual H1D * | sliceX (CSTR name, const H2D &h, int indexY1, int indexY2)
virtual H1D * | sliceY (CSTR name, const H2D &h, int indexX1, int indexX2)
bool | destroy (IBaseHistogram *hist)
H1D * | add (CSTR nameAndTitle, const H1D &a, const H1D &b)
H1D * | subtract (CSTR nameAndTitle, const H1D &a, const H1D &b)
H1D * | multiply (CSTR nameAndTitle, const H1D &a, const H1D &b)
H1D * | divide (CSTR nameAndTitle, const H1D &a, const H1D &b)
H2D * | add (CSTR nameAndTitle, const H2D &a, const H2D &b)
H2D * | subtract (CSTR nameAndTitle, const H2D &a, const H2D &b)
H2D * | multiply (CSTR nameAndTitle, const H2D &a, const H2D &b)
H2D * | divide (CSTR nameAndTitle, const H2D &a, const H2D &b)
H3D * | add (CSTR nameAndTitle, const H3D &a, const H3D &b)
H3D * | subtract (CSTR nameAndTitle, const H3D &a, const H3D &b)
H3D * | multiply (CSTR nameAndTitle, const H3D &a, const H3D &b)
H3D * | divide (CSTR nameAndTitle, const H3D &a, const H3D &b)
H2D * | projectionXY (CSTR nameAndTitle, const H3D &h)
H2D * | projectionXZ (CSTR nameAndTitle, const H3D &h)
H2D * | projectionYZ (CSTR nameAndTitle, const H3D &h)
H2D * | sliceXY (CSTR, const H3D &, int, int) NOT_IMPLEMENTED H2D *sliceXZ(CSTR
H2D *const H3D int NOT_IMPLEMENTED H2D * | sliceYZ (CSTR, const H3D &, int, int) NOT_IMPLEMENTEDH1D *createHistogram1D(CSTR name
H2D *const H3D int NOT_IMPLEMENTED H2D *CSTR | DBINS (x))
H1D * | createHistogram1D (CSTR name, CSTR tit, DBINS(x), CSTR)
H1D * | createHistogram1D (CSTR name, CSTR title, const Edges &x, CSTR)
H1D * | createHistogram1D (CSTR nameAndTitle, DBINS(x))
H1D * | createCopy (CSTR full, const H1D &h)
H1D * | createCopy (CSTR par, CSTR rel, const H1D &h)
H1D * | createCopy (STRPAIR loc, const H1D &h)
H1D * | createCopy (DataObject *pPar, CSTR rel, const H1D &h)
H2D * | createHistogram2D (CSTR name, CSTR tit, DBINS(x), DBINS(y))
H2D * | createHistogram2D (CSTR name, CSTR tit, DBINS(x), DBINS(y), CSTR)
H2D * | createHistogram2D (CSTR name, CSTR title, const Edges &x, const Edges &y, CSTR)
H2D * | createHistogram2D (CSTR nameAndTitle, DBINS(x), DBINS(y))
H2D * | createCopy (CSTR full, const H2D &h)
H2D * | createCopy (CSTR par, CSTR rel, const H2D &h)
H2D * | createCopy (STRPAIR loc, const H2D &h)
H2D * | createCopy (DataObject *pPar, CSTR rel, const H2D &h)
H3D * | createHistogram3D (CSTR name, CSTR tit, DBINS(x), DBINS(y), DBINS(z))
H3D * | createHistogram3D (CSTR name, CSTR tit, DBINS(x), DBINS(y), DBINS(z), CSTR)
H3D * | createHistogram3D (CSTR name, CSTR title, const Edges &x, const Edges &y, const Edges &z, CSTR)
H3D * | createHistogram3D (CSTR nameAndTitle, DBINS(x), DBINS(y), DBINS(z))
H3D * | createCopy (CSTR full, const H3D &h)
H3D * | createCopy (CSTR par, CSTR rel, const H3D &h)
H3D * | createCopy (STRPAIR loc, const H3D &h)
H3D * | createCopy (DataObject *pPar, CSTR rel, const H3D &h)
P1D * | createProfile1D (CSTR name, CSTR tit, DBINS(x), CSTR opt)
P1D * | createProfile1D (CSTR name, CSTR tit, DBINS(x), double upper, double lower, CSTR opt)
P1D * | createProfile1D (CSTR name, CSTR title, const Edges &x, CSTR)
P1D * | createProfile1D (CSTR name, CSTR title, const Edges &x, double upper, double lower, CSTR)
P1D * | createProfile1D (CSTR nametit, DBINS(x))
P1D * | createProfile1D (CSTR nametit, DBINS(x), double upper, double lower)
P1D * | createCopy (CSTR full, const P1D &h)
P1D * | createCopy (CSTR par, CSTR rel, const P1D &h)
P1D * | createCopy (STRPAIR loc, const P1D &h)
P1D * | createCopy (DataObject *pPar, CSTR rel, const P1D &h)
P2D * | createProfile2D (CSTR name, CSTR tit, DBINS(x), DBINS(y))
P2D * | createProfile2D (CSTR name, CSTR tit, DBINS(x), DBINS(y), CSTR)
P2D * | createProfile2D (CSTR name, CSTR title, const Edges &x, const Edges &y, CSTR)
P2D * | createProfile2D (CSTR nameAndTitle, DBINS(x), DBINS(y))
P2D * | createProfile2D (CSTR name, CSTR tit, DBINS(x), DBINS(y), double upper, double lower)
P2D * | createProfile2D (CSTR name, CSTR tit, DBINS(x), DBINS(y), double upper, double lower, CSTR)
P2D * | createProfile2D (CSTR name, CSTR title, const Edges &x, const Edges &y, double upper, double lower, CSTR)
P2D * | createProfile2D (CSTR nameAndTitle, DBINS(x), DBINS(y), double upper, double lower)
P2D * | createCopy (CSTR full, const P2D &h)
P2D * | createCopy (CSTR par, CSTR rel, const P2D &h)
P2D * | createCopy (STRPAIR loc, const P2D &h)
P2D * | createCopy (DataObject *pPar, CSTR rel, const P2D &h)
virtual std::ostream & | print (Base *h, std::ostream &s=std::cout) const
| Print (ASCII) the 1D histogram into the output stream.
virtual std::ostream & | write (Base *h, std::ostream &s=std::cout) const
| Write (ASCII) the 1D histogram table into the output stream.
virtual int | write (Base *h, const char *file_name) const
| Write (ASCII) the 1D histogram table into a file.
virtual DataObject * | createPath (CSTR newPath)
| Create all directories in a given full path.
virtual DataObject * | createDirectory (CSTR parentDir, CSTR subDir)
| Create a sub-directory in a directory.
void | update1Ddefs (Property &)
| handler to be invoked for updating property m_defs1D
## Static Public Member Functions
template<class T>
static DataObject * | __cast (T *p)
## Public Attributes
H2D *const H3D | int
H2D *const H3D int NOT_IMPLEMENTED H2D *CSTR | tit
## Protected Types
typedef const std::string & | CSTR
typedef std::vector< double > | Edges
typedef std::vector< std::string > | DBaseEntries
typedef AIDA::IHistogram1D | H1D
typedef AIDA::IHistogram2D | H2D
typedef AIDA::IHistogram3D | H3D
typedef AIDA::IProfile1D | P1D
typedef AIDA::IProfile2D | P2D
typedef AIDA::IBaseHistogram | Base
## Protected Attributes
DBaseEntries | m_input
| Input streams.
## Private Types
typedef const std::pair < std::string, std::string > & | STRPAIR
## Private Member Functions
void | not_implemented () const
## Private Attributes
Histo1DMap | m_defs1D
std::set< std::string > | m_mods1D
## Friends
class | SvcFactory< HistogramSvc >
## Classes
struct | Helper

## Member Typedef Documentation

typedef const std::pair<std::string,std::string>& HistogramSvc::STRPAIR`[private]`

Definition at line 56 of file HistogramSvc.h.

typedef const std::string& HistogramSvc::CSTR`[protected]`

Definition at line 62 of file HistogramSvc.h.

typedef std::vector<double> HistogramSvc::Edges`[protected]`

Definition at line 63 of file HistogramSvc.h.

typedef std::vector<std::string> HistogramSvc::DBaseEntries`[protected]`

Definition at line 64 of file HistogramSvc.h.

typedef AIDA::IHistogram1D HistogramSvc::H1D`[protected]`

Definition at line 65 of file HistogramSvc.h.

typedef AIDA::IHistogram2D HistogramSvc::H2D`[protected]`

Definition at line 66 of file HistogramSvc.h.

typedef AIDA::IHistogram3D HistogramSvc::H3D`[protected]`

Definition at line 67 of file HistogramSvc.h.

typedef AIDA::IProfile1D HistogramSvc::P1D`[protected]`

Definition at line 68 of file HistogramSvc.h.

typedef AIDA::IProfile2D HistogramSvc::P2D`[protected]`

Definition at line 69 of file HistogramSvc.h.

typedef AIDA::IBaseHistogram HistogramSvc::Base`[protected]`

Definition at line 70 of file HistogramSvc.h.

typedef std::map<std::string,Gaudi::Histo1DDef> HistogramSvc::Histo1DMap

Definition at line 946 of file HistogramSvc.h.

## Constructor & Destructor Documentation

HistogramSvc::HistogramSvc | ( | CSTR | name,
|  | ISvcLocator * | svc |
| ) |  |  |

Statndard Constructor.

Parameters:

  | name | service name
  | pointer | to service locator interface

Definition at line 383 of file HistogramSvc.cpp.

    00384   : base_class(nam, svc)
    00385   , m_defs1D ()
    00386   , m_mods1D ()
    00387 {
    00388   // Properties can be declared here
    00389   m_rootName = "/stat";
    00390   m_rootCLID = CLID_DataObject;
    00391   declareProperty ( "Input",  m_input);
    00392   declareProperty ( "Predefined1DHistos" , m_defs1D ,
    00393                     "Histograms with predefined parameters" ) ;
    00394   // update handler
    00395   Property* p = Gaudi::Utils::getProperty ( this , "Predefined1DHistos" ) ;
    00396   p->declareUpdateHandler ( &HistogramSvc::update1Ddefs , this ) ;
    00397
    00398 }

HistogramSvc::~HistogramSvc | ( |  | ) | `[virtual]`

Destructor.

Definition at line 201 of file HistogramSvc.cpp.

    00201                               {
    00202   setDataLoader( 0 ).ignore();
    00203   clearStore().ignore();
    00204 }

## Member Function Documentation

void HistogramSvc::not_implemented | ( |  | ) | const`[inline, private]`

Definition at line 57 of file HistogramSvc.h.

    00057                                 {
    00058     MsgStream log( msgSvc(), name() );
    00059     log << MSG::ERROR << "Sorry, not yet implemented..." << endmsg;
    00060   }

std::pair< std::string, std::string > HistogramSvc::i_splitPath | ( | CSTR | full | ) |

Split full path into its components.

Parameters:

  | full | Full path of the object
  | dir | Resulting directory path
  | obj | Resulting object path

Definition at line 130 of file HistogramSvc.cpp.

    00130                                                                   {
    00131   std::string tmp = full;
    00132   if (tmp[0] != SEPARATOR)    {
    00133     tmp.insert(tmp.begin(), SEPARATOR);
    00134     tmp.insert(tmp.begin(), m_rootName.begin(), m_rootName.end());
    00135   }
    00136   // Remove trailing "/" from newPath if it exists
    00137   if (tmp.rfind(SEPARATOR) == tmp.length()-1) {
    00138     tmp.erase(tmp.rfind(SEPARATOR),1);
    00139   }
    00140   int sep = tmp.rfind(SEPARATOR);
    00141   return std::pair<std::string,std::string>
    00142     (tmp.substr(0,sep),tmp.substr(sep,tmp.length()-sep));
    00143 }

StatusCode HistogramSvc::connectInput | ( | CSTR | ident | ) |

Connect input histogram file to the service.

Parameters:

  | ident | [IN] Input specification

Definition at line 206 of file HistogramSvc.cpp.

    00206                                                 {
    00207   MsgStream log (msgSvc(), name());
    00208   DataObject* pO = 0;
    00209   StatusCode status = this->findObject(m_rootName, pO);
    00210   if (status.isSuccess())   {
    00211     Tokenizer tok(true);
    00212     std::string::size_type loc = ident.find(" ");
    00213     std::string filename, auth, svc = "", typ = "";
    00214     std::string logname = ident.substr(0,loc);
    00215     tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'");
    00216     for (Tokenizer::Items::iterator i = tok.items().begin();
    00217          i != tok.items().end(); i++) {
    00218       CSTR tag = (*i).tag();
    00219       switch(::toupper(tag[0]))   {
    00220       case 'F':   // FILE='<file name>'
    00221       case 'D':   // DATAFILE='<file name>'
    00222         filename = (*i).value();
    00223         break;
    00224       case 'T':   // TYP='<HBOOK,ROOT,OBJY,...>'
    00225         typ = (*i).value();
    00226         break;
    00227       default:
    00228         break;
    00229       }
    00230     }
    00231     if (typ.length() > 0)    {
    00232       // Now add the registry entry to the store
    00233       std::string entryname = m_rootName;
    00234       entryname += '/';
    00235       entryname += logname;
    00236       GenericAddress* pA = 0;
    00237       switch(::toupper(typ[0])) {
    00238       case 'H':
    00239         pA=new GenericAddress(HBOOK_StorageType,CLID_StatisticsFile,
    00240                               filename,entryname,0,'O');
    00241         break;
    00242       case 'R':
    00243         pA=new GenericAddress(ROOT_StorageType,CLID_StatisticsFile,
    00244                               filename,entryname,0,'O');
    00245         break;
    00246       }
    00247       if (0 != pA)    {
    00248         status = registerAddress(pO, logname, pA);
    00249         if (status.isSuccess())    {
    00250           log << MSG::INFO << "Added stream file:" << filename
    00251               << " as " << logname << endmsg;
    00252           return status;
    00253         }
    00254         pA->release();
    00255       }
    00256     }
    00257   }
    00258   log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endmsg;
    00259   return StatusCode::FAILURE;
    00260 }

std::string HistogramSvc::_STR | ( | int | i | ) |

Definition at line 57 of file HistogramSvc.cpp.

    00057                                    {
    00058   char txt[32];
    00059   return _itoa(i, txt, 10);
    00060 }

template<class T>

T* HistogramSvc::i_book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | const std::pair< DataObject *, T * > & | o |
| ) |  |  | `[inline]`

Definition at line 148 of file HistogramSvc.h.

    00148                                                                                     {
    00149     if (o.first && registerObject(pPar, rel, (Base*)o.second).isSuccess())
    00150       return o.second;
    00151     delete o.first;
    00152     throw GaudiException("Cannot book "+System::typeinfoName(typeid(T))+" "+title,
    00153       "HistogramSvc",StatusCode::FAILURE);
    00154   }

template<class T>

static DataObject* HistogramSvc::__cast | ( | T * | p | ) | `[inline, static]`

Definition at line 155 of file HistogramSvc.h.

    00155                                                       {
    00156     DataObject* q = dynamic_cast<DataObject*>(p);
    00157     if ( 0 == q && 0 != p )  {
    00158       throw std::runtime_error("HistogramSvc: Unexpected object type.");
    00159     }
    00160     return q;
    00161   }

H2D* HistogramSvc::i_project | ( | CSTR | nameAndTitle,
|  | const H3D & | h,
|  | CSTR | dir |
| ) |  |  |

Helper for 2D projections.

StatusCode HistogramSvc::initialize | ( |  | ) | `[virtual]`

Initialise the service.

Reimplemented from DataSvc.

Definition at line 262 of file HistogramSvc.cpp.

    00262                                       {
    00263   MsgStream log(msgSvc(), name());
    00264   StatusCode status = DataSvc::initialize();
    00265   // Set root object
    00266   if (status.isSuccess()) {
    00267     DataObject* rootObj = new DataObject();
    00268     status = setRoot("/stat", rootObj);
    00269     if (!status.isSuccess()) {
    00270       log << MSG::ERROR << "Unable to set hstogram data store root." << endmsg;
    00271       delete rootObj;
    00272       return status;
    00273     }
    00274     IConversionSvc* svc = 0;
    00275     status = service("HistogramPersistencySvc",svc,true);
    00276     if ( status.isSuccess() )   {
    00277       setDataLoader( svc ).ignore();
    00278       svc->release();
    00279     }
    00280     else  {
    00281       log << MSG::ERROR << "Could not find HistogramPersistencySvc." << endmsg;
    00282       return status;
    00283     }
    00284     // Connect all input streams (if any)
    00285     for (DBaseEntries::iterator j = m_input.begin(); j != m_input.end(); j++)    {
    00286       status = connectInput(*j);
    00287       if (!status.isSuccess())  {
    00288         return status;
    00289       }
    00290     }
    00291   }
    00292   if ( !m_defs1D.empty() )
    00293   {
    00294     log << MSG::INFO << " Predefined 1D-Histograms: " << endmsg ;
    00295     for ( Histo1DMap::const_iterator ih = m_defs1D.begin() ;
    00296           m_defs1D.end() != ih ; ++ih )
    00297     {
    00298       log << MSG::INFO
    00299           << " Path='"       << ih->first  << "'"
    00300           << " Description " << ih->second << endmsg ;
    00301     }
    00302   }
    00303   return status;
    00304 }

StatusCode HistogramSvc::reinitialize | ( |  | ) | `[virtual]`

Initialise the service.

Reimplemented from DataSvc.

Definition at line 306 of file HistogramSvc.cpp.

    00306                                         {
    00307   return StatusCode::SUCCESS;
    00308 }

StatusCode HistogramSvc::finalize | ( | void |  | ) | `[virtual]`

finalize the service

Reimplemented from DataSvc.

Definition at line 430 of file HistogramSvc.cpp.

    00431 {
    00432   if ( !m_mods1D.empty() )
    00433   {
    00434     MsgStream log ( msgSvc () , name () ) ;
    00435     log << MSG::DEBUG
    00436         << " Substituted histograms #" << m_mods1D.size() << " : " << endmsg ;
    00437     for ( std::set<std::string>::const_iterator ih = m_mods1D.begin() ;
    00438           m_mods1D.end() != ih ; ++ih )
    00439     {
    00440       log << MSG::DEBUG << " Path='" << (*ih) << "'" ;
    00441       Histo1DMap::const_iterator im = m_defs1D.find( *ih ) ;
    00442       if ( m_defs1D.end() != im ) { log << "  " << im->second ; }
    00443     }
    00444     m_mods1D.clear() ;
    00445   }
    00446   return DataSvc::finalize () ;
    00447 }

virtual AIDA::IHistogramFactory* HistogramSvc::histogramFactory | ( |  | ) | `[inline, virtual]`

Retrieve the AIDA HistogramFactory interface.

Implements IHistogramSvc.

Definition at line 174 of file HistogramSvc.h.

    00174 {  return this; }

virtual H1D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the fullpath) has to be an integer number otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | DBINS(x) | Macro for bin definition. Expands to: int nx: Number of bins on the axis X/Y double lx: Lower histogram edge on the axis X/Y double ux: Upper histogram edge on the axis X/Y

Definition at line 196 of file HistogramSvc.h.

    00197   {  return book(createPath(par), rel, title, BINS(x));                          }

virtual H1D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 198 of file HistogramSvc.h.

    00199   {  return book(par, _STR(hID), title, BINS(x));                                }

virtual H1D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 200 of file HistogramSvc.h.

    00201   {  return book(pPar, _STR(hID), title, BINS(x));                               }

AIDA::IHistogram1D * HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[virtual]`

Definition at line 359 of file HistogramSvc.cpp.

    00360 {
    00361   if ( m_defs1D.empty () )
    00362   { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
    00363   std::string hn = histoAddr ( pPar , rel ) ;
    00364   Histo1DMap::const_iterator ifound = m_defs1D.find( hn ) ;
    00365   if ( m_defs1D.end() == ifound )
    00366   { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
    00367   MsgStream log ( msgSvc() , name() ) ;
    00368   log << MSG::DEBUG
    00369       << " Redefine the parameters for the histogram '" + hn +"' to be "
    00370       << ifound->second
    00371       << endmsg ;
    00372   m_mods1D.insert ( hn ) ;
    00373   return i_book ( pPar , rel , ifound -> second.title   () ,
    00374                   Gaudi::createH1D
    00375                   ( ifound -> second.title   () ,
    00376                     ifound -> second.bins    () ,
    00377                     ifound -> second.lowEdge () ,
    00378                     ifound -> second.lowEdge () ) ) ;
    00379 }

virtual H1D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 203 of file HistogramSvc.h.

    00204   { return book(loc.first, loc.second, title, BINS(x));                          }

virtual H1D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 205 of file HistogramSvc.h.

    00206   { return book(i_splitPath(full), title, BINS(x));                              }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the fullpath) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | DBINS(x) | Macro for bin definition. Expands to: int nx: Number of bins on the axis X/Y double lx: Lower histogram edge on the axis X/Y double ux: Upper histogram edge on the axis X/Y

Definition at line 227 of file HistogramSvc.h.

    00228   { return bookProf(createPath(par), rel, title, BINS(x),opt);                     }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 229 of file HistogramSvc.h.

    00230   { return bookProf(par, _STR(hID), title, BINS(x),opt);                           }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 231 of file HistogramSvc.h.

    00232   { return bookProf(pPar, _STR(hID), title, BINS(x),opt);                          }

virtual P1D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 233 of file HistogramSvc.h.

    00234   { return bookProf(loc.first, loc.second, title, BINS(x),opt);                    }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 235 of file HistogramSvc.h.

    00236   { return bookProf(i_splitPath(full), title, BINS(x),opt);                        }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 237 of file HistogramSvc.h.

    00238   { return i_book(pPar,rel,title,Gaudi::createProf1D(title, BINS(x),0,0,opt));     }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 240 of file HistogramSvc.h.

    00241   { return bookProf(createPath(par), rel, title, BINS(x), upper, lower , opt);                     }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 242 of file HistogramSvc.h.

    00243   { return bookProf(par, _STR(hID), title, BINS(x), upper, lower, opt );                           }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 244 of file HistogramSvc.h.

    00245   { return bookProf(pPar, _STR(hID), title, BINS(x), upper, lower, opt);                          }

virtual P1D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 246 of file HistogramSvc.h.

    00247   { return bookProf(loc.first, loc.second, title, BINS(x), upper, lower,opt);                    }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 248 of file HistogramSvc.h.

    00249   { return bookProf(i_splitPath(full), title, BINS(x), upper, lower , opt );                        }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline, virtual]`

Definition at line 250 of file HistogramSvc.h.

    00251   { return i_book(pPar,rel,title,Gaudi::createProf1D(title, BINS(x), upper, lower, opt));         }

virtual H1D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the fullpath) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | e | Bin edges for variable binned histogram.

Definition at line 269 of file HistogramSvc.h.

    00270   {  return book(par, _STR(hID), title, e);                                 }

virtual H1D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 271 of file HistogramSvc.h.

    00272   {  return book(pPar, _STR(hID), title, e);                                }

virtual H1D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 273 of file HistogramSvc.h.

    00274   {  return book(createPath(par), rel, title, e);                           }

virtual H1D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 275 of file HistogramSvc.h.

    00276   { return book(loc.first, loc.second, title, e);                           }

virtual H1D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 277 of file HistogramSvc.h.

    00278   { return book(i_splitPath(full), title, e);                               }

virtual H1D* HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 279 of file HistogramSvc.h.

    00280   { return i_book(pPar, rel, title, Gaudi::createH1D(title, e));            }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | e | Bin edges for variable binned histogram.

Definition at line 299 of file HistogramSvc.h.

    00300   { return bookProf(i_splitPath(full), title, e);                             }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 301 of file HistogramSvc.h.

    00302   { return bookProf(createPath(par), rel, title, e);                          }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 303 of file HistogramSvc.h.

    00304   { return bookProf(par, _STR(hID), title, e);                                }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 305 of file HistogramSvc.h.

    00306   { return bookProf(pPar, _STR(hID), title, e);                               }

virtual P1D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 307 of file HistogramSvc.h.

    00308   { return bookProf(loc.first, loc.second, title, e);                         }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e |
| ) |  |  | `[inline, virtual]`

Definition at line 309 of file HistogramSvc.h.

    00310   { return i_book(pPar,rel,title,Gaudi::createProf1D(title, e, 0, 0));        }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 312 of file HistogramSvc.h.

    00313   { return bookProf(i_splitPath(full), title, e, upper, lower);               }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 314 of file HistogramSvc.h.

    00315   { return bookProf(createPath(par), rel, title, e, upper, lower);            }

virtual P1D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 316 of file HistogramSvc.h.

    00317   { return bookProf(par, _STR(hID), title, e, upper, lower);                  }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 318 of file HistogramSvc.h.

    00319   { return bookProf(pPar, _STR(hID), title, e, upper, lower);                 }

virtual P1D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 320 of file HistogramSvc.h.

    00321   { return bookProf(loc.first, loc.second, title, e, upper, lower);           }

virtual P1D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | e,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 322 of file HistogramSvc.h.

    00323   { return i_book(pPar,rel,title,Gaudi::createProf1D(title, e, upper, lower));}

virtual H2D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | DBINS(x/y) | Macro for bin definition in X/Y. Expands to: int nx: Number of bins on the axis X/Y double lx: Lower histogram edge on the axis X/Y double ux: Upper histogram edge on the axis X/Y

Definition at line 344 of file HistogramSvc.h.

    00345   { return book(i_splitPath(full), title, BINS(x),BINS(y));               }

virtual H2D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 346 of file HistogramSvc.h.

    00347   { return book(createPath(par), rel, title, BINS(x),BINS(y));            }

virtual H2D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 348 of file HistogramSvc.h.

    00349   { return book(par,_STR(hID), title, BINS(x),BINS(y));                   }

virtual H2D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 350 of file HistogramSvc.h.

    00351   { return book(loc.first, loc.second, title, BINS(x), BINS(y));          }

virtual H2D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 352 of file HistogramSvc.h.

    00353   { return book(pPar,_STR(hID), title, BINS(x),BINS(y));                  }

virtual H2D* HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 354 of file HistogramSvc.h.

    00355   { return i_book(pPar,rel,title,Gaudi::createH2D(title, BINS(x),BINS(y)));}

virtual P2D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | DBINS(x/y) | Macro for bin definition in X/Y. Expands to: int nx: Number of bins on the axis X/Y double lx: Lower histogram edge on the axis X/Y double ux: Upper histogram edge on the axis X/Y

Definition at line 376 of file HistogramSvc.h.

    00377   { return bookProf(i_splitPath(full), title, BINS(x),BINS(y), upper, lower);               }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 378 of file HistogramSvc.h.

    00379   { return bookProf(createPath(par), rel, title, BINS(x),BINS(y), upper, lower);            }

virtual P2D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 380 of file HistogramSvc.h.

    00381   { return bookProf(loc.first, loc.second, title, BINS(x), BINS(y), upper, lower);          }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 382 of file HistogramSvc.h.

    00383   { return bookProf(par, _STR(hID), title, BINS(x),BINS(y), upper, lower);                  }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 384 of file HistogramSvc.h.

    00385   { return bookProf(pPar,_STR(hID), title, BINS(x),BINS(y), upper, lower);                  }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 386 of file HistogramSvc.h.

    00387   { return i_book(pPar,rel,title,Gaudi::createProf2D(title, BINS(x),BINS(y), upper, lower));  }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 389 of file HistogramSvc.h.

    00390   { return bookProf(i_splitPath(full), title, BINS(x),BINS(y));               }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 391 of file HistogramSvc.h.

    00392   { return bookProf(createPath(par), rel, title, BINS(x),BINS(y));            }

virtual P2D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 393 of file HistogramSvc.h.

    00394   { return bookProf(loc.first, loc.second, title, BINS(x), BINS(y));          }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 395 of file HistogramSvc.h.

    00396   { return bookProf(par, _STR(hID), title, BINS(x),BINS(y));                  }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 397 of file HistogramSvc.h.

    00398   { return bookProf(pPar,_STR(hID), title, BINS(x),BINS(y));                  }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 399 of file HistogramSvc.h.

    00400   { return i_book(pPar,rel,title,Gaudi::createProf2D(title, BINS(x),BINS(y),0,0));}

virtual H2D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | x/y | Bin edges for variable binned histogram in X/Y.

Definition at line 418 of file HistogramSvc.h.

    00419   { return book(i_splitPath(full), title, x, y);                        }

virtual H2D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 420 of file HistogramSvc.h.

    00421   { return book(createPath(par), rel, title, x, y);                     }

virtual H2D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 422 of file HistogramSvc.h.

    00423   { return book(par, _STR(hID), title, x, y);                           }

virtual H2D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 424 of file HistogramSvc.h.

    00425   { return book(loc.first, loc.second, title, x, y);                    }

virtual H2D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 426 of file HistogramSvc.h.

    00427   { return book(pPar, _STR(hID), title, x, y);                          }

virtual H2D* HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 428 of file HistogramSvc.h.

    00429   { return i_book(pPar, rel, title, Gaudi::createH2D(title, x,y));      }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | x/y | Bin edges for variable binned histogram in X/Y.

Definition at line 447 of file HistogramSvc.h.

    00448   { return bookProf(i_splitPath(full), title, x, y);                    }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 449 of file HistogramSvc.h.

    00450   { return bookProf(createPath(par), rel, title, x, y);                  }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 451 of file HistogramSvc.h.

    00452   { return bookProf(par, _STR(hID), title, x, y);                        }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 453 of file HistogramSvc.h.

    00454   { return bookProf(pPar, _STR(hID), title, x, y);                       }

virtual P2D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 455 of file HistogramSvc.h.

    00456   { return bookProf(loc.first, loc.second, title, x, y);                 }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y |
| ) |  |  | `[inline, virtual]`

Definition at line 457 of file HistogramSvc.h.

    00458   { return i_book(pPar, rel, title, Gaudi::createProf2D(title,x,y,0,0)); }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 460 of file HistogramSvc.h.

    00461   { return bookProf(i_splitPath(full), title, x, y, upper, lower);       }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 462 of file HistogramSvc.h.

    00463   { return bookProf(createPath(par), rel, title, x, y, upper, lower);                  }

virtual P2D* HistogramSvc::bookProf | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 464 of file HistogramSvc.h.

    00465   { return bookProf(par, _STR(hID), title, x, y, upper, lower);                        }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 466 of file HistogramSvc.h.

    00467   { return bookProf(pPar, _STR(hID), title, x, y, upper, lower);                       }

virtual P2D* HistogramSvc::bookProf | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 468 of file HistogramSvc.h.

    00469   { return bookProf(loc.first, loc.second, title, x, y, upper, lower);                 }

virtual P2D* HistogramSvc::bookProf | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline, virtual]`

Definition at line 470 of file HistogramSvc.h.

    00471   { return i_book(pPar, rel, title, Gaudi::createProf2D(title,x,y, upper, lower));     }

virtual H3D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | DBINS(x/y/z) | Macro for bin definition in X/Y/Z. Expands to: int nx: Number of bins on the axis X/Y/Z double lx: Lower histogram edge on the axis X/Y/Z double ux: Upper histogram edge on the axis X/Y/Z

Definition at line 492 of file HistogramSvc.h.

    00493   { return book(i_splitPath(full),title,BINS(x),BINS(y),BINS(z));            }

virtual H3D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 494 of file HistogramSvc.h.

    00495   { return book(createPath(par),rel,title,BINS(x),BINS(y),BINS(z));          }

virtual H3D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 496 of file HistogramSvc.h.

    00497   { return book(par,_STR(hID),title,BINS(x),BINS(y),BINS(z));                }

virtual H3D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 498 of file HistogramSvc.h.

    00499   { return book(pPar,_STR(hID), title, BINS(x),BINS(y),BINS(z));             }

virtual H3D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 500 of file HistogramSvc.h.

    00501   { return book(loc.first, loc.second, title, BINS(x),BINS(y),BINS(z));      }

virtual H3D* HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline, virtual]`

Definition at line 502 of file HistogramSvc.h.

    00503   { return i_book(pPar, rel, title, Gaudi::createH3D(title,BINS(x),BINS(y),BINS(z)));}

virtual H3D* HistogramSvc::book | ( | CSTR | full,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Book histogram and register it with the histogram data store.

Parameters:

  | full | Full path to the node of the object. The basename (last part of the full) has to be an integer number (otherwise conversion to HBOOK is not possible)
  | par | Path to parent node of the object, the directory the histogram will be stored in.
  | pPar | Pointer to parent node
  | rel | Histogram identifier (std::string), the relative path to the object with respect to the parent node
  | hID | Histogram identifier (int) of the histogram
  | title | Title property of the histogram
  | binsX/Y/Z | Number of bins on the axis X/Y/Z
  | lowX/Y/Z | Lower histogram edge on the axis X/Y/Z
  | highX/Y/Z | Upper histogram edge on the axis X/Y/Z

Definition at line 523 of file HistogramSvc.h.

    00524   { return book(i_splitPath(full), title, x, y, z);                         }

virtual H3D* HistogramSvc::book | ( | CSTR | par,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Definition at line 525 of file HistogramSvc.h.

    00526   { return book(createPath(par), rel, title, x, y, z);                      }

virtual H3D* HistogramSvc::book | ( | CSTR | par,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Definition at line 527 of file HistogramSvc.h.

    00528   { return book(par,_STR(hID), title, x, y, z);                             }

virtual H3D* HistogramSvc::book | ( | DataObject * | pPar,
|  | int | hID,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Definition at line 529 of file HistogramSvc.h.

    00530   { return book(pPar,_STR(hID), title, x, y, z);                            }

virtual H3D* HistogramSvc::book | ( | STRPAIR | loc,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Definition at line 531 of file HistogramSvc.h.

    00532   { return book(loc.first, loc.second, title, x,y,z);                       }

virtual H3D* HistogramSvc::book | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | CSTR | title,
|  | Edges | x,
|  | Edges | y,
|  | Edges | z |
| ) |  |  | `[inline, virtual]`

Definition at line 533 of file HistogramSvc.h.

    00534   { return i_book(pPar, rel, title, Gaudi::createH3D(title,x,y,z));         }

virtual StatusCode HistogramSvc::registerObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | Base * | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 542 of file HistogramSvc.h.

    00543   { return registerObject(createPath(parent), rel, obj);                       }

virtual StatusCode HistogramSvc::registerObject | ( | CSTR | parent,
|  | int | item,
|  | Base * | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 544 of file HistogramSvc.h.

    00545   { return registerObject(parent, _STR(item), obj);                            }

virtual StatusCode HistogramSvc::registerObject | ( | Base * | pPar,
|  | CSTR | rel,
|  | Base * | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 546 of file HistogramSvc.h.

    00547   { return registerObject(__cast(pPar), rel, obj);                             }

virtual StatusCode HistogramSvc::registerObject | ( | DataObject * | pPar,
|  | int | item,
|  | Base * | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 548 of file HistogramSvc.h.

    00549   { return registerObject(pPar, _STR(item), obj);                              }

virtual StatusCode HistogramSvc::registerObject | ( | Base * | pPar,
|  | int | item,
|  | Base * | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 550 of file HistogramSvc.h.

    00551   { return registerObject(__cast(pPar), item, obj);                            }

virtual StatusCode HistogramSvc::registerObject | ( | CSTR | full,
|  | Base * | obj |
| ) |  |  | `[virtual]`

virtual StatusCode HistogramSvc::registerObject | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | Base * | obj |
| ) |  |  | `[virtual]`

virtual StatusCode HistogramSvc::unregisterObject | ( | Base * | obj | ) | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 557 of file HistogramSvc.h.

    00558   { return DataSvc::unregisterObject(__cast(obj));                             }

virtual StatusCode HistogramSvc::unregisterObject | ( | Base * | obj,
|  | CSTR | objectPath |
| ) |  |  | `[inline, virtual]`

Definition at line 559 of file HistogramSvc.h.

    00560   { return DataSvc::unregisterObject(__cast(obj),objectPath);                  }

virtual StatusCode HistogramSvc::unregisterObject | ( | Base * | obj,
|  | int | item |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 561 of file HistogramSvc.h.

    00562   { return DataSvc::unregisterObject(__cast(obj),item);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 566 of file HistogramSvc.h.

    00567   { return Helper(this).retrieve(pReg,path,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 568 of file HistogramSvc.h.

    00569   { return Helper(this).retrieve(pReg,path,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 570 of file HistogramSvc.h.

    00571   { return Helper(this).retrieve(pReg,path,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 572 of file HistogramSvc.h.

    00573   { return Helper(this).retrieve(pReg,path,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 574 of file HistogramSvc.h.

    00575   { return Helper(this).retrieve(pReg,path,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | full,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 577 of file HistogramSvc.h.

    00578   {  return Helper(this).retrieve(full,obj);                                    }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | full,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 579 of file HistogramSvc.h.

    00580   {  return Helper(this).retrieve(full,obj);                                    }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | full,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 581 of file HistogramSvc.h.

    00582   {  return Helper(this).retrieve(full,obj);                                    }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | full,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 583 of file HistogramSvc.h.

    00584   {  return Helper(this).retrieve(full,obj);                                    }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | full,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 585 of file HistogramSvc.h.

    00586   {  return Helper(this).retrieve(full,obj);                                    }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 588 of file HistogramSvc.h.

    00589   {  return Helper(this).retrieve(parent,rel,obj);                              }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 590 of file HistogramSvc.h.

    00591   {  return Helper(this).retrieve(parent,rel,obj);                              }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 592 of file HistogramSvc.h.

    00593   {  return Helper(this).retrieve(parent,rel,obj);                              }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 594 of file HistogramSvc.h.

    00595   {  return Helper(this).retrieve(parent,rel,obj);                              }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | CSTR | rel,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 596 of file HistogramSvc.h.

    00597   {  return Helper(this).retrieve(parent,rel,obj);                              }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 599 of file HistogramSvc.h.

    00600   {  return Helper(this).retrieve(parent,item,obj);                             }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 601 of file HistogramSvc.h.

    00602   {  return Helper(this).retrieve(parent,item,obj);                             }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 603 of file HistogramSvc.h.

    00604   {  return Helper(this).retrieve(parent,item,obj);                             }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 605 of file HistogramSvc.h.

    00606   {  return Helper(this).retrieve(parent,item,obj);                             }

virtual StatusCode HistogramSvc::retrieveObject | ( | CSTR | parent,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 607 of file HistogramSvc.h.

    00608   {  return Helper(this).retrieve(parent,item,obj);                             }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | CSTR | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 610 of file HistogramSvc.h.

    00611   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | CSTR | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 612 of file HistogramSvc.h.

    00613   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 614 of file HistogramSvc.h.

    00615   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 616 of file HistogramSvc.h.

    00617   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 618 of file HistogramSvc.h.

    00619   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 621 of file HistogramSvc.h.

    00622   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 623 of file HistogramSvc.h.

    00624   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 625 of file HistogramSvc.h.

    00626   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 627 of file HistogramSvc.h.

    00628   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | par,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 629 of file HistogramSvc.h.

    00630   {  return Helper(this).retrieve(par,item,obj);                                }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 632 of file HistogramSvc.h.

    00633   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 634 of file HistogramSvc.h.

    00635   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 636 of file HistogramSvc.h.

    00637   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 638 of file HistogramSvc.h.

    00639   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 640 of file HistogramSvc.h.

    00641   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | CSTR | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 643 of file HistogramSvc.h.

    00644   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | CSTR | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 645 of file HistogramSvc.h.

    00646   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | CSTR | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 647 of file HistogramSvc.h.

    00648   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | CSTR | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 649 of file HistogramSvc.h.

    00650   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::retrieveObject | ( | Base * | par,
|  | CSTR | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 651 of file HistogramSvc.h.

    00652   {  return Helper(this).retrieve(__cast(par),item,obj);                        }

virtual StatusCode HistogramSvc::findObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 661 of file HistogramSvc.h.

    00662   {  return Helper(this).find(pReg,path,obj);                                 }

virtual StatusCode HistogramSvc::findObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 663 of file HistogramSvc.h.

    00664   {  return Helper(this).find(pReg,path,obj);                                 }

virtual StatusCode HistogramSvc::findObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 665 of file HistogramSvc.h.

    00666   {  return Helper(this).find(pReg,path,obj);                                 }

virtual StatusCode HistogramSvc::findObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 667 of file HistogramSvc.h.

    00668   {  return Helper(this).find(pReg,path,obj);                                 }

virtual StatusCode HistogramSvc::findObject | ( | IRegistry * | pReg,
|  | CSTR | path,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 669 of file HistogramSvc.h.

    00670   {  return Helper(this).find(pReg,path,obj);                                 }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | full,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 672 of file HistogramSvc.h.

    00673   {  return Helper(this).find(full,obj);                                      }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | full,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 674 of file HistogramSvc.h.

    00675   {  return Helper(this).find(full,obj);                                      }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | full,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 676 of file HistogramSvc.h.

    00677   {  return Helper(this).find(full,obj);                                      }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | full,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 678 of file HistogramSvc.h.

    00679   {  return Helper(this).find(full,obj);                                      }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | full,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 680 of file HistogramSvc.h.

    00681   {  return Helper(this).find(full,obj);                                      }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | CSTR | rel,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 683 of file HistogramSvc.h.

    00684   {  return Helper(this).find(par,rel,obj);                                   }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | CSTR | rel,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 685 of file HistogramSvc.h.

    00686   {  return Helper(this).find(par,rel,obj);                                   }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | CSTR | rel,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 687 of file HistogramSvc.h.

    00688   {  return Helper(this).find(par,rel,obj);                                   }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | CSTR | rel,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 689 of file HistogramSvc.h.

    00690   {  return Helper(this).find(par,rel,obj);                                   }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | CSTR | rel,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 691 of file HistogramSvc.h.

    00692   {  return Helper(this).find(par,rel,obj);                                   }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 694 of file HistogramSvc.h.

    00695   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 696 of file HistogramSvc.h.

    00697   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 698 of file HistogramSvc.h.

    00699   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 700 of file HistogramSvc.h.

    00701   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | CSTR | par,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 702 of file HistogramSvc.h.

    00703   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 705 of file HistogramSvc.h.

    00706   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 707 of file HistogramSvc.h.

    00708   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 709 of file HistogramSvc.h.

    00710   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 711 of file HistogramSvc.h.

    00712   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 713 of file HistogramSvc.h.

    00714   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | CSTR | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 716 of file HistogramSvc.h.

    00717   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | CSTR | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 718 of file HistogramSvc.h.

    00719   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 720 of file HistogramSvc.h.

    00721   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 722 of file HistogramSvc.h.

    00723   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | par,
|  | CSTR | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 724 of file HistogramSvc.h.

    00725   {  return Helper(this).find(par,item,obj);                                  }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | int | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 727 of file HistogramSvc.h.

    00728   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | int | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 729 of file HistogramSvc.h.

    00730   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | int | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 731 of file HistogramSvc.h.

    00732   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | int | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 733 of file HistogramSvc.h.

    00734   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | int | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Implements IHistogramSvc.

Definition at line 735 of file HistogramSvc.h.

    00736   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | CSTR | item,
|  | P1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 738 of file HistogramSvc.h.

    00739   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | CSTR | item,
|  | P2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 740 of file HistogramSvc.h.

    00741   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | CSTR | item,
|  | H1D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 742 of file HistogramSvc.h.

    00743   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | CSTR | item,
|  | H2D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 744 of file HistogramSvc.h.

    00745   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual StatusCode HistogramSvc::findObject | ( | Base * | par,
|  | CSTR | item,
|  | H3D *& | obj |
| ) |  |  | `[inline, virtual]`

Definition at line 746 of file HistogramSvc.h.

    00747   {  return Helper(this).find(__cast(par),item,obj);                          }

virtual H1D* HistogramSvc::projectionX | ( | CSTR | name,
|  | const H2D & | h |
| ) |  |  | `[inline, virtual]`

Definition at line 752 of file HistogramSvc.h.

    00753   {  return sliceX( name, h, IAxis::UNDERFLOW_BIN, IAxis::OVERFLOW_BIN);      }

virtual H1D* HistogramSvc::projectionY | ( | CSTR | name,
|  | const H2D & | h |
| ) |  |  | `[inline, virtual]`

Definition at line 754 of file HistogramSvc.h.

    00755   {  return sliceY( name, h, IAxis::UNDERFLOW_BIN, IAxis::OVERFLOW_BIN);      }

virtual H1D* HistogramSvc::sliceX | ( | CSTR | name,
|  | const H2D & | h,
|  | int | indexY |
| ) |  |  | `[inline, virtual]`

Definition at line 756 of file HistogramSvc.h.

    00757   {  return sliceX( name, h, indexY, indexY );                                }

virtual H1D* HistogramSvc::sliceY | ( | CSTR | name,
|  | const H2D & | h,
|  | int | indexX |
| ) |  |  | `[inline, virtual]`

Definition at line 758 of file HistogramSvc.h.

    00759   {  return sliceY( name, h, indexX, indexX );                                }

virtual H1D* HistogramSvc::sliceX | ( | CSTR | name,
|  | const H2D & | h,
|  | int | indexY1,
|  | int | indexY2 |
| ) |  |  | `[virtual]`

virtual H1D* HistogramSvc::sliceY | ( | CSTR | name,
|  | const H2D & | h,
|  | int | indexX1,
|  | int | indexX2 |
| ) |  |  | `[virtual]`

bool HistogramSvc::destroy | ( | IBaseHistogram * | hist | ) |

Definition at line 351 of file HistogramSvc.cpp.

    00351                                                  {
    00352   StatusCode sc = unregisterObject( dynamic_cast<IHistogram*>(hist) );
    00353   if ( !sc.isSuccess() ) return false;
    00354   if ( hist ) delete hist;
    00355   return true;
    00356 }

H1D* HistogramSvc::add | ( | CSTR | nameAndTitle,
|  | const H1D & | a,
|  | const H1D & | b |
| ) |  |  | `[inline]`

Definition at line 765 of file HistogramSvc.h.

    00766   { return Helper::act(createCopy(nameAndTitle,a),b,&TH1::Add, 1.);          }

H1D* HistogramSvc::subtract | ( | CSTR | nameAndTitle,
|  | const H1D & | a,
|  | const H1D & | b |
| ) |  |  | `[inline]`

Definition at line 767 of file HistogramSvc.h.

    00768   { return Helper::act(createCopy(nameAndTitle,a),b,&TH1::Add,-1.);          }

H1D* HistogramSvc::multiply | ( | CSTR | nameAndTitle,
|  | const H1D & | a,
|  | const H1D & | b |
| ) |  |  | `[inline]`

Definition at line 769 of file HistogramSvc.h.

    00770   { return Helper::act(createCopy(nameAndTitle,a),b,&TH1::Multiply);         }

H1D* HistogramSvc::divide | ( | CSTR | nameAndTitle,
|  | const H1D & | a,
|  | const H1D & | b |
| ) |  |  | `[inline]`

Definition at line 771 of file HistogramSvc.h.

    00772   { return Helper::act(createCopy(nameAndTitle,a),b,&TH1::Divide);           }

H2D* HistogramSvc::add | ( | CSTR | nameAndTitle,
|  | const H2D & | a,
|  | const H2D & | b |
| ) |  |  | `[inline]`

Definition at line 774 of file HistogramSvc.h.

    00775   { return Helper::act(createCopy(nameAndTitle,a),b,&TH2D::Add, 1.);           }

H2D* HistogramSvc::subtract | ( | CSTR | nameAndTitle,
|  | const H2D & | a,
|  | const H2D & | b |
| ) |  |  | `[inline]`

Definition at line 776 of file HistogramSvc.h.

    00777   { return Helper::act(createCopy(nameAndTitle,a),b,&TH2D::Add,-1.);           }

H2D* HistogramSvc::multiply | ( | CSTR | nameAndTitle,
|  | const H2D & | a,
|  | const H2D & | b |
| ) |  |  | `[inline]`

Definition at line 778 of file HistogramSvc.h.

    00779   { return Helper::act(createCopy(nameAndTitle,a),b,&TH2D::Multiply);          }

H2D* HistogramSvc::divide | ( | CSTR | nameAndTitle,
|  | const H2D & | a,
|  | const H2D & | b |
| ) |  |  | `[inline]`

Definition at line 780 of file HistogramSvc.h.

    00781   { return Helper::act(createCopy(nameAndTitle,a),b,&TH2D::Divide);            }

H3D* HistogramSvc::add | ( | CSTR | nameAndTitle,
|  | const H3D & | a,
|  | const H3D & | b |
| ) |  |  | `[inline]`

Definition at line 783 of file HistogramSvc.h.

    00784   { return Helper::act(createCopy(nameAndTitle,a),b,&TH3D::Add, 1.);           }

H3D* HistogramSvc::subtract | ( | CSTR | nameAndTitle,
|  | const H3D & | a,
|  | const H3D & | b |
| ) |  |  | `[inline]`

Definition at line 785 of file HistogramSvc.h.

    00786   { return Helper::act(createCopy(nameAndTitle,a),b,&TH3D::Add,-1.);           }

H3D* HistogramSvc::multiply | ( | CSTR | nameAndTitle,
|  | const H3D & | a,
|  | const H3D & | b |
| ) |  |  | `[inline]`

Definition at line 787 of file HistogramSvc.h.

    00788   { return Helper::act(createCopy(nameAndTitle,a),b,&TH3D::Multiply);          }

H3D* HistogramSvc::divide | ( | CSTR | nameAndTitle,
|  | const H3D & | a,
|  | const H3D & | b |
| ) |  |  | `[inline]`

Definition at line 789 of file HistogramSvc.h.

    00790   { return Helper::act(createCopy(nameAndTitle,a),b,&TH3D::Divide);            }

H2D* HistogramSvc::projectionXY | ( | CSTR | nameAndTitle,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 792 of file HistogramSvc.h.

    00793   { return i_project(nameAndTitle,h,"xy");                                    }

H2D* HistogramSvc::projectionXZ | ( | CSTR | nameAndTitle,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 794 of file HistogramSvc.h.

    00795   { return i_project(nameAndTitle,h,"xz");                                    }

H2D* HistogramSvc::projectionYZ | ( | CSTR | nameAndTitle,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 796 of file HistogramSvc.h.

    00797   { return i_project(nameAndTitle,h,"yz");                                    }

H2D* HistogramSvc::sliceXY | ( | CSTR | ,
|  | const H3D & | ,
|  | int | ,
|  | int |  |
| ) |  |  |

H2D* const H3D int NOT_IMPLEMENTED H2D* HistogramSvc::sliceYZ | ( | CSTR | ,
|  | const H3D & | ,
|  | int | ,
|  | int |  |
| ) |  |  |

Type Constraints

H2D* const H3D int NOT_IMPLEMENTED H2D* CSTR HistogramSvc::DBINS | ( | x |  | ) | `[inline]`

Type Constraints

Definition at line 803 of file HistogramSvc.h.

    00804   {  return book( name, tit, BINS(x));                                        }

H1D* HistogramSvc::createHistogram1D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 805 of file HistogramSvc.h.

    00806   {  return book( name, tit, BINS(x));                                        }

H1D* HistogramSvc::createHistogram1D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 807 of file HistogramSvc.h.

    00808   {  return book(name, title, x);                                             }

H1D* HistogramSvc::createHistogram1D | ( | CSTR | nameAndTitle,
|  | DBINS(x) |  |
| ) |  |  | `[inline]`

Definition at line 809 of file HistogramSvc.h.

    00810   { return book(nameAndTitle, nameAndTitle, BINS(x));                         }

H1D* HistogramSvc::createCopy | ( | CSTR | full,
|  | const H1D & | h |
| ) |  |  | `[inline]`

Definition at line 811 of file HistogramSvc.h.

    00812   {  return createCopy(i_splitPath(full), h);                                 }

H1D* HistogramSvc::createCopy | ( | CSTR | par,
|  | CSTR | rel,
|  | const H1D & | h |
| ) |  |  | `[inline]`

Definition at line 813 of file HistogramSvc.h.

    00814   {  return createCopy(createPath(par), rel, h);                              }

H1D* HistogramSvc::createCopy | ( | STRPAIR | loc,
|  | const H1D & | h |
| ) |  |  | `[inline]`

Definition at line 815 of file HistogramSvc.h.

    00816   {  return createCopy(loc.first, loc.second, h);                             }

H1D* HistogramSvc::createCopy | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | const H1D & | h |
| ) |  |  | `[inline]`

Definition at line 817 of file HistogramSvc.h.

    00818   { return i_book(pPar, rel, h.title(), Gaudi::createH1D(h));                 }

H2D* HistogramSvc::createHistogram2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline]`

Definition at line 820 of file HistogramSvc.h.

    00821   {  return book( name, tit, BINS(x), BINS(y));                               }

H2D* HistogramSvc::createHistogram2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 822 of file HistogramSvc.h.

    00823   {  return book( name, tit, BINS(x), BINS(y));                               }

H2D* HistogramSvc::createHistogram2D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | const Edges & | y,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 824 of file HistogramSvc.h.

    00825   {  return book(name, title, x, y);                                          }

H2D* HistogramSvc::createHistogram2D | ( | CSTR | nameAndTitle,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline]`

Definition at line 826 of file HistogramSvc.h.

    00827   { return book(nameAndTitle, nameAndTitle, BINS(x), BINS(y));                }

H2D* HistogramSvc::createCopy | ( | CSTR | full,
|  | const H2D & | h |
| ) |  |  | `[inline]`

Definition at line 828 of file HistogramSvc.h.

    00829   {  return createCopy(i_splitPath(full), h);                                 }

H2D* HistogramSvc::createCopy | ( | CSTR | par,
|  | CSTR | rel,
|  | const H2D & | h |
| ) |  |  | `[inline]`

Definition at line 830 of file HistogramSvc.h.

    00831   {  return createCopy(createPath(par), rel, h);                              }

H2D* HistogramSvc::createCopy | ( | STRPAIR | loc,
|  | const H2D & | h |
| ) |  |  | `[inline]`

Definition at line 832 of file HistogramSvc.h.

    00833   {  return createCopy(loc.first, loc.second, h);                             }

H2D* HistogramSvc::createCopy | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | const H2D & | h |
| ) |  |  | `[inline]`

Definition at line 834 of file HistogramSvc.h.

    00835   { return i_book(pPar, rel, h.title(), Gaudi::createH2D(h));                 }

H3D* HistogramSvc::createHistogram3D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline]`

Definition at line 837 of file HistogramSvc.h.

    00838   {  return book( name, tit, BINS(x), BINS(y), BINS(z));                      }

H3D* HistogramSvc::createHistogram3D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) | ,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 839 of file HistogramSvc.h.

    00840   {  return book( name, tit, BINS(x), BINS(y), BINS(z));                      }

H3D* HistogramSvc::createHistogram3D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | const Edges & | y,
|  | const Edges & | z,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 841 of file HistogramSvc.h.

    00842   {  return book(name, title, x, y, z);                                       }

H3D* HistogramSvc::createHistogram3D | ( | CSTR | nameAndTitle,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | DBINS(z) |  |
| ) |  |  | `[inline]`

Definition at line 843 of file HistogramSvc.h.

    00844   { return book(nameAndTitle, nameAndTitle, BINS(x), BINS(y), BINS(z));       }

H3D* HistogramSvc::createCopy | ( | CSTR | full,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 845 of file HistogramSvc.h.

    00846   {  return createCopy(i_splitPath(full), h);                                 }

H3D* HistogramSvc::createCopy | ( | CSTR | par,
|  | CSTR | rel,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 847 of file HistogramSvc.h.

    00848   {  return createCopy(createPath(par), rel, h);                              }

H3D* HistogramSvc::createCopy | ( | STRPAIR | loc,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 849 of file HistogramSvc.h.

    00850   {  return createCopy(loc.first, loc.second, h);                             }

H3D* HistogramSvc::createCopy | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | const H3D & | h |
| ) |  |  | `[inline]`

Definition at line 851 of file HistogramSvc.h.

    00852   { return i_book(pPar, rel, h.title(), Gaudi::createH3D(h));                 }

P1D* HistogramSvc::createProfile1D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | CSTR | opt |
| ) |  |  | `[inline]`

Definition at line 856 of file HistogramSvc.h.

    00857   {  return bookProf( name, tit, BINS(x) , opt );                             }

P1D* HistogramSvc::createProfile1D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR | opt |
| ) |  |  | `[inline]`

Definition at line 858 of file HistogramSvc.h.

    00859   {  return bookProf( name, tit, BINS(x), upper, lower , opt );               }

P1D* HistogramSvc::createProfile1D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 860 of file HistogramSvc.h.

    00861   {  return bookProf(name, title, x );                                        }

P1D* HistogramSvc::createProfile1D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | double | upper,
|  | double | lower,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 862 of file HistogramSvc.h.

    00863   {  return bookProf(name, title, x, upper, lower );                          }

P1D* HistogramSvc::createProfile1D | ( | CSTR | nametit,
|  | DBINS(x) |  |
| ) |  |  | `[inline]`

Definition at line 865 of file HistogramSvc.h.

    00866   {  return bookProf( nametit, nametit, BINS(x) , "s");                       }

P1D* HistogramSvc::createProfile1D | ( | CSTR | nametit,
|  | DBINS(x) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline]`

Definition at line 867 of file HistogramSvc.h.

    00868   {  return bookProf( nametit, nametit, BINS(x), upper, lower , "s");         }

P1D* HistogramSvc::createCopy | ( | CSTR | full,
|  | const P1D & | h |
| ) |  |  | `[inline]`

Definition at line 871 of file HistogramSvc.h.

    00872   {  return createCopy(i_splitPath(full), h);                                 }

P1D* HistogramSvc::createCopy | ( | CSTR | par,
|  | CSTR | rel,
|  | const P1D & | h |
| ) |  |  | `[inline]`

Definition at line 873 of file HistogramSvc.h.

    00874   {  return createCopy(createPath(par), rel, h);                              }

P1D* HistogramSvc::createCopy | ( | STRPAIR | loc,
|  | const P1D & | h |
| ) |  |  | `[inline]`

Definition at line 875 of file HistogramSvc.h.

    00876   {  return createCopy(loc.first, loc.second, h);                             }

P1D* HistogramSvc::createCopy | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | const P1D & | h |
| ) |  |  | `[inline]`

Definition at line 877 of file HistogramSvc.h.

    00878   { return i_book(pPar, rel, h.title(), Gaudi::createProf1D(h));              }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline]`

Definition at line 880 of file HistogramSvc.h.

    00881   {  return bookProf( name, tit, BINS(x), BINS(y));                           }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 882 of file HistogramSvc.h.

    00883   {  return bookProf( name, tit, BINS(x), BINS(y));                           }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | const Edges & | y,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 884 of file HistogramSvc.h.

    00885   {  return bookProf(name, title, x, y);                                      }

P2D* HistogramSvc::createProfile2D | ( | CSTR | nameAndTitle,
|  | DBINS(x) | ,
|  | DBINS(y) |  |
| ) |  |  | `[inline]`

Definition at line 886 of file HistogramSvc.h.

    00887   { return bookProf(nameAndTitle, nameAndTitle, BINS(x), BINS(y));            }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline]`

Definition at line 889 of file HistogramSvc.h.

    00890   {  return bookProf( name, tit, BINS(x), BINS(y), upper, lower);             }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | tit,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 891 of file HistogramSvc.h.

    00892   {  return bookProf( name, tit, BINS(x), BINS(y), upper, lower);             }

P2D* HistogramSvc::createProfile2D | ( | CSTR | name,
|  | CSTR | title,
|  | const Edges & | x,
|  | const Edges & | y,
|  | double | upper,
|  | double | lower,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 893 of file HistogramSvc.h.

    00894   {  return bookProf(name, title, x, y, upper, lower);                        }

P2D* HistogramSvc::createProfile2D | ( | CSTR | nameAndTitle,
|  | DBINS(x) | ,
|  | DBINS(y) | ,
|  | double | upper,
|  | double | lower |
| ) |  |  | `[inline]`

Definition at line 895 of file HistogramSvc.h.

    00896   { return bookProf(nameAndTitle, nameAndTitle, BINS(x), BINS(y), upper, lower);}

P2D* HistogramSvc::createCopy | ( | CSTR | full,
|  | const P2D & | h |
| ) |  |  | `[inline]`

Definition at line 898 of file HistogramSvc.h.

    00899   {  return createCopy(i_splitPath(full), h);                                 }

P2D* HistogramSvc::createCopy | ( | CSTR | par,
|  | CSTR | rel,
|  | const P2D & | h |
| ) |  |  | `[inline]`

Definition at line 900 of file HistogramSvc.h.

    00901   {  return createCopy(createPath(par), rel, h);                              }

P2D* HistogramSvc::createCopy | ( | STRPAIR | loc,
|  | const P2D & | h |
| ) |  |  | `[inline]`

Definition at line 902 of file HistogramSvc.h.

    00903   {  return createCopy(loc.first, loc.second, h);                             }

P2D* HistogramSvc::createCopy | ( | DataObject * | pPar,
|  | CSTR | rel,
|  | const P2D & | h |
| ) |  |  | `[inline]`

Definition at line 904 of file HistogramSvc.h.

    00905   { return i_book(pPar, rel, h.title(), Gaudi::createProf2D(h));              }

virtual std::ostream& HistogramSvc::print | ( | Base * | h,
|  | std::ostream & | s = `std::cout` |
| ) |  |  | const`[virtual]`

Print (ASCII) the 1D histogram into the output stream.

Implements IHistogramSvc.

virtual std::ostream& HistogramSvc::write | ( | Base * | h,
|  | std::ostream & | s = `std::cout` |
| ) |  |  | const`[virtual]`

Write (ASCII) the 1D histogram table into the output stream.

Implements IHistogramSvc.

virtual int HistogramSvc::write | ( | Base * | h,
|  | const char * | file_name |
| ) |  |  | const`[virtual]`

Write (ASCII) the 1D histogram table into a file.

Implements IHistogramSvc.

DataObject * HistogramSvc::createPath | ( | CSTR | newPath | ) | `[virtual]`

Create all directories in a given full path.

Definition at line 145 of file HistogramSvc.cpp.

    00145                                                   {
    00146   std::string tmpPath = newPath;
    00147   if (tmpPath[0] != SEPARATOR)    {
    00148     tmpPath.insert(tmpPath.begin(), SEPARATOR);
    00149     tmpPath.insert(tmpPath.begin(), m_rootName.begin(), m_rootName.end());
    00150   }
    00151   // Remove trailing "/" from newPath if it exists
    00152   if (tmpPath.rfind(SEPARATOR) == tmpPath.length()-1) {
    00153     tmpPath.erase(tmpPath.rfind(SEPARATOR),1);
    00154   }
    00155   DataObject* pObject = 0;
    00156   StatusCode sc = DataSvc::findObject(tmpPath, pObject);
    00157   if(sc.isSuccess()) {
    00158     return pObject;
    00159   }
    00160   int sep = tmpPath.rfind(SEPARATOR);
    00161   std::string rest(tmpPath, sep+1, tmpPath.length()-sep);
    00162   std::string subPath(tmpPath, 0, sep);
    00163   if(0 != sep) {
    00164     createPath(subPath);
    00165   }
    00166   else {
    00167     MsgStream log(msgSvc(), name());
    00168     log << MSG::ERROR << "Unable to create the histogram path" << endmsg;
    00169     return 0;
    00170   }
    00171   pObject = createDirectory(subPath, rest);
    00172   return pObject;
    00173 }

DataObject * HistogramSvc::createDirectory | ( | CSTR | parentDir,
|  | CSTR | subDir |
| ) |  |  | `[virtual]`

Create a sub-directory in a directory.

Parameters:

  | parentDir | name of the parent directory
  | subDir | to identify the histogram object in the store

Definition at line 175 of file HistogramSvc.cpp.

    00175                                                                     {
    00176   DataObject*  directory = new DataObject();
    00177   if (0 != directory)  {
    00178     DataObject* pnode;
    00179     StatusCode status = DataSvc::retrieveObject(parentDir, pnode);
    00180     if(status.isSuccess()) {
    00181       status = DataSvc::registerObject(pnode, subDir, directory);
    00182       if (!status.isSuccess())   {
    00183         MsgStream log(msgSvc(), name());
    00184         log << MSG::ERROR << "Unable to create the histogram directory: "
    00185                           << parentDir << "/" << subDir << endmsg;
    00186         delete directory;
    00187         return 0;
    00188       }
    00189     }
    00190     else {
    00191       MsgStream log(msgSvc(), name());
    00192       log << MSG::ERROR << "Unable to create the histogram directory: "
    00193                         << parentDir << "/" << subDir << endmsg;
    00194       delete directory;
    00195       return 0;
    00196     }
    00197   }
    00198   return directory;
    00199 }

void HistogramSvc::update1Ddefs | ( | Property & |  | ) |

handler to be invoked for updating property m_defs1D

Definition at line 423 of file HistogramSvc.cpp.

    00424 {
    00425   // check and remove the leading '/stat/'
    00426   removeLeading  ( m_defs1D , "/stat/" ) ;
    00427 }

## Friends And Related Function Documentation

friend class SvcFactory< HistogramSvc >`[friend]`

Definition at line 55 of file HistogramSvc.h.

## Member Data Documentation

DBaseEntries HistogramSvc::m_input`[protected]`

Input streams.

Definition at line 122 of file HistogramSvc.h.

H2D* const H3D HistogramSvc::int

Definition at line 799 of file HistogramSvc.h.

H2D* const H3D int NOT_IMPLEMENTED H2D* CSTR HistogramSvc::tit

Definition at line 803 of file HistogramSvc.h.

Histo1DMap HistogramSvc::m_defs1D`[private]`

Definition at line 951 of file HistogramSvc.h.

std::set<std::string> HistogramSvc::m_mods1D`[private]`

Definition at line 954 of file HistogramSvc.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/HistogramSvc/HistogramSvc.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiSvc/src/HistogramSvc/HistogramSvc.cpp