| # Gaudi Framework, version v20r4
Generated: 8 Jan 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 47 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 StatusCode | queryInterface (const InterfaceID &iid, void **ppv)
| Query the interface.
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)
AIDA::ICloud1D * | createCloud1D (CSTR, CSTR, int, CSTR) NOT_IMPLEMENTED AIDA
virtual StatusCode | registerObject (CSTR parPath, CSTR rel, DataObject *obj)
virtual StatusCode | registerObject (CSTR parPath, int item, DataObject *obj)
virtual StatusCode | registerObject (DataObject *pPar, CSTR rel, DataObject *obj)
virtual StatusCode | registerObject (DataObject *pPar, int item, DataObject *obj)
| Register object with the data store.
virtual StatusCode | unregisterObject (CSTR full)
| Unregister object from the data store.
virtual StatusCode | unregisterObject (CSTR parPath, CSTR objectPath)
virtual StatusCode | unregisterObject (CSTR parPath, int item)
virtual StatusCode | unregisterObject (DataObject *obj)
| Unregister object from the data store.
virtual StatusCode | unregisterObject (DataObject *obj, CSTR objectPath)
virtual StatusCode | unregisterObject (DataObject *obj, int item)
| Unregister object from the data store.
virtual StatusCode | retrieveObject (IRegistry *dir, CSTR path, DataObject *&obj)
| Retrieve object from data store.
virtual StatusCode | retrieveObject (CSTR full, DataObject *&obj)
virtual StatusCode | retrieveObject (CSTR parPath, CSTR rel, DataObject *&obj)
virtual StatusCode | retrieveObject (CSTR parPath, int item, DataObject *&obj)
virtual StatusCode | retrieveObject (DataObject *pPar, CSTR rel, DataObject *&obj)
virtual StatusCode | retrieveObject (DataObject *pPar, int item, DataObject *&obj)
| Retrieve object from data store.
virtual StatusCode | findObject (CSTR full, DataObject *&obj)
| Find object identified by its full path in the data store.
virtual StatusCode | findObject (IRegistry *dir, CSTR path, DataObject *&obj)
virtual StatusCode | findObject (CSTR parPath, CSTR rel, DataObject *&obj)
virtual StatusCode | findObject (CSTR parPath, int item, DataObject *&obj)
virtual StatusCode | findObject (DataObject *pPar, CSTR rel, DataObject *&obj)
virtual StatusCode | findObject (DataObject *pPar, int item, DataObject *&obj)
| Find object in the data store.
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 55 of file HistogramSvc.h.

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

Definition at line 61 of file HistogramSvc.h.

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

Definition at line 62 of file HistogramSvc.h.

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

Definition at line 63 of file HistogramSvc.h.

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

Definition at line 64 of file HistogramSvc.h.

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

Definition at line 65 of file HistogramSvc.h.

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

Definition at line 66 of file HistogramSvc.h.

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

Definition at line 67 of file HistogramSvc.h.

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

Definition at line 68 of file HistogramSvc.h.

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

Definition at line 69 of file HistogramSvc.h.

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

Definition at line 1002 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 394 of file HistogramSvc.cpp.

    00395   : DataSvc(nam, svc)
    00396   , m_defs1D ()
    00397   , m_mods1D ()
    00398 {
    00399   // Properties can be declared here
    00400   m_rootName = "/stat";
    00401   m_rootCLID = CLID_DataObject;
    00402   declareProperty ( "Input",  m_input);
    00403   declareProperty ( "Predefined1DHistos" , m_defs1D ,
    00404                     "Histograms with predefined parameters" ) ;
    00405   // update handler
    00406   Property* p = Gaudi::Utils::getProperty ( this , "Predefined1DHistos" ) ;
    00407   p->declareUpdateHandler ( &HistogramSvc::update1Ddefs , this ) ;
    00408
    00409 }

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 56 of file HistogramSvc.h.

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

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 = 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 << endreq;
    00252           return status;
    00253         }
    00254         pA->release();
    00255       }
    00256     }
    00257   }
    00258   log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endreq;
    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 147 of file HistogramSvc.h.

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

template<class T>

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

