| # Gaudi Framework, version v21r10p1 |

Home |  | Generated: 29 Jul 2010

# Gaudi::Generic1D< INTERFACE, IMPLEMENTATION > Class Template Reference

Common AIDA implementation stuff for histograms and profiles using ROOT implementations. More...

`#include <GaudiPI/Generic1D.h>`

Inheritance diagram for Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >:

[legend]
Collaboration diagram for Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >:

[legend]

List of all members.

## Public Types
typedef Generic1D< INTERFACE, IMPLEMENTATION > | Base
## Public Member Functions
| Generic1D ()
| Default constructor.
virtual | ~Generic1D ()
| Default destructor.
virtual const std::string & | userLevelClassType () const
| The AIDA user-level unterface leaf class type.
virtual void * | cast (const std::string &cl) const
| Manual cast by class name.
TObject * | representation () const
| ROOT object implementation.
virtual void | adoptRepresentation (TObject *rep)
| Adopt ROOT histogram representation.
virtual std::string | title () const
| Get the title of the object.
virtual bool | setTitle (const std::string &title)
| Set the title of the object.
std::string | name () const
| object name
bool | setName (const std::string &newName)
| Set the name of the object.
virtual AIDA::IAnnotation & | annotation ()
| Access annotation object.
virtual const AIDA::IAnnotation & | annotation () const
| Access annotation object (cons).
Axis & | axis ()
| Access to axis object.
const Axis & | axis () const
| Get the x axis of the IHistogram1D.
virtual int | entries () const
| Get the number or all the entries.
virtual int | allEntries () const
| Get the number or all the entries, both in range and underflow/overflow bins of the IProfile.
virtual int | extraEntries () const
| Get the number of entries in the underflow and overflow bins.
virtual int | binEntries (int index) const
| Number of entries in the corresponding bin (ie the number of times fill was called for this bin).
virtual double | binRms (int index) const
virtual double | sumBinHeights () const
| Get the sum of in range bin heights in the IProfile.
virtual double | sumAllBinHeights () const
| Get the sum of all the bins heights (including underflow and overflow bin).
virtual double | sumExtraBinHeights () const
| Get the sum of the underflow and overflow bin height.
virtual double | minBinHeight () const
| Get the minimum height of the in-range bins.
virtual double | maxBinHeight () const
| Get the maximum height of the in-range bins.
virtual double | equivalentBinEntries () const
| Number of equivalent entries, i.e. `SUM[ weight ] ^ 2 / SUM[ weight^2 ]`.
virtual bool | scale (double scaleFactor)
| Scale the weights and the errors of all the IHistogram's bins (in-range and out-of-range ones) by a given scale factor.
virtual bool | reset ()
| Reset the Histogram; as if just created.
virtual bool | add (const INTERFACE &profile)
| Modifies this IProfile1D by adding the contents of profile to it.
virtual int | rIndex (int index) const
| operator methods
virtual double | binMean (int index) const
| The weighted mean of a bin.
virtual double | binHeight (int index) const
| Total height of the corresponding bin (ie the sum of the weights in this bin).
virtual double | binError (int index) const
| The error of a given bin.
virtual double | mean () const
| The mean of the whole IHistogram1D.
virtual double | rms () const
| The RMS of the whole IHistogram1D.
virtual int | coordToIndex (double coord) const
| Get the bin number corresponding to a given coordinate along the x axis.
virtual int | dimension () const
| Get the Histogram's dimension.
virtual std::ostream & | print (std::ostream &s) const
| Print (ASCII) the histogram into the output stream.
virtual std::ostream & | write (std::ostream &s) const
| Write (ASCII) the histogram table into the output stream.
virtual int | write (const char *file_name) const
| Write (ASCII) the histogram table into a file.
template<>
void * | cast (const std::string &className) const
template<>
int | binEntries (int index) const
template<>
void | adoptRepresentation (TObject *rep)
| Adopt ROOT histogram representation.
template<>
int | binEntries (int index) const
template<>
void * | cast (const std::string &className) const
template<>
void | adoptRepresentation (TObject *rep)
| Adopt ROOT histogram representation.
## Protected Attributes
Axis | m_axis
| Axis member.
AIDA::Annotation | m_annotation
| Object annotations.
IMPLEMENTATION * | m_rep
| Reference to underlying implementation.
std::string | m_classType
int | m_sumEntries

