| # Gaudi Framework, version v21r9 |

Home |  | Generated: 3 May 2010

# Gaudi::Histogram1D Class Reference

AIDA implementation for 1 D histograms using ROOT THD1. More...

`#include <H1D.h>`

Inheritance diagram for Gaudi::Histogram1D:

[legend]
Collaboration diagram for Gaudi::Histogram1D:

[legend]

List of all members.

## Public Member Functions
| Histogram1D ()
| Standard constructor.
| Histogram1D (TH1D *rep)
| Standard constructor with initialization. The histogram representation will be adopted.
virtual | ~Histogram1D ()
| Destructor.
virtual void | adoptRepresentation (TObject *rep)
| Adopt ROOT histogram representation.
virtual bool | setBinContents (int i, int entries, double height, double error, double centre)
| set bin content (entries and centre are not used )
virtual bool | reset ()
| need to overwrite reset to reset the sums
virtual bool | setStatistics (int allEntries, double eqBinEntries, double mean, double rms)
| set histogram statistics
virtual bool | fill (double x, double weight)
| Fill the Profile1D with a value and the corresponding weight.
bool | setRms (double rms)
| Update histogram RMS.
void | copyFromAida (const AIDA::IHistogram1D &h)
| Create new histogram from any AIDA based histogram.
virtual const CLID & | clID () const
| Retrieve reference to class defininition identifier.
StreamBuffer & | serialize (StreamBuffer &s)
| Serialization mechanism, Serialize the object for reading.
StreamBuffer & | serialize (StreamBuffer &s) const
| Serialization mechanism, Serialize the object for writing.
## Static Public Member Functions
static const CLID & | classID ()
| Retrieve reference to class definition structure (static access).
## Protected Attributes
double | m_sumwx
| cache sumwx when setting contents since I don't have bin mean
## Private Member Functions
void | init (const std::string &title, bool initialize_axis=true)
void | initSums ()

## Detailed Description

AIDA implementation for 1 D histograms using ROOT THD1.

Author:
  M.Frank

Definition at line 17 of file H1D.h.

## Constructor & Destructor Documentation

Gaudi::Histogram1D::Histogram1D | ( |  | ) |

Standard constructor.

Definition at line 56 of file H1D.cpp.

    00056                                {
    00057   m_rep = new TH1D();
    00058   init("",false);
    00059 }

Gaudi::Histogram1D::Histogram1D | ( | TH1D * | rep | ) |

Standard constructor with initialization. The histogram representation will be adopted.

Definition at line 61 of file H1D.cpp.

    00061                                         {
    00062   m_rep = rep;
    00063   init(m_rep->GetTitle());
    00064   initSums();
    00065 }

virtual Gaudi::Histogram1D::~Histogram1D | ( |  | ) | `[inline, virtual]`

Destructor.

Definition at line 30 of file H1D.h.

    00030 {}

## Member Function Documentation

void Gaudi::Histogram1D::init | ( | const std::string & | title,
|  | bool | initialize_axis = `true` |
| ) |  |  | `[private]`

Definition at line 67 of file H1D.cpp.

    00067                                                                          {
    00068   m_classType = "IHistogram1D";
    00069   if ( initialize_axis )  {
    00070     m_axis.initialize(m_rep->GetXaxis(),false);
    00071   }
    00072   const TArrayD* a = m_rep->GetSumw2();
    00073   if ( 0 == a || (a && a->GetSize()==0) ) m_rep->Sumw2();
    00074   setTitle(title);
    00075   m_rep->SetDirectory(0);
    00076   m_sumEntries = 0;
    00077   m_sumwx = 0;
    00078 }

void Gaudi::Histogram1D::initSums | ( |  | ) | `[private]`

Definition at line 80 of file H1D.cpp.

    00080                                  {
    00081   m_sumwx = 0;
    00082   m_sumEntries = 0;
    00083   for(int i=1, n=m_rep->GetNbinsX(); i<=n; ++i)    {
    00084     m_sumwx += m_rep->GetBinContent(i)*m_rep->GetBinCenter(i);
    00085     m_sumEntries += (int)m_rep->GetBinContent(i);
    00086   }
    00087 }

void Gaudi::Histogram1D::adoptRepresentation | ( | TObject * | rep | ) | `[virtual]`

Adopt ROOT histogram representation.

Definition at line 96 of file H1D.cpp.

    00096                                                         {
    00097   Gaudi::Generic1D<AIDA::IHistogram1D,TH1D>::adoptRepresentation(rep);
    00098   if ( m_rep )  {
    00099     init(m_rep->GetTitle());
    00100     initSums();
    00101   }
    00102 }

bool Gaudi::Histogram1D::setBinContents | ( | int | i,
|  | int | entries,
|  | double | height,
|  | double | error,
|  | double | centre |
| ) |  |  | `[virtual]`

set bin content (entries and centre are not used )