Definition at line 154 of file HistogramSvc.h.

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

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." << endreq;
    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." << endreq;
    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: " << endreq ;
    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 << endreq ;
    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 441 of file HistogramSvc.cpp.

    00442 {
    00443   if ( !m_mods1D.empty() )
    00444   {
    00445     MsgStream log ( msgSvc () , name () ) ;
    00446     log << MSG::DEBUG
    00447         << " Substituted histograms #" << m_mods1D.size() << " : " << endreq ;
    00448     for ( std::set<std::string>::const_iterator ih = m_mods1D.begin() ;
    00449           m_mods1D.end() != ih ; ++ih )
    00450     {
    00451       log << MSG::DEBUG << " Path='" << (*ih) << "'" ;
    00452       Histo1DMap::const_iterator im = m_defs1D.find( *ih ) ;
    00453       if ( m_defs1D.end() != im ) { log << "  " << im->second ; }
    00454     }
    00455     m_mods1D.clear() ;
    00456   }
    00457   return DataSvc::finalize () ;
    00458 }

StatusCode HistogramSvc::queryInterface | ( | const InterfaceID & | iid,
|  | void ** | ppv |
| ) |  |  | `[virtual]`

Query the interface.

Parameters:

  | iid | requested interface ID
  | ppv | pointer to requested interface

Reimplemented from DataSvc.

Definition at line 311 of file HistogramSvc.cpp.

    00311                                                {
    00312   if(riid == IID_IHistogramSvc)  {
    00313     *ppvInterface = static_cast<IHistogramSvc*>(this);
    00314     addRef();
    00315     return StatusCode::SUCCESS;
    00316   }
    00317   // Interface is not directly availible: try out a base class
    00318   return DataSvc::queryInterface(riid, ppvInterface);
    00319 }

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

Retrieve the AIDA HistogramFactory interface.

Implements IHistogramSvc.