## Detailed Description

### template<class INTERFACE, class IMPLEMENTATION>
class Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >

Common AIDA implementation stuff for histograms and profiles using ROOT implementations.

Credits: This code is the result of some stripdown implementation of LCG/PI. Credits to them!

Author:
  M.Frank

Definition at line 29 of file Generic1D.h.

## Member Typedef Documentation

template<class INTERFACE, class IMPLEMENTATION>

typedef Generic1D<INTERFACE,IMPLEMENTATION> Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::Base

Definition at line 31 of file Generic1D.h.

## Constructor & Destructor Documentation

template<class INTERFACE, class IMPLEMENTATION>

Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::Generic1D | ( |  | ) | `[inline]`

Default constructor.

Definition at line 33 of file Generic1D.h.

    00033 : m_rep(0) {}

template<class INTERFACE, class IMPLEMENTATION>

virtual Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::~Generic1D | ( |  | ) | `[inline, virtual]`

Default destructor.

Definition at line 35 of file Generic1D.h.

    00035 { delete m_rep;                       }

## Member Function Documentation

template<class INTERFACE, class IMPLEMENTATION>

virtual const std::string& Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::userLevelClassType | ( |  | ) | const`[inline, virtual]`

The AIDA user-level unterface leaf class type.

Definition at line 37 of file Generic1D.h.

    00037 { return m_classType;                 }

template<class INTERFACE, class IMPLEMENTATION>

virtual void* Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::cast | ( | const std::string & | cl | ) | const`[virtual]`

Manual cast by class name.

template<class INTERFACE, class IMPLEMENTATION>

TObject* Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::representation | ( |  | ) | const`[inline, virtual]`

ROOT object implementation.

Implements Gaudi::HistogramBase.

Definition at line 41 of file Generic1D.h.

    00041 { return m_rep;                       }

template<class INTERFACE, class IMPLEMENTATION>

virtual void Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::adoptRepresentation | ( | TObject * | rep | ) | `[virtual]`

Adopt ROOT histogram representation.

Implements Gaudi::HistogramBase.

template<class INTERFACE, class IMPLEMENTATION>

virtual std::string Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::title | ( |  | ) | const`[inline, virtual]`

Get the title of the object.

Definition at line 45 of file Generic1D.h.

    00045 { return m_annotation.value("Title"); }

template<class INTERFACE, class IMPLEMENTATION>

bool Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::setTitle | ( | const std::string & | title | ) | `[inline, virtual]`

Set the title of the object.

Definition at line 127 of file Generic1D.h.

    00127                                                                              {
    00128     m_rep->SetTitle(title.c_str());
    00129     if ( !annotation().addItem( "Title", title ) )
    00130       m_annotation.setValue( "Title" , title );
    00131     if ( !annotation().addItem( "title", title ) )
    00132       annotation().setValue( "title", title );
    00133     return true;
    00134   }

template<class INTERFACE, class IMPLEMENTATION>

std::string Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::name | ( |  | ) | const`[inline]`

object name

Definition at line 49 of file Generic1D.h.

    00049 { return m_annotation.value("Name");  }

template<class INTERFACE, class IMPLEMENTATION>

bool Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::setName | ( | const std::string & | newName | ) | `[inline]`

Set the name of the object.

Definition at line 137 of file Generic1D.h.

    00137                                                                               {
    00138     m_rep->SetName(newName.c_str());
    00139     m_annotation.setValue( "Name", newName );
    00140     return true;
    00141   }

template<class INTERFACE, class IMPLEMENTATION>

virtual AIDA::IAnnotation& Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::annotation | ( |  | ) | `[inline, virtual]`

Access annotation object.

Definition at line 53 of file Generic1D.h.

    00053 { return m_annotation;                }

template<class INTERFACE, class IMPLEMENTATION>

virtual const AIDA::IAnnotation& Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::annotation | ( |  | ) | const`[inline, virtual]`

Access annotation object (cons).

Definition at line 55 of file Generic1D.h.

    00055 { return m_annotation;                }

template<class INTERFACE, class IMPLEMENTATION>

Axis& Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::axis | ( |  | ) | `[inline]`

Access to axis object.

Definition at line 57 of file Generic1D.h.

    00057 { return m_axis;                      }

template<class INTERFACE, class IMPLEMENTATION>

const Axis& Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::axis | ( |  | ) | const`[inline]`