Definition at line 104 of file H1D.cpp.

    00104                                                                                                  {
    00105   m_rep->SetBinContent(rIndex(i),height);
    00106   m_rep->SetBinError(rIndex(i),error);
    00107   // accumulate sumwx for in range bins
    00108   if (i != AIDA::IAxis::UNDERFLOW_BIN && i !=  AIDA::IAxis::OVERFLOW_BIN )
    00109     m_sumwx  += centre*height;
    00110   m_sumEntries += entries;
    00111   return true;
    00112 }

bool Gaudi::Histogram1D::reset | ( |  | ) | `[virtual]`

need to overwrite reset to reset the sums

Definition at line 89 of file H1D.cpp.

    00089                                {
    00090   m_sumwx = 0;
    00091   m_sumEntries = 0;
    00092   return Base::reset();
    00093 }

bool Gaudi::Histogram1D::setStatistics | ( | int | allEntries,
|  | double | eqBinEntries,
|  | double | mean,
|  | double | rms |
| ) |  |  | `[virtual]`

set histogram statistics

Definition at line 137 of file H1D.cpp.

    00137                                                                                               {
    00138   m_rep->SetEntries(allEntries);
    00139   // fill statistcal vector for Root
    00140   std::vector<double> stat(11);
    00141   // sum weights
    00142   stat[0] =  sumBinHeights();
    00143   // sum weights **2
    00144   stat[1] = 0;
    00145   if (eqBinEntries != 0)
    00146     stat[1] = (  sumBinHeights() * sumBinHeights() ) / eqBinEntries;
    00147   // sum weights * x
    00148   stat[2] = mean*sumBinHeights();
    00149   // sum weight * x **2
    00150   stat[3] = ( mean*mean + rms*rms )* sumBinHeights();
    00151   m_rep->PutStats(&stat.front());
    00152   return true;
    00153 }

bool Gaudi::Histogram1D::fill | ( | double | x,
|  | double | weight |
| ) |  |  | `[virtual]`

Fill the Profile1D with a value and the corresponding weight.

Definition at line 155 of file H1D.cpp.

    00155                                                       {
    00156   (weight == 1.) ? m_rep->Fill(x) : m_rep->Fill(x,weight);
    00157   return true;
    00158 }

bool Gaudi::Histogram1D::setRms | ( | double | rms | ) |

Update histogram RMS.

Definition at line 120 of file H1D.cpp.

    00120                                         {
    00121   m_rep->SetEntries(m_sumEntries);
    00122   std::vector<double> stat(11);
    00123   // sum weights
    00124   stat[0] =  sumBinHeights();
    00125   stat[1] = 0;
    00126   if (equivalentBinEntries() != 0)
    00127     stat[1] = (  sumBinHeights() * sumBinHeights() ) / equivalentBinEntries();
    00128   stat[2] = m_sumwx;
    00129   double mean = 0;
    00130   if ( sumBinHeights() != 0 ) mean =  m_sumwx/ sumBinHeights();
    00131   stat[3] = ( mean*mean + rms*rms )* sumBinHeights();
    00132   m_rep->PutStats(&stat.front());
    00133   return true;
    00134 }

void Gaudi::Histogram1D::copyFromAida | ( | const AIDA::IHistogram1D & | h | ) |

Create new histogram from any AIDA based histogram.

Definition at line 160 of file H1D.cpp.

    00160                                                               {
    00161  // implement here the copy
    00162   std::string tit = h.title()+"Copy";
    00163   delete m_rep;
    00164   if (h.axis().isFixedBinning() )  {
    00165     m_rep = new TH1D(tit.c_str(),tit.c_str(),h.axis().bins(),h.axis().lowerEdge(),h.axis().upperEdge());
    00166   }
    00167   else {
    00168     Edges e;
    00169     for (int i =0; i < h.axis().bins(); ++i)  {
    00170       e.push_back(h.axis().binLowerEdge(i));
    00171     }
    00172     // add also upperedges at the end
    00173     e.push_back(h.axis().upperEdge() );
    00174     m_rep = new TH1D(tit.c_str(),tit.c_str(),e.size()-1,&e.front());
    00175   }
    00176   m_axis.initialize(m_rep->GetXaxis(),false);
    00177   m_rep->Sumw2();
    00178   m_sumEntries = 0;
    00179   m_sumwx = 0;
    00180   // sumw
    00181   double sumw = h.sumBinHeights();
    00182   // sumw2
    00183   double sumw2 = 0;
    00184   if (h.equivalentBinEntries() != 0)
    00185     sumw2 = ( sumw * sumw ) /h.equivalentBinEntries();
    00186
    00187   double sumwx = h.mean()*h.sumBinHeights();
    00188   double sumwx2 = (h.mean()*h.mean() + h.rms()*h.rms() )*h.sumBinHeights();
    00189
    00190   // copy the contents in
    00191   for (int i=-2; i < axis().bins(); ++i) {
    00192     // root binning starts from one !
    00193     m_rep->SetBinContent(rIndex(i),h.binHeight(i) );
    00194     m_rep->SetBinError(rIndex(i),h.binError(i) );
    00195   }
    00196   // need to do set entries after setting contents otherwise root will recalulate them
    00197   // taking into account how many time  SetBinContents() has been called
    00198   m_rep->SetEntries(h.allEntries());
    00199     // stat vector
    00200   std::vector<double> stat(11);
    00201   stat[0] = sumw;
    00202   stat[1] = sumw2;
    00203   stat[2] = sumwx;
    00204   stat[3] = sumwx2;
    00205   m_rep->PutStats(&stat.front());
    00206 }