Definition at line 179 of file HistogramSvc.h.

    00179 {  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 201 of file HistogramSvc.h.

    00202   {  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 203 of file HistogramSvc.h.

    00204   {  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 205 of file HistogramSvc.h.

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

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

Definition at line 370 of file HistogramSvc.cpp.

    00371 {
    00372   if ( m_defs1D.empty () )
    00373   { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
    00374   std::string hn = histoAddr ( pPar , rel ) ;
    00375   Histo1DMap::const_iterator ifound = m_defs1D.find( hn ) ;
    00376   if ( m_defs1D.end() == ifound )
    00377   { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
    00378   MsgStream log ( msgSvc() , name() ) ;
    00379   log << MSG::DEBUG
    00380       << " Redefine the parameters for the histogram '" + hn +"' to be "
    00381       << ifound->second
    00382       << endreq ;
    00383   m_mods1D.insert ( hn ) ;
    00384   return i_book ( pPar , rel , ifound -> second.title   () ,
    00385                   Gaudi::createH1D
    00386                   ( ifound -> second.title   () ,
    00387                     ifound -> second.bins    () ,
    00388                     ifound -> second.lowEdge () ,
    00389                     ifound -> second.lowEdge () ) ) ;
    00390 }

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

Definition at line 208 of file HistogramSvc.h.

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

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

Definition at line 210 of file HistogramSvc.h.

    00211   { 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 232 of file HistogramSvc.h.

    00233   { 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 234 of file HistogramSvc.h.

    00235   { 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 236 of file HistogramSvc.h.

    00237   { 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 238 of file HistogramSvc.h.

    00239   { 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 240 of file HistogramSvc.h.

    00241   { 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 242 of file HistogramSvc.h.

    00243   { 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 245 of file HistogramSvc.h.

    00246   { 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 247 of file HistogramSvc.h.

    00248   { 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 249 of file HistogramSvc.h.

    00250   { 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 251 of file HistogramSvc.h.

    00252   { 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 253 of file HistogramSvc.h.

    00254   { 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 255 of file HistogramSvc.h.

    00256   { 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 274 of file HistogramSvc.h.

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

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

Definition at line 276 of file HistogramSvc.h.

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

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

Definition at line 278 of file HistogramSvc.h.

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

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

Definition at line 280 of file HistogramSvc.h.

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

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

Definition at line 282 of file HistogramSvc.h.

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

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

Definition at line 284 of file HistogramSvc.h.

    00285   { 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 304 of file HistogramSvc.h.

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

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

Definition at line 306 of file HistogramSvc.h.

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

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

Definition at line 308 of file HistogramSvc.h.

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

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

Definition at line 310 of file HistogramSvc.h.

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

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

Definition at line 312 of file HistogramSvc.h.

    00313   { 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 314 of file HistogramSvc.h.

    00315   { 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 317 of file HistogramSvc.h.

    00318   { 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 319 of file HistogramSvc.h.

    00320   { 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 321 of file HistogramSvc.h.

    00322   { 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 323 of file HistogramSvc.h.

    00324   { 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 325 of file HistogramSvc.h.

    00326   { 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 327 of file HistogramSvc.h.

    00328   { 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 349 of file HistogramSvc.h.

    00350   { 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 351 of file HistogramSvc.h.

    00352   { 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 353 of file HistogramSvc.h.

    00354   { 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 355 of file HistogramSvc.h.

    00356   { 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 357 of file HistogramSvc.h.

    00358   { 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 359 of file HistogramSvc.h.

    00360   { 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 381 of file HistogramSvc.h.

    00382   { 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 383 of file HistogramSvc.h.

    00384   { 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 385 of file HistogramSvc.h.

    00386   { 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 387 of file HistogramSvc.h.

    00388   { 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 389 of file HistogramSvc.h.

    00390   { 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 391 of file HistogramSvc.h.

    00392   { 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 394 of file HistogramSvc.h.

    00395   { 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 396 of file HistogramSvc.h.

    00397   { 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 398 of file HistogramSvc.h.

    00399   { 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 400 of file HistogramSvc.h.

    00401   { 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 402 of file HistogramSvc.h.

    00403   { 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 404 of file HistogramSvc.h.

    00405   { 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 423 of file HistogramSvc.h.

    00424   { 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 425 of file HistogramSvc.h.

    00426   { 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 427 of file HistogramSvc.h.

    00428   { 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 429 of file HistogramSvc.h.

    00430   { 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 431 of file HistogramSvc.h.

    00432   { 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 433 of file HistogramSvc.h.

    00434   { 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 452 of file HistogramSvc.h.

    00453   { 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 454 of file HistogramSvc.h.

    00455   { 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 456 of file HistogramSvc.h.

    00457   { 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 458 of file HistogramSvc.h.

    00459   { 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 460 of file HistogramSvc.h.

    00461   { 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 462 of file HistogramSvc.h.

    00463   { 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 465 of file HistogramSvc.h.

    00466   { 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 467 of file HistogramSvc.h.

    00468   { 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 469 of file HistogramSvc.h.

    00470   { 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 471 of file HistogramSvc.h.

    00472   { 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 473 of file HistogramSvc.h.

    00474   { 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 475 of file HistogramSvc.h.

    00476   { 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 497 of file HistogramSvc.h.

    00498   { 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 499 of file HistogramSvc.h.

    00500   { 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 501 of file HistogramSvc.h.

    00502   { 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 503 of file HistogramSvc.h.

    00504   { 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 505 of file HistogramSvc.h.

    00506   { 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 507 of file HistogramSvc.h.

    00508   { 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 528 of file HistogramSvc.h.

    00529   { 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 530 of file HistogramSvc.h.

    00531   { 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 532 of file HistogramSvc.h.

    00533   { 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 534 of file HistogramSvc.h.

    00535   { 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 536 of file HistogramSvc.h.

    00537   { 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 538 of file HistogramSvc.h.

    00539   { 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 547 of file HistogramSvc.h.

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

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

Definition at line 549 of file HistogramSvc.h.

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

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

Definition at line 551 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 553 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 555 of file HistogramSvc.h.

    00556   { 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 562 of file HistogramSvc.h.

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

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

Definition at line 564 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 566 of file HistogramSvc.h.

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

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

Definition at line 571 of file HistogramSvc.h.

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

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

Definition at line 573 of file HistogramSvc.h.

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

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

Definition at line 575 of file HistogramSvc.h.

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

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

Definition at line 577 of file HistogramSvc.h.

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

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

Definition at line 579 of file HistogramSvc.h.

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

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

Definition at line 582 of file HistogramSvc.h.

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

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

Definition at line 584 of file HistogramSvc.h.

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

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

Definition at line 586 of file HistogramSvc.h.

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

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

Definition at line 588 of file HistogramSvc.h.

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

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

Definition at line 590 of file HistogramSvc.h.

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

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

Definition at line 593 of file HistogramSvc.h.

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

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

Definition at line 595 of file HistogramSvc.h.

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

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

Definition at line 597 of file HistogramSvc.h.

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

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

Definition at line 599 of file HistogramSvc.h.

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

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

Definition at line 601 of file HistogramSvc.h.

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

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

Definition at line 604 of file HistogramSvc.h.

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

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

Definition at line 606 of file HistogramSvc.h.

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

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

Definition at line 608 of file HistogramSvc.h.

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

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

Definition at line 610 of file HistogramSvc.h.

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

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

Definition at line 612 of file HistogramSvc.h.

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

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

Definition at line 615 of file HistogramSvc.h.

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

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

Definition at line 617 of file HistogramSvc.h.

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

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

Definition at line 619 of file HistogramSvc.h.

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

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

Definition at line 621 of file HistogramSvc.h.

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

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

Definition at line 623 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 626 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 628 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 630 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 632 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 634 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 637 of file HistogramSvc.h.

    00638   {  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 639 of file HistogramSvc.h.

    00640   {  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 641 of file HistogramSvc.h.

    00642   {  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 643 of file HistogramSvc.h.

    00644   {  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 645 of file HistogramSvc.h.

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

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

Definition at line 648 of file HistogramSvc.h.

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

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

Definition at line 650 of file HistogramSvc.h.

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

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

Definition at line 652 of file HistogramSvc.h.

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

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

Definition at line 654 of file HistogramSvc.h.

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

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

Definition at line 656 of file HistogramSvc.h.

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

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

Definition at line 666 of file HistogramSvc.h.

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

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

Definition at line 668 of file HistogramSvc.h.

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

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

Definition at line 670 of file HistogramSvc.h.

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

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

Definition at line 672 of file HistogramSvc.h.

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

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

Definition at line 674 of file HistogramSvc.h.

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

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

Definition at line 677 of file HistogramSvc.h.

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

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

Definition at line 679 of file HistogramSvc.h.

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

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

Definition at line 681 of file HistogramSvc.h.

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

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

Definition at line 683 of file HistogramSvc.h.

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

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

Definition at line 685 of file HistogramSvc.h.

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

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

Definition at line 688 of file HistogramSvc.h.

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

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

Definition at line 690 of file HistogramSvc.h.

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

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

Definition at line 692 of file HistogramSvc.h.

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

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

Definition at line 694 of file HistogramSvc.h.

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

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

Definition at line 696 of file HistogramSvc.h.

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

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

Definition at line 699 of file HistogramSvc.h.

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

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

Definition at line 701 of file HistogramSvc.h.

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

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

Definition at line 703 of file HistogramSvc.h.

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

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

Definition at line 705 of file HistogramSvc.h.

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

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

Definition at line 707 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 710 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 712 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 714 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 716 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 718 of file HistogramSvc.h.

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

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

Definition at line 721 of file HistogramSvc.h.

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

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

Definition at line 723 of file HistogramSvc.h.

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

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

Definition at line 725 of file HistogramSvc.h.

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

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

Definition at line 727 of file HistogramSvc.h.

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

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

Definition at line 729 of file HistogramSvc.h.

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

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

Implements IHistogramSvc.

Definition at line 732 of file HistogramSvc.h.

    00733   {  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 734 of file HistogramSvc.h.

    00735   {  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 736 of file HistogramSvc.h.

    00737   {  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 738 of file HistogramSvc.h.

    00739   {  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 740 of file HistogramSvc.h.

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

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

Definition at line 743 of file HistogramSvc.h.

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

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

Definition at line 745 of file HistogramSvc.h.

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

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

Definition at line 747 of file HistogramSvc.h.

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

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

Definition at line 749 of file HistogramSvc.h.

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

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

Definition at line 751 of file HistogramSvc.h.

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

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

Definition at line 757 of file HistogramSvc.h.

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

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

Definition at line 759 of file HistogramSvc.h.

    00760   {  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 761 of file HistogramSvc.h.

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

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

Definition at line 763 of file HistogramSvc.h.

    00764   {  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 362 of file HistogramSvc.cpp.

    00362                                                  {
    00363   StatusCode sc = unregisterObject( dynamic_cast<IHistogram*>(hist) );
    00364   if ( !sc.isSuccess() ) return false;
    00365   if ( hist ) delete hist;
    00366   return true;
    00367 }

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

Definition at line 770 of file HistogramSvc.h.

    00771   { 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 772 of file HistogramSvc.h.

    00773   { 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 774 of file HistogramSvc.h.

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

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

Definition at line 776 of file HistogramSvc.h.

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

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

Definition at line 779 of file HistogramSvc.h.

    00780   { 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 781 of file HistogramSvc.h.

    00782   { 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 783 of file HistogramSvc.h.

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

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

Definition at line 785 of file HistogramSvc.h.

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

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

Definition at line 788 of file HistogramSvc.h.

    00789   { 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 790 of file HistogramSvc.h.

    00791   { 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 792 of file HistogramSvc.h.

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

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

Definition at line 794 of file HistogramSvc.h.

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

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

Definition at line 797 of file HistogramSvc.h.

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

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

Definition at line 799 of file HistogramSvc.h.

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

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

Definition at line 801 of file HistogramSvc.h.

    00802   { 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 808 of file HistogramSvc.h.

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

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

Definition at line 810 of file HistogramSvc.h.

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

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

Definition at line 812 of file HistogramSvc.h.

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

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

Definition at line 814 of file HistogramSvc.h.

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

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

Definition at line 816 of file HistogramSvc.h.

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

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

Definition at line 818 of file HistogramSvc.h.

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

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

Definition at line 820 of file HistogramSvc.h.

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

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

Definition at line 822 of file HistogramSvc.h.

    00823   { 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 825 of file HistogramSvc.h.

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

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

Definition at line 827 of file HistogramSvc.h.

    00828   {  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 829 of file HistogramSvc.h.

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

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

Definition at line 831 of file HistogramSvc.h.

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

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

Definition at line 833 of file HistogramSvc.h.

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

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

Definition at line 835 of file HistogramSvc.h.

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

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

Definition at line 837 of file HistogramSvc.h.

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

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

Definition at line 839 of file HistogramSvc.h.

    00840   { 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 842 of file HistogramSvc.h.

    00843   {  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 844 of file HistogramSvc.h.

    00845   {  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 846 of file HistogramSvc.h.

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

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

Definition at line 848 of file HistogramSvc.h.

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

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

Definition at line 850 of file HistogramSvc.h.

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

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

Definition at line 852 of file HistogramSvc.h.

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

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

Definition at line 854 of file HistogramSvc.h.

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

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

Definition at line 856 of file HistogramSvc.h.

    00857   { 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 861 of file HistogramSvc.h.

    00862   {  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 863 of file HistogramSvc.h.

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

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

Definition at line 865 of file HistogramSvc.h.

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

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

Definition at line 867 of file HistogramSvc.h.

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

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

Definition at line 870 of file HistogramSvc.h.

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

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

Definition at line 872 of file HistogramSvc.h.

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

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

Definition at line 876 of file HistogramSvc.h.

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

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

Definition at line 878 of file HistogramSvc.h.

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

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

Definition at line 880 of file HistogramSvc.h.

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

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

Definition at line 882 of file HistogramSvc.h.

    00883   { 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 885 of file HistogramSvc.h.

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

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

Definition at line 887 of file HistogramSvc.h.

    00888   {  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 889 of file HistogramSvc.h.

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

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

Definition at line 891 of file HistogramSvc.h.

    00892   { 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 894 of file HistogramSvc.h.

    00895   {  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 896 of file HistogramSvc.h.

    00897   {  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 898 of file HistogramSvc.h.

    00899   {  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 900 of file HistogramSvc.h.

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

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

Definition at line 903 of file HistogramSvc.h.

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

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

Definition at line 905 of file HistogramSvc.h.

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

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

Definition at line 907 of file HistogramSvc.h.

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

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

Definition at line 909 of file HistogramSvc.h.

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

AIDA::ICloud1D* HistogramSvc::createCloud1D | ( | CSTR | ,
|  | CSTR | ,
|  | int | ,
|  | CSTR |  |
| ) |  |  | `[inline]`

Definition at line 912 of file HistogramSvc.h.

    00927   {    return DataSvc::registerObject(full, obj );                            }

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

Definition at line 928 of file HistogramSvc.h.

    00929   {    return DataSvc::registerObject(parPath, rel, obj );                    }

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

Definition at line 930 of file HistogramSvc.h.

    00931   {    return DataSvc::registerObject(parPath, item, obj );                   }

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

Definition at line 932 of file HistogramSvc.h.

    00933   {    return DataSvc::registerObject(pPar, rel, obj );                       }

virtual StatusCode HistogramSvc::registerObject | ( | DataObject * | parentObj,
|  | int | item,
|  | DataObject * | pObject |
| ) |  |  | `[inline, virtual]`

Register object with the data store.

Reimplemented from DataSvc.

Definition at line 934 of file HistogramSvc.h.

    00935   {    return DataSvc::registerObject(pPar, item, obj );                      }

virtual StatusCode HistogramSvc::unregisterObject | ( | CSTR | full | ) | `[inline, virtual]`

Unregister object from the data store.

Definition at line 938 of file HistogramSvc.h.

    00939   {    return DataSvc::unregisterObject(full );                               }

virtual StatusCode HistogramSvc::unregisterObject | ( | CSTR | parPath,
|  | CSTR | objectPath |
| ) |  |  | `[inline, virtual]`

Definition at line 940 of file HistogramSvc.h.

    00941   {    return DataSvc::unregisterObject(parPath, objectPath );                }

virtual StatusCode HistogramSvc::unregisterObject | ( | CSTR | parPath,
|  | int | item |
| ) |  |  | `[inline, virtual]`

Definition at line 942 of file HistogramSvc.h.

    00943   {    return DataSvc::unregisterObject(parPath, item );                      }

virtual StatusCode HistogramSvc::unregisterObject | ( | DataObject * | pObject | ) | `[inline, virtual]`

Unregister object from the data store.

Reimplemented from DataSvc.

Definition at line 944 of file HistogramSvc.h.

    00945   {    return DataSvc::unregisterObject(obj );                                }

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

Definition at line 946 of file HistogramSvc.h.

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

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

Unregister object from the data store.

Reimplemented from DataSvc.

Definition at line 948 of file HistogramSvc.h.

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

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

Retrieve object from data store.

Definition at line 952 of file HistogramSvc.h.

    00953   {    return DataSvc::retrieveObject(dir, path, obj );                       }

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

Definition at line 954 of file HistogramSvc.h.

    00955   {    return DataSvc::retrieveObject(full, obj );                            }

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

Definition at line 956 of file HistogramSvc.h.

    00957   {    return DataSvc::retrieveObject(parPath, rel, obj );                    }

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

Definition at line 958 of file HistogramSvc.h.

    00959   {    return DataSvc::retrieveObject(parPath, item, obj );                   }

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

Definition at line 960 of file HistogramSvc.h.

    00961   {    return DataSvc::retrieveObject(pPar, rel, obj );                       }

virtual StatusCode HistogramSvc::retrieveObject | ( | DataObject * | parentObj,
|  | int | item,
|  | DataObject *& | pObject |
| ) |  |  | `[inline, virtual]`

Retrieve object from data store.

Retrieve registry entry from store.

Reimplemented from DataSvc.

Definition at line 962 of file HistogramSvc.h.

    00963   {    return DataSvc::retrieveObject(pPar, item, obj );                      }

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

Find object identified by its full path in the data store.

Definition at line 966 of file HistogramSvc.h.

    00967   {    return DataSvc::findObject(full, obj );                                }

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

Definition at line 968 of file HistogramSvc.h.

    00969   {    return DataSvc::findObject(dir, path, obj );                           }

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

Definition at line 970 of file HistogramSvc.h.

    00971   {    return DataSvc::findObject(parPath, rel, obj );                        }

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

Definition at line 972 of file HistogramSvc.h.

    00973   {    return DataSvc::findObject(parPath, item, obj );                       }

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

Definition at line 974 of file HistogramSvc.h.

    00975   {    return DataSvc::findObject(pPar, rel, obj );                           }

virtual StatusCode HistogramSvc::findObject | ( | DataObject * | parentObj,
|  | int | item,
|  | DataObject *& | pObject |
| ) |  |  | `[inline, virtual]`

Find object in the data store.

Find object identified by its full path in the data store.

Reimplemented from DataSvc.

Definition at line 976 of file HistogramSvc.h.

    00977   {    return DataSvc::findObject(pPar, item, obj );                          }

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" << endreq;
    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 << endreq;
    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 << endreq;
    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 434 of file HistogramSvc.cpp.

    00435 {
    00436   // check and remove the leading '/stat/'
    00437   removeLeading  ( m_defs1D , "/stat/" ) ;
    00438 }

## Friends And Related Function Documentation

friend class SvcFactory< HistogramSvc >`[friend]`

Definition at line 54 of file HistogramSvc.h.

## Member Data Documentation

DBaseEntries HistogramSvc::m_input`[protected]`

Input streams.

Definition at line 121 of file HistogramSvc.h.

H2D* const H3D HistogramSvc::int

Definition at line 804 of file HistogramSvc.h.

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

Definition at line 808 of file HistogramSvc.h.

Histo1DMap HistogramSvc::m_defs1D`[private]`

Definition at line 1007 of file HistogramSvc.h.

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

Definition at line 1010 of file HistogramSvc.h.

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

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