| # Gaudi Framework, version v23r1 |

Home |  | Generated: Wed Feb 29 2012

Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Protected Types | Protected Attributes | Private Types | Private Member Functions | Private Attributes | Friends

# HistogramSvc Class Reference

HistogramSvc class definition. More...

`#include <HistogramSvc.h>`

Inheritance diagram for HistogramSvc:
[legend]
Collaboration diagram for HistogramSvc:
[legend]

List of all members.

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

## Detailed Description

HistogramSvc class definition.

Definition at line 49 of file HistogramSvc.h.

## Member Typedef Documentation

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

Definition at line 70 of file HistogramSvc.h.

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

Definition at line 62 of file HistogramSvc.h.

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

Definition at line 64 of file HistogramSvc.h.

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

Definition at line 63 of file HistogramSvc.h.

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

Definition at line 65 of file HistogramSvc.h.

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

Definition at line 66 of file HistogramSvc.h.

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

Definition at line 67 of file HistogramSvc.h.

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

Definition at line 946 of file HistogramSvc.h.

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

Definition at line 68 of file HistogramSvc.h.

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

Definition at line 69 of file HistogramSvc.h.

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

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

      : base_class(nam, svc)
      , m_defs1D ()
      , m_mods1D ()
    {
      // Properties can be declared here
      m_rootName = "/stat";
      m_rootCLID = CLID_DataObject;
      declareProperty ( "Input",  m_input);
      declareProperty ( "Predefined1DHistos" , m_defs1D ,
                        "Histograms with predefined parameters" ) ;
      // update handler
      Property* p = Gaudi::Utils::getProperty ( this , "Predefined1DHistos" ) ;
      p->declareUpdateHandler ( &HistogramSvc::update1Ddefs , this ) ;

    }

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

Destructor.

Definition at line 213 of file HistogramSvc.cpp.

                                  {
      setDataLoader( 0 ).ignore();
      clearStore().ignore();
    }

## Member Function Documentation

template<class T >

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

Definition at line 155 of file HistogramSvc.h.

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

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

Definition at line 69 of file HistogramSvc.cpp.

                                       {
      std::ostringstream txt; txt << i;
      return txt.str();
    }

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

Definition at line 765 of file HistogramSvc.h.

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

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

Definition at line 774 of file HistogramSvc.h.

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

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

Definition at line 783 of file HistogramSvc.h.

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

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

Definition at line 203 of file HistogramSvc.h.

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

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

Definition at line 205 of file HistogramSvc.h.

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

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

Definition at line 273 of file HistogramSvc.h.

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

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

Definition at line 275 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 418 of file HistogramSvc.h.

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

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

Definition at line 420 of file HistogramSvc.h.

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

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

Definition at line 277 of file HistogramSvc.h.

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

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

Definition at line 422 of file HistogramSvc.h.

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

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

Definition at line 424 of file HistogramSvc.h.

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

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

Definition at line 279 of file HistogramSvc.h.

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

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

Definition at line 426 of file HistogramSvc.h.

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

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

Definition at line 428 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 492 of file HistogramSvc.h.

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

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

Definition at line 494 of file HistogramSvc.h.

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

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

Definition at line 496 of file HistogramSvc.h.

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

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

Definition at line 498 of file HistogramSvc.h.

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

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

Definition at line 500 of file HistogramSvc.h.

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

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

Definition at line 502 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 523 of file HistogramSvc.h.

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

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

Definition at line 525 of file HistogramSvc.h.

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

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

Definition at line 527 of file HistogramSvc.h.

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

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

Definition at line 529 of file HistogramSvc.h.

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

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

Definition at line 531 of file HistogramSvc.h.

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

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

Definition at line 533 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 196 of file HistogramSvc.h.

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

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

Definition at line 346 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 344 of file HistogramSvc.h.

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

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

Definition at line 348 of file HistogramSvc.h.

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

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

Definition at line 350 of file HistogramSvc.h.

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

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

Definition at line 198 of file HistogramSvc.h.

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

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

Definition at line 352 of file HistogramSvc.h.

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

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

Definition at line 354 of file HistogramSvc.h.

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

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

Definition at line 200 of file HistogramSvc.h.

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

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