Get the x axis of the IHistogram1D.

Definition at line 59 of file Generic1D.h.

    00059 { return m_axis;                      }

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::entries | ( |  | ) | const`[inline, virtual]`

Get the number or all the entries.

Definition at line 62 of file Generic1D.h.

    00062 { return (int)m_rep->GetEntries();           }

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::allEntries | ( |  | ) | const`[inline, virtual]`

Get the number or all the entries, both in range and underflow/overflow bins of the IProfile.

Definition at line 64 of file Generic1D.h.

    00064 { return int(m_rep->GetEntries());           }

template<class INTERFACE, class IMPLEMENTATION>

int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::extraEntries | ( |  | ) | const`[inline, virtual]`

Get the number of entries in the underflow and overflow bins.

Definition at line 164 of file Generic1D.h.

    00164                                                               {
    00165     return binEntries(AIDA::IAxis::UNDERFLOW_BIN) +
    00166           binEntries(AIDA::IAxis::OVERFLOW_BIN);
    00167   }

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::binEntries | ( | int | index | ) | const`[virtual]`

Number of entries in the corresponding bin (ie the number of times fill was called for this bin).

template<class INTERFACE, class IMPLEMENTATION>

double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::binRms | ( | int | index | ) | const`[inline, virtual]`

Definition at line 144 of file Generic1D.h.

    00144                                                                     {
    00145     return m_rep->GetBinError ( rIndex(index) );
    00146   }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::sumBinHeights | ( |  | ) | const`[inline, virtual]`

Get the sum of in range bin heights in the IProfile.

Definition at line 72 of file Generic1D.h.

    00072 { return m_rep->GetSumOfWeights();            }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::sumAllBinHeights | ( |  | ) | const`[inline, virtual]`

Get the sum of all the bins heights (including underflow and overflow bin).

Definition at line 74 of file Generic1D.h.

    00074 { return m_rep->GetSum();                     }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::sumExtraBinHeights | ( |  | ) | const`[inline, virtual]`

Get the sum of the underflow and overflow bin height.

Definition at line 76 of file Generic1D.h.

    00076 { return  sumAllBinHeights()-sumBinHeights(); }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::minBinHeight | ( |  | ) | const`[inline, virtual]`

Get the minimum height of the in-range bins.

Definition at line 78 of file Generic1D.h.

    00078 { return m_rep->GetMinimum();                 }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::maxBinHeight | ( |  | ) | const`[inline, virtual]`

Get the maximum height of the in-range bins.

Definition at line 80 of file Generic1D.h.

    00080 { return m_rep->GetMaximum();                 }

template<class INTERFACE, class IMPLEMENTATION>

double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::equivalentBinEntries | ( |  | ) | const`[inline, virtual]`

Number of equivalent entries, i.e. `SUM[ weight ] ^ 2 / SUM[ weight^2 ]`.

Definition at line 176 of file Generic1D.h.

    00176                                                                           {
    00177     if (sumBinHeights() <= 0) return 0;
    00178     Stat_t stats[11];   // cover up to 3D...
    00179     m_rep->GetStats(stats);
    00180     return stats[0]*stats[0]/stats[1];
    00181   }

template<class INTERFACE, class IMPLEMENTATION>

bool Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::scale | ( | double | scaleFactor | ) | `[inline, virtual]`

Scale the weights and the errors of all the IHistogram's bins (in-range and out-of-range ones) by a given scale factor.

Definition at line 184 of file Generic1D.h.

    00184                                                                       {
    00185     m_rep->Scale ( scaleFactor );
    00186     return true;
    00187   }

template<class INTERFACE, class IMPLEMENTATION>

bool Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::reset | ( |  | ) | `[inline, virtual]`

Reset the Histogram; as if just created.

Definition at line 169 of file Generic1D.h.

    00169                                                     {
    00170     m_sumEntries = 0;
    00171     m_rep->Reset();
    00172     return true;
    00173   }

template<class INTERFACE, class IMPLEMENTATION>

bool Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::add | ( | const INTERFACE & | profile | ) | `[inline, virtual]`

Modifies this IProfile1D by adding the contents of profile to it.

