Index: /trunk/SophyaLib/NTools/cvector.cc
===================================================================
--- /trunk/SophyaLib/NTools/cvector.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/cvector.cc	(revision 307)
@@ -171,18 +171,20 @@
 //////////////////////////////////////////////////////////
 //++
-Vector* Vector::FitResidus(GeneralFit& gfit)
+Vector Vector::FitResidus(GeneralFit& gfit,double xorg,double dx)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
-//	On suppose que x=i.
-//--
-{
-if(NElts()<=0) return NULL;
+//	La coordonnee de l'element (i) est -> x = xorg + i*dx
+//--
+{
+if(NElts()<=0)
+  throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Vector* v = new Vector(*this);
+Vector v(*this);
 for(int i=0;i<NElts();i++) {
-  double x = (double)i;
-  (*v)(i) -= f->Value(&x,par.Data());
+  double x = xorg+i*dx;
+  v(i) -= f->Value(&x,par.Data());
 }
 return v;
@@ -190,18 +192,20 @@
 
 //++
-Vector* Vector::FitFunction(GeneralFit& gfit)
+Vector Vector::FitFunction(GeneralFit& gfit,double xorg,double dx)
 //
 //	Retourne une classe contenant la fonction du fit ``gfit''.
-//	On suppose que x=i.
-//--
-{
-if(NElts()<=0) return NULL;
+//	La coordonnee de l'element (i) est -> x = xorg + i*dx
+//--
+{
+if(NElts()<=0)
+  throw(SzMismatchError("Vector::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Vector::FitResidus: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Vector* v = new Vector(*this);
+Vector v(*this);
 for(int i=0;i<NElts();i++) {
-  double x = (double)i;
-  (*v)(i) = f->Value(&x,par.Data());
+  double x = xorg+i*dx;
+  v(i) = f->Value(&x,par.Data());
 }
 return v;
Index: /trunk/SophyaLib/NTools/cvector.h
===================================================================
--- /trunk/SophyaLib/NTools/cvector.h	(revision 306)
+++ /trunk/SophyaLib/NTools/cvector.h	(revision 307)
@@ -5,6 +5,8 @@
 #include "matrix.h"
 
-class GeneralFit;
-namespace PlanckDPC {template <class T> class TVector;}
+namespace PlanckDPC {
+  class GeneralFit;
+  template <class T> class TVector;
+}
 
 // <summary> Vecteur colonne pour operations matricielles </summary>
@@ -66,6 +68,6 @@
 
   // Residus et fonction fittees.
-  Vector* FitResidus(GeneralFit& gfit);
-  Vector* FitFunction(GeneralFit& gfit);
+  Vector FitResidus(GeneralFit& gfit,double xorg=0.,double dx=1.);
+  Vector FitFunction(GeneralFit& gfit,double xorg=0.,double dx=1.);
 
 };
@@ -98,5 +100,2 @@
 
 #endif /* VECTOR_SEEN */
-
-
-
Index: /trunk/SophyaLib/NTools/difeq.h
===================================================================
--- /trunk/SophyaLib/NTools/difeq.h	(revision 306)
+++ /trunk/SophyaLib/NTools/difeq.h	(revision 307)
@@ -7,6 +7,5 @@
 #include "cvector.h"
 
-class GeneralFunction;
-
+namespace PlanckDPC {class GeneralFunction;}
 
 // <summary> fonction pour equadifs </summary>
Index: /trunk/SophyaLib/NTools/fct1dfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/fct1dfit.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/fct1dfit.cc	(revision 307)
@@ -8,4 +8,6 @@
 #include "nbconst.h"
 #include "tabmath.h"
+
+using namespace PlanckDPC;
 
 //define EXPO exp
Index: /trunk/SophyaLib/NTools/fct1dfit.h
===================================================================
--- /trunk/SophyaLib/NTools/fct1dfit.h	(revision 306)
+++ /trunk/SophyaLib/NTools/fct1dfit.h	(revision 307)
@@ -3,4 +3,6 @@
 
 #include "generalfit.h"
+
+namespace PlanckDPC {
 
 //================================================================
@@ -134,3 +136,5 @@
 };
 
+} // Fin du namespace
+
 #endif
Index: /trunk/SophyaLib/NTools/fct2dfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/fct2dfit.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/fct2dfit.cc	(revision 307)
@@ -16,4 +16,6 @@
 #define EXPO tabFExp
 #define MINEXPM (100.)
+
+using namespace PlanckDPC;
 
 //================================================================
Index: /trunk/SophyaLib/NTools/fct2dfit.h
===================================================================
--- /trunk/SophyaLib/NTools/fct2dfit.h	(revision 306)
+++ /trunk/SophyaLib/NTools/fct2dfit.h	(revision 307)
@@ -3,4 +3,6 @@
 
 #include "generalfit.h"
+
+namespace PlanckDPC {
 
 //================================================================
@@ -193,3 +195,5 @@
 };
 
+} // Fin du namespace
+
 #endif
Index: /trunk/SophyaLib/NTools/generaldata.cc
===================================================================
--- /trunk/SophyaLib/NTools/generaldata.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/generaldata.cc	(revision 307)
@@ -3,4 +3,5 @@
 #include <stdlib.h>
 #include <iostream.h>
+#include <values.h>
 #include <math.h>
 #include <string.h>
@@ -11,8 +12,11 @@
 #endif
 
-#include "perrors.h"
 #include "nbtri.h"
 #include "generalfit.h"
 #include "generaldata.h"
+#include "pexceptions.h"
+#include "objfio.h"
+
+using namespace PlanckDPC;
 
 //================================================================
@@ -52,15 +56,14 @@
   , BuffVar(NULL), BuffVarR4(NULL)
 {
- TRY {
-   Alloc(nVar,ndatalloc,errx);
- } CATCHALL {
-   cout<<"GeneralFitData::GeneralFitData Impossible d'allouer l'espace"<<endl;
-   THROW_SAME;
- } ENDTRY
- END_CONSTRUCTOR
-}
-
-//++
-GeneralFitData::GeneralFitData(GeneralFitData& data, bool clean)
+try {
+  Alloc(nVar,ndatalloc,errx);
+} catch(PException e) {
+  cout << "Exception : " << typeid(e).name() << " " << e.Msg() << endl;
+  throw;
+}
+}
+
+//++
+GeneralFitData::GeneralFitData(const GeneralFitData& data, bool clean)
 //
 //	Constructeur par copie. Si ``clean'' est ``true''
@@ -74,10 +77,10 @@
   , BuffVar(NULL), BuffVarR4(NULL)
 {
- TRY {
-   Alloc(data.mNVar,((clean)?data.mNDataGood:data.mNDataAlloc),((data.mErrXP)?1:0));
- } CATCHALL {
-   cout<<"GeneralFitData::GeneralFitData Impossible d'allouer l'espace"<<endl;
-   THROW_SAME;
- } ENDTRY
+try {
+  Alloc(data.mNVar,((clean)?data.mNDataGood:data.mNDataAlloc),((data.mErrXP)?1:0));
+} catch(PException e) {
+  cout << "Exception : " << typeid(e).name() << " " << e.Msg() << endl;
+  throw;
+}
 
  // Remplissage
@@ -113,18 +116,4 @@
 
 //++
-GeneralFitData::GeneralFitData(char *flnm)
-//
-//	Constructeur par lecture d'un fichier ppersist..
-//--
-  : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
-  , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
-  , BuffVar(NULL), BuffVarR4(NULL)
-{
-  PInPersist s(flnm);
-  Read(s);
-  END_CONSTRUCTOR
-}
-
-//++
 GeneralFitData::~GeneralFitData()
 //
@@ -153,5 +142,5 @@
 mNDataAlloc = ndatalloc;
 
-TRY {
+try {
   mXP  = new r_8[nVar*ndatalloc];
   if(mOk_EXP) mErrXP  = new r_8[nVar*ndatalloc];
@@ -161,7 +150,7 @@
   BuffVar   = new r_8[2*nVar+3];
   BuffVarR4 = (r_4 *) BuffVar;
-} CATCHALL {
-  THROW_SAME;
-} ENDTRY
+} catch(PException e) {
+  throw(AllocationError("GeneralFitData::Alloc allocation error\n"));
+}
 }
 
@@ -824,20 +813,22 @@
 //////////////////////////////////////////////////////////////////////
 //++
-GeneralFitData* GeneralFitData::FitResidus(GeneralFit& gfit)
+GeneralFitData GeneralFitData::FitResidus(GeneralFit& gfit)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
 //--
 {
-if(gfit.GetNVar()!=mNVar) return NULL;
+if(gfit.GetNVar()!=mNVar)
+  throw(SzMismatchError("GeneralFitData::FitResidus: size mismatch\n"));
 return gfit.DataResidus(true);
 }
 
 //++
-GeneralFitData* GeneralFitData::FitFunction(GeneralFit& gfit)
+GeneralFitData GeneralFitData::FitFunction(GeneralFit& gfit)
 //
 //	Retourne une classe contenant la function du fit ``gfit''.
 //--
 {
-if(gfit.GetNVar()!=mNVar) return NULL;
+if(gfit.GetNVar()!=mNVar)
+  throw(SzMismatchError("GeneralFitData::FitFunction: size mismatch\n"));
 return gfit.DataFunction(true);
 }
@@ -922,39 +913,200 @@
 //////////////////////////////////////////////////////////////////////
 //++
-void GeneralFitData::WriteSelf(POutPersist& s)  const
-//
-//	Ecriture ppersist
-//--
-{
+// int inline int GetSpaceFree() const
+//	Retourne la place restante dans la structure (nombre de
+//	donnees que l'on peut encore stoquer).
+//--
+//++
+// inline int  NVar()       const
+//	Retourne le nombre de variables Xi
+//--
+//++
+// inline int  NData()
+//	Retourne le nombre de donnees
+//--
+//++
+// inline int  NDataGood()  const
+//	Retourne le nombre de bonnes donnees (utilisees pour le fit)
+//--
+//++
+// inline int  NDataAlloc() const
+//	Retourne la place maximale allouee pour les donnees
+//--
+//++
+// inline unsigned short int IsValid(int i) const
+//	Retourne 1 si point valide, sinon 0
+//--
+//++
+// inline bool HasXErrors()
+//	Retourne ``true'' si il y a des erreurs sur les variables
+//	d'abscisse, ``false'' sinon.
+//--
+//++
+// inline double X1(int i) const
+//	Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
+//--
+//++
+// inline double X(int i) const
+//	Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double Y(int i) const
+//	Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double Z(int i) const
+//	Retourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double Absc(int j,int i) const
+//	Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
+//--
+//++
+// inline double Val(int i) const
+//	Retourne la valeur de la Ieme donnee
+//--
+//++
+// inline double EX1(int i) const
+//	Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
+//--
+//++
+// inline double EX(int i) const
+//	Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double EY(int i) const
+//	Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double EZ(int i) const
+//	Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
+//--
+//++
+// inline double EAbsc(int j,int i) const
+//	Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
+//--
+//++
+// inline double EVal(int i) const {return mErr[i];}
+//	Retourne l'erreur de la Ieme donnee
+//--
+
+///////////////////////////////////////////////////////////
+// --------------------------------------------------------
+//   Les objets delegues pour la gestion de persistance 
+// --------------------------------------------------------
+///////////////////////////////////////////////////////////
+
+FIO_GeneralFitData::FIO_GeneralFitData()
+{
+dobj=new GeneralFitData;
+ownobj=true;
+}
+
+FIO_GeneralFitData::FIO_GeneralFitData(string const & filename) 
+{
+dobj=new GeneralFitData;
+ownobj=true; 
+Read(filename);
+}
+
+FIO_GeneralFitData::FIO_GeneralFitData(const GeneralFitData & obj) 
+{ 
+dobj = new GeneralFitData(obj);
+ownobj=true; 
+}
+
+FIO_GeneralFitData::FIO_GeneralFitData(GeneralFitData * obj) 
+{ 
+dobj = obj;
+ownobj=false; 
+}
+
+FIO_GeneralFitData::~FIO_GeneralFitData()
+{
+if (ownobj && dobj) delete dobj;
+}
+
+AnyDataObj* FIO_GeneralFitData::DataObj()
+{
+return(dobj);
+}
+
+void FIO_GeneralFitData::ReadSelf(PInPersist& is)
+{
+char strg[256];
+
+if(dobj==NULL) dobj=new GeneralFitData;
+  else         dobj->Delete();
+
+// Lecture entete
+is.GetLine(strg, 255);
+
+// Ecriture des valeurs de definitions
+int_4 nvar,ndatalloc,ndata,ndatagood;
+is.Get(nvar);
+is.Get(ndatalloc);
+is.Get(ndata);
+is.Get(ndatagood);
+is.Get(dobj->mOk_EXP);
+if(nvar<=0 || ndatalloc<=0 || ndata<=0 || ndatagood<0 || ndatalloc<ndata) return;
+
+// Allocation de la place (attention Alloc efface mNData,mNDataGood);
+dobj->Alloc(nvar,ndatalloc,-1);
+dobj->mNData = ndata;
+dobj->mNDataGood = ndatagood;
+
+// Lecture des datas
+is.GetLine(strg, 255);
+int blen = dobj->mNVar + 3;
+if(dobj->mOk_EXP) blen += dobj->mNVar;
+double *buff = new double[blen];
+for(int i=0;i<dobj->mNData;i++) {
+  is.Get(buff, blen);
+  int ip = i*dobj->mNVar;
+  {for(int j=0;j<dobj->mNVar;j++)  dobj->mXP[ip+j] = buff[j];}
+  dobj->mF[i] = buff[dobj->mNVar];
+  dobj->mErr[i] = buff[dobj->mNVar+1];
+  dobj->mOK[i] = (uint_2)(buff[dobj->mNVar+2]+0.01);
+  if(dobj->mOk_EXP) {for(int j=0;j<dobj->mNVar;j++)
+                        dobj->mErrXP[ip+j] = buff[dobj->mNVar+3+j];}
+}
+delete [] buff;
+
+return;
+}
+
+void FIO_GeneralFitData::WriteSelf(POutPersist& os) const
+{
+if (dobj == NULL)   return;
 char strg[256];
 
 // Ecriture entete pour identifier facilement
 sprintf(strg,"GeneralFitData: NVar=%d NDataAlloc=%d NData=%d NDataGood=%d Ok_EXP=%d"
-       ,mNVar,mNDataAlloc,mNData,mNDataGood,mOk_EXP);
-s.PutLine(strg);
+       ,dobj->mNVar,dobj->mNDataAlloc,dobj->mNData,dobj->mNDataGood,dobj->mOk_EXP);
+os.PutLine(strg);
 
 // Ecriture des valeurs de definitions
-s.PutI4(mNVar);
-s.PutI4(mNDataAlloc);
-s.PutI4(mNData);
-s.PutI4(mNDataGood);
-s.PutU2(mOk_EXP);
-if(mNVar<=0 || mNDataAlloc<=0 || mNData<=0 || mNDataGood<0) return;
+os.Put(dobj->mNVar);
+os.Put(dobj->mNDataAlloc);
+os.Put(dobj->mNData);
+os.Put(dobj->mNDataGood);
+os.Put(dobj->mOk_EXP);
+if(dobj->mNVar<=0 || dobj->mNDataAlloc<=0 || dobj->mNData<=0 || dobj->mNDataGood<0) return;
 
 // Ecriture des datas (on n'ecrit que mNData / mNDataAlloc)
 sprintf(strg
        ,"GeneralFitData: Abscisses, Ordonnee, Erreur Ordonnee, Flag, Erreur Abscisses");
-s.PutLine(strg);
-
-int blen = mNVar + 3;
-if(mOk_EXP) blen += mNVar;
+os.PutLine(strg);
+
+int blen = dobj->mNVar + 3;
+if(dobj->mOk_EXP) blen += dobj->mNVar;
 double *buff = new double[blen];
-for(int i=0;i<mNData;i++) {
-  {for(int j=0;j<mNVar;j++) buff[j] = Absc(j,i);}
-  buff[mNVar] = Val(i);
-  buff[mNVar+1] = EVal(i);
-  buff[mNVar+2] = (double) IsValid(i);
-  if(mOk_EXP) {for(int j=0;j<mNVar;j++) buff[mNVar+3+j] = EAbsc(j,i);}
-  s.PutR8s(buff, blen);
+for(int i=0;i<dobj->mNData;i++) {
+  {for(int j=0;j<dobj->mNVar;j++) buff[j] = dobj->Absc(j,i);}
+  buff[dobj->mNVar] = dobj->Val(i);
+  buff[dobj->mNVar+1] = dobj->EVal(i);
+  buff[dobj->mNVar+2] = (double) dobj->IsValid(i);
+  if(dobj->mOk_EXP) {for(int j=0;j<dobj->mNVar;j++) buff[dobj->mNVar+3+j] = dobj->EAbsc(j,i);}
+  os.Put(buff, blen);
 }
 delete [] buff;
@@ -962,129 +1114,2 @@
 return;
 }
-
-//////////////////////////////////////////////////////////////////////
-//++
-void GeneralFitData::ReadSelf(PInPersist& s)
-//
-//	Lecture ppersist
-//--
-{
-char strg[256];
-
-Delete();
-
-// Lecture entete
-s.GetLine(strg, 255);
-
-// Ecriture des valeurs de definitions
-int_4 nvar,ndatalloc,ndata,ndatagood;
-s.GetI4(nvar);
-s.GetI4(ndatalloc);
-s.GetI4(ndata);
-s.GetI4(ndatagood);
-s.GetU2(mOk_EXP);
-if(nvar<=0 || ndatalloc<=0 || ndata<=0 || ndatagood<0 || ndatalloc<ndata) return;
-
-// Allocation de la place (attention Alloc efface mNData,mNDataGood);
-Alloc(nvar,ndatalloc,-1);
-mNData = ndata;
-mNDataGood = ndatagood;
-
-// Lecture des datas
-s.GetLine(strg, 255);
-int blen = mNVar + 3;
-if(mOk_EXP) blen += mNVar;
-double *buff = new double[blen];
-for(int i=0;i<mNData;i++) {
-  s.GetR8s(buff, blen);
-  int ip = i*mNVar;
-  {for(int j=0;j<mNVar;j++)  mXP[ip+j] = buff[j];}
-  mF[i] = buff[mNVar];
-  mErr[i] = buff[mNVar+1];
-  mOK[i] = (uint_2)(buff[mNVar+2]+0.01);
-  if(mOk_EXP) {for(int j=0;j<mNVar;j++) mErrXP[ip+j] = buff[mNVar+3+j];}
-}
-delete [] buff;
-
-return;
-}
-
-//////////////////////////////////////////////////////////////////////
-//++
-// int inline int GetSpaceFree() const
-//	Retourne la place restante dans la structure (nombre de
-//	donnees que l'on peut encore stoquer).
-//--
-//++
-// inline int  NVar()       const
-//	Retourne le nombre de variables Xi
-//--
-//++
-// inline int  NData()
-//	Retourne le nombre de donnees
-//--
-//++
-// inline int  NDataGood()  const
-//	Retourne le nombre de bonnes donnees (utilisees pour le fit)
-//--
-//++
-// inline int  NDataAlloc() const
-//	Retourne la place maximale allouee pour les donnees
-//--
-//++
-// inline unsigned short int IsValid(int i) const
-//	Retourne 1 si point valide, sinon 0
-//--
-//++
-// inline bool HasXErrors()
-//	Retourne ``true'' si il y a des erreurs sur les variables
-//	d'abscisse, ``false'' sinon.
-//--
-//++
-// inline double X1(int i) const
-//	Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double X(int i) const
-//	Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Y(int i) const
-//	Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Z(int i) const
-//	Retourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double Absc(int j,int i) const
-//	Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double Val(int i) const
-//	Retourne la valeur de la Ieme donnee
-//--
-//++
-// inline double EX1(int i) const
-//	Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
-//--
-//++
-// inline double EX(int i) const
-//	Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EY(int i) const
-//	Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EZ(int i) const
-//	Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
-//--
-//++
-// inline double EAbsc(int j,int i) const
-//	Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
-//--
-//++
-// inline double EVal(int i) const {return mErr[i];}
-//	Retourne l'erreur de la Ieme donnee
-//--
Index: /trunk/SophyaLib/NTools/generaldata.h
===================================================================
--- /trunk/SophyaLib/NTools/generaldata.h	(revision 306)
+++ /trunk/SophyaLib/NTools/generaldata.h	(revision 307)
@@ -1,2 +1,4 @@
+// This may look like C code, but it is really -*- C++ -*-
+//                         C.Magneville          04/99
 #ifndef GENERALDATA_SEEN
 #define GENERALDATA_SEEN
@@ -5,6 +7,10 @@
 #include "ppersist.h"
 #include "poly.h"
+#include "anydataobj.h"
+
+namespace PlanckDPC {
 
 class GeneralFit;
+class FIO_GeneralFitData;
 
 //================================================================
@@ -12,13 +18,13 @@
 //================================================================
 
-class GeneralFitData : public PPersist {
+class GeneralFitData : public AnyDataObj {
+  friend class GeneralFit;
+  friend class FIO_GeneralFitData;
 public:
-  enum {classId = ClassId_GeneralFitData };
   enum {Def_ErrF = 1, Def_ErrX = 0};
 
   GeneralFitData(unsigned int nVar, unsigned int nDataAlloc, uint_2 errx=0);
-  GeneralFitData(GeneralFitData& data, bool clean=false);
+  GeneralFitData(const GeneralFitData& data, bool clean=false);
   GeneralFitData();
-  GeneralFitData(char *flnm);
   virtual ~GeneralFitData();
 
@@ -107,15 +113,7 @@
   double PolFit(int varx,Poly& pol,int degre,bool ey=true);
   double PolFit(int varx,int vary,Poly2& pol,int degre1,int degre2=-1,bool ez=true);
-  GeneralFitData* FitResidus(GeneralFit& gfit);
-  GeneralFitData* FitFunction(GeneralFit& gfit);
+  GeneralFitData FitResidus(GeneralFit& gfit);
+  GeneralFitData FitFunction(GeneralFit& gfit);
   string VarList_C(const char* nomx)  const;
-
-  int_4             ClassId() const        { return classId; }
-  static PPersist*  Create()               { return new GeneralFitData;}
-
-  virtual void      WriteSelf(POutPersist&) const;
-  virtual void      ReadSelf(PInPersist&);
-
-friend class GeneralFit;
 
 protected:
@@ -136,3 +134,23 @@
 };
 
+/////////////////////////////////////////////////////////////////////////
+// Classe pour la gestion de persistance
+class FIO_GeneralFitData : public  PPersist  {
+public:
+  FIO_GeneralFitData();
+  FIO_GeneralFitData(string const & filename); 
+  FIO_GeneralFitData(const GeneralFitData & obj);
+  FIO_GeneralFitData(GeneralFitData * obj);
+  virtual ~FIO_GeneralFitData();
+  virtual AnyDataObj* DataObj();
+  inline operator GeneralFitData() { return(*dobj); }
+protected :
+  virtual void ReadSelf(PInPersist&);           
+  virtual void WriteSelf(POutPersist&) const;  
+  GeneralFitData * dobj;
+  bool ownobj;
+};
+
+} // Fin du namespace
+
 #endif
Index: /trunk/SophyaLib/NTools/generalfit.cc
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/generalfit.cc	(revision 307)
@@ -11,11 +11,11 @@
 #endif
 
+#include "pexceptions.h"
 #include "generalfit.h"
-#include "perrors.h"
 #include "cvector.h"
-#include "nbconst.h"
-#include "tabmath.h"
 
 #define EPS_FIT_MIN 1.e-8
+
+using namespace PlanckDPC;
 
 //================================================================
@@ -1433,5 +1433,5 @@
 //////////////////////////////////////////////////////////////////////
 //++
-GeneralFitData* GeneralFit::DataResidus(bool clean)
+GeneralFitData GeneralFit::DataResidus(bool clean)
 //
 //	Retourne une structure ``GeneralFitData'' contenant
@@ -1444,9 +1444,9 @@
 //--
 {
-if(!mData) return NULL;
-if(!mFunction) return NULL;
-GeneralFitData* datres = new GeneralFitData(*mData,clean);
+if(!mData || !mFunction)
+  throw(NullPtrError("GeneralFit::DataResidus: NULL pointer\n"));
+GeneralFitData datres(*mData,clean);
 for(int k=0; k<mData->NData(); k++)
-  datres->mF[k] -= mFunction->Value(&datres->mXP[mNVar*k],Param.Data());
+  datres.mF[k] -= mFunction->Value(&datres.mXP[mNVar*k],Param.Data());
 return datres;
 }
@@ -1454,5 +1454,5 @@
 //////////////////////////////////////////////////////////////////////
 //++
-GeneralFitData* GeneralFit::DataFunction(bool clean)
+GeneralFitData GeneralFit::DataFunction(bool clean)
 //
 //	Retourne une structure ``GeneralFitData'' contenant
@@ -1461,9 +1461,9 @@
 //--
 {
-if(!mData) return NULL;
-if(!mFunction) return NULL;
-GeneralFitData* datres = new GeneralFitData(*mData,clean);
+if(!mData || !mFunction)
+  throw(NullPtrError("GeneralFit::DataFunction: NULL pointer\n"));
+GeneralFitData datres(*mData,clean);
 for(int k=0; k<mData->NData(); k++)
-  datres->mF[k] = mFunction->Value(&datres->mXP[mNVar*k],Param.Data());
+  datres.mF[k] = mFunction->Value(&datres.mXP[mNVar*k],Param.Data());
 return datres;
 }
Index: /trunk/SophyaLib/NTools/generalfit.h
===================================================================
--- /trunk/SophyaLib/NTools/generalfit.h	(revision 306)
+++ /trunk/SophyaLib/NTools/generalfit.h	(revision 307)
@@ -8,9 +8,11 @@
 #include "generaldata.h"
 
+namespace PlanckDPC {
+
 //================================================================
 // GeneralFunction
 //================================================================
 
-class GeneralFunction EXC_AWARE {
+class GeneralFunction {
 public:
   GeneralFunction(unsigned int nVar, unsigned int nPar);
@@ -61,5 +63,5 @@
 class GeneralFitData;
 
-class GeneralXi2 EXC_AWARE {
+class GeneralXi2 {
 public:
   GeneralXi2(unsigned int nPar);
@@ -85,5 +87,5 @@
 //================================================================
 
-class GeneralFit EXC_AWARE {
+class GeneralFit {
 public:
   GeneralFit(GeneralFunction* f);
@@ -152,6 +154,6 @@
   int             Fit();
   double          ReCalChi2(int& nddl, double* par = NULL);
-  GeneralFitData* DataResidus(bool clean=true);
-  GeneralFitData* DataFunction(bool clean=true);
+  GeneralFitData  DataResidus(bool clean=true);
+  GeneralFitData  DataFunction(bool clean=true);
   void            PrintFitErr(int rc);
 
@@ -227,3 +229,5 @@
 };
 
+} // Fin du namespace
+
 #endif
Index: /trunk/SophyaLib/NTools/hisprof.cc
===================================================================
--- /trunk/SophyaLib/NTools/hisprof.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/hisprof.cc	(revision 307)
@@ -7,4 +7,6 @@
 #include "cvector.h"
 
+using namespace PlanckDPC;
+
 //++
 // Class	HProf
@@ -47,18 +49,4 @@
   Histo::Errors();
   Zero();
-  END_CONSTRUCTOR
-}
-
-/********* Methode *********/
-//++
-HProf::HProf(char *flnm)
-//
-//	Constructeur a partir d'un fichier ppersist.
-//--
-: Histo()
-, SumY(NULL), SumY2(NULL), SumW(NULL), Ok(false), YMin(1.), YMax(-1.), Opt(0)
-{
-  PInPersist s(flnm);
-  Read(s);
   END_CONSTRUCTOR
 }
@@ -261,119 +249,154 @@
 //--
 {
-if (b.bins!=a.bins) THROW(sizeMismatchErr);
+if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
 HProf c(a);
 return (c += b);
 }
 
-/********* Methode *********/
-//++
-void  HProf::WriteSelf(POutPersist& s)  const
-//
-//	Ecriture ppersist
-//--
+// Rappel des inlines functions pour commentaires
+//++
+//   inline Histo GetHisto()
+//	Retourne l'histogramme de profil.
+//--
+//++
+// inline void GetMean(Vector& v)
+//	Retourne le contenu de la moyenne dans le vecteur v
+//--
+//++
+// inline void GetError2(Vector& v)
+//	Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
+//--
+//++
+// inline float operator()(int i) const
+//	Retourne le contenu du bin i
+//--
+//++
+// inline float Error2(int i) const
+//	Retourne le carre de la dispersion/erreur du bin i
+//--
+//++
+// inline float Error(int i) const
+//	Retourne la dispersion/erreur du bin i
+//--
+//++
+// inline int Fit(GeneralFit& gfit)
+//	Fit du profile par ``gfit''.
+//--
+//++
+// inline Histo* FitResidus(GeneralFit& gfit)
+//	Retourne l'Histogramme des residus par ``gfit''.
+//--
+//++
+// inline Histo* FitFunction(GeneralFit& gfit)
+//	Retourne l'Histogramme de la fonction fittee par ``gfit''.
+//--
+//++
+// inline void Print(int dyn,float hmin,float hmax,int pflag,int il,int ih)
+//	Print, voir detail dans Histo::Print
+//--
+
+
+///////////////////////////////////////////////////////////
+// --------------------------------------------------------
+//   Les objets delegues pour la gestion de persistance 
+// --------------------------------------------------------
+///////////////////////////////////////////////////////////
+
+FIO_HProf::FIO_HProf()
+{
+dobj=new HProf;
+ownobj=true;
+}
+
+FIO_HProf::FIO_HProf(string const & filename) 
+{
+dobj=new HProf;
+ownobj=true; 
+Read(filename);
+}
+
+FIO_HProf::FIO_HProf(const HProf & obj) 
+{ 
+dobj = new HProf(obj);
+ownobj=true; 
+}
+
+FIO_HProf::FIO_HProf(HProf * obj) 
+{ 
+dobj = obj;
+ownobj=false; 
+}
+
+FIO_HProf::~FIO_HProf()
+{
+if (ownobj && dobj) delete dobj;
+}
+
+AnyDataObj* FIO_HProf::DataObj()
+{
+return(dobj);
+}
+
+void FIO_HProf::ReadSelf(PInPersist& is)
 {
 char strg[256];
 
-UpdateHisto();
+if(dobj==NULL) dobj=new HProf;
+  else         dobj->Delete();
+
+// Lecture entete
+is.GetLine(strg,255);
+
+// Ecriture des valeurs
+is.Get(dobj->bins);
+is.Get(dobj->YMin);
+is.Get(dobj->YMax);
+is.Get(dobj->Opt);
+dobj->Ok = true;
+
+// Ecriture des donnees propres a l'histogramme de profil.
+is.GetLine(strg,255);
+dobj->SumY  = new double[dobj->bins];
+dobj->SumY2 = new double[dobj->bins];
+dobj->SumW  = new double[dobj->bins];
+is.Get(dobj->SumY,  dobj->bins);
+is.Get(dobj->SumY2, dobj->bins);
+is.Get(dobj->SumW,  dobj->bins);
+
+// Ecriture de l'histogramme
+FIO_Histo fio_h((Histo&)dobj);
+fio_h.Read(is);
+
+return;
+}
+
+void FIO_HProf::WriteSelf(POutPersist& os) const
+{
+if (dobj == NULL)   return;
+char strg[256];
+
+dobj->UpdateHisto();
 
 // Ecriture entete pour identifier facilement
-sprintf(strg,"HProf: YMin=%f  YMax=%f  Opt=%1d",YMin,YMax,Opt);
-s.PutLine(strg);
+sprintf(strg,"HProf: YMin=%f  YMax=%f  Opt=%1d",dobj->YMin,dobj->YMax,dobj->Opt);
+os.PutLine(strg);
 
 // Ecriture des valeurs
-s.PutI4(bins);
-s.PutR4(YMin);
-s.PutR4(YMax);
-s.PutU2(Opt);
+os.Put(dobj->bins);
+os.Put(dobj->YMin);
+os.Put(dobj->YMax);
+os.Put(dobj->Opt);
 
 // Ecriture des donnees propres a l'histogramme de profil.
 sprintf(strg,"HProf: SumY SumY2 SumW");
-s.PutLine(strg);
-s.PutR8s(SumY,  bins);
-s.PutR8s(SumY2, bins);
-s.PutR8s(SumW,  bins);
+os.PutLine(strg);
+os.Put(dobj->SumY,  dobj->bins);
+os.Put(dobj->SumY2, dobj->bins);
+os.Put(dobj->SumW,  dobj->bins);
 
 // Ecriture de l'histogramme
-Histo::WriteSelf(s);
+FIO_Histo fio_h((Histo&)dobj);
+fio_h.Write(os);
 
 return;
 }
-
-/********* Methode *********/
-//++
-void  HProf::ReadSelf(PInPersist& s)
-//
-//	Lecture ppersist
-//--
-{
-char strg[256];
-
-Delete();
-
-// Lecture entete
-s.GetLine(strg,255);
-
-// Ecriture des valeurs
-s.GetI4(bins);
-s.GetR4(YMin);
-s.GetR4(YMax);
-s.GetU2(Opt);
-Ok = true;
-
-// Ecriture des donnees propres a l'histogramme de profil.
-s.GetLine(strg,255);
-SumY  = new double[bins];
-SumY2 = new double[bins];
-SumW  = new double[bins];
-s.GetR8s(SumY,  bins);
-s.GetR8s(SumY2, bins);
-s.GetR8s(SumW,  bins);
-
-// Ecriture de l'histogramme
-Histo::ReadSelf(s);
-
-return;
-}
-
-
-// Rappel des inlines functions pour commentaires
-//++
-//   inline Histo GetHisto()
-//	Retourne l'histogramme de profil.
-//--
-//++
-// inline void GetMean(Vector& v)
-//	Retourne le contenu de la moyenne dans le vecteur v
-//--
-//++
-// inline void GetError2(Vector& v)
-//	Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
-//--
-//++
-// inline float operator()(int i) const
-//	Retourne le contenu du bin i
-//--
-//++
-// inline float Error2(int i) const
-//	Retourne le carre de la dispersion/erreur du bin i
-//--
-//++
-// inline float Error(int i) const
-//	Retourne la dispersion/erreur du bin i
-//--
-//++
-// inline int Fit(GeneralFit& gfit)
-//	Fit du profile par ``gfit''.
-//--
-//++
-// inline Histo* FitResidus(GeneralFit& gfit)
-//	Retourne l'Histogramme des residus par ``gfit''.
-//--
-//++
-// inline Histo* FitFunction(GeneralFit& gfit)
-//	Retourne l'Histogramme de la fonction fittee par ``gfit''.
-//--
-//++
-// inline void Print(int dyn,float hmin,float hmax,int pflag,int il,int ih)
-//	Print, voir detail dans Histo::Print
-//--
Index: /trunk/SophyaLib/NTools/hisprof.h
===================================================================
--- /trunk/SophyaLib/NTools/hisprof.h	(revision 306)
+++ /trunk/SophyaLib/NTools/hisprof.h	(revision 307)
@@ -8,13 +8,13 @@
 #include "histos.h"
 
+namespace PlanckDPC {
+
 class HProf : public Histo {
-
+  friend class FIO_HProf;
 public:
-  enum {classId = ClassId_HProf };
 
   // CREATOR / DESTRUCTOR
   HProf();
   HProf(float xMin, float xMax, int nBin=100, float yMin=1., float yMax=-1.);
-  HProf(char *flnm);
   HProf(const HProf& H);
   virtual ~HProf();
@@ -44,7 +44,7 @@
   inline int    Fit(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::Fit(gfit,0);}
-  inline Histo* FitResidus(GeneralFit& gfit)
+  inline Histo  FitResidus(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::FitResidus(gfit);}
-  inline Histo* FitFunction(GeneralFit& gfit)
+  inline Histo  FitFunction(GeneralFit& gfit)
          {if(!Ok) UpdateHisto(); return Histo::FitFunction(gfit);}
 
@@ -52,11 +52,4 @@
   inline void Print(int dyn=100,float hmin=1.,float hmax=-1.,int pflag=0,int il=1,int ih=-1)
                            {if(!Ok) UpdateHisto(); Histo::Print(dyn,hmin,hmax,pflag,il,ih);}
-
-  int_4             ClassId() const        { return classId; }
-  static PPersist*  Create()               { return new HProf;}
-
-  virtual void      WriteSelf(POutPersist&) const;
-  virtual void      ReadSelf(PInPersist&);
-
 
 protected:
@@ -72,3 +65,23 @@
 };
 
+/////////////////////////////////////////////////////////////////////////
+// Classe pour la gestion de persistance
+class FIO_HProf : public  PPersist  {
+public:
+  FIO_HProf();
+  FIO_HProf(string const & filename); 
+  FIO_HProf(const HProf & obj);
+  FIO_HProf(HProf * obj);
+  virtual ~FIO_HProf();
+  virtual AnyDataObj* DataObj();
+  inline operator HProf() { return(*dobj); }
+protected :
+  virtual void ReadSelf(PInPersist&);           
+  virtual void WriteSelf(POutPersist&) const;  
+  HProf * dobj;
+  bool ownobj;
+};
+
+} // Fin du namespace
+
 #endif // HISPROF_SEEN
Index: /trunk/SophyaLib/NTools/histos.cc
===================================================================
--- /trunk/SophyaLib/NTools/histos.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/histos.cc	(revision 307)
@@ -1,4 +1,4 @@
 //
-// $Id: histos.cc,v 1.2 1999-04-22 16:18:36 ansari Exp $
+// $Id: histos.cc,v 1.3 1999-05-19 15:57:59 ansari Exp $
 //
 
@@ -14,4 +14,6 @@
 #include "generalfit.h"
 
+using namespace PlanckDPC;
+
 //++
 // Class	Histo
@@ -50,18 +52,4 @@
 {
   Zero();
-  END_CONSTRUCTOR
-}
-
-/********* Methode *********/
-//++
-Histo::Histo(char *flnm)
-//
-//--
-: data(NULL), err2(NULL),
-  under(0), over(0), nHist(0), nEntries(0),
-  bins(0), min(0), max(0), binWidth(0)
-{
-  PInPersist s(flnm);
-  Read(s);
   END_CONSTRUCTOR
 }
@@ -379,5 +367,5 @@
 //--
 {
-if (b.bins!=a.bins) THROW(sizeMismatchErr);
+if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
 Histo c(a);
 return (c += b);
@@ -389,5 +377,5 @@
 //--
 {
-if (b.bins!=a.bins) THROW(sizeMismatchErr);
+if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
 Histo c(a);
 return (c -= b);
@@ -399,5 +387,5 @@
 //--
 {
-if (b.bins!=a.bins) THROW(sizeMismatchErr);
+if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
 Histo c(a);
 return (c *= b);
@@ -409,5 +397,5 @@
 //--
 {
-if (b.bins!=a.bins) THROW(sizeMismatchErr);
+if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
 Histo c(a);
 return (c /= b);
@@ -1446,17 +1434,19 @@
 
 //++
-Histo* Histo::FitResidus(GeneralFit& gfit)
+Histo Histo::FitResidus(GeneralFit& gfit)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
 //--
 {
-if(NBins()<=0) return NULL;
+if(NBins()<=0)
+  throw(SzMismatchError("Histo::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Histo::FitResidus: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Histo* h = new Histo(*this);
+Histo h(*this);
 for(int i=0;i<NBins();i++) {
   double x = (double) BinCenter(i);
-  (*h)(i) -= (float) f->Value(&x,par.Data());
+  h(i) -= (float) f->Value(&x,par.Data());
 }
 return h;
@@ -1464,17 +1454,19 @@
 
 //++
-Histo* Histo::FitFunction(GeneralFit& gfit)
+Histo Histo::FitFunction(GeneralFit& gfit)
 //
 //	Retourne une classe contenant la fonction du fit ``gfit''.
 //--
 {
-if(NBins()<=0) return NULL;
+if(NBins()<=0)
+  throw(SzMismatchError("Histo::FitFunction: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Histo::FitFunction: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Histo* h = new Histo(*this);
+Histo h(*this);
 for(int i=0;i<NBins();i++) {
   double x = (double) BinCenter(i);
-  (*h)(i) = (float) f->Value(&x,par.Data());
+  h(i) = (float) f->Value(&x,par.Data());
 }
 return h;
@@ -1662,172 +1654,204 @@
  Histo::PrintF(stdout, hdyn, hmin, hmax, pflag, il, ih);
 }
- 
-
-/********* Methode *********/
-//++
-void  Histo::WriteSelf(POutPersist& s)  const
-//
-//	Ecriture ppersist
-//--
+
+
+// Rappel des inlines functions pour commentaires
+//++
+// inline float          XMin() const
+//	Retourne l'abscisse minimum
+//--
+//++
+// inline float          XMax() const
+//	Retourne l'abscisse maximum
+//--
+//++
+// inline int            NBins() const
+//	Retourne le nombre de bins
+//--
+//++
+// inline float          BinWidth() const
+//	Retourne la largeur du bin
+//--
+//++
+// inline float*         Bins() const
+//	Retourne le pointeur sur le tableaux des contenus
+//--
+//++
+// inline float          operator()(int i) const
+//	Retourne le contenu du bin i
+//--
+//++
+// inline float&         operator()(int i)
+//	Remplit le contenu du bin i
+//--
+//++
+// inline float          Error(int i) const
+//	Retourne l'erreur du bin i
+//--
+//++
+// inline double         Error2(int i) const
+//	Retourne l'erreur au carre du bin i
+//--
+//++
+// inline double&        Error2(int i)
+//	Remplit l'erreur au carre du bin i
+//--
+//++
+// inline float          NData() const
+//	Retourne la somme ponderee
+//--
+//++
+// inline float          NEntries()
+//	Retourne le nombre d'entrees
+//--
+//++
+// inline float          NOver() const
+//	Retourne le nombre d'overflow
+//--
+//++
+// inline float          NUnder() const
+//	Retourne le nombre d'underflow
+//--
+//++
+// inline float          BinLowEdge(int i)  const
+//	Retourne l'abscisse du bord inferieur du bin i
+//--
+//++
+// inline float          BinCenter(int i)   const
+//	Retourne l'abscisse du centre du bin i
+//--
+//++
+// inline float          BinHighEdge(int i) const
+//	Retourne l'abscisse du bord superieur du bin i
+//--
+//++
+// inline int            FindBin(float x) const   
+//	Retourne le numero du bin contenant l'abscisse x
+//--
+
+
+///////////////////////////////////////////////////////////
+// --------------------------------------------------------
+//   Les objets delegues pour la gestion de persistance 
+// --------------------------------------------------------
+///////////////////////////////////////////////////////////
+
+FIO_Histo::FIO_Histo()
+{
+dobj=new Histo;
+ownobj=true;
+}
+
+FIO_Histo::FIO_Histo(string const & filename) 
+{
+dobj=new Histo;
+ownobj=true; 
+Read(filename);
+}
+
+FIO_Histo::FIO_Histo(const Histo & obj) 
+{ 
+dobj = new Histo(obj);
+ownobj=true; 
+}
+
+FIO_Histo::FIO_Histo(Histo * obj) 
+{ 
+dobj = obj;
+ownobj=false; 
+}
+
+FIO_Histo::~FIO_Histo()
+{
+if (ownobj && dobj) delete dobj;
+}
+
+AnyDataObj* FIO_Histo::DataObj()
+{
+return(dobj);
+}
+
+void FIO_Histo::ReadSelf(PInPersist& is)
 {
 char strg[256];
 
+if(dobj==NULL) dobj=new Histo;
+  else         dobj->Delete();
+
+// Lecture entete
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+
+// Lecture des valeurs
+is.Get(dobj->bins);
+is.Get(dobj->nEntries);
+int_4 errok;
+is.Get(errok);
+
+is.Get(dobj->binWidth);
+is.Get(dobj->min);
+is.Get(dobj->max);
+is.Get(dobj->under);
+is.Get(dobj->over);
+
+is.Get(dobj->nHist);
+
+// Lecture des donnees Histo 1D
+dobj->data = new float[dobj->bins];
+is.GetLine(strg, 255);
+is.Get(dobj->data, dobj->bins);
+
+// Lecture des erreurs
+if(errok) {
+  is.GetLine(strg, 255);
+  dobj->err2 = new double[dobj->bins];
+  is.Get(dobj->err2, dobj->bins);
+}
+
+return;
+}
+
+void FIO_Histo::WriteSelf(POutPersist& os) const
+{
+if (dobj == NULL)   return;
+char strg[256];
+
 // Que faut-il ecrire?
-int errok = (err2) ? 1 : 0;
+int errok = (dobj->err2) ? 1 : 0;
 
 // Ecriture entete pour identifier facilement
-sprintf(strg,"bins=%6d  NEnt=%15d  errok=%1d",bins,nEntries,errok);
-s.PutLine(strg);
-sprintf(strg,"binw=%g  min=%g max=%g",binWidth,min,max);
-s.PutLine(strg);
-sprintf(strg, "under=%g over=%g nHist=%g",under,over,nHist);
-s.PutLine(strg);
+sprintf(strg,"bins=%6d  NEnt=%15d  errok=%1d",dobj->bins,dobj->nEntries,errok);
+os.PutLine(strg);
+sprintf(strg,"binw=%g  min=%g max=%g",dobj->binWidth,dobj->min,dobj->max);
+os.PutLine(strg);
+sprintf(strg, "under=%g over=%g nHist=%g",dobj->under,dobj->over,dobj->nHist);
+os.PutLine(strg);
 
 // Ecriture des valeurs
-s.PutI4(bins);
-s.PutI4(nEntries);
-s.PutI4(errok);
-
-s.PutR4(binWidth);
-s.PutR4(min);
-s.PutR4(max);
-s.PutR4(under);
-s.PutR4(over);
-
-s.PutR8(nHist);
+os.Put(dobj->bins);
+os.Put(dobj->nEntries);
+os.Put(errok);
+
+os.Put(dobj->binWidth);
+os.Put(dobj->min);
+os.Put(dobj->max);
+os.Put(dobj->under);
+os.Put(dobj->over);
+
+os.Put(dobj->nHist);
 
 // Ecriture des donnees Histo 1D
-sprintf(strg,"Histo: Tableau des donnees %d",bins);
-s.PutLine(strg);
-s.PutR4s(data, bins);
+sprintf(strg,"Histo: Tableau des donnees %d",dobj->bins);
+os.PutLine(strg);
+os.Put(dobj->data, dobj->bins);
 
 // Ecriture des erreurs
 if(errok) {
-  sprintf(strg,"Histo: Tableau des erreurs %d",bins);
-  s.PutLine(strg);
-  s.PutR8s(err2, bins);
+  sprintf(strg,"Histo: Tableau des erreurs %d",dobj->bins);
+  os.PutLine(strg);
+  os.Put(dobj->err2, dobj->bins);
 }
 
 return;
 }
-
-/********* Methode *********/
-//++
-void  Histo::ReadSelf(PInPersist& s)
-//
-//	Lecture ppersist
-//--
-{
-char strg[256];
-
-Delete();
-
-// Lecture entete
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-
-// Lecture des valeurs
-s.GetI4(bins);
-s.GetI4(nEntries);
-int_4 errok;
-s.GetI4(errok);
-
-s.GetR4(binWidth);
-s.GetR4(min);
-s.GetR4(max);
-s.GetR4(under);
-s.GetR4(over);
-
-s.GetR8(nHist);
-
-// Lecture des donnees Histo 1D
-data = new float[bins];
-s.GetLine(strg, 255);
-s.GetR4s(data, bins);
-
-// Lecture des erreurs
-if(errok) {
-  s.GetLine(strg, 255);
-  err2 = new double[bins];
-  s.GetR8s(err2, bins);
-}
-
-return;
-}
-
-
-
-// Rappel des inlines functions pour commentaires
-//++
-// inline float          XMin() const
-//	Retourne l'abscisse minimum
-//--
-//++
-// inline float          XMax() const
-//	Retourne l'abscisse maximum
-//--
-//++
-// inline int            NBins() const
-//	Retourne le nombre de bins
-//--
-//++
-// inline float          BinWidth() const
-//	Retourne la largeur du bin
-//--
-//++
-// inline float*         Bins() const
-//	Retourne le pointeur sur le tableaux des contenus
-//--
-//++
-// inline float          operator()(int i) const
-//	Retourne le contenu du bin i
-//--
-//++
-// inline float&         operator()(int i)
-//	Remplit le contenu du bin i
-//--
-//++
-// inline float          Error(int i) const
-//	Retourne l'erreur du bin i
-//--
-//++
-// inline double         Error2(int i) const
-//	Retourne l'erreur au carre du bin i
-//--
-//++
-// inline double&        Error2(int i)
-//	Remplit l'erreur au carre du bin i
-//--
-//++
-// inline float          NData() const
-//	Retourne la somme ponderee
-//--
-//++
-// inline float          NEntries()
-//	Retourne le nombre d'entrees
-//--
-//++
-// inline float          NOver() const
-//	Retourne le nombre d'overflow
-//--
-//++
-// inline float          NUnder() const
-//	Retourne le nombre d'underflow
-//--
-//++
-// inline float          BinLowEdge(int i)  const
-//	Retourne l'abscisse du bord inferieur du bin i
-//--
-//++
-// inline float          BinCenter(int i)   const
-//	Retourne l'abscisse du centre du bin i
-//--
-//++
-// inline float          BinHighEdge(int i) const
-//	Retourne l'abscisse du bord superieur du bin i
-//--
-//++
-// inline int            FindBin(float x) const   
-//	Retourne le numero du bin contenant l'abscisse x
-//--
Index: /trunk/SophyaLib/NTools/histos.h
===================================================================
--- /trunk/SophyaLib/NTools/histos.h	(revision 306)
+++ /trunk/SophyaLib/NTools/histos.h	(revision 307)
@@ -1,5 +1,5 @@
 // This may look like C code, but it is really -*- C++ -*-
 //
-// $Id: histos.h,v 1.1.1.1 1999-04-09 17:57:56 ansari Exp $
+// $Id: histos.h,v 1.2 1999-05-19 15:58:00 ansari Exp $
 //
 
@@ -11,16 +11,17 @@
 #include "cvector.h"
 #include "ppersist.h"
+#include "anydataobj.h"
+
+namespace PlanckDPC {
 
 class GeneralFit;
 
-class Histo : public PPersist {
-
+class Histo : public AnyDataObj {
+  friend class FIO_Histo;
 public:
-  enum {classId = ClassId_Histo1D };
 
   // CREATOR / DESTRUCTOR
   Histo();
   Histo(float xMin, float xMax, int nBin=100);
-  Histo(char *flnm);
   Histo(const Histo& H);
   virtual        ~Histo();
@@ -131,6 +132,6 @@
   // Fit
   int    Fit(GeneralFit& gfit,unsigned short typ_err=0);
-  Histo* FitResidus(GeneralFit& gfit);
-  Histo* FitFunction(GeneralFit& gfit);
+  Histo  FitResidus(GeneralFit& gfit);
+  Histo  FitFunction(GeneralFit& gfit);
 
   // Print et Display ASCII
@@ -139,12 +140,4 @@
   void           Print(int dyn = 100, float hmin = 1., float hmax = -1.,
 			int pflag = 0, int il = 1, int ih = -1);
-
-  // PPersist objet
-  int_4             ClassId() const        { return classId; }
-  static PPersist*  Create()               { return new Histo;}
-
-  virtual void      WriteSelf(POutPersist&) const;
-  virtual void      ReadSelf(PInPersist&);
-
 
 protected:
@@ -163,3 +156,23 @@
 };
 
+/////////////////////////////////////////////////////////////////////////
+// Classe pour la gestion de persistance
+class FIO_Histo : public  PPersist  {
+public:
+  FIO_Histo();
+  FIO_Histo(string const & filename); 
+  FIO_Histo(const Histo & obj);
+  FIO_Histo(Histo * obj);
+  virtual ~FIO_Histo();
+  virtual AnyDataObj* DataObj();
+  inline operator Histo() { return(*dobj); }
+protected :
+  virtual void ReadSelf(PInPersist&);           
+  virtual void WriteSelf(POutPersist&) const;  
+  Histo * dobj;
+  bool ownobj;
+};
+
+} // Fin du namespace
+
 #endif // HISTOS_SEEN
Index: /trunk/SophyaLib/NTools/histos2.cc
===================================================================
--- /trunk/SophyaLib/NTools/histos2.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/histos2.cc	(revision 307)
@@ -16,4 +16,6 @@
 #include "generalfit.h"
 
+using namespace PlanckDPC;
+
 //++
 // Class	Histo2D
@@ -132,22 +134,4 @@
 for(int i=0;i<3;i++) for(int j=0;j<3;j++) over[i][j]=0.;
 b_s.H = NULL;
-END_CONSTRUCTOR
-}
-
-//++
-Histo2D::Histo2D(char *flnm)
-//
-//	Constructeur par lecture d'un fichier ppersist.
-//--
-      : data(NULL), err2(NULL)
-      , nHist(0), nEntries(0)
-      , nx(0), ny(0), nxy(0)
-      , xmin(0), xmax(0), ymin(0), ymax(0)
-      , wbinx(0), wbiny(0)
-      , hprojx(NULL), hprojy(NULL)
-{
-b_s.H = NULL;
-PInPersist s(flnm);
-Read(s);
 END_CONSTRUCTOR
 }
@@ -582,5 +566,5 @@
 //--
 {
-if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
+if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
 Histo2D c(a);
 return (c += b);
@@ -592,5 +576,5 @@
 //--
 {
-if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
+if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
 Histo2D c(a);
 return (c -= b);
@@ -602,5 +586,5 @@
 //--
 {
-if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
+if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
 Histo2D c(a);
 return (c *= b);
@@ -612,5 +596,5 @@
 //--
 {
-if (b.nx!=a.nx || b.ny!=a.ny) THROW(sizeMismatchErr);
+if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
 Histo2D c(a);
 return (c /= b);
@@ -1113,19 +1097,21 @@
 
 //++
-Histo2D* Histo2D::FitResidus(GeneralFit& gfit)
+Histo2D Histo2D::FitResidus(GeneralFit& gfit)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
 //--
 {
-if(NBinX()<=0 || NBinY()<=0) return NULL;
+if(NBinX()<=0 || NBinY()<=0)
+  throw(SzMismatchError("Histo2D::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Histo2D::FitResidus: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Histo2D* h2 = new Histo2D(*this);
+Histo2D h2(*this);
 for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
   float xc,yc;
   BinCenter(i,j,xc,yc);
   double x[2] = {(double)xc,(double)yc};
-  (*h2)(i,j) -= (float) f->Value(x,par.Data());
+  h2(i,j) -= (float) f->Value(x,par.Data());
 }
 return h2;
@@ -1133,19 +1119,21 @@
 
 //++
-Histo2D* Histo2D::FitFunction(GeneralFit& gfit)
+Histo2D Histo2D::FitFunction(GeneralFit& gfit)
 //
 //	Retourne une classe contenant la fonction du fit ``gfit''.
 //--
 {
-if(NBinX()<=0 || NBinY()<=0) return NULL;
+if(NBinX()<=0 || NBinY()<=0)
+  throw(SzMismatchError("Histo2D::FitFunction: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Histo2D::FitFunction: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Histo2D* h2 = new Histo2D(*this);
+Histo2D h2(*this);
 for(int i=0;i<NBinX();i++) for(int j=0;j<NBinY();j++) {
   float xc,yc;
   BinCenter(i,j,xc,yc);
   double x[2] = {(double)xc,(double)yc};
-  (*h2)(i,j) = (float) f->Value(x,par.Data());
+  h2(i,j) = (float) f->Value(x,par.Data());
 }
 return h2;
@@ -1792,82 +1780,229 @@
 
 
-///////////////////////////////////////////////////////////////////
-//++
-// Titre	Methodes pour ecriture ppersist
-//--
-
-//++
-void  Histo2D::WriteSelf(POutPersist& s)  const
-//
-//	Ecriture fichier de type ppersist.
-//--
+///////////////////////////////////////////////////////////
+// --------------------------------------------------------
+//   Les objets delegues pour la gestion de persistance 
+// --------------------------------------------------------
+///////////////////////////////////////////////////////////
+
+FIO_Histo2D::FIO_Histo2D()
+{
+dobj=new Histo2D;
+ownobj=true;
+}
+
+FIO_Histo2D::FIO_Histo2D(string const & filename) 
+{
+dobj=new Histo2D;
+ownobj=true; 
+Read(filename);
+}
+
+FIO_Histo2D::FIO_Histo2D(const Histo2D & obj) 
+{ 
+dobj = new Histo2D(obj);
+ownobj=true; 
+}
+
+FIO_Histo2D::FIO_Histo2D(Histo2D * obj) 
+{ 
+dobj = obj;
+ownobj=false; 
+}
+
+FIO_Histo2D::~FIO_Histo2D()
+{
+if (ownobj && dobj) delete dobj;
+}
+
+AnyDataObj* FIO_Histo2D::DataObj()
+{
+return(dobj);
+}
+
+void FIO_Histo2D::ReadSelf(PInPersist& is)
 {
 char strg[256];
-int j;
+
+if(dobj==NULL) dobj=new Histo2D;
+  else         dobj->Delete();
+
 float min,max;
 Histo* h;
+int_4 errok, projx, projy, nslix, nsliy, nbanx, nbany;
+
+// Lecture entete
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+is.GetLine(strg, 255);
+
+// Lecture variables de definitions
+is.Get(dobj->nx);
+is.Get(dobj->ny);
+is.Get(dobj->nxy);
+is.Get(errok);
+is.Get(dobj->nEntries);
+is.Get(dobj->nHist);
+
+is.Get(dobj->xmin);
+is.Get(dobj->xmax);
+is.Get(dobj->ymin);
+is.Get(dobj->ymax);
+is.Get(dobj->wbinx);
+is.Get(dobj->wbiny);
+
+is.Get(&(dobj->over[0][0]),9);
+
+is.Get(projx);
+is.Get(projy);
+is.Get(nslix);
+is.Get(nsliy);
+is.Get(nbanx);
+is.Get(nbany);
+
+// Lecture histo2D
+dobj->data = new float[dobj->nxy];
+is.GetLine(strg, 255);
+{for(int j=0;j<dobj->ny;j++) is.Get(dobj->data+j*dobj->nx,dobj->nx);}
+
+// Lecture erreurs
+if(errok) {
+  is.GetLine(strg, 255);
+  dobj->err2 = new double[dobj->nxy];
+  for(int j=0;j<dobj->ny;j++) is.Get(dobj->err2+j*dobj->nx,dobj->nx);
+}
+
+// Lecture des projections
+if(projx) {
+  is.GetLine(strg, 255);
+  dobj->SetProjX();
+  FIO_Histo fio_h(dobj->hprojx);
+  fio_h.Read(is);
+}
+if(projy) {
+  is.GetLine(strg, 255);
+  dobj->SetProjY();
+  FIO_Histo fio_h(dobj->hprojy);
+  fio_h.Read(is);
+}
+
+// Lecture des slices
+if(nslix>0) {
+  is.GetLine(strg, 255);
+  dobj->SetSliX(nslix);
+  DBASSERT (nslix==dobj->NSliX());
+  for(int j=0;j<dobj->NSliX();j++)
+    {FIO_Histo fio_h(dobj->HSliX(j)); fio_h.Read(is);}
+}
+if(nsliy>0) {
+  is.GetLine(strg, 255);
+  dobj->SetSliY(nsliy);
+  DBASSERT (nsliy==dobj->NSliY());
+  for(int j=0;j<dobj->NSliY();j++)
+    {FIO_Histo fio_h(dobj->HSliY(j)); fio_h.Read(is);}
+}
+
+// Lecture des bandes
+if( nbanx>0 ) {
+  is.GetLine(strg, 255);
+  {for(int j=0; j<nbanx; j++) {
+    is.Get(min); is.Get(max);
+    dobj->SetBandX(min,max);
+  }}
+  DBASSERT (nbanx==dobj->NBandX());
+  {for(int j=0; j<dobj->NBandX(); j++) {
+    FIO_Histo fio_h(dobj->HBandX(j));
+    fio_h.Read(is);
+  }}
+}
+if( nbany>0 ) {
+  is.GetLine(strg, 255);
+  {for(int j=0; j<nbany; j++) {
+    is.Get(min); is.Get(max);
+    dobj->SetBandY(min,max);
+  }}
+  DBASSERT (nbany==dobj->NBandY());
+  {for(int j=0; j<dobj->NBandY(); j++) {
+    FIO_Histo fio_h(dobj->HBandY(j));
+    fio_h.Read(is);
+  }}
+}
+
+return;
+}
+
+void FIO_Histo2D::WriteSelf(POutPersist& os) const
+{
+if (dobj == NULL)   return;
+char strg[256];
 
 // Que faut-il ecrire?
-int_4 errok = (err2) ? 1 : 0;
-int_4 projx = (hprojx) ? 1 : 0;
-int_4 projy = (hprojy) ? 1 : 0;
-int_4 nslix = NSliX();
-int_4 nsliy = NSliY();
-int_4 nbanx = NBandX();
-int_4 nbany = NBandY();
+int_4 errok = (dobj->err2) ? 1 : 0;
+int_4 projx = (dobj->hprojx) ? 1 : 0;
+int_4 projy = (dobj->hprojy) ? 1 : 0;
+int_4 nslix = dobj->NSliX();
+int_4 nsliy = dobj->NSliY();
+int_4 nbanx = dobj->NBandX();
+int_4 nbany = dobj->NBandY();
 
 // Ecriture entete pour identifier facilement
-sprintf(strg,"nx=%d  ny=%d  nxy=%d errok=%1d",nx,ny,nxy,errok);
-s.PutLine(strg);
-sprintf(strg,"nHist=%g nEntries=%d",nHist,nEntries);
-s.PutLine(strg);
-sprintf(strg,"wbinx=%g wbiny=%g",wbinx,wbiny);
-s.PutLine(strg);
-sprintf(strg,"xmin=%g xmax=%g ymin=%g ymax=%g",xmin,xmax,ymin,ymax);
-s.PutLine(strg);
+sprintf(strg,"nx=%d  ny=%d  nxy=%d errok=%1d"
+       ,dobj->nx,dobj->ny,dobj->nxy,errok);
+os.PutLine(strg);
+sprintf(strg,"nHist=%g nEntries=%d",dobj->nHist,dobj->nEntries);
+os.PutLine(strg);
+sprintf(strg,"wbinx=%g wbiny=%g",dobj->wbinx,dobj->wbiny);
+os.PutLine(strg);
+sprintf(strg,"xmin=%g xmax=%g ymin=%g ymax=%g"
+       ,dobj->xmin,dobj->xmax,dobj->ymin,dobj->ymax);
+os.PutLine(strg);
 sprintf(strg,"projx/y=%d %d nbandx/y=%d %d nbslix/y=%d %d"
        ,projx,projy,nbanx,nbany,nslix,nsliy);
-s.PutLine(strg);
+os.PutLine(strg);
 sprintf(strg,"over %g %g %g %g %g %g %g %g %g"
-       ,over[0][0],over[0][1],over[0][2]
-       ,over[1][0],over[1][1],over[1][2]
-       ,over[2][0],over[2][1],over[2][2]);
-s.PutLine(strg);
+       ,dobj->over[0][0],dobj->over[0][1],dobj->over[0][2]
+       ,dobj->over[1][0],dobj->over[1][1],dobj->over[1][2]
+       ,dobj->over[2][0],dobj->over[2][1],dobj->over[2][2]);
+os.PutLine(strg);
 
 // Ecriture variables de definitions
-s.PutI4(nx);
-s.PutI4(ny);
-s.PutI4(nxy);
-s.PutI4(errok);
-s.PutI4(nEntries);
-s.PutR8(nHist);
-
-s.PutR4(xmin);
-s.PutR4(xmax);
-s.PutR4(ymin);
-s.PutR4(ymax);
-s.PutR4(wbinx);
-s.PutR4(wbiny);
-
-s.PutR4s(&over[0][0],9);
-
-s.PutI4(projx);
-s.PutI4(projy);
-s.PutI4(nslix);
-s.PutI4(nsliy);
-s.PutI4(nbanx);
-s.PutI4(nbany);
+os.Put(dobj->nx);
+os.Put(dobj->ny);
+os.Put(dobj->nxy);
+os.Put(errok);
+os.Put(dobj->nEntries);
+os.Put(dobj->nHist);
+
+os.Put(dobj->xmin);
+os.Put(dobj->xmax);
+os.Put(dobj->ymin);
+os.Put(dobj->ymax);
+os.Put(dobj->wbinx);
+os.Put(dobj->wbiny);
+
+os.Put(&(dobj->over[0][0]),9);
+
+os.Put(projx);
+os.Put(projy);
+os.Put(nslix);
+os.Put(nsliy);
+os.Put(nbanx);
+os.Put(nbany);
 
 // Ecriture histo2D
-sprintf(strg,"Histo2D: Tableau des donnees %d = %d * %d",nxy,nx,ny);
-s.PutLine(strg);
-for(j=0;j<ny;j++) s.PutR4s(data+j*nx,nx);
-
+sprintf(strg,"Histo2D: Tableau des donnees %d = %d * %d"
+       ,dobj->nxy,dobj->nx,dobj->ny);
+os.PutLine(strg);
+{for(int j=0;j<dobj->ny;j++) os.Put(dobj->data+j*dobj->nx,dobj->nx);}
 
 // Ecriture erreurs
 if(errok) {
-  sprintf(strg,"Histo2D: Tableau des erreurs %d = %d * %d",nxy,nx,ny);
-  s.PutLine(strg);
-  for(j=0;j<ny;j++) s.PutR8s(err2+j*nx,nx);
+  sprintf(strg,"Histo2D: Tableau des erreurs %d = %d * %d"
+         ,dobj->nxy,dobj->nx,dobj->ny);
+  os.PutLine(strg);
+  for(int j=0;j<dobj->ny;j++) os.Put(dobj->err2+j*dobj->nx,dobj->nx);
 }
 
@@ -1875,11 +2010,11 @@
 if(projx) {
   sprintf(strg,"Histo2D: Projection X");
-  s.PutLine(strg);
-  hprojx->Write(s);
+  os.PutLine(strg);
+  FIO_Histo fio_h(dobj->hprojx); fio_h.Write(os);
 }
 if(projy) {
   sprintf(strg,"Histo2D: Projection Y");
-  s.PutLine(strg);
-  hprojy->Write(s);
+  os.PutLine(strg);
+  FIO_Histo fio_h(dobj->hprojy); fio_h.Write(os);
 }
 
@@ -1887,16 +2022,16 @@
 if(nslix>0) {
   sprintf(strg,"Histo2D: Slices X %d",nslix);
-  s.PutLine(strg);
-  for(j=0;j<nslix;j++) {
-    h = HSliX(j);
-    h->Write(s);
+  os.PutLine(strg);
+  for(int j=0;j<nslix;j++) {
+    Histo* h = dobj->HSliX(j);
+    FIO_Histo fio_h(h); fio_h.Write(os);
   }
 }
 if(nsliy>0) {
   sprintf(strg,"Histo2D: Slices Y %d",nsliy);
-  s.PutLine(strg);
-  for(j=0;j<nsliy;j++) {
-    h = HSliY(j);
-    h->Write(s);
+  os.PutLine(strg);
+  for(int j=0;j<nsliy;j++) {
+    Histo* h = dobj->HSliY(j);
+    FIO_Histo fio_h(h); fio_h.Write(os);
   }
 }
@@ -1905,30 +2040,26 @@
 if( nbanx>0 ) {
   sprintf(strg,"Histo2D: Bandes X %d",nbanx);
-  s.PutLine(strg);
-  list<bande_slice>::const_iterator it;
-  for(it = lbandx.begin(); it != lbandx.end(); it++) {
-    min = (*it).min;
-    max = (*it).max;
-    s.PutR4(min);
-    s.PutR4(max);
-  }
-  for(it = lbandx.begin(); it != lbandx.end(); it++) {
-    h = (*it).H;
-    h->Write(s);
+  os.PutLine(strg);
+  list<Histo2D::bande_slice>::const_iterator it;
+  for(it = dobj->lbandx.begin(); it != dobj->lbandx.end(); it++) {
+    float min = (*it).min; float max = (*it).max;
+    os.Put(min); os.Put(max);
+  }
+  for(it = dobj->lbandx.begin(); it != dobj->lbandx.end(); it++) {
+    Histo* h = (*it).H;
+    FIO_Histo fio_h(h); fio_h.Write(os);
   }
 }
 if( nbany>0 ) {
   sprintf(strg,"Histo2D: Bandes Y %d",nbany);
-  s.PutLine(strg);
-  list<bande_slice>::const_iterator it;
-  for(it = lbandy.begin(); it != lbandy.end(); it++) {
-    min = (*it).min;
-    max = (*it).max;
-    s.PutR4(min);
-    s.PutR4(max);
-  }
-  for(it = lbandy.begin(); it != lbandy.end(); it++) {
-    h = (*it).H;
-    h->Write(s);
+  os.PutLine(strg);
+  list<Histo2D::bande_slice>::const_iterator it;
+  for(it = dobj->lbandy.begin(); it != dobj->lbandy.end(); it++) {
+    float min = (*it).min; float max = (*it).max;
+    os.Put(min); os.Put(max);
+  }
+  for(it = dobj->lbandy.begin(); it != dobj->lbandy.end(); it++) {
+    Histo* h = (*it).H;
+    FIO_Histo fio_h(h); fio_h.Write(os);
   }
 }
@@ -1936,118 +2067,2 @@
 return;
 }
-
-//++
-void  Histo2D::ReadSelf(PInPersist& s)
-//
-//	Lecture fichier de type ppersist.
-//--
-{
-Delete();
-
-int j;
-float min,max;
-Histo* h;
-char strg[256];
-int_4 errok, projx, projy, nslix, nsliy, nbanx, nbany;
-
-// Lecture entete
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-s.GetLine(strg, 255);
-
-
-// Lecture variables de definitions
-s.GetI4(nx);
-s.GetI4(ny);
-s.GetI4(nxy);
-s.GetI4(errok);
-s.GetI4(nEntries);
-s.GetR8(nHist);
-
-s.GetR4(xmin);
-s.GetR4(xmax);
-s.GetR4(ymin);
-s.GetR4(ymax);
-s.GetR4(wbinx);
-s.GetR4(wbiny);
-
-s.GetR4s(&over[0][0],9);
-
-s.GetI4(projx);
-s.GetI4(projy);
-s.GetI4(nslix);
-s.GetI4(nsliy);
-s.GetI4(nbanx);
-s.GetI4(nbany);
-
-// Lecture histo2D
-data = new float[nxy];
-s.GetLine(strg, 255);
-for(j=0;j<ny;j++) s.GetR4s(data+j*nx,nx);
-
-// Lecture erreurs
-if(errok) {
-  s.GetLine(strg, 255);
-  err2 = new double[nxy];
-  for(j=0;j<ny;j++) s.GetR8s(err2+j*nx,nx);
-}
-
-// Lecture des projections
-if(projx) {
-  s.GetLine(strg, 255);
-  SetProjX();
-  hprojx->Read(s);
-}
-if(projy) {
-  s.GetLine(strg, 255);
-  SetProjY();
-  hprojy->Read(s);
-}
-
-// Lecture des slices
-if(nslix>0) {
-  s.GetLine(strg, 255);
-  SetSliX(nslix);
-  DBASSERT (nslix==NSliX());
-  for(j=0;j<NSliX();j++) HSliX(j)->Read(s);
-}
-if(nsliy>0) {
-  s.GetLine(strg, 255);
-  SetSliY(nsliy);
-  DBASSERT (nsliy==NSliY());
-  for(j=0;j<NSliY();j++) HSliY(j)->Read(s);
-}
-
-// Lecture des bandes
-if( nbanx>0 ) {
-  s.GetLine(strg, 255);
-  for( j=0; j<nbanx; j++) {
-    s.GetR4(min);
-    s.GetR4(max);
-    SetBandX(min,max);
-  }
-  DBASSERT (nbanx==NBandX());
-  for( j=0; j<NBandX(); j++) {
-    h = HBandX(j);
-    h->Read(s);
-  }
-}
-if( nbany>0 ) {
-  s.GetLine(strg, 255);
-  for( j=0; j<nbany; j++) {
-    s.GetR4(min);
-    s.GetR4(max);
-    SetBandY(min,max);
-  }
-  DBASSERT (nbany==NBandY());
-  for( j=0; j<NBandY(); j++) {
-    h = HBandY(j);
-    h->Read(s);
-  }
-}
-
-return;
-}
Index: /trunk/SophyaLib/NTools/histos2.h
===================================================================
--- /trunk/SophyaLib/NTools/histos2.h	(revision 306)
+++ /trunk/SophyaLib/NTools/histos2.h	(revision 307)
@@ -15,16 +15,14 @@
 
 #include "peida.h"
+#include "utils.h"
 #include "histos.h"
-#include "utils.h"
-#include "ppersist.h"
-
+
+namespace PlanckDPC {
 
 class GeneralFit;
 
-
-class Histo2D : public PPersist {
-
+class Histo2D : public AnyDataObj {
+  friend class FIO_Histo2D;
 public:
-  enum {classId = ClassId_Histo2D };
 
   // CREATOR / DESTRUCTOR
@@ -33,6 +31,4 @@
   Histo2D(const Histo2D& h);
   Histo2D();
-  Histo2D(char *flnm);
-
   virtual  ~Histo2D();
 
@@ -125,6 +121,6 @@
   // Fit
   int      Fit(GeneralFit& gfit,unsigned short typ_err=0);
-  Histo2D* FitResidus(GeneralFit& gfit);
-  Histo2D* FitFunction(GeneralFit& gfit);
+  Histo2D  FitResidus(GeneralFit& gfit);
+  Histo2D  FitFunction(GeneralFit& gfit);
 
   // Print et Display ASCII
@@ -175,10 +171,4 @@
   void           ShowSli(int lp = 0);
 
-  int_4             ClassId() const        { return classId; }
-  static PPersist*  Create()               { return new Histo2D;}
-
-  virtual void      WriteSelf(POutPersist&) const;
-  virtual void      ReadSelf(PInPersist&);
-
 #ifndef __DECCXX
 protected:
@@ -224,3 +214,23 @@
 };
 
+/////////////////////////////////////////////////////////////////////////
+// Classe pour la gestion de persistance
+class FIO_Histo2D : public  PPersist  {
+public:
+  FIO_Histo2D();
+  FIO_Histo2D(string const & filename); 
+  FIO_Histo2D(const Histo2D & obj);
+  FIO_Histo2D(Histo2D * obj);
+  virtual ~FIO_Histo2D();
+  virtual AnyDataObj* DataObj();
+  inline operator Histo2D() { return(*dobj); }
+protected :
+  virtual void ReadSelf(PInPersist&);           
+  virtual void WriteSelf(POutPersist&) const;  
+  Histo2D * dobj;
+  bool ownobj;
+};
+
+} // Fin du namespace
+
 #endif // HISTOS2_SEEN
Index: /trunk/SophyaLib/NTools/integ.h
===================================================================
--- /trunk/SophyaLib/NTools/integ.h	(revision 306)
+++ /trunk/SophyaLib/NTools/integ.h	(revision 307)
@@ -3,5 +3,5 @@
 // integ.h
 //
-// $Id: integ.h,v 1.2 1999-04-22 16:18:40 ansari Exp $
+// $Id: integ.h,v 1.3 1999-05-19 15:58:01 ansari Exp $
 //
 
@@ -16,5 +16,5 @@
 #endif
 
-class GeneralFunction;
+namespace PlanckDPC {class GeneralFunction;}
 
 class Integrator EXC_AWARE {
Index: /trunk/SophyaLib/NTools/matrix.cc
===================================================================
--- /trunk/SophyaLib/NTools/matrix.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/matrix.cc	(revision 307)
@@ -1,3 +1,3 @@
-// $Id: matrix.cc,v 1.3 1999-05-03 16:55:21 ansari Exp $
+// $Id: matrix.cc,v 1.4 1999-05-19 15:58:02 ansari Exp $
 
 #include "machdefs.h"
@@ -983,18 +983,22 @@
 //////////////////////////////////////////////////////////
 //++
-Matrix* Matrix::FitResidus(GeneralFit& gfit)
+Matrix Matrix::FitResidus(GeneralFit& gfit
+               ,double xorg,double yorg,double dx,double dy)
 //
 //	Retourne une classe contenant les residus du fit ``gfit''.
-//	On suppose que x=j (colonnes) et y=i (lignes) pour m(i,j).
-//--
-{
-if(NCol()<=0||NRows()<=0) return NULL;
+//	Les coordonnees de l'element (i,j) sont :
+//	(i,j) -> x = xorg + j*dx , y = yorg + i*dy
+//--
+{
+if(NCol()<=0||NRows()<=0)
+  throw(SzMismatchError("Matrix::FitResidus: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Matrix::FitResidus: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Matrix* m = new Matrix(*this);
+Matrix m(*this);
 for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
-  double x[2] = {(double)j,(double)i};
-  (*m)(i,j) -= f->Value(x,par.Data());
+  double x[2] = {xorg+j*dx,yorg+i*dy};
+  m(i,j) -= f->Value(x,par.Data());
 }
 return m;
@@ -1002,18 +1006,22 @@
 
 //++
-Matrix* Matrix::FitFunction(GeneralFit& gfit)
+Matrix Matrix::FitFunction(GeneralFit& gfit
+               ,double xorg,double yorg,double dx,double dy)
 //
 //	Retourne une classe contenant la fonction du fit ``gfit''.
-//	On suppose que x=j (colonnes) et y=i (lignes) pour m(i,j).
-//--
-{
-if(NCol()<=0||NRows()<=0) return NULL;
+//	Les coordonnees de l'element (i,j) sont :
+//	(i,j) -> x = xorg + j*dx , y = yorg + i*dy
+//--
+{
+if(NCol()<=0||NRows()<=0)
+  throw(SzMismatchError("Matrix::FitFunction: size mismatch\n"));
 GeneralFunction* f = gfit.GetFunction();
-if(f==NULL) return NULL;
+if(f==NULL)
+  throw(NullPtrError("Matrix::FitFunction: NULL pointer\n"));
 Vector par = gfit.GetParm();
-Matrix* m = new Matrix(*this);
+Matrix m(*this);
 for(int i=0;i<NRows();i++) for(int j=0;j<NCol();j++) {
-  double x[2] = {(double)j,(double)i};
-  (*m)(i,j) = f->Value(x,par.Data());
+  double x[2] = {xorg+j*dx,yorg+i*dy};
+  m(i,j) = f->Value(x,par.Data());
 }
 return m;
Index: /trunk/SophyaLib/NTools/matrix.h
===================================================================
--- /trunk/SophyaLib/NTools/matrix.h	(revision 306)
+++ /trunk/SophyaLib/NTools/matrix.h	(revision 307)
@@ -11,6 +11,8 @@
 #include "ppersist.h"
 
-class GeneralFit;
-namespace PlanckDPC {template <class T> class TMatrix;}
+namespace PlanckDPC {
+  class GeneralFit;
+  template <class T> class TMatrix;
+}
 
 // <summary> Operations matricielles </summary>
@@ -146,6 +148,8 @@
 
   // Residus et fonction fittees.
-  Matrix* FitResidus(GeneralFit& gfit);
-  Matrix* FitFunction(GeneralFit& gfit);
+  Matrix FitResidus(GeneralFit& gfit
+            ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
+  Matrix FitFunction(GeneralFit& gfit
+            ,double xorg=0.,double yorg=0.,double dx=1.,double dy=1.);
 
 protected:
Index: /trunk/SophyaLib/NTools/outilsinit.cc
===================================================================
--- /trunk/SophyaLib/NTools/outilsinit.cc	(revision 306)
+++ /trunk/SophyaLib/NTools/outilsinit.cc	(revision 307)
@@ -35,9 +35,9 @@
   PPRegister(Poly2);
   PPRegister(ObjFileIO<DVList>);
-  PPRegister(Histo);
-  PPRegister(Histo2D);
-  PPRegister(HProf);
+  //PPRegister(Histo);
+  //PPRegister(Histo2D);
+  //PPRegister(HProf);
   PPRegister(NTuple);
-  PPRegister(GeneralFitData);
+  //PPRegister(GeneralFitData);
 
   PPRegister(RzImage);
Index: /trunk/SophyaLib/NTools/rzimage.h
===================================================================
--- /trunk/SophyaLib/NTools/rzimage.h	(revision 306)
+++ /trunk/SophyaLib/NTools/rzimage.h	(revision 307)
@@ -15,5 +15,5 @@
 #include "dvlist.h"
 
-class GeneralFit;
+namespace PlanckDPC {class GeneralFit;}
 
 // Flags de verifications sur les indices 
Index: /trunk/SophyaLib/NTools/tmatrix.h
===================================================================
--- /trunk/SophyaLib/NTools/tmatrix.h	(revision 306)
+++ /trunk/SophyaLib/NTools/tmatrix.h	(revision 307)
@@ -12,8 +12,7 @@
 #include "ndatablock.h"
 
+namespace PlanckDPC {
+
 class GeneralFit;
-
-namespace PlanckDPC {
-
 template <class T> class TVector;
 template <class T> class TMatrixRC;
Index: /trunk/SophyaLib/NTools/tvector.h
===================================================================
--- /trunk/SophyaLib/NTools/tvector.h	(revision 306)
+++ /trunk/SophyaLib/NTools/tvector.h	(revision 307)
@@ -5,7 +5,8 @@
 
 #include "tmatrix.h"
-class GeneralFit;
 
 namespace PlanckDPC {
+
+class GeneralFit;
 
 template <class T>