virtual const CLID& Gaudi::Histogram1D::clID | ( |  | ) | const`[inline, virtual]`

Retrieve reference to class defininition identifier.

Reimplemented from DataObject.

Definition at line 46 of file H1D.h.

    00046 { return Gaudi::Histogram1D::classID(); }

static const CLID& Gaudi::Histogram1D::classID | ( |  | ) | `[inline, static]`

Retrieve reference to class definition structure (static access).

Retrieve Pointer to class definition structure.

Reimplemented from DataObject.

Definition at line 47 of file H1D.h.

    00047 { return CLID_H1D; }

StreamBuffer & Gaudi::Histogram1D::serialize | ( | StreamBuffer & | s | ) | `[virtual]`

Serialization mechanism, Serialize the object for reading.

Parameters:

  | s | the StreamBuffer containing the data to be read

Returns:
  the resulting StreamBuffer, after reading

Reimplemented from DataObject.

Definition at line 213 of file H1D.cpp.

    00213                                                          {
    00214   DataObject::serialize(s);
    00215   std::string title;
    00216   int size;
    00217   s >> size;
    00218   for (int j = 0; j < size; j++) {
    00219     std::string key, value;
    00220     s >> key >> value;
    00221     annotation().addItem (key, value);
    00222     if ("Title" == key) {
    00223       title = value;
    00224     }
    00225   }
    00226   double lowerEdge, upperEdge, binHeight, binError;
    00227   int    isFixedBinning, bins;
    00228   s >> isFixedBinning >> bins;
    00229
    00230   if ( m_rep ) delete m_rep;
    00231   if ( isFixedBinning ) {
    00232     s >> lowerEdge >> upperEdge;
    00233     m_rep = new TH1D(title.c_str(),title.c_str(),bins,lowerEdge,upperEdge);
    00234   } else {
    00235     Edges edges;
    00236     edges.resize(bins);
    00237     for ( int i = 0; i <= bins; ++i )
    00238       s >> *(double*)&edges[i];
    00239     m_rep = new TH1D(title.c_str(),title.c_str(),edges.size()-1,&edges.front());
    00240   }
    00241   m_axis.initialize(m_rep->GetXaxis(),true);
    00242   m_rep->Sumw2();
    00243   m_sumEntries = 0;
    00244   m_sumwx = 0;
    00245
    00246   for ( int i = 0; i <= bins + 1; ++i ) {
    00247     s >> binHeight >> binError;
    00248     m_rep->SetBinContent( i, binHeight );
    00249     m_rep->SetBinError( i, binError );
    00250   }
    00251   Stat_t allEntries;
    00252   s >> allEntries;
    00253   m_rep->SetEntries( allEntries );
    00254   Stat_t stats[4];                                    // stats array
    00255   s >> stats[0] >> stats[1] >> stats[2] >> stats[3];
    00256   m_rep->PutStats( stats );
    00257   return s;
    00258 }

StreamBuffer & Gaudi::Histogram1D::serialize | ( | StreamBuffer & | s | ) | const`[virtual]`

Serialization mechanism, Serialize the object for writing.

Parameters:

  | s | the StreamBuffer where to write the data

Returns:
  the resulting StreamBuffer, after wrinting

Reimplemented from DataObject.

Definition at line 260 of file H1D.cpp.

    00260                                                                {
    00261   DataObject::serialize(s);
    00262   s << static_cast<int>( annotation().size() );
    00263   for (int i = 0; i < annotation().size(); i++) {
    00264     s << annotation().key(i);
    00265     s << annotation().value(i);
    00266   }
    00267   const AIDA::IAxis & axis( this->axis() );
    00268   const int isFixedBinning = axis.isFixedBinning();
    00269   const int bins = axis.bins();
    00270   s << isFixedBinning << bins;
    00271   if ( isFixedBinning ) {
    00272     s << axis.lowerEdge();
    00273   }
    00274   else {
    00275     for ( int i = 0; i < bins; ++i )
    00276       s << axis.binLowerEdge(i);
    00277   }
    00278   s << axis.upperEdge();
    00279   for ( int i = 0; i <= bins + 1; ++i )
    00280     s << m_rep->GetBinContent(i) << m_rep->GetBinError( i );
    00281
    00282   s << m_rep->GetEntries();
    00283   Stat_t stats[4];  // stats array
    00284   m_rep->GetStats( stats );
    00285   s << stats[0] << stats[1] << stats[2] << stats[3];
    00286   return s;
    00287 }

## Member Data Documentation

double Gaudi::Histogram1D::m_sumwx`[protected]`

cache sumwx when setting contents since I don't have bin mean

Definition at line 23 of file H1D.h.

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

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