Definition at line 190 of file Generic1D.h.

    00190                                                                     {
    00191     const Generic1D<INTERFACE,IMPLEMENTATION>* p =
    00192       dynamic_cast<const Generic1D<INTERFACE,IMPLEMENTATION>*>(&h);
    00193     if ( p )  {
    00194       m_rep->Add(p->m_rep);
    00195       return true;
    00196     }
    00197     throw std::runtime_error("Cannot add profile histograms of different implementations.");
    00198   }

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::rIndex | ( | int | index | ) | const`[inline, virtual]`

operator methods

Definition at line 91 of file Generic1D.h.

    00091 { return m_axis.rIndex(index);}

template<class INTERFACE, class IMPLEMENTATION>

double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::binMean | ( | int | index | ) | const`[inline, virtual]`

The weighted mean of a bin.

Definition at line 149 of file Generic1D.h.

    00149                                                                          {
    00150     return m_rep->GetBinCenter ( rIndex(index) );
    00151   }

template<class INTERFACE, class IMPLEMENTATION>

double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::binHeight | ( | int | index | ) | const`[inline, virtual]`

Total height of the corresponding bin (ie the sum of the weights in this bin).

Definition at line 154 of file Generic1D.h.

    00154                                                                            {
    00155     return m_rep->GetBinContent ( rIndex(index) );
    00156   }

template<class INTERFACE, class IMPLEMENTATION>

double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::binError | ( | int | index | ) | const`[inline, virtual]`

The error of a given bin.

Definition at line 159 of file Generic1D.h.

    00159                                                                           {
    00160     return m_rep->GetBinError ( rIndex(index) );
    00161   }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::mean | ( |  | ) | const`[inline, virtual]`

The mean of the whole IHistogram1D.

Definition at line 99 of file Generic1D.h.

    00099 { return m_rep->GetMean();                    }

template<class INTERFACE, class IMPLEMENTATION>

virtual double Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::rms | ( |  | ) | const`[inline, virtual]`

The RMS of the whole IHistogram1D.

Definition at line 101 of file Generic1D.h.

    00101 {  return m_rep->GetRMS();                    }

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::coordToIndex | ( | double | coord | ) | const`[inline, virtual]`

Get the bin number corresponding to a given coordinate along the x axis.

Definition at line 103 of file Generic1D.h.

    00103 { return axis().coordToIndex(coord);}

template<class INTERFACE, class IMPLEMENTATION>

virtual int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::dimension | ( |  | ) | const`[inline, virtual]`

Get the Histogram's dimension.

Definition at line 105 of file Generic1D.h.

    00105 { return 1; }

template<class INTERFACE, class IMPLEMENTATION>

std::ostream & Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::print | ( | std::ostream & | s | ) | const`[inline, virtual]`

Print (ASCII) the histogram into the output stream.

bin contents and errors are printed for all bins including under and overflows

Implements Gaudi::HistogramBase.

Definition at line 201 of file Generic1D.h.

    00201                                                                                  {
    00203     m_rep->Print("all");
    00204     return s;
    00205   }

template<class INTERFACE, class IMPLEMENTATION>

std::ostream & Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::write | ( | std::ostream & | s | ) | const`[inline, virtual]`

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

Implements Gaudi::HistogramBase.

Definition at line 209 of file Generic1D.h.

    00209                                                                                {
    00210     s << "\n1D Histogram Table: " << std::endl;
    00211     s << "Bin, Height, Error "  << std::endl;
    00212     for( int i = 0; i < axis().bins(); ++i )
    00213       s << binMean( i ) << ", "
    00214         << binHeight( i ) << ", "
    00215         << binError ( i ) << std::endl;
    00216     s << std::endl;
    00217     return s;
    00218   }

template<class INTERFACE, class IMPLEMENTATION>

int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::write | ( | const char * | file_name | ) | const`[inline, virtual]`

Write (ASCII) the histogram table into a file.

Implements Gaudi::HistogramBase.

Definition at line 222 of file Generic1D.h.

    00223   {
    00224     TFile *f = TFile::Open(file_name,"RECREATE");
    00225     Int_t nbytes = m_rep->Write();
    00226     f->Close();
    00227     return nbytes;
    00228   }

template<>

void * Gaudi::Generic1D< AIDA::IHistogram1D, TH1D >::cast | ( | const std::string & | className | ) | const`[inline]`