Definition at line 371 of file HistogramSvc.cpp.

    {
      if ( m_defs1D.empty () )
      { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
      std::string hn = histoAddr ( pPar , rel ) ;
      Histo1DMap::const_iterator ifound = m_defs1D.find( hn ) ;
      if ( m_defs1D.end() == ifound )
      { return i_book(pPar,rel,title,Gaudi::createH1D(title, BINS(x))); }
      if (msgLevel(MSG::DEBUG)) {
        MsgStream log ( msgSvc() , name() ) ;
        log << MSG::DEBUG
            << " Redefine the parameters for the histogram '" + hn + "' to be "
            << ifound->second
            << endmsg;
      }
      m_mods1D.insert ( hn ) ;
      return i_book ( pPar , rel , ifound -> second.title   () ,
                      Gaudi::createH1D
                      ( ifound -> second.title   () ,
                        ifound -> second.bins    () ,
                        ifound -> second.lowEdge () ,
                        ifound -> second.lowEdge () ) ) ;
    }

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 269 of file HistogramSvc.h.

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

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

Definition at line 271 of file HistogramSvc.h.

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

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

Definition at line 397 of file HistogramSvc.h.

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

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

Definition at line 399 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 227 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 299 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 447 of file HistogramSvc.h.

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

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

Definition at line 449 of file HistogramSvc.h.

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

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

Definition at line 301 of file HistogramSvc.h.

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

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

Definition at line 451 of file HistogramSvc.h.

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

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

Definition at line 453 of file HistogramSvc.h.

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

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

Definition at line 229 of file HistogramSvc.h.

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

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

Definition at line 303 of file HistogramSvc.h.

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

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

Definition at line 455 of file HistogramSvc.h.

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

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

Definition at line 457 of file HistogramSvc.h.

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

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

Definition at line 305 of file HistogramSvc.h.

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

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

Definition at line 460 of file HistogramSvc.h.

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

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

Definition at line 462 of file HistogramSvc.h.

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

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

Definition at line 307 of file HistogramSvc.h.

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

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

Definition at line 464 of file HistogramSvc.h.

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

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

Definition at line 466 of file HistogramSvc.h.

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

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

Definition at line 309 of file HistogramSvc.h.

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

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

Definition at line 468 of file HistogramSvc.h.

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

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

Definition at line 470 of file HistogramSvc.h.

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

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

Definition at line 233 of file HistogramSvc.h.

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

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

Definition at line 312 of file HistogramSvc.h.

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

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

Definition at line 314 of file HistogramSvc.h.

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

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

Definition at line 231 of file HistogramSvc.h.

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

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

Definition at line 235 of file HistogramSvc.h.

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

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

Definition at line 316 of file HistogramSvc.h.

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

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

Definition at line 318 of file HistogramSvc.h.

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

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

Definition at line 320 of file HistogramSvc.h.

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

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

Definition at line 237 of file HistogramSvc.h.

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

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

Definition at line 322 of file HistogramSvc.h.

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

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

Definition at line 240 of file HistogramSvc.h.

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

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

Definition at line 242 of file HistogramSvc.h.

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

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

Definition at line 244 of file HistogramSvc.h.

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

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

Definition at line 246 of file HistogramSvc.h.

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

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

Book histogram and register it with the histogram data store.

Parameters:

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

Definition at line 376 of file HistogramSvc.h.

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

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

Definition at line 378 of file HistogramSvc.h.

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

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

Definition at line 248 of file HistogramSvc.h.

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

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

Definition at line 380 of file HistogramSvc.h.

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

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

Definition at line 382 of file HistogramSvc.h.

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

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

Definition at line 250 of file HistogramSvc.h.

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

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

Definition at line 384 of file HistogramSvc.h.

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

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

Definition at line 386 of file HistogramSvc.h.

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

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

Definition at line 389 of file HistogramSvc.h.

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

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

Definition at line 391 of file HistogramSvc.h.

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

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

Definition at line 393 of file HistogramSvc.h.

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

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

Definition at line 395 of file HistogramSvc.h.

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

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

Connect input histogram file to the service.

Parameters:

  ident | [IN] Input specification

Definition at line 218 of file HistogramSvc.cpp.

                                                    {
      MsgStream log (msgSvc(), name());
      DataObject* pO = 0;
      StatusCode status = this->findObject(m_rootName, pO);
      if (status.isSuccess())   {
        Tokenizer tok(true);
        std::string::size_type loc = ident.find(" ");
        std::string filename, auth, svc = "", typ = "";
        std::string logname = ident.substr(0,loc);
        tok.analyse(ident.substr(loc+1,ident.length()), " ", "", "", "=", "'", "'");
        for (Tokenizer::Items::iterator i = tok.items().begin();
             i != tok.items().end(); i++) {
          CSTR tag = (*i).tag();
          switch(::toupper(tag[0]))   {
          case 'F':   // FILE='<file name>'
          case 'D':   // DATAFILE='<file name>'
            filename = (*i).value();
            break;
          case 'T':   // TYP='<HBOOK,ROOT,OBJY,...>'
            typ = (*i).value();
            break;
          default:
            break;
          }
        }
        if (typ.length() > 0)    {
          // Now add the registry entry to the store
          std::string entryname = m_rootName;
          entryname += '/';
          entryname += logname;
          GenericAddress* pA = 0;
          switch(::toupper(typ[0])) {
          case 'H':
            pA=new GenericAddress(HBOOK_StorageType,CLID_StatisticsFile,
                                  filename,entryname,0,'O');
            break;
          case 'R':
            pA=new GenericAddress(ROOT_StorageType,CLID_StatisticsFile,
                                  filename,entryname,0,'O');
            break;
          }
          if (0 != pA)    {
            status = registerAddress(pO, logname, pA);
            if (status.isSuccess())    {
              log << MSG::INFO << "Added stream file:" << filename
                  << " as " << logname << endmsg;
              return status;
            }
            pA->release();
          }
        }
      }
      log << MSG::ERROR << "Cannot add " << ident << " invalid filename!" << endmsg;
      return StatusCode::FAILURE;
    }

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

Definition at line 904 of file HistogramSvc.h.

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

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

Definition at line 900 of file HistogramSvc.h.

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

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

Definition at line 817 of file HistogramSvc.h.

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

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

Definition at line 873 of file HistogramSvc.h.

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

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

Definition at line 877 of file HistogramSvc.h.

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

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

Definition at line 847 of file HistogramSvc.h.

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

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

Definition at line 851 of file HistogramSvc.h.

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

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

Definition at line 811 of file HistogramSvc.h.

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

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

Definition at line 813 of file HistogramSvc.h.

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

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

Definition at line 815 of file HistogramSvc.h.

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

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

Definition at line 828 of file HistogramSvc.h.

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

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

Definition at line 832 of file HistogramSvc.h.

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

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

Definition at line 834 of file HistogramSvc.h.

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

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

Definition at line 830 of file HistogramSvc.h.

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

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

Definition at line 845 of file HistogramSvc.h.

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

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

Definition at line 849 of file HistogramSvc.h.

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

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

Definition at line 871 of file HistogramSvc.h.

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

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

Definition at line 875 of file HistogramSvc.h.

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

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

Definition at line 898 of file HistogramSvc.h.

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

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

Definition at line 902 of file HistogramSvc.h.

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

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 187 of file HistogramSvc.cpp.

                                                                        {
      DataObject*  directory = new DataObject();
      if (0 != directory)  {
        DataObject* pnode;
        StatusCode status = DataSvc::retrieveObject(parentDir, pnode);
        if(status.isSuccess()) {
          status = DataSvc::registerObject(pnode, subDir, directory);
          if (!status.isSuccess())   {
            MsgStream log(msgSvc(), name());
            log << MSG::ERROR << "Unable to create the histogram directory: "
                              << parentDir << "/" << subDir << endmsg;
            delete directory;
            return 0;
          }
        }
        else {
          MsgStream log(msgSvc(), name());
          log << MSG::ERROR << "Unable to create the histogram directory: "
                            << parentDir << "/" << subDir << endmsg;
          delete directory;
          return 0;
        }
      }
      return directory;
    }

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

Definition at line 809 of file HistogramSvc.h.

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

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

Definition at line 805 of file HistogramSvc.h.

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

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

Definition at line 807 of file HistogramSvc.h.

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

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

Definition at line 826 of file HistogramSvc.h.

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

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

Definition at line 822 of file HistogramSvc.h.

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

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

Definition at line 820 of file HistogramSvc.h.

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

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

Definition at line 824 of file HistogramSvc.h.

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

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

Definition at line 839 of file HistogramSvc.h.

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

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

Definition at line 843 of file HistogramSvc.h.

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

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

Definition at line 837 of file HistogramSvc.h.

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

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

Definition at line 841 of file HistogramSvc.h.

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

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

Create all directories in a given full path.

Definition at line 157 of file HistogramSvc.cpp.

                                                      {
      std::string tmpPath = newPath;
      if (tmpPath[0] != SEPARATOR)    {
        tmpPath.insert(tmpPath.begin(), SEPARATOR);
        tmpPath.insert(tmpPath.begin(), m_rootName.begin(), m_rootName.end());
      }
      // Remove trailing "/" from newPath if it exists
      if (tmpPath.rfind(SEPARATOR) == tmpPath.length()-1) {
        tmpPath.erase(tmpPath.rfind(SEPARATOR),1);
      }
      DataObject* pObject = 0;
      StatusCode sc = DataSvc::findObject(tmpPath, pObject);
      if(sc.isSuccess()) {
        return pObject;
      }
      int sep = tmpPath.rfind(SEPARATOR);
      std::string rest(tmpPath, sep+1, tmpPath.length()-sep);
      std::string subPath(tmpPath, 0, sep);
      if(0 != sep) {
        createPath(subPath);
      }
      else {
        MsgStream log(msgSvc(), name());
        log << MSG::ERROR << "Unable to create the histogram path" << endmsg;
        return 0;
      }
      pObject = createDirectory(subPath, rest);
      return pObject;
    }

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

Definition at line 858 of file HistogramSvc.h.

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

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

Definition at line 862 of file HistogramSvc.h.

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

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

Definition at line 867 of file HistogramSvc.h.

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

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

Definition at line 856 of file HistogramSvc.h.

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

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

Definition at line 860 of file HistogramSvc.h.

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

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

Definition at line 865 of file HistogramSvc.h.

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

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

Definition at line 886 of file HistogramSvc.h.

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

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

Definition at line 891 of file HistogramSvc.h.

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

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

Definition at line 895 of file HistogramSvc.h.

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

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

Definition at line 882 of file HistogramSvc.h.

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

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

Definition at line 880 of file HistogramSvc.h.

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

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

Definition at line 884 of file HistogramSvc.h.

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

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

Definition at line 889 of file HistogramSvc.h.

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

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

Definition at line 893 of file HistogramSvc.h.

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

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

Definition at line 803 of file HistogramSvc.h.

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

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

Definition at line 363 of file HistogramSvc.cpp.

                                                     {
      StatusCode sc = unregisterObject( dynamic_cast<IHistogram*>(hist) );
      if ( !sc.isSuccess() ) return false;
      if ( hist ) delete hist;
      return true;
    }

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

Definition at line 771 of file HistogramSvc.h.

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

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

Definition at line 780 of file HistogramSvc.h.

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

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

Definition at line 789 of file HistogramSvc.h.

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

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

finalize the service

Reimplemented from DataSvc.

Definition at line 444 of file HistogramSvc.cpp.

    {
      if ( !m_mods1D.empty() )
      {
        MsgStream log ( msgSvc () , name () ) ;
        if (msgLevel(MSG::DEBUG))
          log << MSG::DEBUG
              << " Substituted histograms #" << m_mods1D.size() << " : " << endmsg;
        for ( std::set<std::string>::const_iterator ih = m_mods1D.begin() ;
              m_mods1D.end() != ih ; ++ih )
        {
          if (msgLevel(MSG::DEBUG))
            log << MSG::DEBUG << " Path='" << (*ih) << "'" ;
          Histo1DMap::const_iterator im = m_defs1D.find( *ih ) ;
          if ( m_defs1D.end() != im ) { log << "  " << im->second ; }
        }
        m_mods1D.clear() ;
      }
      return DataSvc::finalize () ;
    }

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

Definition at line 716 of file HistogramSvc.h.

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

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

Definition at line 661 of file HistogramSvc.h.

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

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

Definition at line 663 of file HistogramSvc.h.

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

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

Definition at line 665 of file HistogramSvc.h.

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

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

Definition at line 667 of file HistogramSvc.h.

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

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

Definition at line 669 of file HistogramSvc.h.

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

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

Definition at line 672 of file HistogramSvc.h.

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

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

Definition at line 674 of file HistogramSvc.h.

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

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

Definition at line 676 of file HistogramSvc.h.

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

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

Definition at line 678 of file HistogramSvc.h.

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

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

Definition at line 683 of file HistogramSvc.h.

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

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

Definition at line 685 of file HistogramSvc.h.

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

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

Definition at line 687 of file HistogramSvc.h.

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

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

Definition at line 691 of file HistogramSvc.h.

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

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

Definition at line 694 of file HistogramSvc.h.

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

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

Definition at line 696 of file HistogramSvc.h.

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

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

Definition at line 700 of file HistogramSvc.h.

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

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

Definition at line 702 of file HistogramSvc.h.

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

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

Definition at line 705 of file HistogramSvc.h.

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

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

Definition at line 711 of file HistogramSvc.h.

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

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

Definition at line 709 of file HistogramSvc.h.

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

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

Definition at line 713 of file HistogramSvc.h.

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

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

Definition at line 718 of file HistogramSvc.h.

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

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

Definition at line 720 of file HistogramSvc.h.

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

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

Definition at line 722 of file HistogramSvc.h.

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

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

Definition at line 727 of file HistogramSvc.h.

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

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

Definition at line 729 of file HistogramSvc.h.

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

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

Definition at line 731 of file HistogramSvc.h.

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

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

Definition at line 735 of file HistogramSvc.h.

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

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

Definition at line 738 of file HistogramSvc.h.

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

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

Definition at line 740 of file HistogramSvc.h.

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

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

Definition at line 744 of file HistogramSvc.h.

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

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

Definition at line 746 of file HistogramSvc.h.

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

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

Definition at line 698 of file HistogramSvc.h.

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

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

Definition at line 707 of file HistogramSvc.h.

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

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

Definition at line 689 of file HistogramSvc.h.

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

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

Definition at line 724 of file HistogramSvc.h.

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

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

Definition at line 742 of file HistogramSvc.h.

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

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

Definition at line 733 of file HistogramSvc.h.

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

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

Definition at line 680 of file HistogramSvc.h.

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

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

Retrieve the AIDA HistogramFactory interface.

Implements IHistogramSvc.

Definition at line 174 of file HistogramSvc.h.

    {  return this; }

template<class T >

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

Definition at line 148 of file HistogramSvc.h.

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

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

Helper for 2D projections.

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 142 of file HistogramSvc.cpp.

                                                                      {
      std::string tmp = full;
      if (tmp[0] != SEPARATOR)    {
        tmp.insert(tmp.begin(), SEPARATOR);
        tmp.insert(tmp.begin(), m_rootName.begin(), m_rootName.end());
      }
      // Remove trailing "/" from newPath if it exists
      if (tmp.rfind(SEPARATOR) == tmp.length()-1) {
        tmp.erase(tmp.rfind(SEPARATOR),1);
      }
      int sep = tmp.rfind(SEPARATOR);
      return std::pair<std::string,std::string>
        (tmp.substr(0,sep),tmp.substr(sep,tmp.length()-sep));
    }

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

Initialise the service.

Reimplemented from DataSvc.

Definition at line 274 of file HistogramSvc.cpp.

                                          {
      MsgStream log(msgSvc(), name());
      StatusCode status = DataSvc::initialize();
      // Set root object
      if (status.isSuccess()) {
        DataObject* rootObj = new DataObject();
        status = setRoot("/stat", rootObj);
        if (!status.isSuccess()) {
          log << MSG::ERROR << "Unable to set hstogram data store root." << endmsg;
          delete rootObj;
          return status;
        }
        IConversionSvc* svc = 0;
        status = service("HistogramPersistencySvc",svc,true);
        if ( status.isSuccess() )   {
          setDataLoader( svc ).ignore();
          svc->release();
        }
        else  {
          log << MSG::ERROR << "Could not find HistogramPersistencySvc." << endmsg;
          return status;
        }
        // Connect all input streams (if any)
        for (DBaseEntries::iterator j = m_input.begin(); j != m_input.end(); j++)    {
          status = connectInput(*j);
          if (!status.isSuccess())  {
            return status;
          }
        }
      }
      if ( !m_defs1D.empty() )
      {
        log << MSG::INFO << " Predefined 1D-Histograms: " << endmsg ;
        for ( Histo1DMap::const_iterator ih = m_defs1D.begin() ;
              m_defs1D.end() != ih ; ++ih )
        {
          log << MSG::INFO
              << " Path='"       << ih->first  << "'"
              << " Description " << ih->second << endmsg ;
        }
      }
      return status;
    }

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

Definition at line 769 of file HistogramSvc.h.

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

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

Definition at line 778 of file HistogramSvc.h.

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

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

Definition at line 787 of file HistogramSvc.h.

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

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

Definition at line 57 of file HistogramSvc.h.

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

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

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

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

Definition at line 752 of file HistogramSvc.h.

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

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

Definition at line 792 of file HistogramSvc.h.

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

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

Definition at line 794 of file HistogramSvc.h.

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

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

Definition at line 754 of file HistogramSvc.h.

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

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

Definition at line 796 of file HistogramSvc.h.

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

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

Definition at line 546 of file HistogramSvc.h.

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

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

Definition at line 542 of file HistogramSvc.h.

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

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

Definition at line 550 of file HistogramSvc.h.

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

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

Definition at line 548 of file HistogramSvc.h.

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

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

Definition at line 544 of file HistogramSvc.h.

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

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

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

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

Initialise the service.

Reimplemented from DataSvc.

Definition at line 318 of file HistogramSvc.cpp.

                                            {
      return StatusCode::SUCCESS;
    }

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

Definition at line 607 of file HistogramSvc.h.

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

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

Definition at line 572 of file HistogramSvc.h.

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

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

Definition at line 585 of file HistogramSvc.h.

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

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

Definition at line 632 of file HistogramSvc.h.

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

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

Definition at line 579 of file HistogramSvc.h.

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

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

Definition at line 647 of file HistogramSvc.h.

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

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

Definition at line 590 of file HistogramSvc.h.

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

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

Definition at line 570 of file HistogramSvc.h.

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

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

Definition at line 605 of file HistogramSvc.h.

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

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

Definition at line 634 of file HistogramSvc.h.

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

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

Definition at line 610 of file HistogramSvc.h.

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

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

Definition at line 612 of file HistogramSvc.h.

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

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

Definition at line 577 of file HistogramSvc.h.

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

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

Definition at line 574 of file HistogramSvc.h.

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

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

Definition at line 636 of file HistogramSvc.h.

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

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

Definition at line 651 of file HistogramSvc.h.

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

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

Definition at line 623 of file HistogramSvc.h.

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

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

Definition at line 616 of file HistogramSvc.h.

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

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

Definition at line 568 of file HistogramSvc.h.

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

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

Definition at line 599 of file HistogramSvc.h.

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

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

Definition at line 640 of file HistogramSvc.h.

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

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

Definition at line 649 of file HistogramSvc.h.

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

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

Definition at line 566 of file HistogramSvc.h.

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

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

Definition at line 618 of file HistogramSvc.h.

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

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

Definition at line 638 of file HistogramSvc.h.

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

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

Definition at line 583 of file HistogramSvc.h.

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

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

Definition at line 629 of file HistogramSvc.h.

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

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

Definition at line 592 of file HistogramSvc.h.

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

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

Definition at line 601 of file HistogramSvc.h.

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

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

Definition at line 625 of file HistogramSvc.h.

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

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

Definition at line 603 of file HistogramSvc.h.

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

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

Definition at line 581 of file HistogramSvc.h.

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

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

Definition at line 594 of file HistogramSvc.h.

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

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

Definition at line 643 of file HistogramSvc.h.

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

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

Definition at line 614 of file HistogramSvc.h.

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

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

Definition at line 627 of file HistogramSvc.h.

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

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

Definition at line 588 of file HistogramSvc.h.

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

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

Definition at line 645 of file HistogramSvc.h.

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

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

Definition at line 596 of file HistogramSvc.h.

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

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

Definition at line 621 of file HistogramSvc.h.

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

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

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

Definition at line 756 of file HistogramSvc.h.

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

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

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

Definition at line 758 of file HistogramSvc.h.

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

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

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

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

Definition at line 785 of file HistogramSvc.h.

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

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

Definition at line 767 of file HistogramSvc.h.

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

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

Definition at line 776 of file HistogramSvc.h.

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

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

Definition at line 561 of file HistogramSvc.h.

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

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

Definition at line 557 of file HistogramSvc.h.

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

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

Definition at line 559 of file HistogramSvc.h.

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

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

handler to be invoked for updating property m_defs1D

Definition at line 437 of file HistogramSvc.cpp.

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

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

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

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

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

## Friends And Related Function Documentation

friend class SvcFactory< HistogramSvc >`[friend]`

Definition at line 55 of file HistogramSvc.h.

## Member Data Documentation

H2D* const H3D HistogramSvc::int

Definition at line 799 of file HistogramSvc.h.

Histo1DMap HistogramSvc::m_defs1D`[private]`

Definition at line 951 of file HistogramSvc.h.

DBaseEntries HistogramSvc::m_input`[protected]`

Input streams.

Definition at line 122 of file HistogramSvc.h.

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

Definition at line 954 of file HistogramSvc.h.

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

Definition at line 803 of file HistogramSvc.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v23r1/GaudiCommonSvc/src/HistogramSvc/HistogramSvc.h
- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v23r1/GaudiCommonSvc/src/HistogramSvc/HistogramSvc.cpp

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines