Index: trunk/SophyaLib/HiStats/histerr.cc
===================================================================
--- trunk/SophyaLib/HiStats/histerr.cc	(revision 3057)
+++ trunk/SophyaLib/HiStats/histerr.cc	(revision 3123)
@@ -4,7 +4,7 @@
 #include <stdio.h>
 #include <math.h>
-#include "histinit.h"
+#include "perrors.h"
+#include "fioarr.h"
 #include "histerr.h"
-#include "perrors.h"
 
 /*!
@@ -17,14 +17,15 @@
 /*! Constructeur par defaut */
 HistoErr::HistoErr(void)
-: Histo(), mNData(NULL), mCorrel(0)
-{
-}
-
-/********* Methode *********/
-/*! Constructeur d'un histo de nBin bins allant de xMin a xMax */
-HistoErr::HistoErr(r_8 xMin, r_8 xMax, int_4 nBin)
-: Histo(), mNData(NULL)
-{
-  CreateOrResize(xMin,xMax,nBin);
+: xmin_(1.), xmax_(-1.), nx_(0), dx_(0.)
+, mCorrel(0)
+{
+}
+
+/********* Methode *********/
+/*! Constructeur d'un histo */
+HistoErr::HistoErr(r_8 xmin,r_8 xmax,int_4 nx)
+: mCorrel(0)
+{
+  CreateOrResize(xmin,xmax,nx);
 }
 
@@ -32,7 +33,11 @@
 /*! Constructeur par copie */
 HistoErr::HistoErr(const HistoErr& H)
-: Histo(H), mNData((H.mBins>0)? new r_8[H.mBins] : NULL), mCorrel(H.mCorrel)
-{
- if(mNData>0) memcpy(mNData,H.mNData,mBins*sizeof(r_8));
+: mCorrel(H.mCorrel)
+{
+ if(H.nx_<=0) return;
+ CreateOrResize(H.xmin_,H.xmax_,H.nx_);
+ data_  = H.data_; 
+ err2_  = H.err2_; 
+ ndata_ = H.ndata_; 
 }
 
@@ -41,32 +46,22 @@
 HistoErr::~HistoErr(void)
 {
- Delete();
+ mCorrel = 0;
 }
 
 /********* Methode *********/
 /*! Gestion de l'allocation */
-void HistoErr::CreateOrResize(r_8 xMin, r_8 xMax, int_4 nBin)
-{
-  //cout<<"HistoErr::CreateOrResize()"<<endl;
-  bool samelen = (nBin==mBins)? true: false;
-  Histo::CreateOrResize(xMin,xMax,nBin);
-  Histo::Errors();
-  if(mNData!=NULL && !samelen) {delete [] mNData; mNData=NULL;}
-  if(nBin>0 && mNData==NULL) mNData = new r_8[nBin];
-  if(mNData) memset(mNData,0,nBin*sizeof(r_8));
+void HistoErr::CreateOrResize(r_8 xmin,r_8 xmax,int_4 nx)
+{
+  xmin_ = xmin; xmax_ = xmax; nx_ = nx; dx_=0.;
+  if(nx_>0) {
+    data_.ReSize(nx_);  data_ = 0.;
+    err2_.ReSize(nx_);  err2_ = 0.;
+    ndata_.ReSize(nx_); ndata_ = 0.;
+    dx_ = (xmax_-xmin_)/nx_;
+  }
   mCorrel = 0;
 }
 
 /********* Methode *********/
-/*! Delete des tableaux */
-void HistoErr::Delete(void)
-{
-  //cout<<"HistoErr::Delete()"<<endl;
-  Histo::Delete();
-  if(mNData) {delete [] mNData; mNData=NULL;}
-  mCorrel = 0;
-}
-
-/********* Methode *********/
 /*!
   Remise a zero
@@ -74,50 +69,26 @@
 void HistoErr::Zero(void)
 {
-  Histo::Zero();
-  if(mNData) memset(mNData,0,mBins*sizeof(r_8));
-  mCorrel = 0;
-}
-
-/********* Methode *********/
-/*!
- Remplissage du contenu de l'histo pour le bin numBin poids w et l'erreur e
-*/
-void HistoErr::SetBin(int_4 numBin, r_8 w, r_8 e, r_8 nb)
-{
-Histo::SetBin(numBin,w);
-Histo::SetErr2(numBin,e*e);
-SetNentB(numBin,nb);
-return;
-}
-
-/********* Methode *********/
-/*!
- Remplissage nombre d'entrees pour le bin numBin
-*/
-void HistoErr::SetNentB(int_4 numBin, r_8 nb)
-{
- if(numBin>=0 && numBin<mBins) mNData[numBin] = nb;
-return;
-}
-
-/*!
-  Remplissage d'un tableau avec les nombres d'entrees dans le bin de l'histo
-*/
-void HistoErr::GetNBin(TVector<r_8>& v) const
-{
-v.Realloc(mBins);
-for(int_4 i=0;i<mBins;i++) v(i) = mNData[i];
-return;
-}
-
-/********* Methode *********/
-/*!
-  Remplissage du nombre d'entrees dans les bins de l'histo avec les valeurs d'un vecteur
-*/
-void HistoErr::PutNBin(TVector<r_8> &v)
-{
-int_4 n = (v.NElts()<mBins) ? v.NElts(): mBins;
-if(n>0) for(int_4 i=0;i<n;i++) mNData[i] = v(i);
-return;
+ if(nx_<=0) return;
+ data_ = 0.;
+ err2_ = 0.;
+ ndata_ = 0.;
+}
+
+/********* Methode *********/
+/*!
+ Recompute XMin (and XMax so that
+ the CENTER of the first bin is exactly XMin and
+ the CENTER of the last bin is exactly XMax.
+ Remember that otherwise
+ XMin is the beginning of the first bin
+ and XMax is the end of the last bin
+*/
+void HistoErr::ReCenterBin(void)
+{
+ if(nx_<=1) return;
+ double dx = (xmax_-xmin_)/(nx_-1);
+ xmin_ -= dx/2.;
+ xmax_ += dx/2.;
+ dx_ = (xmax_-xmin_)/nx_;
 }
 
@@ -132,10 +103,10 @@
 void HistoErr::ToCorrel(void)
 {
- if(mBins<1) return;
+ if(nx_<1) return;
  mCorrel++;
- for(int_4 i=0;i<mBins;i++) {
-   if(mNData[i]<1.) continue;
-   mData[i] /= mNData[i];
-   mErr2[i] /= mNData[i];
+ for(int_4 i=0;i<nx_;i++) {
+   if(ndata_(i)<1.) continue;
+   data_(i) /= ndata_(i);
+   err2_(i) /= ndata_(i);
  }
  return;
@@ -148,10 +119,10 @@
 void HistoErr::FromCorrel(void)
 {
- if(mBins<1) return;
+ if(nx_<1) return;
  mCorrel--;
- for(int_4 i=0;i<mBins;i++) {
-   if(mNData[i]<1.) continue;
-   mData[i] *= mNData[i];
-   mErr2[i] *= mNData[i];
+ for(int_4 i=0;i<nx_;i++) {
+   if(ndata_(i)<1.) continue;
+   data_(i) *= ndata_(i);
+   err2_(i) *= ndata_(i);
  }
  return;
@@ -164,20 +135,16 @@
 void HistoErr::FillFrHErr(HistoErr& hfrom)
 {
- if(mBins<=0) return;
- if(hfrom.mBins<=0) return;
+ if(nx_<=0) return;
+ if(hfrom.nx_<=0) return;
 
  Zero();
 
- for(int_4 i=0;i<hfrom.mBins;i++) {
-   int numBin = FindBin(hfrom.BinCenter(i));
-   if(numBin<0) mUnder += hfrom.mData[i];
-   else if(numBin>=mBins) mOver += hfrom.mData[i];
-   else {
-     mData[numBin]  += hfrom.mData[i];
-     mNData[numBin] += hfrom.mNData[i];
-     mErr2[numBin]  += hfrom.mErr2[i];
-     nHist          += hfrom.mData[i];
-     nEntries++;
-   }
+ for(int_4 i=0;i<hfrom.nx_;i++) {
+   r_8 x = hfrom.BinCenter(i);
+   int ii = FindBin(x);
+   if(ii<0 || ii>=nx_) continue;
+   data_(ii)  += hfrom.data_(ii);
+   err2_(ii)  += hfrom.err2_(ii);
+   ndata_(ii) += hfrom.ndata_(ii);
  }
  mCorrel = hfrom.mCorrel;
@@ -192,12 +159,9 @@
 {
   if(this==&h) return *this;
-  CreateOrResize(h.mMin,h.mMax,h.mBins);
-  if(mData) memcpy(mData,h.mData,mBins*sizeof(r_8));
-  if(mErr2) memcpy(mErr2,h.mErr2,mBins*sizeof(r_8));
-  mUnder = h.mUnder; mOver = h.mOver;
-  nHist = h.nHist; nEntries = h.nEntries;
-  if(mNData) memcpy(mNData,h.mNData,mBins*sizeof(r_8));
+  CreateOrResize(h.xmin_,h.xmax_,h.nx_);
+  data_  = h.data_;
+  err2_  = h.err2_;
+  ndata_ = h.ndata_;
   mCorrel = h.mCorrel;
-
   return *this;
 }
@@ -209,6 +173,6 @@
 void HistoErr::Show(ostream & os) const
 {
-  Histo::Show(os);
-  os <<"       ncorrel="<<mCorrel<< endl;
+  os <<"HistoErr(ncorrel="<<mCorrel<<")"<<endl
+     <<"          nx="<<nx_<<" ["<<xmin_<<","<<xmax_<<"] dx="<<dx_<<endl;
 }
 
@@ -224,6 +188,5 @@
 string strg;
 
-if(dobj==NULL) dobj=new HistoErr;
-  else         dobj->Delete();
+if(dobj==NULL) dobj = new HistoErr;
 
 // Lecture entete
@@ -233,11 +196,16 @@
 is.Get(dobj->mCorrel);
 
-// Lecture des donnees HistoErr
-is.Get(dobj->mBins);
-if(dobj->mBins>0) dobj->mNData = new r_8[dobj->mBins];
-is.Get(dobj->mNData, dobj->mBins);
-
-// Lecture de l'histogramme
-is >> (Histo&)(*dobj);
+// Lecture des parametres HistoErr
+is.Get(dobj->xmin_);
+is.Get(dobj->xmax_);
+is.Get(dobj->nx_);
+is.Get(dobj->dx_);
+
+// Lecture des donnees
+if(dobj->nx_>0) {
+  is >> dobj->data_;
+  is >> dobj->err2_;
+  is >> dobj->ndata_;
+}
 
 return;
@@ -257,12 +225,16 @@
 os.Put(dobj->mCorrel);
 
-// Ecriture des valeurs
-os.Put(dobj->mBins);
-
-// Ecriture des donnees HistoErr nombre d entree par bin
-os.Put(dobj->mNData, dobj->mBins);
-
-// Ecriture de l'histogramme
-os << (Histo&)(*dobj);
+// Ecriture des parametres HistoErr
+os.Put(dobj->xmin_);
+os.Put(dobj->xmax_);
+os.Put(dobj->nx_);
+os.Put(dobj->dx_);
+
+// Ecriture des donnees
+if(dobj->nx_>0) {
+  os << dobj->data_;
+  os << dobj->err2_;
+  os << dobj->ndata_;
+}
 
 return;