Definition at line 30 of file H1D.cpp.

    00030                                                                                             {
    00031     if (className == "AIDA::IHistogram1D")
    00032       return const_cast<AIDA::IHistogram1D*>((AIDA::IHistogram1D*)this);
    00033     if (className == "AIDA::IHistogram")
    00034       return const_cast<AIDA::IHistogram*>((AIDA::IHistogram*)this);
    00035     return 0;
    00036   }

template<>

int Gaudi::Generic1D< AIDA::IHistogram1D, TH1D >::binEntries | ( | int | index | ) | const`[inline]`

Definition at line 38 of file H1D.cpp.

    00038                                                                                {
    00039     if (binHeight(index)<=0) return 0;
    00040     double xx =  binHeight(index)/binError(index);
    00041     return int(xx*xx+0.5);
    00042   }

template<>

void Gaudi::Generic1D< AIDA::IHistogram1D, TH1D >::adoptRepresentation | ( | TObject * | rep | ) | `[inline, virtual]`

Adopt ROOT histogram representation.

Implements Gaudi::HistogramBase.

Definition at line 45 of file H1D.cpp.

    00045                                                                           {
    00046     TH1D* imp = dynamic_cast<TH1D*>(rep);
    00047     if ( imp )  {
    00048       if ( m_rep ) delete m_rep;
    00049       m_rep = imp;
    00050       return;
    00051     }
    00052     throw std::runtime_error("Cannot adopt native histogram representation.");
    00053   }

template<>

int Gaudi::Generic1D< AIDA::IProfile1D, TProfile >::binEntries | ( | int | index | ) | const`[inline]`

Definition at line 40 of file P1D.cpp.

    00040                                                                       {
    00041     return int(m_rep->GetBinEntries( rIndex(index) )+0.5);
    00042   }

template<>

void * Gaudi::Generic1D< AIDA::IProfile1D, TProfile >::cast | ( | const std::string & | className | ) | const`[inline]`

Definition at line 44 of file P1D.cpp.

    00044                                                                                              {
    00045     if (className == "AIDA::IProfile1D")
    00046       return const_cast<AIDA::IProfile1D*>((AIDA::IProfile1D*)this);
    00047     else if (className == "AIDA::IProfile")
    00048       return const_cast<AIDA::IProfile*>((AIDA::IProfile*)this);
    00049     else if (className == "AIDA::IBaseHistogram")
    00050       return const_cast<AIDA::IBaseHistogram*>((AIDA::IBaseHistogram*)this);
    00051     return 0;
    00052   }

template<>

void Gaudi::Generic1D< AIDA::IProfile1D, TProfile >::adoptRepresentation | ( | TObject * | rep | ) | `[inline, virtual]`

Adopt ROOT histogram representation.

Implements Gaudi::HistogramBase.

Definition at line 55 of file P1D.cpp.

    00055                                                                             {
    00056     TProfile* imp = dynamic_cast<TProfile*>(rep);
    00057     if ( imp )  {
    00058     if ( m_rep ) delete m_rep;
    00059       m_rep = imp;
    00060       m_axis.initialize(m_rep->GetXaxis(),true);
    00061       const TArrayD* a = m_rep->GetSumw2();
    00062       if ( 0 == a || (a && a->GetSize()==0) ) m_rep->Sumw2();
    00063       setTitle(m_rep->GetTitle());
    00064       return;
    00065     }
    00066     throw std::runtime_error("Cannot adopt native histogram representation.");
    00067   }

## Member Data Documentation

template<class INTERFACE, class IMPLEMENTATION>

Axis Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::m_axis`[protected]`

Axis member.

Definition at line 115 of file Generic1D.h.

template<class INTERFACE, class IMPLEMENTATION>

AIDA::Annotation Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::m_annotation`[mutable, protected]`

Object annotations.

Definition at line 117 of file Generic1D.h.

template<class INTERFACE, class IMPLEMENTATION>

IMPLEMENTATION* Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::m_rep`[protected]`

Reference to underlying implementation.

Definition at line 119 of file Generic1D.h.

template<class INTERFACE, class IMPLEMENTATION>

std::string Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::m_classType`[protected]`

Definition at line 121 of file Generic1D.h.

template<class INTERFACE, class IMPLEMENTATION>

int Gaudi::Generic1D< INTERFACE, IMPLEMENTATION >::m_sumEntries`[protected]`

Definition at line 123 of file Generic1D.h.

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

- /afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r10p1/GaudiSvc/src/HistogramSvc/Generic1D.h