Changeset 914 in Sophya


Ignore:
Timestamp:
Apr 13, 2000, 6:04:50 PM (25 years ago)
Author:
ansari
Message:

documentation cmv 13/4/00

Location:
trunk/SophyaLib
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/HiStats/hisprof.cc

    r763 r914  
    66#include "perrors.h"
    77
    8 //++
    9 // Class        HProf
    10 // Lib  Outils++
    11 // include      hisprof.h
    12 //
    13 //      Classe de profil d'histogrammes.
    14 //--
    15 
    16 //++
    17 // Titre        Constructeurs
    18 //--
    19 
    20 /********* Methode *********/
    21 //++
     8
     9/********* Methode *********/
     10/*!
     11  Constructeur par defaut.
     12*/
    2213HProf::HProf()
    23 //
    24 //      Constructeur par defaut.
    25 //--
    2614: Histo()
    2715, SumY(NULL), SumY2(NULL), SumW(NULL), Ok(false), YMin(1.), YMax(-1.), Opt(0)
    … …  
    3119
    3220/********* Methode *********/
    33 //++
     21/*!
     22  Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin''
     23  et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''.
     24  Si yMin>=yMax alors pas de coupure d'acceptance sur y.
     25  Par defaut l'erreur du profil represente la dispersion dans le bin,
     26  SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne.
     27*/
    3428HProf::HProf(float xMin, float xMax, int nBin, float yMin, float yMax)
    35 //
    36 //      Constructeur. Histogramme de profil de ``nBin'' bins entre ``xMin''
    37 //      et ``xMax'' avec coupure d'acceptance sur y entre ``yMin'' et ``yMax''.
    38 //      Si yMin>=yMax alors pas de coupure d'acceptance sur y.
    39 //      Par defaut l'erreur du profil represente la dispersion dans le bin,
    40 //      SetErrOpt(1) permet de demander de calculer l'erreur sur la moyenne.
    41 //--
    4229: Histo(xMin,xMax,nBin)
    4330, SumY(new double[nBin]), SumY2(new double[nBin]), SumW(new double[nBin])
    … …  
    5037
    5138/********* Methode *********/
    52 //++
     39/*!
     40  Constructeur par copie.
     41*/
    5342HProf::HProf(const HProf& H)
    54 //
    55 //      Constructeur par copie.
    56 //--
    5743: Histo(H)
    5844, SumY(new double[H.bins]), SumY2(new double[H.bins]), SumW(new double[H.bins])
    … …  
    6652
    6753/********* Methode *********/
     54/*!
     55  Des-allocation
     56*/
    6857void HProf::Delete()
    6958{
    … …  
    7564
    7665/********* Methode *********/
     66/*!
     67  Destructeur
     68*/
    7769HProf::~HProf()
    7870{
    … …  
    8072}
    8173
    82 //++
    83 // Titre        Methodes
    84 //--
    85 
    86 /********* Methode *********/
    87 //++
     74/********* Methode *********/
     75/*!
     76  Remise a zero
     77*/
    8878void HProf::Zero()
    89 //
    90 //      Remise a zero
    91 //--
    9279{
    9380  memset(SumY,  0, bins*sizeof(double));
    … …  
    9986
    10087/********* Methode *********/
    101 //++
     88/*!
     89  Pour changer l'option de calcul de l'erreur du profile.
     90  Si ``spread'' = true alors l'erreur represente la dispersion
     91  des donnees dans le bin, si = false elle represente l'erreur
     92  sur la moyenne du bin.
     93  \verbatim
     94    - Pour le bin (j):
     95    H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w)
     96    ->  s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2)  dispersion
     97    ->  e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne
     98    spread=true:  opt=0 : dispersion des donnees dans le bin = s(j)
     99    spread=false: opt=1 : erreur sur la moyenne du bin = e(j)
     100  \endverbatim
     101*/
    102102void HProf::SetErrOpt(bool spread)
    103 //
    104 //      Pour changer l'option de calcul de l'erreur du profile.
    105 //      Si ``spread'' = true alors l'erreur represente la dispersion
    106 //      des donnees dans le bin, si = false elle represente l'erreur
    107 //      sur la moyenne du bin.
    108 //| - Pour le bin (j):
    109 //| H(j) = sum(y), E(j) = sum(y^2), L(j) = sum(w)
    110 //| ->  s(j) = sqrt(E(j)/L(j) - (H(j)/L(j))^2)  dispersion
    111 //| ->  e(j) = s(j)/sqrt(L(j)) erreur sur la moyenne
    112 //| spread=true:  opt=0 : dispersion des donnees dans le bin = s(j)
    113 //| spread=false: opt=1 : erreur sur la moyenne du bin = e(j)
    114 //--
    115103{
    116104int opt = (spread) ? 0 : 1;
    … …  
    119107
    120108/********* Methode *********/
    121 //++
     109/*!
     110  Pour mettre a jour l'histogramme de profil.
     111  Il est important d'appeler cette methode si on veut
     112  utiliser les methodes de la classe Histo qui ne sont
     113  pas redefinies dans la classe HProf.
     114  En effet, pour des raisons de precision la classe
     115  HProf travaille avec des tableaux en double precision
     116  et seulement au moment ou l'on a besoin de l'histogramme
     117  ce dernier est rempli avec les valeurs demandees (moyenne
     118  et dispersion/erreur sur la moyenne).
     119*/
    122120void HProf::UpdateHisto() const
    123 //
    124 //      Pour mettre a jour l'histogramme de profil.
    125 //      Il est important d'appeler cette methode si on veut
    126 //      utiliser les methodes de la classe Histo qui ne sont
    127 //      pas redefinies dans la classe HProf.
    128 //      En effet, pour des raisons de precision la classe
    129 //      HProf travaille avec des tableaux en double precision
    130 //      et seulement au moment ou l'on a besoin de l'histogramme
    131 //      ce dernier est rempli avec les valeurs demandees (moyenne
    132 //      et dispersion/erreur sur la moyenne).
    133 //--
    134121{
    135122
    … …  
    153140
    154141/********* Methode *********/
    155 //++
     142/*!
     143  Addition au contenu de l'histo pour abscisse x de la valeur y et poids w
     144*/
    156145void HProf::Add(float x, float y, float w)
    157 //
    158 //      Addition au contenu de l'histo pour abscisse x de la valeur y et poids w
    159 //--
    160146{
    161147  if(YMax>YMin && (y<YMin || YMax<y)) return;
    … …  
    174160
    175161/********* Methode *********/
    176 //++
     162/*!
     163  Addition au contenu de l'histo bin numBin de la valeur y poids w
     164*/
    177165void HProf::AddBin(int numBin, float y, float w)
    178 //
    179 //      Addition au contenu de l'histo bin numBin de la valeur y poids w
    180 //--
    181166{
    182167  if(YMax>YMin && (y<YMin || YMax<y)) return;
    … …  
    194179
    195180/********* Methode *********/
    196 //++
     181/*!
     182  Operateur H = H1
     183*/
    197184HProf& HProf::operator = (const HProf& h)
    198 //
    199 //--
    200185{
    201186if(this == &h) return *this;
    … …  
    218203
    219204/********* Methode *********/
    220 //++
     205/*!
     206  Operateur H += H1
     207
     208  Attention dans cette addition il n'y a pas de gestion
     209  des YMin et YMax. L'addition est faite meme si les limites
     210  en Y de ``a'' sont differentes de celles de ``this''.
     211*/
    221212HProf& HProf::operator += (const HProf& a)
    222 //
    223 //      Attention dans cette addition il n'y a pas de gestion
    224 //      des YMin et YMax. L'addition est faite meme si les limites
    225 //      en Y de ``a'' sont differentes de celles de ``this''.
    226 //--
    227213{
    228214if(bins!=a.bins) THROW(sizeMismatchErr);
    … …  
    240226
    241227/********* Methode *********/
    242 //++
     228/*!
     229  Operateur H = H1 + H2
     230  Meme commentaire que pour l'operateur +=
     231*/
    243232HProf operator + (const HProf& a, const HProf& b)
    244 //
    245 //      Meme commentaire que pour l'operateur +=
    246 //--
    247233{
    248234if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
    … …  
    250236return (c += b);
    251237}
    252 
    253 // Rappel des inlines functions pour commentaires
    254 //++
    255 //   inline Histo GetHisto()
    256 //      Retourne l'histogramme de profil.
    257 //--
    258 //++
    259 // inline void GetMean(Vector& v)
    260 //      Retourne le contenu de la moyenne dans le vecteur v
    261 //--
    262 //++
    263 // inline void GetError2(Vector& v)
    264 //      Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
    265 //--
    266 //++
    267 // inline float operator()(int i) const
    268 //      Retourne le contenu du bin i
    269 //--
    270 //++
    271 // inline float Error2(int i) const
    272 //      Retourne le carre de la dispersion/erreur du bin i
    273 //--
    274 //++
    275 // inline float Error(int i) const
    276 //      Retourne la dispersion/erreur du bin i
    277 //--
    278 //++
    279 // inline int Fit(GeneralFit& gfit)
    280 //      Fit du profile par ``gfit''.
    281 //--
    282 //++
    283 // inline Histo* FitResidus(GeneralFit& gfit)
    284 //      Retourne l'Histogramme des residus par ``gfit''.
    285 //--
    286 //++
    287 // inline Histo* FitFunction(GeneralFit& gfit)
    288 //      Retourne l'Histogramme de la fonction fittee par ``gfit''.
    289 //--
    290 //++
    291 // inline void Print(int dyn,float hmin,float hmax,int pflag,int il,int ih)
    292 //      Print, voir detail dans Histo::Print
    293 //--
    294 
    295238
    296239///////////////////////////////////////////////////////////

  • trunk/SophyaLib/HiStats/hisprof.h

    r763 r914  
    1010namespace SOPHYA {
    1111
     12/*!
     13  Classe de profil d'histogrammes.
     14*/
    1215class HProf : public Histo {
    1316  friend class ObjFileIO<HProf>;
    … …  
    2831 
    2932  // Acces a l information
     33  //! Retourne l'histogramme de profil.
    3034  inline Histo GetHisto() {if(!Ok) UpdateHisto(); return (Histo) *this;}
     35  //! Retourne le contenu de la moyenne dans le vecteur v
    3136  inline void GetMean(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetValue(v);}
     37  //! Retourne le contenu au carre de la dispersion/erreur dans le vecteur v
    3238  inline void GetError2(Vector& v) {if(!Ok) UpdateHisto(); Histo::GetError2(v);}
     39  //! Retourne le contenu du bin i
    3340  inline float operator()(int i) const {if(!Ok) UpdateHisto(); return data[i];}
     41  //! Retourne le carre de la dispersion/erreur du bin i
    3442  inline float Error2(int i) const {if(!Ok) UpdateHisto(); return (float) err2[i];}
     43  //! Retourne la dispersion/erreur du bin i
    3544  inline float Error(int i) const
    3645         {if(!Ok) UpdateHisto(); return err2[i]>0. ? (float) sqrt(err2[i]) : 0.f;}
    … …  
    4251
    4352  // Fit
     53  //! Fit du profile par ``gfit''.
    4454  inline int    Fit(GeneralFit& gfit)
    4555         {if(!Ok) UpdateHisto(); return Histo::Fit(gfit,0);}
     56  //! Retourne l'Histogramme des residus par ``gfit''.
    4657  inline Histo  FitResidus(GeneralFit& gfit)
    4758         {if(!Ok) UpdateHisto(); return Histo::FitResidus(gfit);}
     59  //! Retourne l'Histogramme de la fonction fittee par ``gfit''.
    4860  inline Histo  FitFunction(GeneralFit& gfit)
    4961         {if(!Ok) UpdateHisto(); return Histo::FitFunction(gfit);}
    5062
    5163  // Print
     64  //! Print, voir detail dans Histo::Print
    5265  inline void Print(int dyn=100,float hmin=1.,float hmax=-1.,int pflag=0,int il=1,int ih=-1)
    5366                           {if(!Ok) UpdateHisto(); Histo::Print(dyn,hmin,hmax,pflag,il,ih);}
    … …  
    5669  void Delete();
    5770
    58   double*        SumY;
    59   double*        SumY2;
    60   double*        SumW;
    61   bool           Ok;
    62   float          YMin;
    63   float          YMax;
    64   uint_2         Opt;
     71  double*        SumY;  //!< somme
     72  double*        SumY2; //!< somme des carres
     73  double*        SumW;  //!< somme des poids
     74  bool           Ok;    //!< true isiupdate fait
     75  float          YMin;  //!< limite minimum Y pour somme
     76  float          YMax;  //!< limite maximum Y pour somme
     77  uint_2         Opt;   //!< options pour les erreurs
    6578};
    6679

  • trunk/SophyaLib/HiStats/histos.cc

    r763 r914  
    11//
    2 // $Id: histos.cc,v 1.1.1.1 2000-03-02 16:51:32 ansari Exp $
     2// $Id: histos.cc,v 1.2 2000-04-13 16:04:11 ansari Exp $
    33//
    44
    … …  
    1313#include "generalfit.h"
    1414
    15 //++
    16 // Class        Histo
    17 // Lib  Outils++
    18 // include      histos.h
    19 //
    20 //      Classe d'histogrammes 1D
    21 //--
    22 
    23 //++
    24 // Titre        Constructeurs
    25 //--
    26 
    27 /********* Methode *********/
    28 //++
     15/********* Methode *********/
     16/*! Constructeur par defaut */
    2917Histo::Histo()
    30 //
    31 //--
    3218: data(NULL), err2(NULL),
    3319  under(0), over(0), nHist(0), nEntries(0),
    … …  
    3925
    4026/********* Methode *********/
    41 //++
     27/*! Constructeur d'un histo de nBin bins allant de xMin a xMax */
    4228Histo::Histo(float xMin, float xMax, int nBin)
    43 //
    44 //--
    4529: data(new float[nBin]), err2(NULL),
    4630  under(0), over(0), nHist(0), nEntries(0),
    … …  
    5337
    5438/********* Methode *********/
    55 //++
     39/*! Constructeur par copie */
    5640Histo::Histo(const Histo& H)
    57 //
    58 //--
    5941: data(new float[H.bins]), err2(NULL),
    6042  under(H.under), over(H.over), nHist(H.nHist), nEntries(H.nEntries),
    … …  
    7153
    7254/********* Methode *********/
     55/*! Gestion de la des-allocation */
    7356void Histo::Delete()
    7457{
    … …  
    8164
    8265/********* Methode *********/
     66/*! Destructeur */
    8367Histo::~Histo()
    8468{
    … …  
    8670}
    8771
    88 //++
    89 // Titre        Methodes
    90 //--
    91 
    92 /********* Methode *********/
    93 //++
     72/********* Methode *********/
     73/*!
     74  Remise a zero
     75*/
    9476void Histo::Zero()
    95 //
    96 //      Remise a zero
    97 //--
    9877{
    9978  memset(data, 0, bins*sizeof(float));
    … …  
    10584
    10685/********* Methode *********/
    107 //++
     86/*!
     87  Pour avoir le calcul des erreurs
     88*/
    10889void Histo::Errors()
    109 //
    110 //      Pour avoir le calcul des erreurs
    111 //--
    11290{
    11391 if( bins > 0 ) {
    … …  
    11896
    11997/********* Methode *********/
    120 //++
     98/*!
     99  Operateur egal
     100*/
    121101Histo& Histo::operator = (const Histo& h)
    122 //
    123 //--
    124102{
    125103  if(this == &h) return *this;
    … …  
    145123
    146124/********* Methode *********/
    147 //++
     125/*!
     126  Operateur de multiplication par une constante
     127*/
    148128Histo& Histo::operator *= (double b)
    149 //
    150 //--
    151129{
    152130double b2 = b*b;
    … …  
    162140}
    163141
    164 //++
     142/*!
     143  Operateur de division par une constante
     144*/
    165145Histo& Histo::operator /= (double b)
    166 //
    167 //--
    168146{
    169147if (b==0.) THROW(inconsistentErr);
    … …  
    180158}
    181159
    182 //++
     160/*!
     161  Operateur d'addition d'une constante
     162*/
    183163Histo& Histo::operator += (double b)
    184 //
    185 //--
    186164{
    187165for(int i=0;i<bins;i++) data[i] += b;
    … …  
    193171}
    194172
    195 //++
     173/*!
     174  Operateur de soustraction d'une constante
     175*/
    196176Histo& Histo::operator -= (double b)
    197 //
    198 //--
    199177{
    200178for(int i=0;i<bins;i++) data[i] -= b;
    … …  
    207185
    208186/********* Methode *********/
    209 //++
     187/*!
     188  Operateur H2 = H1 * b
     189*/
    210190Histo operator * (const Histo& a, double b)
    211 //
    212 //--
    213191{
    214192  Histo result(a);
    … …  
    216194}
    217195
    218 //++
     196/*!
     197  Operateur H2 = b * H1
     198*/
    219199Histo operator * (double b, const Histo& a)
    220 //
    221 //--
    222200{
    223201  Histo result(a);
    … …  
    225203}
    226204
    227 //++
     205/*!
     206  Operateur H2 = H1 / b
     207*/
    228208Histo operator / (const Histo& a, double b)
    229 //
    230 //--
    231209{
    232210  Histo result(a);
    … …  
    234212}
    235213
    236 //++
     214/*!
     215  Operateur H2 = H1 + b
     216*/
    237217Histo operator + (const Histo& a, double b)
    238 //
    239 //--
    240218{
    241219  Histo result(a);
    … …  
    243221}
    244222
    245 //++
     223/*!
     224  Operateur H2 = b + H1
     225*/
    246226Histo operator + (double b, const Histo& a)
    247 //
    248 //--
    249227{
    250228  Histo result(a);
    … …  
    252230}
    253231
    254 //++
     232/*!
     233  Operateur H2 = H1 - b
     234*/
    255235Histo operator - (const Histo& a, double b)
    256 //
    257 //--
    258236{
    259237  Histo result(a);
    … …  
    261239}
    262240
    263 //++
     241/*!
     242  Operateur H2 = b - H1
     243*/
    264244Histo operator - (double b, const Histo& a)
    265 //
    266 //--
    267245{
    268246  Histo result(a);
    … …  
    272250
    273251/********* Methode *********/
    274 //++
     252/*!
     253  Operateur H += H1
     254*/
    275255Histo& Histo::operator += (const Histo& a)
    276 //
    277 //--
    278256{
    279257if(bins!=a.bins) THROW(sizeMismatchErr);
    … …  
    291269}
    292270
    293 //++
     271/*!
     272  Operateur H -= H1
     273*/
    294274Histo& Histo::operator -= (const Histo& a)
    295 //
    296 //--
    297275{
    298276if(bins!=a.bins) THROW(sizeMismatchErr);
    … …  
    310288}
    311289
    312 //++
     290/*!
     291  Operateur H *= H1
     292*/
    313293Histo& Histo::operator *= (const Histo& a)
    314 //
    315 //--
    316294{
    317295if(bins!=a.bins) THROW(sizeMismatchErr);
    … …  
    331309}
    332310
    333 //++
     311/*!
     312  Operateur H /= H1
     313*/
    334314Histo& Histo::operator /= (const Histo& a)
    335 //
    336 //--
    337315{
    338316if(bins!=a.bins) THROW(sizeMismatchErr);
    … …  
    359337
    360338/********* Methode *********/
    361 //++
     339/*!
     340  Operateur H = H1 + H2
     341*/
    362342Histo operator + (const Histo& a, const Histo& b)
    363 //
    364 //--
    365343{
    366344if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
    … …  
    369347}
    370348
    371 //++
     349/*!
     350  Operateur H = H1 - H2
     351*/
    372352Histo operator - (const Histo& a, const Histo& b)
    373 //
    374 //--
    375353{
    376354if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
    … …  
    379357}
    380358
    381 //++
     359/*!
     360  Operateur H = H1 * H2
     361*/
    382362Histo operator * (const Histo& a, const Histo& b)
    383 //
    384 //--
    385363{
    386364if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
    … …  
    389367}
    390368
    391 //++
     369/*!
     370  Operateur H = H1 / H2
     371*/
    392372Histo operator / (const Histo& a, const Histo& b)
    393 //
    394 //--
    395373{
    396374if (b.NBins()!=a.NBins()) THROW(sizeMismatchErr);
    … …  
    400378
    401379/********* Methode *********/
    402 //++
     380/*!
     381  Remplissage d'un tableau avec la valeur des abscisses
     382*/
    403383void Histo::GetAbsc(Vector &v)
    404 //
    405 //      Remplissage d'un tableau avec la valeur des abscisses
    406 //--
    407384{
    408385v.Realloc(bins);
    … …  
    411388}
    412389
    413 //++
     390/*!
     391  Remplissage d'un tableau avec la valeur du contenu
     392*/
    414393void Histo::GetValue(Vector &v)
    415 //
    416 //      Remplissage d'un tableau avec la valeur du contenu
    417 //--
    418394{
    419395v.Realloc(bins);
    … …  
    422398}
    423399
    424 //++
     400/*!
     401  Remplissage d'un tableau avec la valeur des erreurs au carre
     402*/
    425403void Histo::GetError2(Vector &v)
    426 //
    427 //      Remplissage d'un tableau avec la valeur des erreurs au carre
    428 //--
    429404{
    430405v.Realloc(bins);
    … …  
    434409}
    435410
    436 //++
     411/*!
     412  Remplissage d'un tableau avec la valeur des erreurs
     413*/
    437414void Histo::GetError(Vector &v)
    438 //
    439 //      Remplissage d'un tableau avec la valeur des erreurs
    440 //--
    441415{
    442416v.Realloc(bins);
    … …  
    447421
    448422/********* Methode *********/
    449 //++
     423/*!
     424  Remplissage du contenu de l'histo avec les valeurs d'un vecteur
     425*/
    450426void Histo::PutValue(Vector &v, int ierr)
    451 //
    452 //      Remplissage du contenu de l'histo avec les valeurs d'un vecteur
    453 //--
    454427{
    455428if(v.NElts()<bins) THROW(sizeMismatchErr);
    … …  
    461434}
    462435
    463 //++
     436/*!
     437  Addition du contenu de l'histo avec les valeurs d'un vecteur
     438*/
    464439void Histo::PutValueAdd(Vector &v, int ierr)
    465 //
    466 //      Addition du contenu de l'histo avec les valeurs d'un vecteur
    467 //--
    468440{
    469441if(v.NElts()<bins) THROW(sizeMismatchErr);
    … …  
    475447}
    476448
    477 //++
     449/*!
     450  Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
     451*/
    478452void Histo::PutError2(Vector &v)
    479 //
    480 //      Remplissage des erreurs au carre de l'histo avec les valeurs d'un vecteur
    481 //--
    482453{
    483454if(v.NElts()<bins) THROW(sizeMismatchErr);
    … …  
    487458}
    488459
    489 //++
     460/*!
     461  Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
     462*/
    490463void Histo::PutError2Add(Vector &v)
    491 //
    492 //      Addition des erreurs au carre de l'histo avec les valeurs d'un vecteur
    493 //--
    494464{
    495465if(v.NElts()<bins) THROW(sizeMismatchErr);
    … …  
    499469}
    500470
    501 //++
     471/*!
     472  Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
     473*/
    502474void Histo::PutError(Vector &v)
    503 //
    504 //      Remplissage des erreurs de l'histo avec les valeurs d'un vecteur
    505 //--
    506475{
    507476if(v.NElts()<bins) THROW(sizeMismatchErr);
    … …  
    513482
    514483/********* Methode *********/
    515 //++
     484/*!
     485  Addition du contenu de l'histo pour abscisse x poids w
     486*/
    516487void Histo::Add(float x, float w)
    517 //
    518 //      Addition du contenu de l'histo pour abscisse x poids w
    519 //--
    520488{
    521489  int numBin = FindBin(x);
    … …  
    531499
    532500/********* Methode *********/
    533 //++
     501/*!
     502  Addition du contenu de l'histo bin numBin poids w
     503*/
    534504void Histo::AddBin(int numBin, float w)
    535 //
    536 //      Addition du contenu de l'histo bin numBin poids w
    537 //--
    538505{
    539506  if (numBin<0) under += w;
    … …  
    548515
    549516/********* Methode *********/
    550 //++
     517/*!
     518  Remplissage du contenu de l'histo pour abscisse x poids w
     519*/
    551520void Histo::SetBin(float x, float w)
    552 //
    553 //      Remplissage du contenu de l'histo pour abscisse x poids w
    554 //--
    555521{
    556522  int numBin = FindBin(x);
    … …  
    559525
    560526/********* Methode *********/
    561 //++
     527/*!
     528  Remplissage du contenu de l'histo pour numBin poids w
     529*/
    562530void Histo::SetBin(int numBin, float w)
    563 //
    564 //      Remplissage du contenu de l'histo pour numBin poids w
    565 //--
    566531{
    567532  if (numBin<0) under = w;
    … …  
    575540
    576541/********* Methode *********/
    577 //++
     542/*!
     543  Remplissage des erreurs au carre pour abscisse x
     544*/
    578545void Histo::SetErr2(float x, double e2)
    579 //
    580 //      Remplissage des erreurs au carre pour abscisse x
    581 //--
    582546{
    583547  int numBin = FindBin(x);
    … …  
    586550
    587551/********* Methode *********/
    588 //++
     552/*!
     553  Remplissage des erreurs au carre pour numBin poids
     554*/
    589555void Histo::SetErr2(int numBin, double e2)
    590 //
    591 //      Remplissage des erreurs au carre pour numBin poids
    592 //--
    593556{
    594557  if( err2==NULL) return;
    … …  
    598561
    599562/********* Methode *********/
    600 //++
     563/*!
     564  Remplissage des erreurs pour abscisse x
     565*/
    601566void Histo::SetErr(float x, float e)
    602 //
    603 //      Remplissage des erreurs pour abscisse x
    604 //--
    605567{
    606568SetErr2(x, (double) e*e);
    … …  
    608570
    609571/********* Methode *********/
    610 //++
     572/*!
     573  Remplissage des erreurs pour numBin
     574*/
    611575void Histo::SetErr(int numBin, float e)
    612 //
    613 //      Remplissage des erreurs pour numBin
    614 //--
    615576{
    616577SetErr2(numBin, (double) e*e);
    … …  
    618579
    619580/********* Methode *********/
    620 //++
     581/*!
     582  Numero du bin ayant le contenu maximum
     583*/
    621584int Histo::IMax() const
    622 //
    623 //      Numero du bin ayant le contenu maximum
    624 //--
    625585{
    626586  int imx=0;
    … …  
    633593
    634594/********* Methode *********/
    635 //++
     595/*!
     596  Numero du bin ayant le contenu minimum
     597*/
    636598int Histo::IMin() const
    637 //
    638 //      Numero du bin ayant le contenu minimum
    639 //--
    640599{
    641600  int imx=0;
    … …  
    648607
    649608/********* Methode *********/
    650 //++
     609/*!
     610  Valeur le contenu maximum
     611*/
    651612float Histo::VMax() const
    652 //
    653 //      Valeur le contenu maximum
    654 //--
    655613{
    656614  float mx=data[0];
    … …  
    661619
    662620/********* Methode *********/
    663 //++
     621/*!
     622  Valeur le contenu minimum
     623*/
    664624float Histo::VMin() const
    665 //
    666 //      Valeur le contenu minimum
    667 //--
    668625{
    669626  float mx=data[0];
    … …  
    674631
    675632/********* Methode *********/
    676 //++
     633/*!
     634  Valeur moyenne
     635*/
    677636float Histo::Mean() const
    678 //
    679 //      Valeur moyenne
    680 //--
    681637{
    682638  double n = 0;
    … …  
    691647
    692648/********* Methode *********/
    693 //++
     649/*!
     650  Valeur du sigma
     651*/
    694652float Histo::Sigma() const
    695 //
    696 //      Valeur du sigma
    697 //--
    698653{
    699654  double n = 0;
    … …  
    714669
    715670/********* Methode *********/
    716 //++
     671/*!
     672  Valeur de la moyenne calculee entre les bin il et ih
     673*/
    717674float Histo::MeanLH(int il,int ih) const
    718 //
    719 //      Valeur de la moyenne calculee entre les bin il et ih
    720 //--
    721675{
    722676  if( ih < il ) { il = 0; ih = bins-1; }
    … …  
    734688
    735689/********* Methode *********/
    736 //++
     690/*!
     691  Valeur de la moyenne calculee entre les bin il et ih
     692*/
    737693float Histo::SigmaLH(int il,int ih) const
    738 //
    739 //      Valeur de la moyenne calculee entre les bin il et ih
    740 //--
    741694{
    742695  if( ih < il ) { il = 0; ih = bins - 1; }
    … …  
    759712
    760713/********* Methode *********/
    761 //++
     714/*!
     715  Valeur de la moyenne calculee entre x0-dx et x0+dx
     716*/
    762717float Histo::Mean(float x0, float dx) const
    763 //
    764 //      Valeur de la moyenne calculee entre x0-dx et x0+dx
    765 //--
    766718{
    767719  double sdata = 0;
    … …  
    780732
    781733/********* Methode *********/
    782 //++
     734/*!
     735  Valeur du sigma calcule entre x0-dx et x0+dx
     736*/
    783737float Histo::Sigma(float x0, float dx) const
    784 //
    785 //      Valeur du sigma calcule entre x0-dx et x0+dx
    786 //--
    787738{
    788739  double sx = 0;
    … …  
    804755
    805756/********* Methode *********/
    806 //++
     757/*!
     758  Valeur de la moyenne et du sigma nettoyes
     759*/
    807760float Histo::CleanedMean(float& sigma) const
    808 //
    809 //      Valeur de la moyenne et du sigma nettoyes
    810 //--
    811761{
    812762  if (!nHist) return 0;
    … …  
    825775
    826776/********* Methode *********/
    827 //++
     777/*!
     778  Valeur de la moyenne nettoyee
     779*/
    828780float Histo::CleanedMean() const
    829 //
    830 //      Valeur de la moyenne nettoyee
    831 //--
    832781{
    833782  if (!nHist) return 0;
    … …  
    837786
    838787/********* Methode *********/
    839 //++
     788/*!
     789  Retourne le nombre de bins non-nul
     790*/
    840791int Histo::BinNonNul() const
    841 //
    842 //      Retourne le nombre de bins non-nul
    843 //--
    844792{
    845793int non=0;
    … …  
    849797
    850798/********* Methode *********/
    851 //++
     799/*!
     800  Retourne le nombre de bins ayant une erreur non-nulle
     801*/
    852802int Histo::ErrNonNul() const
    853 //
    854 //      Retourne le nombre de bins ayant une erreur non-nulle
    855 //--
    856803{
    857804if(err2==NULL) return -1;
    … …  
    862809
    863810/********* Methode *********/
    864 //++
     811/*!
     812  Renvoie le numero de bin tel que il y ait "per" pourcent entrees
     813  entre le bin 0 et ce bin (y compris le contenu de ce bin).
     814*/
    865815int Histo::BinPercent(float per) const
    866 //
    867 //      Renvoie le numero de bin tel que il y ait "per" pourcent entrees
    868 //      entre le bin 0 et ce bin (y compris le contenu de ce bin).
    869 //--
    870816{
    871817double n = nHist*per;
    … …  
    881827
    882828/********* Methode *********/
    883 //++
     829/*!
     830  Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
     831  \verbatim
     832       notons I = bin contenant l'abscisse x
     833              N1 = nombre d'entrees entre bin 0 et I compris
     834              N2 = nombre d'entrees entre bin I et bins-1 compris
     835       imin = bin tel que nombre d'entrees entre imin et I = N1 * per
     836       imax = bin tel que nombre d'entrees entre I et imax = N2 * per
     837     Return: <0 si echec
     838             min(I-imin,imax-I) si ok
     839  \endverbatim
     840*/
    884841int Histo::BinPercent(float x,float per,int& imin,int& imax)
    885 //
    886 //      Renvoie les numeros de bins imin,imax (0=<i<bins) tels que:
    887 //|    notons I = bin contenant l'abscisse x
    888 //|           N1 = nombre d'entrees entre bin 0 et I compris
    889 //|           N2 = nombre d'entrees entre bin I et bins-1 compris
    890 //|    imin = bin tel que nombre d'entrees entre imin et I = N1 * per
    891 //|    imax = bin tel que nombre d'entrees entre I et imax = N2 * per
    892 //|  Return: <0 si echec
    893 //|          min(I-imin,imax-I) si ok
    894 //--
    895842{
    896843imin = imax = -1;
    … …  
    917864
    918865/********* Methode *********/
    919 //++
     866/*!
     867  Idem precedent mais renvoie xmin et xmax
     868*/
    920869int Histo::BinPercent(float x,float per,float& xmin,float& xmax)
    921 //
    922 //      Idem precedent mais renvoie xmin et xmax
    923 //--
    924870{
    925871xmin = xmax = 0.;
    … …  
    931877
    932878/********* Methode *********/
    933 //++
     879/*!
     880  Remplace l'histogramme par son integrale normalise a norm:
     881  si norm <= 0 : pas de normalisation, integration seule
     882*/
    934883void Histo::HInteg(float norm)
    935 //
    936 //      Remplace l'histogramme par son integrale normalise a norm:
    937 //      si norm <= 0 : pas de normalisation, integration seule
    938 //--
    939884{
    940885if(bins>1)
    … …  
    952897
    953898/********* Methode *********/
    954 //++
     899/*!
     900  Remplace l'histogramme par sa derivee
     901*/
    955902void Histo::HDeriv()
    956 //
    957 //      Remplace l'histogramme par sa derivee
    958 //--
    959903{
    960904if( bins <= 1 ) return;
    … …  
    970914
    971915/********* Methode *********/
    972 //++
     916/*!
     917  Pour rebinner l'histogramme sur nbinew bins
     918*/
    973919void Histo::HRebin(int nbinew)
    974 //
    975 //      Pour rebinner l'histogramme sur nbinew bins
    976 //--
    977920{
    978921  if( nbinew <= 0 ) return;
    … …  
    1023966
    1024967/********* Methode *********/
    1025 //++
     968/*!
     969  Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
     970  et sa position (imax), ainsi que la valeur du second maximum
     971  local (maxn) et sa position (imaxn).
     972  Attention: si un maximum a la meme valeur sur plusieurs bins
     973  consecutifs, le bin le plus a droite est pris.
     974*/
    1026975int Histo::MaxiLocal(float& maxi,int& imax,float& maxn,int& imaxn)
    1027 //
    1028 //      Retourne le nombre de maxima locaux, la valeur du maximum (maxi)
    1029 //      et sa position (imax), ainsi que la valeur du second maximum
    1030 //      local (maxn) et sa position (imaxn).
    1031 //      Attention: si un maximum a la meme valeur sur plusieurs bins
    1032 //      consecutifs, le bin le plus a droite est pris.
    1033 //--
    1034976{
    1035977int nml = 0;
    … …  
    10641006
    10651007/********* Methode *********/
    1066 //++
     1008/*!
     1009  Fit de la position du maximum de l'histo par un polynome
     1010  de degre `degree' a `frac' pourcent du maximum.
     1011  L'histo est suppose etre remplit de valeurs positives
     1012*/
    10671013float Histo::FitMax(int degree, float frac, int debug) const
    1068 //
    1069 //      Fit de la position du maximum de l'histo par un polynome
    1070 //      de degre `degree' a `frac' pourcent du maximum.
    1071 //      L'histo est suppose etre remplit de valeurs positives
    1072 //--
    10731014{
    10741015  if (degree < 2 || degree > 3) degree = 3;
    … …  
    12001141
    12011142/********* Methode *********/
    1202 //++
     1143/*!
     1144  Calcul de la largeur a frac pourcent du maximum
     1145  autour du bin du maximum.
     1146  L'histo est suppose etre remplit de valeurs positives
     1147*/
    12031148float Histo::FindWidth(float frac, int debug) const
    1204 //
    1205 //      Calcul de la largeur a frac pourcent du maximum
    1206 //      autour du bin du maximum.
    1207 //      L'histo est suppose etre remplit de valeurs positives
    1208 //--
    12091149{
    12101150  float xmax = BinCenter( IMax() );
    … …  
    12131153
    12141154/********* Methode *********/
    1215 //++
     1155/*!
     1156  Calcul de la largeur a frac pourcent de la valeur du bin xmax.
     1157  L'histo est suppose etre remplit de valeurs positives
     1158*/
    12161159float Histo::FindWidth(float xmax,float frac, int debug) const
    1217 //
    1218 //      Calcul de la largeur a frac pourcent de la valeur du bin xmax.
    1219 //      L'histo est suppose etre remplit de valeurs positives
    1220 //--
    12211160{
    12221161  if (frac <= 0 || frac >= 1.) frac = 0.5;
    … …  
    12921231
    12931232/********* Methode *********/
    1294 //++
     1233/*!
     1234  Cf suivant mais im est le bin du maximum de l'histo
     1235*/
    12951236int Histo::EstimeMax(float& xm,int SzPav)
    1296 //
    1297 //      Cf suivant mais im est le bin du maximum de l'histo
    1298 //--
    12991237{
    13001238int im = IMax();
    … …  
    13031241
    13041242/********* Methode *********/
    1305 //++
     1243/*!
     1244  Determine l'abscisses du maximum donne par im
     1245  en moyennant dans un pave SzPav  autour du maximum
     1246  \verbatim
     1247     Return:
     1248        0 = si fit maximum reussi avec SzPav pixels
     1249        1 = si fit maximum reussi avec moins que SzPav pixels
     1250        2 = si fit maximum echoue et renvoit BinCenter()
     1251       -1 = si echec: SzPav <= 0 ou im hors limites
     1252  \endverbatim
     1253*/
    13061254int Histo::EstimeMax(int& im,float& xm,int SzPav)
    1307 //
    1308 //      Determine l'abscisses du maximum donne par im
    1309 //      en moyennant dans un pave SzPav  autour du maximum
    1310 //|  Return:
    1311 //|     0 = si fit maximum reussi avec SzPav pixels
    1312 //|     1 = si fit maximum reussi avec moins que SzPav pixels
    1313 //|     2 = si fit maximum echoue et renvoit BinCenter()
    1314 //|    -1 = si echec: SzPav <= 0 ou im hors limites
    1315 //--
    13161255{
    13171256xm = 0;
    … …  
    13411280
    13421281/********* Methode *********/
    1343 //++
     1282/*!
     1283  Determine la largeur a frac% du maximum a gauche (widthG)
     1284  et a droite (widthD)
     1285*/
    13441286void Histo::EstimeWidthS(float frac,float& widthG,float& widthD)
    1345 //
    1346 //      Determine la largeur a frac% du maximum a gauche (widthG)
    1347 //      et a droite (widthD)
    1348 //--
    13491287{
    13501288int i;
    … …  
    13851323
    13861324//////////////////////////////////////////////////////////
    1387 //++
     1325/*!
     1326  Fit de l'histogramme par ``gfit''.
     1327  \verbatim
     1328    typ_err = 0 :
     1329       - erreur attachee au bin si elle existe
     1330       - sinon 1
     1331    typ_err = 1 :
     1332       - erreur attachee au bin si elle existe
     1333       - sinon max( sqrt(abs(bin) ,1 )
     1334    typ_err = 2 :
     1335       - erreur forcee a 1
     1336    typ_err = 3 :
     1337       - erreur forcee a max( sqrt(abs(bin) ,1 )
     1338    typ_err = 4 :
     1339       - erreur forcee a 1, nulle si bin a zero.
     1340    typ_err = 5 :
     1341       - erreur forcee a max( sqrt(abs(bin) ,1 ),
     1342         nulle si bin a zero.
     1343  \endverbatim
     1344*/
    13881345int  Histo::Fit(GeneralFit& gfit,unsigned short typ_err)
    1389 //
    1390 //      Fit de l'histogramme par ``gfit''.
    1391 //| typ_err = 0 :
    1392 //|    - erreur attachee au bin si elle existe
    1393 //|    - sinon 1
    1394 //| typ_err = 1 :
    1395 //|    - erreur attachee au bin si elle existe
    1396 //|    - sinon max( sqrt(abs(bin) ,1 )
    1397 //| typ_err = 2 :
    1398 //|    - erreur forcee a 1
    1399 //| typ_err = 3 :
    1400 //|    - erreur forcee a max( sqrt(abs(bin) ,1 )
    1401 //| typ_err = 4 :
    1402 //|    - erreur forcee a 1, nulle si bin a zero.
    1403 //| typ_err = 5 :
    1404 //|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
    1405 //|      nulle si bin a zero.
    1406 //--
    14071346{
    14081347if(NBins()<=0) return -1000;
    … …  
    14301369}
    14311370
    1432 //++
     1371/*!
     1372  Retourne une classe contenant les residus du fit ``gfit''.
     1373*/
    14331374Histo Histo::FitResidus(GeneralFit& gfit)
    1434 //
    1435 //      Retourne une classe contenant les residus du fit ``gfit''.
    1436 //--
    14371375{
    14381376if(NBins()<=0)
    … …  
    14501388}
    14511389
    1452 //++
     1390/*!
     1391  Retourne une classe contenant la fonction du fit ``gfit''.
     1392*/
    14531393Histo Histo::FitFunction(GeneralFit& gfit)
    1454 //
    1455 //      Retourne une classe contenant la fonction du fit ``gfit''.
    1456 //--
    14571394{
    14581395if(NBins()<=0)
    … …  
    14711408
    14721409/********* Methode *********/
    1473 //++
     1410/*!
     1411  Impression de l'histogramme dans le fichier fp
     1412  \verbatim
     1413      hdyn = nombre de colonnes pour imprimer les etoiles
     1414          si =0 alors defaut(100),
     1415          si <0 pas de print histo seulement infos
     1416      hmin = minimum de la dynamique
     1417      hmax = maximum de la dynamique
     1418          si hmax<=hmin           : hmin=VMin() hmax=VMax()
     1419          si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
     1420          sinon : hmin hmax
     1421      pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
     1422            = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
     1423            bit 0 on : (v=1): numero_bin "... ..."
     1424            bit 1 on : (v=2): "... ..." erreur
     1425  \endverbatim
     1426*/
    14741427void Histo::PrintF(FILE * fp, int hdyn,float hmin, float hmax,int pflag,
    14751428              int il, int ih)
    1476 //
    1477 //      Impression de l'histogramme dans le fichier fp
    1478 //|   hdyn = nombre de colonnes pour imprimer les etoiles
    1479 //|       si =0 alors defaut(100),
    1480 //|       si <0 pas de print histo seulement infos
    1481 //|   hmin = minimum de la dynamique
    1482 //|   hmax = maximum de la dynamique
    1483 //|       si hmax<=hmin           : hmin=VMin() hmax=VMax()
    1484 //|       si hmax<=hmin et hmin=0 : hmin=0 hmax=VMax()
    1485 //|       sinon : hmin hmax
    1486 //|   pflag < 0 : on imprime les informations (nbin,min,...) sans l'histogramme
    1487 //|         = 0 : on imprime  "BinCenter(i) data[i]"  (note "... ...")
    1488 //|         bit 0 on : (v=1): numero_bin "... ..."
    1489 //|         bit 1 on : (v=2): "... ..." erreur
    1490 //--
    14911429{
    14921430
    … …  
    16421580
    16431581/********* Methode *********/
    1644 //++
     1582/*!
     1583  Impression de l'histogramme sur stdout
     1584*/
    16451585void Histo::Print(int hdyn,float hmin, float hmax,int pflag,
    16461586             int il, int ih)
    1647 //
    1648 //      Impression de l'histogramme sur stdout
    1649 //--
    16501587{
    16511588 Histo::PrintF(stdout, hdyn, hmin, hmax, pflag, il, ih);
    16521589}
    1653 
    1654 
    1655 // Rappel des inlines functions pour commentaires
    1656 //++
    1657 // inline float          XMin() const
    1658 //      Retourne l'abscisse minimum
    1659 //--
    1660 //++
    1661 // inline float          XMax() const
    1662 //      Retourne l'abscisse maximum
    1663 //--
    1664 //++
    1665 // inline int            NBins() const
    1666 //      Retourne le nombre de bins
    1667 //--
    1668 //++
    1669 // inline float          BinWidth() const
    1670 //      Retourne la largeur du bin
    1671 //--
    1672 //++
    1673 // inline float*         Bins() const
    1674 //      Retourne le pointeur sur le tableaux des contenus
    1675 //--
    1676 //++
    1677 // inline float          operator()(int i) const
    1678 //      Retourne le contenu du bin i
    1679 //--
    1680 //++
    1681 // inline float&         operator()(int i)
    1682 //      Remplit le contenu du bin i
    1683 //--
    1684 //++
    1685 // inline float          Error(int i) const
    1686 //      Retourne l'erreur du bin i
    1687 //--
    1688 //++
    1689 // inline double         Error2(int i) const
    1690 //      Retourne l'erreur au carre du bin i
    1691 //--
    1692 //++
    1693 // inline double&        Error2(int i)
    1694 //      Remplit l'erreur au carre du bin i
    1695 //--
    1696 //++
    1697 // inline float          NData() const
    1698 //      Retourne la somme ponderee
    1699 //--
    1700 //++
    1701 // inline float          NEntries()
    1702 //      Retourne le nombre d'entrees
    1703 //--
    1704 //++
    1705 // inline float          NOver() const
    1706 //      Retourne le nombre d'overflow
    1707 //--
    1708 //++
    1709 // inline float          NUnder() const
    1710 //      Retourne le nombre d'underflow
    1711 //--
    1712 //++
    1713 // inline float          BinLowEdge(int i)  const
    1714 //      Retourne l'abscisse du bord inferieur du bin i
    1715 //--
    1716 //++
    1717 // inline float          BinCenter(int i)   const
    1718 //      Retourne l'abscisse du centre du bin i
    1719 //--
    1720 //++
    1721 // inline float          BinHighEdge(int i) const
    1722 //      Retourne l'abscisse du bord superieur du bin i
    1723 //--
    1724 //++
    1725 // inline int            FindBin(float x) const   
    1726 //      Retourne le numero du bin contenant l'abscisse x
    1727 //--
    17281590
    17291591

  • trunk/SophyaLib/HiStats/histos.h

    r763 r914  
    11// This may look like C code, but it is really -*- C++ -*-
    22//
    3 // $Id: histos.h,v 1.1.1.1 2000-03-02 16:51:32 ansari Exp $
     3// $Id: histos.h,v 1.2 2000-04-13 16:04:11 ansari Exp $
    44//
    55
    … …  
    1919class GeneralFit;
    2020
     21
     22/*!
     23  Classe d'histogrammes 1D
     24*/
    2125class Histo : public AnyDataObj {
    2226  friend class ObjFileIO<Histo>;
    … …  
    7781
    7882  // INLINES
     83  //! Retourne l'abscisse minimum
    7984  inline float          XMin() const             {return min;}
     85  //! Retourne l'abscisse maximum
    8086  inline float          XMax() const             {return max;}
     87  //! Retourne le nombre de bins
    8188  inline int_4          NBins() const            {return bins;}
     89  //! Retourne la largeur du bin
    8290  inline float          BinWidth() const         {return binWidth;}
     91  //! Retourne le pointeur sur le tableaux des contenus
    8392  inline float*         Bins() const             {return data;}
     93  //! Retourne le contenu du bin i
    8494  inline float          operator()(int i) const  {return data[i];}
     95  //! Remplit le contenu du bin i
    8596  inline float&         operator()(int i)        {return data[i];}
     97  //! retourne "true" si il y a des erreurs stoquees
    8698  inline bool           HasErrors() { if(err2) return true; else return false;}
     99  //! Retourne l'erreur du bin i
    87100  inline float          Error(int i) const
    88101                          {if(err2) {if(err2[i]>0.) return sqrt(err2[i]); else return 0.;}
    89102                           else return 0.;}
     103  //! Retourne l'erreur au carre du bin i
    90104  inline double         Error2(int i) const
    91105                          {if(err2) return err2[i]; else return 0.;}
     106  //! Remplit l'erreur au carre du bin i
    92107  inline double&        Error2(int i) {return err2[i];}
     108  //! Retourne la somme ponderee
    93109  inline float          NData() const            {return (float) nHist;}
     110  //! Retourne le nombre d'entrees
    94111  inline float          NEntries() const         {return nEntries;}
     112  //! Retourne le nombre d'overflow
    95113  inline float          NOver() const            {return over;}
     114  //! Retourne le nombre d'underflow
    96115  inline float          NUnder() const           {return under;}
    97116
     117  //! Retourne l'abscisse du bord inferieur du bin i
    98118  inline float          BinLowEdge(int i)  const {return min + i*binWidth;}
     119  //! Retourne l'abscisse du centre du bin i
    99120  inline float          BinCenter(int i)   const {return min + (i+0.5)*binWidth;}
     121  //! Retourne l'abscisse du bord superieur du bin i
    100122  inline float          BinHighEdge(int i) const {return min + (i+1)*binWidth;}
     123  //! Retourne le numero du bin contenant l'abscisse x
    101124  inline int_4          FindBin(float x) const   
    102125                            {return (int_4) floorf((x - min) / binWidth);}
    … …  
    146169  void Delete();
    147170
    148   float*         data;           
    149   double*        err2;           
    150   float          under;
    151   float          over;
    152   double         nHist;
    153   int_4          nEntries;
    154   int_4          bins;
    155   float          min;
    156   float          max;
    157   float          binWidth;
     171  float*         data;     //!< donnees
     172  double*        err2;     //!< erreurs carrees
     173  float          under;    //!< underflow
     174  float          over;     //!< overflow
     175  double         nHist;    //!< somme ponderee des entrees
     176  int_4          nEntries; //!< nombre d'entrees
     177  int_4          bins;     //!< nombre de bins
     178  float          min;      //!< abscisse minimum
     179  float          max;      //!< abscisse maximum
     180  float          binWidth; //!< largeur du bin
    158181};
    159182

  • trunk/SophyaLib/HiStats/histos2.cc

    r763 r914  
    1616#include "generalfit.h"
    1717
    18 //++
    19 // Class        Histo2D
    20 // Lib  Outils++
    21 // include      histos2.h
    22 //
    23 //      Classe d'histogrammes 2D
    24 //--
    25 
    26 ///////////////////////////////////////////////////////////////////
    27 //++
    28 // Titre        Constructeurs
    29 //--
    30 
    31 //++
     18///////////////////////////////////////////////////////////////////
     19/*!
     20  Createur d'un histogramme 2D ayant nxBin,nyBin bins
     21  entre xMin,xMax et yMin,yMax.
     22*/
    3223Histo2D::Histo2D(float xMin, float xMax, int nxBin
    3324                ,float yMin, float yMax, int nyBin)
    34 //
    35 //      Createur d'un histogramme 2D ayant nxBin,nyBin bins
    36 //      entre xMin,xMax et yMin,yMax.
    37 //--
    3825      : data(new float[nxBin*nyBin]), err2(NULL)
    3926      , nHist(0), nEntries(0)
    … …  
    5037}
    5138
    52 //++
     39/*!
     40  Constructeur par copie.
     41*/
    5342Histo2D::Histo2D(const Histo2D& h)
    54 //
    55 //      Constructeur par copie.
    56 //--
    5743{
    5844int i,j;
    … …  
    118104}
    119105
    120 //++
     106/*!
     107  Constructeur par defaut.
     108*/
    121109Histo2D::Histo2D()
    122 //
    123 //      Constructeur par defaut.
    124 //--
    125110      : data(NULL), err2(NULL)
    126111      , nHist(0), nEntries(0)
    … …  
    136121
    137122///////////////////////////////////////////////////////////////////
    138 //++
     123/*!
     124  Desallocation de la place de l'histogramme (fct privee).
     125*/
    139126void Histo2D::Delete()
    140 //
    141 //      Desallocation de la place de l'histogramme (fct privee).
    142 //--
    143127{
    144128  if( data != NULL ) { delete[] data; data = NULL;}
    … …  
    163147}
    164148
    165 //++
     149/*!
     150  Destructeur.
     151*/
    166152Histo2D::~Histo2D()
    167 //
    168 //      Destructeur.
    169 //--
    170153{
    171154Delete();
    … …  
    173156
    174157///////////////////////////////////////////////////////////////////
    175 //++
    176 // Titre        Methodes generales
    177 //--
    178 
    179 //++
     158/*!
     159  Remise a zero du contenu, des erreurs et des valeurs.
     160*/
    180161void Histo2D::Zero()
    181 //
    182 //      Remise a zero du contenu, des erreurs et des valeurs.
    183 //--
    184162{
    185163  nHist = nEntries = 0;
    … …  
    200178
    201179///////////////////////////////////////////////////////////////////
    202 //++
     180/*!
     181  Pour avoir le calcul des erreurs.
     182*/
    203183void Histo2D::Errors()
    204 //
    205 //      Pour avoir le calcul des erreurs.
    206 //--
    207184{
    208185 if( nxy > 0 ) {
    … …  
    213190
    214191///////////////////////////////////////////////////////////////////
    215 //++
     192/*!
     193  Operateur H2 = H1
     194*/
    216195Histo2D& Histo2D::operator = (const Histo2D& h)
    217 //
    218 //--
    219196{
    220197  int i,j,nb;
    … …  
    286263
    287264///////////////////////////////////////////////////////////////////
    288 //++
     265/*!
     266  Operateur H *= b
     267*/
    289268Histo2D& Histo2D::operator *= (double b)
    290 //
    291 //--
    292269{
    293270int i,j;
    … …  
    310287}
    311288
    312 //++
     289/*!
     290  Operateur H /= b
     291*/
    313292Histo2D& Histo2D::operator /= (double b)
    314 //
    315 //--
    316293{
    317294int i,j;
    … …  
    335312}
    336313
    337 //++
     314/*!
     315  Operateur H += b
     316*/
    338317Histo2D& Histo2D::operator += (double b)
    339 //
    340 //--
    341318{
    342319int i,j;
    … …  
    362339}
    363340
    364 //++
     341/*!
     342  Operateur H -= b
     343*/
    365344Histo2D& Histo2D::operator -= (double b)
    366 //
    367 //--
    368345{
    369346int i,j;
    … …  
    390367
    391368///////////////////////////////////////////////////////////////////
    392 //++
     369/*!
     370  Operateur H2 = H1 * b
     371*/
    393372Histo2D operator * (const Histo2D& a, double b)
    394 //
    395 //--
    396373{
    397374  Histo2D result(a);
    … …  
    399376}
    400377
    401 //++
     378/*!
     379  Operateur H2 = b * H1
     380*/
    402381Histo2D operator * (double b, const Histo2D& a)
    403 //
    404 //--
    405382{
    406383  Histo2D result(a);
    … …  
    408385}
    409386
    410 //++
     387/*!
     388  Operateur H2 = H1 / b
     389*/
    411390Histo2D operator / (const Histo2D& a, double b)
    412 //
    413 //--
    414391{
    415392  Histo2D result(a);
    … …  
    417394}
    418395
    419 //++
     396/*!
     397  Operateur H2 = H1 + b
     398*/
    420399Histo2D operator + (const Histo2D& a, double b)
    421 //
    422 //--
    423400{
    424401  Histo2D result(a);
    … …  
    426403}
    427404
    428 //++
     405/*!
     406  Operateur H2 = b + H1
     407*/
    429408Histo2D operator + (double b, const Histo2D& a)
    430 //
    431 //--
    432409{
    433410  Histo2D result(a);
    … …  
    435412}
    436413
    437 //++
     414/*!
     415  Operateur H2 = H1 - b
     416*/
    438417Histo2D operator - (const Histo2D& a, double b)
    439 //
    440 //--
    441418{
    442419  Histo2D result(a);
    … …  
    444421}
    445422
    446 //++
     423/*!
     424  Operateur H2 = b - H1
     425*/
    447426Histo2D operator - (double b, const Histo2D& a)
    448 //
    449 //--
    450427{
    451428  Histo2D result(a);
    … …  
    455432
    456433///////////////////////////////////////////////////////////////////
    457 //++
     434/*!
     435  Operateur H += H1
     436*/
    458437Histo2D& Histo2D::operator += (const Histo2D& a)
    459 //
    460 //--
    461438{
    462439int i,j;
    … …  
    478455}
    479456
    480 //++
     457/*!
     458  Operateur H -= H1
     459*/
    481460Histo2D& Histo2D::operator -= (const Histo2D& a)
    482 //
    483 //--
    484461{
    485462int i,j;
    … …  
    501478}
    502479
    503 //++
     480/*!
     481  Operateur H *= H1
     482*/
    504483Histo2D& Histo2D::operator *= (const Histo2D& a)
    505 //
    506 //--
    507484{
    508485int i,j;
    … …  
    526503}
    527504
    528 //++
     505/*!
     506  Operateur H /= H1
     507*/
    529508Histo2D& Histo2D::operator /= (const Histo2D& a)
    530 //
    531 //--
    532509{
    533510int i,j;
    … …  
    559536
    560537///////////////////////////////////////////////////////////////////
    561 //++
     538/*!
     539  Operateur H = H1 + H2
     540*/
     541
    562542Histo2D operator + (const Histo2D& a, const Histo2D& b)
    563 //
    564 //--
    565543{
    566544if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    … …  
    569547}
    570548
    571 //++
     549/*!
     550  Operateur H = H1 - H2
     551*/
    572552Histo2D operator - (const Histo2D& a, const Histo2D& b)
    573 //
    574 //--
    575553{
    576554if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    … …  
    579557}
    580558
    581 //++
     559/*!
     560  Operateur H = H1 * H2
     561*/
    582562Histo2D operator * (const Histo2D& a, const Histo2D& b)
    583 //
    584 //--
    585563{
    586564if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    … …  
    589567}
    590568
    591 //++
     569/*!
     570  Operateur H = H1 / H2
     571*/
    592572Histo2D operator / (const Histo2D& a, const Histo2D& b)
    593 //
    594 //--
    595573{
    596574if (b.NBinX()!=a.NBinX() || b.NBinY()!=a.NBinY()) THROW(sizeMismatchErr);
    … …  
    600578
    601579///////////////////////////////////////////////////////////////////
    602 //++
     580/*!
     581  Remplissage d'un tableau avec les valeurs des abscisses.
     582*/
    603583void Histo2D::GetXCoor(Vector &v)
    604 //
    605 //      Remplissage d'un tableau avec les valeurs des abscisses.
    606 //--
    607584{
    608585float x,y;
    … …  
    612589}
    613590
    614 //++
     591/*!
     592  Remplissage d'un tableau avec les valeurs des ordonnees.
     593*/
    615594void Histo2D::GetYCoor(Vector &v)
    616 //
    617 //      Remplissage d'un tableau avec les valeurs des ordonnees.
    618 //--
    619595{
    620596float x,y;
    … …  
    624600}
    625601
    626 //++
    627 //| Remarque sur les indices:
    628 //|  H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
    629 //|  v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
    630 //|  On fait une correspondance directe i<->ii et j<->jj
    631 //|  ce qui, en representation classique des histos2D et des matrices
    632 //|  entraine une inversion x<->y cad une symetrie / diagonale principale
    633 //|  H(0,...)  represente ^         mais v(0,...) represente
    634 //|                       |x.......               |xxxxxxxx|
    635 //|                       |x.......               |........|
    636 //|                       |x.......               |........|
    637 //|                       |x.......               |........|
    638 //|                       |x.......               |........|
    639 //|                       --------->
    640 //|                       colonne no 1            ligne no 1
    641 //--
    642 
    643 //++
     602/*!
     603  Remplissage d'un tableau avec les valeurs du contenu.
     604*/
    644605void Histo2D::GetValue(Matrix &v)
    645 //
    646 //      Remplissage d'un tableau avec les valeurs du contenu.
    647 //--
    648606{
    649607v.Realloc(nx,ny);
    … …  
    653611}
    654612
    655 //++
     613/*!
     614  Remplissage d'un tableau avec les valeurs du carre des erreurs.
     615*/
    656616void Histo2D::GetError2(Matrix &v)
    657 //
    658 //      Remplissage d'un tableau avec les valeurs du carre des erreurs.
    659 //--
    660617{
    661618int i,j;
    … …  
    667624}
    668625
    669 //++
     626/*!
     627  Remplissage d'un tableau avec les valeurs des erreurs.
     628*/
    670629void Histo2D::GetError(Matrix &v)
    671 //
    672 //      Remplissage d'un tableau avec les valeurs des erreurs.
    673 //--
    674630{
    675631int i,j;
    … …  
    682638
    683639///////////////////////////////////////////////////////////////////
    684 //++
     640/*!
     641  Remplissage du contenu de l'histo avec les valeurs d'un tableau.
     642*/
    685643void Histo2D::PutValue(Matrix &v, int ierr)
    686 //
    687 //      Remplissage du contenu de l'histo avec les valeurs d'un tableau.
    688 //--
    689644{
    690645int i,j;
    … …  
    697652}
    698653
    699 //++
     654/*!
     655  Addition du contenu de l'histo avec les valeurs d'un tableau.
     656*/
    700657void Histo2D::PutValueAdd(Matrix &v, int ierr)
    701 //
    702 //      Addition du contenu de l'histo avec les valeurs d'un tableau.
    703 //--
    704658{
    705659int i,j;
    … …  
    712666}
    713667
    714 //++
     668/*!
     669  Remplissage des erreurs au carre de l'histo
     670  avec les valeurs d'un tableau.
     671*/
    715672void Histo2D::PutError2(Matrix &v)
    716 //
    717 //      Remplissage des erreurs au carre de l'histo
    718 //      avec les valeurs d'un tableau.
    719 //--
    720673{
    721674int i,j;
    … …  
    726679}
    727680
    728 //++
     681/*!
     682  Addition des erreurs au carre de l'histo
     683  avec les valeurs d'un tableau.
     684*/
    729685void Histo2D::PutError2Add(Matrix &v)
    730 //
    731 //      Addition des erreurs au carre de l'histo
    732 //      avec les valeurs d'un tableau.
    733 //--
    734686{
    735687int i,j;
    … …  
    741693}
    742694
    743 //++
     695/*!
     696  Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
     697*/
    744698void Histo2D::PutError(Matrix &v)
    745 //
    746 //      Remplissage des erreurs de l'histo avec les valeurs d'un tableau.
    747 //--
    748699{
    749700int i,j;
    … …  
    757708///////////////////////////////////////////////////////////////////
    758709/********* Methode *********/
    759 //++
     710/*!
     711  Addition du contenu de l'histo pour x,y poids w.
     712*/
    760713void Histo2D::Add(float x, float y, float w)
    761 //
    762 //      Addition du contenu de l'histo pour x,y poids w.
    763 //--
    764714{
    765715list<bande_slice>::iterator it;
    … …  
    801751
    802752///////////////////////////////////////////////////////////////////
    803 //++
     753/*!
     754  Recherche du bin du maximum dans le pave [il,ih][jl,jh].
     755*/
    804756void Histo2D::IJMax(int& imax,int& jmax,int il,int ih,int jl,int jh)
    805 //
    806 //      Recherche du bin du maximum dans le pave [il,ih][jl,jh].
    807 //--
    808757{
    809758if( il > ih ) { il = 0; ih = nx-1; }
    … …  
    823772}
    824773
    825 //++
     774/*!
     775  Recherche du bin du minimum dans le pave [il,ih][jl,jh].
     776*/
    826777void Histo2D::IJMin(int& imax,int& jmax,int il,int ih,int jl,int jh)
    827 //
    828 //      Recherche du bin du minimum dans le pave [il,ih][jl,jh].
    829 //--
    830778{
    831779if( il > ih ) { il = 0; ih = nx-1; }
    … …  
    846794
    847795
    848 //++
     796/*!
     797  Recherche du maximum dans le pave [il,ih][jl,jh].
     798*/
    849799float Histo2D::VMax(int il,int ih,int jl,int jh) const
    850 //
    851 //      Recherche du maximum dans le pave [il,ih][jl,jh].
    852 //--
    853800{
    854801if( il > ih ) { il = 0; ih = nx-1; }
    … …  
    867814}
    868815
    869 //++
     816/*!
     817  Recherche du minimum dans le pave [il,ih][jl,jh].
     818*/
    870819float Histo2D::VMin(int il,int ih,int jl,int jh) const
    871 //
    872 //      Recherche du minimum dans le pave [il,ih][jl,jh].
    873 //--
    874820{
    875821if( il > ih ) { il = 0; ih = nx-1; }
    … …  
    889835
    890836///////////////////////////////////////////////////////////////////
    891 //++
     837/*!
     838  Renvoie les under.overflow dans les 8 quadrants.
     839  \verbatim
     840     over[3][3]:        20 | 21 | 22
     841                           |    |
     842                       --------------
     843                           |    |
     844                        10 | 11 | 12        11 = all overflow+underflow
     845                           |    |
     846                       --------------
     847                           |    |
     848                        00 | 01 | 02
     849  \endverbatim
     850*/
    892851float Histo2D::NOver(int i,int j) const
    893 //
    894 //      Renvoie les under.overflow dans les 8 quadrants.
    895 //|  over[3][3]:        20 | 21 | 22
    896 //|                        |    |
    897 //|                    --------------
    898 //|                        |    |
    899 //|                     10 | 11 | 12        11 = all overflow+underflow
    900 //|                        |    |
    901 //|                    --------------
    902 //|                        |    |
    903 //|                     00 | 01 | 02
    904 //--
    905852{
    906853if( i < 0 || i>=3 || j < 0 || j>=3 ) return over[1][1];
    … …  
    910857
    911858///////////////////////////////////////////////////////////////////
    912 //++
     859/*!
     860  Retourne le nombre de bins non-nuls.
     861*/
    913862int Histo2D::BinNonNul() const
    914 //
    915 //      Retourne le nombre de bins non-nuls.
    916 //--
    917863{
    918864int non=0;
    … …  
    921867}
    922868
    923 //++
     869/*!
     870  Retourne le nombre de bins avec erreurs non-nulles.
     871*/
    924872int Histo2D::ErrNonNul() const
    925 //
    926 //      Retourne le nombre de bins avec erreurs non-nulles.
    927 //--
    928873{
    929874if(err2==NULL) return -1;
    … …  
    934879
    935880///////////////////////////////////////////////////////////////////
    936 //++
     881/*!
     882  Idem EstimeMax(int...) mais retourne x,y.
     883*/
    937884int Histo2D::EstimeMax(float& xm,float& ym,int SzPav
    938885                      ,int il,int ih,int jl,int jh)
    939 //
    940 //      Idem EstimeMax(int...) mais retourne x,y.
    941 //--
    942886{
    943887int im,jm;
    … …  
    946890}
    947891
    948 //++
     892/*!
     893  Determine les abscisses et ordonnees du maximum donne par im,jm
     894  en moyennant dans un pave SzPav x SzPav autour du maximum.
     895  \verbatim
     896     Return:
     897       0 = si fit maximum reussi avec SzPav pixels
     898       1 = si fit maximum reussi avec moins que SzPav pixels
     899                                   dans au moins 1 direction
     900       2 = si fit maximum echoue et renvoit BinCenter()
     901      -1 = si echec: SzPav <= 0 ou im,jm hors limites
     902  \endverbatim
     903*/
    949904int Histo2D::EstimeMax(int im,int jm,float& xm,float& ym,int SzPav)
    950 //
    951 //      Determine les abscisses et ordonnees du maximum donne par im,jm
    952 //      en moyennant dans un pave SzPav x SzPav autour du maximum.
    953 //|  Return:
    954 //|    0 = si fit maximum reussi avec SzPav pixels
    955 //|    1 = si fit maximum reussi avec moins que SzPav pixels
    956 //|                                dans au moins 1 direction
    957 //|    2 = si fit maximum echoue et renvoit BinCenter()
    958 //|   -1 = si echec: SzPav <= 0 ou im,jm hors limites
    959 //--
    960905{
    961906xm = ym = 0;
    … …  
    992937}
    993938
    994 //++
     939/*!
     940  Pour trouver le maximum de l'histogramme en tenant compte
     941  des fluctuations.
     942  \verbatim
     943    Methode:
     944    1-/ On recherche le bin maximum MAX de l'histogramme
     945    2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
     946        peuvent etre des pixels maxima.
     947    3-/ On identifie le bin maximum en choissisant le pixel du 2-/
     948        tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
     949    INPUT:
     950     SzPav = taille du pave pour departager
     951     Dz    = tolerance pour identifier tous les pixels "maximum"
     952    OUTPUT:
     953     im,jm = pixel maximum trouve
     954    RETURN:
     955      <0 =  Echec
     956      >0 =  nombre de pixels possibles pour le maximum
     957  \endverbatim
     958*/
    995959int Histo2D::FindMax(int& im,int& jm,int SzPav,float Dz
    996960                    ,int il,int ih,int jl,int jh)
    997 //
    998 //      Pour trouver le maximum de l'histogramme en tenant compte
    999 //      des fluctuations.
    1000 //| Methode:
    1001 //| 1-/ On recherche le bin maximum MAX de l'histogramme
    1002 //| 2-/ On considere que tous les pixels compris entre [MAX-Dz,MAX]
    1003 //|     peuvent etre des pixels maxima.
    1004 //| 3-/ On identifie le bin maximum en choissisant le pixel du 2-/
    1005 //|     tel que la somme des pixels dans un pave SzPav x SzPav soit maximale.
    1006 //| INPUT:
    1007 //|  SzPav = taille du pave pour departager
    1008 //|  Dz    = tolerance pour identifier tous les pixels "maximum"
    1009 //| OUTPUT:
    1010 //|  im,jm = pixel maximum trouve
    1011 //| RETURN:
    1012 //|   <0 =  Echec
    1013 //|   >0 =  nombre de pixels possibles pour le maximum
    1014 //--
    1015961{
    1016962if( il > ih ) { il = 0; ih = nx-1; }
    … …  
    1046992
    1047993//////////////////////////////////////////////////////////
    1048 //++
     994/*!
     995  Fit de l'histogramme par ``gfit''.
     996  \verbatim
     997    typ_err = 0 :
     998       - erreur attachee au bin si elle existe
     999       - sinon 1
     1000    typ_err = 1 :
     1001       - erreur attachee au bin si elle existe
     1002       - sinon max( sqrt(abs(bin) ,1 )
     1003    typ_err = 2 :
     1004       - erreur forcee a 1
     1005    typ_err = 3 :
     1006       - erreur forcee a max( sqrt(abs(bin) ,1 )
     1007    typ_err = 4 :
     1008       - erreur forcee a 1, nulle si bin a zero.
     1009    typ_err = 5 :
     1010       - erreur forcee a max( sqrt(abs(bin) ,1 ),
     1011         nulle si bin a zero.
     1012  \endverbatim
     1013*/
    10491014int  Histo2D::Fit(GeneralFit& gfit,unsigned short typ_err)
    1050 //
    1051 //      Fit de l'histogramme par ``gfit''.
    1052 //| typ_err = 0 :
    1053 //|    - erreur attachee au bin si elle existe
    1054 //|    - sinon 1
    1055 //| typ_err = 1 :
    1056 //|    - erreur attachee au bin si elle existe
    1057 //|    - sinon max( sqrt(abs(bin) ,1 )
    1058 //| typ_err = 2 :
    1059 //|    - erreur forcee a 1
    1060 //| typ_err = 3 :
    1061 //|    - erreur forcee a max( sqrt(abs(bin) ,1 )
    1062 //| typ_err = 4 :
    1063 //|    - erreur forcee a 1, nulle si bin a zero.
    1064 //| typ_err = 5 :
    1065 //|    - erreur forcee a max( sqrt(abs(bin) ,1 ),
    1066 //|      nulle si bin a zero.
    1067 //--
    10681015{
    10691016if(NBinX()*NBinY()<=0) return -1000;
    … …  
    10921039}
    10931040
    1094 //++
     1041/*!
     1042  Retourne une classe contenant les residus du fit ``gfit''.
     1043*/
    10951044Histo2D Histo2D::FitResidus(GeneralFit& gfit)
    1096 //
    1097 //      Retourne une classe contenant les residus du fit ``gfit''.
    1098 //--
    10991045{
    11001046if(NBinX()<=0 || NBinY()<=0)
    … …  
    11141060}
    11151061
    1116 //++
     1062/*!
     1063  Retourne une classe contenant la fonction du fit ``gfit''.
     1064*/
    11171065Histo2D Histo2D::FitFunction(GeneralFit& gfit)
    1118 //
    1119 //      Retourne une classe contenant la fonction du fit ``gfit''.
    1120 //--
    11211066{
    11221067if(NBinX()<=0 || NBinY()<=0)
    … …  
    11371082
    11381083///////////////////////////////////////////////////////////////////
    1139 //++
     1084/*!
     1085  Impression des informations sur l'histogramme.
     1086*/
    11401087void Histo2D::PrintStatus()
    1141 //
    1142 //      Impression des informations sur l'histogramme.
    1143 //--
    11441088{
    11451089printf("~Histo::Print    nHist=%g nEntries=%d\n",nHist,nEntries);
    … …  
    11531097
    11541098///////////////////////////////////////////////////////////////////
    1155 //++
     1099/*!
     1100  Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
     1101  \verbatim
     1102    numero d'index:  00000000001111111111222222222233333
     1103                     01234567890123456789012345678901234
     1104    valeur entiere:  00000000001111111111222222222233333
     1105                     12345678901234567890123456789012345
     1106  \endverbatim
     1107*/
    11561108void Histo2D::Print(float min,float max
    11571109                   ,int il,int ih,int jl,int jh)
    1158 //
    1159 //      Impression de l'histogramme sur stdout entre [il,ih] et [jl,jh].
    1160 //--
    11611110{
    11621111int ns = 35;
    1163 // numero d'index:  00000000001111111111222222222233333
    1164 //                  01234567890123456789012345678901234
    1165 // valeur entiere:  00000000001111111111222222222233333
    1166 //                  12345678901234567890123456789012345
    11671112const char *s =    "+23456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    11681113
    … …  
    12451190}
    12461191
    1247 // Rappel des inline functions pour commentaires
    1248 //++
    1249 // inline float   XMin()
    1250 //      Retourne l'abscisse minimum.
    1251 //--
    1252 //++
    1253 // inline float   XMax()
    1254 //      Retourne l'abscisse maximum.
    1255 //--
    1256 //++
    1257 // inline float   YMin()
    1258 //      Retourne l'ordonnee minimum.
    1259 //--
    1260 //++
    1261 // inline float   YMax()
    1262 //      Retourne l'ordonnee maximum.
    1263 //--
    1264 //++
    1265 // inline int     NBinX()
    1266 //      Retourne le nombre de bins selon X.
    1267 //--
    1268 //++
    1269 // inline int     NBinY()
    1270 //      Retourne le nombre de bins selon Y.
    1271 //--
    1272 //++
    1273 // inline float   WBinX()
    1274 //      Retourne la largeur du bin selon X.
    1275 //--
    1276 //++
    1277 // inline float   WBinY()
    1278 //      Retourne la largeur du bin selon Y.
    1279 //--
    1280 //++
    1281 // inline float*  Bins() const
    1282 //      Retourne le pointeur sur le tableaux des contenus.
    1283 //--
    1284 //++
    1285 // inline float   operator()(int i,int j) const
    1286 //      Retourne le contenu du bin i,j.
    1287 //--
    1288 //++
    1289 // inline float&  operator()(int i,int j)
    1290 //      Remplit le contenu du bin i,j.
    1291 //--
    1292 //++
    1293 // inline float   Error(int i,int j)  const
    1294 //      Retourne l'erreur du bin i,j.
    1295 //--
    1296 //++
    1297 // inline double  Error2(int i,int j) const
    1298 //      Retourne l'erreur au carre du bin i,j.
    1299 //--
    1300 //++
    1301 // inline double& Error2(int i,int j)
    1302 //      Remplit l'erreur au carre du bin i,j.
    1303 //--
    1304 //++
    1305 // inline float   NData() const
    1306 //      Retourne la somme ponderee.
    1307 //--
    1308 //++
    1309 // inline int     NEntries() const
    1310 //      Retourne le nombre d'entrees.
    1311 //--
    1312 //++
    1313 // inline void BinLowEdge(int i,int j,float& x,float& y)
    1314 //      Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
    1315 //--
    1316 //++
    1317 // inline void BinCenter(int i,int j,float& x,float& y)
    1318 //      Retourne l'abscisse et l'ordonnee du centre du bin i,j.
    1319 //--
    1320 //++
    1321 // inline void BinHighEdge(int i,int j,float& x,float& y)
    1322 //      Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
    1323 //--
    1324 //++
    1325 // inline void FindBin(float x,float y,int& i,int& j)
    1326 //      Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
    1327 //--
    1328 
    1329 ///////////////////////////////////////////////////////////////////
    1330 //++
     1192///////////////////////////////////////////////////////////////////
    13311193// Titre        Methodes pour gerer les projections
    1332 //--
    1333 
    1334 //++
     1194
     1195/*!
     1196  Pour creer la projection X.
     1197*/
    13351198void Histo2D::SetProjX()
    1336 //
    1337 //      Pour creer la projection X.
    1338 //--
    13391199{
    13401200if( hprojx != NULL ) DelProjX();
    … …  
    13431203}
    13441204
    1345 //++
     1205/*!
     1206  Pour creer la projection Y.
     1207*/
    13461208void Histo2D::SetProjY()
    1347 //
    1348 //      Pour creer la projection Y.
    1349 //--
    13501209{
    13511210if( hprojy != NULL ) DelProjY();
    … …  
    13541213}
    13551214
    1356 //++
     1215/*!
     1216  Pour creer les projections X et Y.
     1217*/
    13571218void Histo2D::SetProj()
    1358 //
    1359 //      Pour creer les projections X et Y.
    1360 //--
    13611219{
    13621220SetProjX();
    … …  
    13641222}
    13651223
    1366 //++
     1224/*!
     1225  Informations sur les projections.
     1226*/
    13671227void Histo2D::ShowProj()
    1368 //
    1369 //      Informations sur les projections.
    1370 //--
    13711228{
    13721229if( hprojx != NULL ) cout << ">>>> Projection X set : "<< hprojx <<endl;
    … …  
    13761233}
    13771234
    1378 //++
     1235/*!
     1236  Destruction de l'histogramme de la projection selon X.
     1237*/
    13791238void Histo2D::DelProjX()
    1380 //
    1381 //      Destruction de l'histogramme de la projection selon X.
    1382 //--
    13831239{
    13841240if( hprojx == NULL ) return;
    … …  
    13871243}
    13881244
    1389 //++
     1245/*!
     1246  Destruction de l'histogramme de la projection selon X.
     1247*/
    13901248void Histo2D::DelProjY()
    1391 //
    1392 //      Destruction de l'histogramme de la projection selon X.
    1393 //--
    13941249{
    13951250if( hprojy == NULL ) return;
    … …  
    13981253}
    13991254
    1400 //++
     1255/*!
     1256  Destruction des histogrammes des projections selon X et Y.
     1257*/
    14011258void Histo2D::DelProj()
    1402 //
    1403 //      Destruction des histogrammes des projections selon X et Y.
    1404 //--
    14051259{
    14061260DelProjX();
    … …  
    14081262}
    14091263
    1410 //++
     1264/*!
     1265  Remise a zero de la projection selon X.
     1266*/
    14111267void Histo2D::ZeroProjX()
    1412 //
    1413 //      Remise a zero de la projection selon X.
    1414 //--
    14151268{
    14161269if( hprojx == NULL ) return;
    … …  
    14181271}
    14191272
    1420 //++
     1273/*!
     1274  Remise a zero de la projection selon Y.
     1275*/
    14211276void Histo2D::ZeroProjY()
    1422 //
    1423 //      Remise a zero de la projection selon Y.
    1424 //--
    14251277{
    14261278if( hprojy == NULL ) return;
    … …  
    14281280}
    14291281
    1430 //++
     1282/*!
     1283  Remise a zero des projections selon X et Y.
     1284*/
    14311285void Histo2D::ZeroProj()
    1432 //
    1433 //      Remise a zero des projections selon X et Y.
    1434 //--
    14351286{
    14361287ZeroProjX();
    … …  
    14381289}
    14391290
    1440 // Rappel des inline functions pour commentaires
    1441 //++
    1442 // inline Histo*  HProjX()
    1443 //      Retourne le pointeur sur l'histo 1D de la projection selon X.
    1444 //--
    1445 //++
    1446 // inline Histo*  HProjY()
    1447 //      Retourne le pointeur sur l'histo 1D de la projection selon Y.
    1448 //--
    1449 
    1450 ///////////////////////////////////////////////////////////////////
    1451 //++
     1291///////////////////////////////////////////////////////////////////
    14521292// Titre        Methodes pour gerer les bandes
    1453 //--
    1454 
    1455 //++
     1293
     1294/*!
     1295  Pour creer une bande en X entre ybmin et ybmax.
     1296*/
    14561297int Histo2D::SetBandX(float ybmin,float ybmax)
    1457 //
    1458 //      Pour creer une bande en X entre ybmin et ybmax.
    1459 //--
    14601298{
    14611299b_s.num = lbandx.size();
    … …  
    14681306}
    14691307
    1470 //++
     1308/*!
     1309  Pour creer une bande en Y entre xbmin et xbmax.
     1310*/
    14711311int Histo2D::SetBandY(float xbmin,float xbmax)
    1472 //
    1473 //      Pour creer une bande en Y entre xbmin et xbmax.
    1474 //--
    14751312{
    14761313b_s.num = lbandy.size();
    … …  
    14831320}
    14841321
    1485 //++
     1322/*!
     1323  Destruction des histogrammes des bandes selon X.
     1324*/
    14861325void Histo2D::DelBandX()
    1487 //
    1488 //      Destruction des histogrammes des bandes selon X.
    1489 //--
    14901326{
    14911327if( lbandx.size() <= 0 ) return;
    … …  
    14951331}
    14961332
    1497 //++
     1333/*!
     1334  Destruction des histogrammes des bandes selon Y.
     1335*/
    14981336void Histo2D::DelBandY()
    1499 //
    1500 //      Destruction des histogrammes des bandes selon Y.
    1501 //--
    15021337{
    15031338if( lbandy.size() <= 0 ) return;
    … …  
    15071342}
    15081343
    1509 //++
     1344/*!
     1345  Remise a zero des bandes selon X.
     1346*/
    15101347void Histo2D::ZeroBandX()
    1511 //
    1512 //      Remise a zero des bandes selon X.
    1513 //--
    15141348{
    15151349if( lbandx.size() <= 0 ) return;
    … …  
    15191353}
    15201354
    1521 //++
     1355/*!
     1356  Remise a zero des bandes selon Y.
     1357*/
    15221358void Histo2D::ZeroBandY()
    1523 //
    1524 //      Remise a zero des bandes selon Y.
    1525 //--
    15261359{
    15271360if( lbandy.size() <= 0 ) return;
    … …  
    15311364}
    15321365
    1533 //++
     1366/*!
     1367  Retourne un pointeur sur la bande numero `n' selon X.
     1368*/
    15341369Histo* Histo2D::HBandX(int n) const
    1535 //
    1536 //      Retourne un pointeur sur la bande numero `n' selon X.
    1537 //--
    15381370{
    15391371if( lbandx.size() <= 0 || n < 0 || n >= (int) lbandx.size() ) return NULL;
    … …  
    15431375}
    15441376
    1545 //++
     1377/*!
     1378  Retourne un pointeur sur la bande numero `n' selon Y.
     1379*/
    15461380Histo* Histo2D::HBandY(int n) const
    1547 //
    1548 //      Retourne un pointeur sur la bande numero `n' selon Y.
    1549 //--
    15501381{
    15511382if( lbandy.size() <= 0 || n < 0 || n >= (int) lbandy.size() ) return NULL;
    … …  
    15551386}
    15561387
    1557 //++
     1388/*!
     1389  Retourne les limites de la bande numero `n' selon X.
     1390*/
    15581391void Histo2D::GetBandX(int n,float& ybmin,float& ybmax) const
    1559 //
    1560 //      Retourne les limites de la bande numero `n' selon X.
    1561 //--
    15621392{
    15631393ybmin = 0.; ybmax = 0.;
    … …  
    15681398}
    15691399
    1570 //++
     1400/*!
     1401  Retourne les limites de la bande numero `n' selon Y.
     1402*/
    15711403void Histo2D::GetBandY(int n,float& xbmin,float& xbmax) const
    1572 //
    1573 //      Retourne les limites de la bande numero `n' selon Y.
    1574 //--
    15751404{
    15761405xbmin = 0.; xbmax = 0.;
    … …  
    15811410}
    15821411
    1583 //++
     1412/*!
     1413  Informations sur les bandes.
     1414*/
    15841415void Histo2D::ShowBand(int lp)
    1585 //
    1586 //      Informations sur les bandes.
    1587 //--
    15881416{
    15891417  cout << ">>>> Nombre de bande X : " << lbandx.size() << endl;
    … …  
    16081436}
    16091437
    1610 // Rappel des inline functions pour commentaires
    1611 //++
    1612 // inline int     NBandX()
    1613 //      Retourne le nombre de bandes selon X
    1614 //--
    1615 //++
    1616 // inline int     NBandY()
    1617 //      Retourne le nombre de bandes selon Y
    1618 //--
    1619 
    1620 ///////////////////////////////////////////////////////////////////
    1621 //++
    1622 // Titre        Methodes pour gerer les bandes equidistantes
    1623 //--
    1624 
    1625 //++
     1438///////////////////////////////////////////////////////////////////
     1439// Titre  Methodes pour gerer les bandes equidistantes ou slices
     1440
     1441/*!
     1442  Pour creer `nsli' bandes equidistantes selon X.
     1443*/
    16261444int Histo2D::SetSliX(int nsli)
    1627 //
    1628 //      Pour creer `nsli' bandes equidistantes selon X.
    1629 //--
    16301445{
    16311446if( nsli <= 0 ) return -1;
    … …  
    16451460}
    16461461
    1647 //++
     1462/*!
     1463  Pour creer `nsli' bandes equidistantes selon Y.
     1464*/
    16481465int Histo2D::SetSliY(int nsli)
    1649 //
    1650 //      Pour creer `nsli' bandes equidistantes selon Y.
    1651 //--
    16521466{
    16531467if( nsli <= 0 ) return -1;
    … …  
    16671481}
    16681482
    1669 //++
     1483/*!
     1484  Destruction des bandes equidistantes selon X.
     1485*/
    16701486void Histo2D::DelSliX()
    1671 //
    1672 //      Destruction des bandes equidistantes selon X.
    1673 //--
    16741487{
    16751488if( lslix.size() <= 0 ) return;
    … …  
    16791492}
    16801493
    1681 //++
     1494/*!
     1495  Destruction des bandes equidistantes selon Y.
     1496*/
    16821497void Histo2D::DelSliY()
    1683 //
    1684 //      Destruction des bandes equidistantes selon Y.
    1685 //--
    16861498{
    16871499if( lsliy.size() <= 0 ) return;
    … …  
    16911503}
    16921504
    1693 //++
     1505/*!
     1506  Remise a zero des bandes equidistantes selon X.
     1507*/
    16941508void Histo2D::ZeroSliX()
    1695 //
    1696 //      Remise a zero des bandes equidistantes selon X.
    1697 //--
    16981509{
    16991510if( lslix.size() <= 0 ) return;
    … …  
    17031514}
    17041515
    1705 //++
     1516/*!
     1517  Remise a zero des bandes equidistantes selon Y.
     1518*/
    17061519void Histo2D::ZeroSliY()
    1707 //
    1708 //      Remise a zero des bandes equidistantes selon Y.
    1709 //--
    17101520{
    17111521if( lsliy.size() <= 0 ) return;
    … …  
    17151525}
    17161526
    1717 //++
     1527/*!
     1528  Retourne un pointeur sur la bande equidistante numero `n'
     1529  selon X.
     1530*/
    17181531Histo* Histo2D::HSliX(int n) const
    1719 //
    1720 //      Retourne un pointeur sur la bande equidistante numero `n'
    1721 //      selon X.
    1722 //--
    17231532{
    17241533if( lslix.size() <= 0 || n < 0 || n >= (int) lslix.size() ) return NULL;
    … …  
    17281537}
    17291538
    1730 //++
     1539/*!
     1540  Retourne un pointeur sur la bande equidistante numero `n'
     1541  selon Y.
     1542*/
    17311543Histo* Histo2D::HSliY(int n) const
    1732 //
    1733 //      Retourne un pointeur sur la bande equidistante numero `n'
    1734 //      selon Y.
    1735 //--
    17361544{
    17371545if( lsliy.size() <= 0 || n < 0 || n >= (int) lsliy.size() ) return NULL;
    … …  
    17411549}
    17421550
    1743 //++
     1551/*!
     1552  Informations sur les bandes equidistantes.
     1553*/
    17441554void Histo2D::ShowSli(int lp)
    1745 //
    1746 //      Informations sur les bandes equidistantes.
    1747 //--
    17481555{
    17491556list<bande_slice>::iterator i;
    … …  
    17641571  }
    17651572}
    1766 
    1767 // Rappel des inline functions pour commentaires
    1768 //++
    1769 // inline int     NSliX()
    1770 //      Retourne le nombre de slices selon X
    1771 //--
    1772 //++
    1773 // inline int     NSliY()
    1774 //      Retourne le nombre de slices selon Y
    1775 //--
    1776 
    17771573
    17781574///////////////////////////////////////////////////////////

  • trunk/SophyaLib/HiStats/histos2.h

    r763 r914  
    2222class GeneralFit;
    2323
     24
     25/*!
     26  Classe d'histogrammes 2D
     27  \verbatim
     28    Remarque sur les indices:
     29     H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
     30     v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
     31     On fait une correspondance directe i<->ii et j<->jj
     32     ce qui, en representation classique des histos2D et des matrices
     33     entraine une inversion x<->y cad une symetrie / diagonale principale
     34     H(0,...)  represente ^         mais v(0,...) represente
     35                          |x.......               |xxxxxxxx|
     36                          |x.......               |........|
     37                          |x.......               |........|
     38                          |x.......               |........|
     39                          |x.......               |........|
     40                          --------->
     41                          colonne no 1            ligne no 1
     42  \endverbatim
     43*/
    2444class Histo2D : public AnyDataObj {
    2545  friend class ObjFileIO<Histo2D>;
    … …  
    7595
    7696  // INLINES
     97  //! Retourne l'abscisse minimum.
    7798  inline float   XMin() const {return xmin;}
     99  //! Retourne l'abscisse maximum.
    78100  inline float   XMax() const {return xmax;}
     101  //! Retourne l'ordonnee minimum.
    79102  inline float   YMin() const {return ymin;}
     103  //! Retourne l'ordonnee maximum.
    80104  inline float   YMax() const {return ymax;}
     105  //! Retourne le nombre de bins selon X.
    81106  inline int_4   NBinX() const {return nx;}
     107  //! Retourne le nombre de bins selon Y.
    82108  inline int_4   NBinY() const {return ny;}
     109  //! Retourne la largeur du bin selon X.
    83110  inline float   WBinX() const {return wbinx;}
     111  //! Retourne la largeur du bin selon Y.
    84112  inline float   WBinY() const {return wbiny;}
     113  //! Retourne le pointeur sur le tableaux des contenus.
    85114  inline float*  Bins() const  {return data;}
     115  //! Retourne le contenu du bin i,j.
    86116  inline float   operator()(int i,int j) const {return data[j*nx+i];}
     117  //! Remplit le contenu du bin i,j.
    87118  inline float&  operator()(int i,int j)       {return data[j*nx+i];}
     119  //! retourne "true" si il y a des erreurs stoquees
    88120  inline bool    HasErrors() { if(err2) return true; else return false;}
     121  //! Retourne l'erreur du bin i,j.
    89122  inline float   Error(int i,int j)  const
    90123                   {if(err2)
    91124                      {if(err2[j*nx+i]>0.) return sqrt(err2[j*nx+i]); else return 0.;}
    92125                    else return 0.;}
     126  //! Remplit l'erreur au carre du bin i,j.
    93127  inline double  Error2(int i,int j) const
    94128                   {if(err2) return err2[j*nx+i]; else return 0.;}
     129  //! Remplit l'erreur au carre du bin i,j.
    95130  inline double& Error2(int i,int j) {return err2[j*nx+i];}
     131  //! Retourne la somme ponderee.
    96132  inline float   NData() const    {return (float) nHist;}
     133  //! Retourne le nombre d'entrees.
    97134  inline int_4   NEntries() const {return nEntries;}
     135  //! Retourne l'abscisse et l'ordonnee du coin inferieur du bin i,j.
    98136  inline void BinLowEdge(int i,int j,float& x,float& y)
    99137                 {x = xmin + i*wbinx; y = ymin + j*wbiny;}
     138  //! Retourne l'abscisse et l'ordonnee du centre du bin i,j.
    100139  inline void BinCenter(int i,int j,float& x,float& y)
    101140                 {x = xmin + (i+0.5)*wbinx; y = ymin + (j+0.5)*wbiny;}
     141  //! Retourne l'abscisse et l'ordonnee du coin superieur du bin i,j.
    102142  inline void BinHighEdge(int i,int j,float& x,float& y)
    103143                 {x = xmin + (i+1)*wbinx; y = ymin + (j+1)*wbiny;}
     144  //! Retourne les numeros du bin contenant l'abscisse et l'ordonnee x,y.
    104145  inline void FindBin(float x,float y,int& i,int& j)
    105146    { i = (int) floorf((x - xmin)/wbinx); j = (int) floorf((y - ymin)/wbiny);}
    … …  
    139180  void           ZeroProjY();
    140181  void           ZeroProj();
     182  //! Retourne le pointeur sur l'histo 1D de la projection selon X.
    141183  inline Histo*  HProjX() const {return hprojx;}
     184  //! Retourne le pointeur sur l'histo 1D de la projection selon Y.
    142185  inline Histo*  HProjY() const {return hprojy;}
    143186  void           ShowProj();
    144187
    145188  // BANDES
     189  //! Retourne le nombre de bandes selon X
    146190  inline int     NBandX() const {return lbandx.size();}
     191  //! Retourne le nombre de bandes selon Y
    147192  inline int     NBandY() const {return lbandy.size();}
    148193  int            SetBandX(float ybmin,float ybmax);
    … …  
    159204
    160205  // SLICES
     206  //! Retourne le nombre de slices selon X
    161207  inline int     NSliX() const {return lslix.size();}
     208  //! Retourne le nombre de slices selon Y
    162209  inline int     NSliY() const {return lsliy.size();}
    163210  int            SetSliX(int nsli);
    … …  
    174221protected:
    175222#endif
     223  //! structure de definition des bandes
    176224  struct bande_slice {
    177     int num;
    178     float min, max;
    179     Histo* H;
     225    int num;   //!< nombre de bandes
     226    float min; //!< limite minimum pour remplir la bande
     227    float max; //!< limite maximum pour remplir la bande
     228    Histo* H;  //!< pointer sur l Histo 1D de la bande
    180229    STRUCTCOMP(bande_slice)
    181230  };
    … …  
    186235  void Delete();
    187236
    188   float*         data;
    189   double*        err2;
    190 
    191   float          over[3][3];
    192   double         nHist;
    193   int_4          nEntries;
    194 
    195   int_4          nx,ny,nxy;
    196   float          xmin;
    197   float          xmax;
    198   float          ymin;
    199   float          ymax;
    200   float          wbinx;
    201   float          wbiny;
     237  float*         data; //!< donnees
     238  double*        err2; //!< erreurs carrees
     239
     240  float          over[3][3]; //!< overflow table
     241  double         nHist;      //!< somme ponderee des entrees
     242  int_4          nEntries;   //!< nombre d'entrees
     243
     244  int_4          nx;    //!< nombre de bins en X
     245  int_4          ny;    //!< nombre de bins en Y
     246  int_4          nxy;   //!< nombre de bins total
     247  float          xmin;  //!< abscisse minimum
     248  float          xmax;  //!< abscisse maximum
     249  float          ymin;  //!< ordonnee minimum
     250  float          ymax;  //!< ordonnee maximum
     251  float          wbinx; //!< largeur du bin en X
     252  float          wbiny; //!< largeur du bin en Y
    202253
    203254  bande_slice    b_s;
    204255
    205   Histo*         hprojx;
    206   Histo*         hprojy;
    207 
    208   list<bande_slice>  lbandx;
    209   list<bande_slice>  lbandy;
     256  Histo*         hprojx; //!< pointer sur Histo des proj X
     257  Histo*         hprojy; //!< pointer sur Histo des proj Y
     258
     259  list<bande_slice>  lbandx; //!< liste des bandes selon X
     260  list<bande_slice>  lbandy; //!< liste des bandes selon Y
    210261 
    211   list<bande_slice>  lslix;
    212   list<bande_slice>  lsliy;
     262  list<bande_slice>  lslix; //!< liste des slices selon X
     263  list<bande_slice>  lsliy; //!< liste des slices selon Y
    213264
    214265};

  • trunk/SophyaLib/NTools/generaldata.cc

    r514 r914  
    1919//================================================================
    2020
    21 //++
    22 // Class        GeneralFitData
    23 // Lib          Outils++
    24 // include      generaldata.h
    25 //
    26 //      Classe de stoquage de donnees a plusieurs variables avec erreur
    27 //      sur l'ordonnee et sur les abscisses (options).
    28 //|   {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)}
    29 //--
    30 
    31 // Pour memoire, structure du rangement (n=mNVar):
    32 // - Valeur des abscisses mXP (idem pour mErrXP):
    33 //   x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
    34 //   |  1er point  |   |  2sd point  |  ....  | point mNData |
    35 //   Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
    36 // - Valeur de l'ordonnee mF (idem pour mErr et mOK):
    37 //          f                f                      f
    38 //   |  1er point  |  |  2sd point  |  .... | point mNData |
    39 //   Donc point numero I [0,mNData[ : mF[i]
    40 
    41 //////////////////////////////////////////////////////////////////////
    42 //++
     21//////////////////////////////////////////////////////////////////////
     22/*!
     23  Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
     24  ``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
     25  indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
     26*/
    4327GeneralFitData::GeneralFitData(unsigned int nVar, unsigned int ndatalloc, uint_2 errx)
    44 //
    45 //      Constructeur. ``nVar'' represente la dimension de l'espace des abscisses,
    46 //      ``ndatalloc'' le nombre maximum de points et ``errx'' si non nul
    47 //      indique que l'on fournit des erreurs sur les ``nVar'' variables en abscisse.
    48 //--
    4928  : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
    5029  , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
    … …  
    5938}
    6039
    61 //++
     40/*!
     41  Constructeur par copie. Si ``clean'' est ``true''
     42  seules les donnees valides de ``data'' sont copiees.
     43  Si ``clean'' est ``false'' (defaut) toutes les donnees
     44  sont copiees et la taille totale de ``data'' est allouee
     45  meme si elle est plus grande que la taille des donnees stoquees.
     46*/
    6247GeneralFitData::GeneralFitData(const GeneralFitData& data, bool clean)
    63 //
    64 //      Constructeur par copie. Si ``clean'' est ``true''
    65 //      seules les donnees valides de ``data'' sont copiees.
    66 //      Si ``clean'' est ``false'' (defaut) toutes les donnees
    67 //      sont copiees et la taille totale de ``data'' est allouee
    68 //      meme si elle est plus grande que la taille des donnees stoquees.
    69 //--
    7048  : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
    7149  , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
    … …  
    9876}
    9977
    100 //++
     78/*!
     79  Constructeur par defaut.
     80*/
    10181GeneralFitData::GeneralFitData()
    102 //
    103 //      Constructeur par defaut.
    104 //--
    10582  : mNVar(0), mNDataAlloc(0), mNData(0), mNDataGood(0), mOk_EXP(0)
    10683  , mXP(NULL), mErrXP(NULL), mF(NULL), mErr(NULL), mOK(NULL)
    … …  
    11087}
    11188
    112 //++
     89/*!
     90  Destructeur
     91*/
    11392GeneralFitData::~GeneralFitData()
    114 //
    115 //      Destructeur
    116 //--
    11793{
    11894 Delete();
    … …  
    12096
    12197//////////////////////////////////////////////////////////////////////
    122 //++
     98/*!
     99  Pour redefinir la structure de donnees (ou la creer si on a utilise
     100  le createur par defaut). Voir les explications des arguments
     101  dans les commentaires du constructeur. Si ``errx''\<0 alors
     102  la valeur prise est celle definie auparavent.
     103*/
    123104void GeneralFitData::Alloc(unsigned int nVar, unsigned int ndatalloc, int_2 errx)
    124 //
    125 //      Pour redefinir la structure de donnees (ou la creer si on a utilise
    126 //      le createur par defaut). Voir les explications des arguments
    127 //      dans les commentaires du constructeur. Si ``errx''<0 alors
    128 //      la valeur prise est celle definie auparavent.
    129 //--
    130105{
    131106ASSERT( nVar>0 && ndatalloc>0 );
    … …  
    151126
    152127//////////////////////////////////////////////////////////////////////
     128/*!
     129   Gestion des des-allocations
     130*/
    153131void GeneralFitData::Delete()
    154132{
    … …  
    163141
    164142//////////////////////////////////////////////////////////////////////
    165 //++
     143/*!
     144  Remise a zero de la structure pour nouveau remplissage (pas d'arg)
     145  ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
     146  sont sur-ecrites.
     147*/
    166148void GeneralFitData::SetDataPtr(int ptr)
    167 //
    168 //      Remise a zero de la structure pour nouveau remplissage (pas d'arg)
    169 //      ou remise a la position ``ptr'' (si arg). Les donnees apres ``ptr''
    170 //      sont sur-ecrites.
    171 //--
    172149{
    173150 ASSERT(ptr >= 0 && ptr < mNDataAlloc);
    … …  
    179156
    180157//////////////////////////////////////////////////////////////////////
    181 //++
     158/*!
     159  Pour tuer un point
     160*/
    182161void GeneralFitData::KillData(int i)
    183 //
    184 //      Pour tuer un point
    185 //--
    186162{
    187163 ASSERT(i >= 0 && i < mNData);
    … …  
    192168}
    193169
    194 //++
     170/*!
     171  Pour tuer une serie de points
     172*/
    195173void GeneralFitData::KillData(int i1,int i2)
    196 //
    197 //      Pour tuer une serie de points
    198 //--
    199174{
    200175 ASSERT(i1 >= 0 && i1 < mNData);
    … …  
    206181
    207182//////////////////////////////////////////////////////////////////////
    208 //++
     183/*!
     184  Pour re-valider le point numero i ([0,NData]).
     185*/
    209186void GeneralFitData::ValidData(int i)
    210 //
    211 //      Pour re-valider le point numero i ([0,NData]).
    212 //--
    213187{
    214188 ASSERT(i >= 0 && i < mNData);
    … …  
    223197}
    224198
    225 //++
     199/*!
     200  Pour re-valider les points numeros i1 a i2.
     201*/
    226202void GeneralFitData::ValidData(int i1,int i2)
    227 //
    228 //      Pour re-valider les points numeros i1 a i2.
    229 //--
    230203{
    231204 ASSERT(i1 >= 0 && i1 < mNData);
    … …  
    236209}
    237210
    238 //++
     211/*!
     212  Pour re-valider tous les points.
     213*/
    239214void GeneralFitData::ValidData()
    240 //
    241 //      Pour re-valider tous les points.
    242 //--
    243215{
    244216 for(int i=0;i<mNData;i++) ValidData(i);
    … …  
    246218
    247219//////////////////////////////////////////////////////////////////////
    248 //++
     220/*!
     221  Pour redefinir un point a \f$ {x,[errx] ; f,err} \f$
     222*/
    249223void GeneralFitData::RedefineData1(int i,double x,double f,double err,double errx)
    250 //
    251 //      Pour redefinir un point a
    252 //|     {x,[errx] ; f,err}
    253 //--
    254224{
    255225 RedefineData(i,&x,f,err,&errx);
    256226}
    257227
    258 //++
     228/*!
     229  Pour redefinir un point a \f$ {x,[errx], y,[erry] ; f,err} \f$
     230*/
    259231void GeneralFitData::RedefineData2(int i,double x,double y,double f
    260232                                  ,double err,double errx,double erry)
    261 //
    262 //      Pour redefinir un point a
    263 //|     {x,[errx], y,[erry] ; f,err}
    264 //--
    265233{
    266234 double xp[2] = {x,y};
    … …  
    269237}
    270238
    271 //++
     239/*!
     240  Pour redefinir un point a
     241  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$
     242*/
    272243void GeneralFitData::RedefineData(int i,double* xp,double f,double err,double* errxp)
    273 //
    274 //      Pour redefinir un point a
    275 //| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
    276 //--
    277244{
    278245 ASSERT(i>=0 && i<mNData);
    … …  
    300267
    301268//////////////////////////////////////////////////////////////////////
    302 //++
     269/*!
     270  Pour ajouter un point \f$ {x,[errx] ; f,err} \f$
     271*/
    303272void GeneralFitData::AddData1(double x, double f, double err, double errx)
    304 //
    305 //      Pour ajouter un point
    306 //|     {x,[errx] ; f,err}
    307 //--
    308273{
    309274 AddData(&x,f,err,&errx);
    310275}
    311276
    312 //++
     277/*!
     278  Pour ajouter un point \f$ {x,[errx], y,[erry] ; f,err} \f$
     279*/
    313280void GeneralFitData::AddData2(double x, double y, double f
    314281                             , double err, double errx, double erry)
    315 //
    316 //      Pour ajouter un point
    317 //|     {x,[errx], y,[erry] ; f,err}
    318 //--
    319282{
    320283 double xp[2] = {x,y};
    … …  
    323286}
    324287
    325 //++
     288/*!
     289  Pour ajouter un point
     290  \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$
     291*/
    326292void GeneralFitData::AddData(double* xp, double f, double err,double* errxp)
    327 //
    328 //      Pour ajouter un point
    329 //| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
    330 //--
    331293{
    332294 ASSERT(mNData < mNDataAlloc);
    … …  
    351313}
    352314
    353 //++
     315/*!
     316  Pour ajouter un point
     317 \f$ {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err} \f$
     318*/
    354319void GeneralFitData::AddData(float* xp, float f, float err, float* errxp)
    355 //
    356 //      Pour ajouter un point
    357 //| {xp[0],[errxp[0]], xp[1],[errxp[1]], xp[2],[errxp[2]],... ; f,err}
    358 //--
    359320{
    360321 {for(int i=0;i<mNVar;i++) BuffVar[i] = (double) xp[i];}
    … …  
    364325
    365326//////////////////////////////////////////////////////////////////////
    366 //++
     327/*!
     328  Pour remplir la structure de donnees d'un seul coup avec
     329  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
     330*/
    367331void GeneralFitData::SetData1(int nData
    368332            , double* x, double* f, double *err, double *errx)
    369 //
    370 //      Pour remplir la structure de donnees d'un seul coup avec
    371 //|     {x(i),[errx(i)] ; f(i),err(i)}
    372 //--
    373333{
    374334 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    381341}
    382342
    383 //++
     343/*!
     344  Pour remplir la structure de donnees d'un seul coup avec
     345  \f$ {x(i),[errx(i)] ; f(i),err(i)} \f$
     346*/
    384347void GeneralFitData::SetData1(int nData
    385348            , float* x, float* f, float* err, float *errx)
    386 //
    387 //      Pour remplir la structure de donnees d'un seul coup avec
    388 //|     {x(i),[errx(i)] ; f(i),err(i)}
    389 //--
    390349{
    391350 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    398357}
    399358
    400 //++
     359/*!
     360  Pour remplir la structure de donnees d'un seul coup avec
     361  \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
     362*/
    401363void GeneralFitData::SetData2(int nData, double* x, double* y, double* f
    402364                             ,double *err,double *errx,double *erry)
    403 //
    404 //      Pour remplir la structure de donnees d'un seul coup avec
    405 //|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
    406 //--
    407365{
    408366 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    416374}
    417375
    418 //++
     376/*!
     377  Pour remplir la structure de donnees d'un seul coup avec
     378 \f$ {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)} \f$
     379*/
    419380void GeneralFitData::SetData2(int nData, float* x, float* y, float* f
    420381                             ,float *err,float *errx,float *erry)
    421 //
    422 //      Pour remplir la structure de donnees d'un seul coup avec
    423 //|     {x(i),[errx(i)], y(i),[erry(i)], ; f(i),err(i)}
    424 //--
    425382{
    426383 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    434391}
    435392
    436 //++
     393/*!
     394  Pour remplir la structure de donnees d'un seul coup avec
     395  \f$ {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)} \f$
     396
     397  Attention: si la structure est n'est pas vide, les tableaux sont copies
     398  apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
     399  effacer les donnees pre-existantes utiliser SetDataPtr(0).
     400  \verbatim
     401      Ici **xp est un pointeur sur un tableau de pointeurs tq
     402        xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
     403      ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
     404      des variables (meme commentaire pour errxp).
     405  \endverbatim
     406*/
    437407void GeneralFitData::SetData(int nData,double** xp, double *f
    438408                            , double *err, double** errxp)
    439 //
    440 //      Pour remplir la structure de donnees d'un seul coup avec
    441 //|   {X0(i),[EX0(i)], X1(i),[EX1(i)], X2(i),[EX2(i)], ... ; F(i),Err(i)}
    442 //      Attention: si la structure est n'est pas vide, les tableaux sont copies
    443 //      apres les donnees pre-existantes (qui ne sont donc pas detruites). Pour
    444 //      effacer les donnees pre-existantes utiliser SetDataPtr(0).
    445 //|   Ici **xp est un pointeur sur un tableau de pointeurs tq
    446 //|     xp[0] = &X0[0], xp[1] = &X1[0], xp[2] = &X2[0] ...
    447 //|   ou X0,X1,X2,... sont les tableaux X0[nData] X1[nData] X2[nData] ...
    448 //|   des variables (meme commentaire pour errxp).
    449 //--
    450409{
    451410 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    461420}
    462421
    463 //++
     422/*!
     423  Voir commentaire ci-dessus.
     424*/
    464425void GeneralFitData::SetData(int nData,float** xp, float *f
    465426                            , float *err, float** errxp)
    466 //
    467 //      Voir commentaire ci-dessus.
    468 //--
    469427{
    470428 ASSERT(nData>0 && mNData+nData<=mNDataAlloc);
    … …  
    482440
    483441//////////////////////////////////////////////////////////////////////
    484 //++
     442/*!
     443  Impression de l'etat de la structure de donnees
     444*/
    485445void GeneralFitData::PrintStatus()
    486 //
    487 //      Impression de l'etat de la structure de donnees
    488 //--
    489446{
    490447  cout<<"GeneralFitData:: "<<endl
    … …  
    495452}
    496453
    497 //++
     454/*!
     455  Impression du point i
     456*/
    498457void GeneralFitData::PrintData(int i)
    499 //
    500 //      Impression du point i
    501 //--
    502458{
    503459 ASSERT(i>=0 && i<mNData);
    … …  
    512468}
    513469
    514 //++
     470/*!
     471  Impression des points i1 a i2
     472*/
    515473void GeneralFitData::PrintData(int i1,int i2)
    516 //
    517 //      Impression des points i1 a i2
    518 //--
    519474{
    520475 if(i1<0) i1=0;
    … …  
    529484}
    530485
    531 //++
     486/*!
     487  Impression de tous les points
     488*/
    532489void GeneralFitData::PrintData()
    533 //
    534 //      Impression de tous les points
    535 //--
    536490{
    537491 ASSERT(mNData>0);
    … …  
    540494}
    541495
    542 //++
     496/*!
     497  Impression de l'etat de la structure de donnees avec bornes sur "s"
     498*/
    543499void GeneralFitData::Show(ostream& os) const
    544 //
    545 //      Impression de l'etat de la structure de donnees avec bornes sur "s"
    546 //--
    547500{
    548501double min,max;
    … …  
    557510
    558511//////////////////////////////////////////////////////////////////////
    559 //++
     512/*!
     513  Retourne les numeros des points de valeurs minimum et maximum
     514  de la variable ``var'':
     515  \verbatim
     516    La variable "var" est de la forme : var = AB avec
     517     B = 0 : variable d'ordonnee Y (valeur de A indifferente)
     518     B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
     519     B = 2 : variable d'abscisse X numero A #[0,NVar[
     520     B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
     521    - Return NData checked si ok, -1 si probleme.
     522  \endverbatim
     523*/
    560524int GeneralFitData::GetMnMx(int var,int& imin,int& imax) const
    561 //
    562 //      Retourne les numeros des points de valeurs minimum et maximum
    563 //      de la variable ``var'':
    564 //| La variable "var" est de la forme : var = AB avec
    565 //|  B = 0 : variable d'ordonnee Y (valeur de A indifferente)
    566 //|  B = 1 : erreur variable d'ordonnee EY (valeur de A indifferente)
    567 //|  B = 2 : variable d'abscisse X numero A #[0,NVar[
    568 //|  B = 3 : erreur variable d'abscisse EX numero A #[0,NVar[
    569 //| - Return NData checked si ok, -1 si probleme.
    570 //--
    571525{
    572526imin = imax = -1;
    … …  
    592546}
    593547
    594 //++
     548/*!
     549  Retourne le minimum et le maximum de la variable ``var''
     550  (cf commentaires GetMnMx).
     551*/
    595552int GeneralFitData::GetMnMx(int var,double& min,double& max) const
    596 //
    597 //      Retourne le minimum et le maximum de la variable ``var''
    598 //      (cf commentaires GetMnMx).
    599 //--
    600553{
    601554min = 1.; max = -1.;
    … …  
    622575
    623576//////////////////////////////////////////////////////////////////////
    624 //++
     577/*!
     578//
     579  Retourne la moyenne et le sigma de la variable ``var''
     580  (cf commentaires GetMnMx).
     581  \verbatim
     582    - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
     583    - Seuls les points valides de valeur entre min,max sont utilises.
     584      Si min>=max pas de coupures sur les valeurs.
     585  \endverbatim
     586*/
    625587int GeneralFitData::GetMeanSigma(int var,double& mean,double& sigma,double min,double max)
    626 //
    627 //      Retourne la moyenne et le sigma de la variable ``var''
    628 //      (cf commentaires GetMnMx).
    629 //| - Return : nombre de donnees utilisees, -1 si pb, -2 si sigma<0.
    630 //| - Seuls les points valides de valeur entre min,max sont utilises.
    631 //|   Si min>=max pas de coupures sur les valeurs.
    632 //--
    633588{
    634589mean = sigma = 0.;
    … …  
    661616}
    662617
    663 //++
     618/*!
     619  Retourne le mode de la variable ``var''
     620  (cf commentaires GetMnMx).
     621  \verbatim
     622    - Return : nombre de donnees utilisees, -1 si pb.
     623    - Seuls les points valides de valeur entre min,max sont utilises.
     624      Si min>=max pas de coupures sur les valeurs.
     625    - Le calcul du mode est approximee par la formule:
     626        Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
     627    - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
     628  \endverbatim
     629*/
    664630int GeneralFitData::GetMoMeMed(int var,double& mode,double& mean,double& median,
    665631                               double min,double max,double coeff)
    666 //
    667 //      Retourne le mode de la variable ``var''
    668 //      (cf commentaires GetMnMx).
    669 //| - Return : nombre de donnees utilisees, -1 si pb.
    670 //| - Seuls les points valides de valeur entre min,max sont utilises.
    671 //|   Si min>=max pas de coupures sur les valeurs.
    672 //| - Le calcul du mode est approximee par la formule:
    673 //|     Mode = Median - coeff*(Mean-Median)   (def: coeff=0.8)
    674 //| - Kendall and Stuart donne coeff=2., mais coeff peut etre regle.
    675 //--
    676632{
    677633mode = mean = median = 0.;
    … …  
    716672}
    717673
    718 //++
     674/*!
     675  Cf description ci-dessus ``GetMoMeMed''.
     676*/
    719677int GeneralFitData::GetMode(int var,double& mode,double min,double max,double coeff)
    720 //
    721 //      Cf description ci-dessus ``GetMoMeMed''.
    722 //--
    723678{
    724679double mean,median;
    … …  
    727682
    728683//////////////////////////////////////////////////////////////////////
    729 //++
     684/*!
     685  Pour fiter un polynome de degre ``degre''. On fite
     686  Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
     687  le fit prend en compte les erreurs stoquees dans EVal,
     688  sinon fit sans erreurs. Le resultat du fit est retourne
     689  dans le polynome ``pol''.
     690  \verbatim
     691  Return:
     692     -   Res = le residu du fit
     693     -   -1 si degre<0
     694     -   -2 si probleme sur numero de variable X
     695     -   -4 si NDataGood<0
     696     -   -5 si nombre de data trouves different de NDataGood
     697  \endverbatim
     698*/
    730699double GeneralFitData::PolFit(int varx,Poly& pol,int degre,bool ey)
    731 //
    732 //      Pour fiter un polynome de degre ``degre''. On fite
    733 //      Y=f(X) ou Y=Val et X=Absc(varx). Si ``ey'' est ``true''
    734 //      le fit prend en compte les erreurs stoquees dans EVal,
    735 //      sinon fit sans erreurs. Le resultat du fit est retourne
    736 //      dans le polynome ``pol''.
    737 //| Return:
    738 //|  -   Res = le residu du fit
    739 //|  -   -1 si degre<0
    740 //|  -   -2 si probleme sur numero de variable X
    741 //|  -   -4 si NDataGood<0
    742 //|  -   -5 si nombre de data trouves different de NDataGood
    743 //--
    744700{
    745701if(degre<0) return -1.;
    … …  
    769725}
    770726
    771 //++
     727/*!
     728  Pour fiter un polynome de degre ``degre1''. On fite
     729  Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
     730  Si ``ey'' est ``true'' le fit prend en compte les erreurs
     731  stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
     732  negatif, le fit determine un polynome en X,Y de degre
     733  total ``degre`''. Si ``degre2'' positif ou nul, le fit
     734  demande un fit de ``degre1'' pour la variable X et de degre
     735  ``degre2'' sur la variable Y. Le resultat du fit est retourne
     736  dans le polynome ``pol''.
     737  \verbatim
     738    Return:
     739     -   Res = le residu du fit
     740     -   -1 si degre<0
     741     -   -2 si probleme sur numero de variable X
     742     -   -3 si probleme sur numero de variable Y
     743     -   -4 si NDataGood<0
     744     -   -5 si nombre de data trouves different de NDataGood
     745  \endverbatim
     746*/
    772747double GeneralFitData::PolFit(int varx,int vary,Poly2& pol,int degre1,int degre2,bool ez)
    773 //
    774 //
    775 //      Pour fiter un polynome de degre ``degre1''. On fite
    776 //      Z=f(X,Y) ou Z=Val et X=Absc(varx) et Y=Absc(vary).
    777 //      Si ``ey'' est ``true'' le fit prend en compte les erreurs
    778 //      stoquees dans EVal, sinon fit sans erreurs. Si ``degre2''
    779 //      negatif, le fit determine un polynome en X,Y de degre
    780 //      total ``degre`''. Si ``degre2'' positif ou nul, le fit
    781 //      demande un fit de ``degre1'' pour la variable X et de degre
    782 //      ``degre2'' sur la variable Y. Le resultat du fit est retourne
    783 //      dans le polynome ``pol''.
    784 //| Return:
    785 //|  -   Res = le residu du fit
    786 //|  -   -1 si degre<0
    787 //|  -   -2 si probleme sur numero de variable X
    788 //|  -   -3 si probleme sur numero de variable Y
    789 //|  -   -4 si NDataGood<0
    790 //|  -   -5 si nombre de data trouves different de NDataGood
    791 //--
    792748{
    793749if(degre1<0) return -1.;
    … …  
    823779
    824780//////////////////////////////////////////////////////////////////////
    825 //++
     781/*!
     782  Retourne une classe contenant les residus du fit ``gfit''.
     783*/
    826784GeneralFitData GeneralFitData::FitResidus(GeneralFit& gfit)
    827 //
    828 //      Retourne une classe contenant les residus du fit ``gfit''.
    829 //--
    830785{
    831786if(gfit.GetNVar()!=mNVar)
    … …  
    834789}
    835790
    836 //++
     791/*!
     792  Retourne une classe contenant la function du fit ``gfit''.
     793*/
    837794GeneralFitData GeneralFitData::FitFunction(GeneralFit& gfit)
    838 //
    839 //      Retourne une classe contenant la function du fit ``gfit''.
    840 //--
    841795{
    842796if(gfit.GetNVar()!=mNVar)
    … …  
    846800
    847801//////////////////////////////////////////////////////////////////////
    848 //++
     802/*!
     803//
     804  Retourne la donnee `n' dans le vecteur de double `ret'.
     805  \verbatim
     806    Par defaut, ret=NULL et le buffer interne de la classe est retourne
     807    - Les donnees sont rangees dans l'ordre:
     808       x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
     809       |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
     810      Le vecteur ret a la taille 2*NVar+2+1
     811  \endverbatim
     812*/
    849813r_8* GeneralFitData::GetVec(int n, r_8* ret)   const
    850 //
    851 //      Retourne la donnee `n' dans le vecteur de double `ret'.
    852 //| Par defaut, ret=NULL et le buffer interne de la classe est retourne
    853 //| - Les donnees sont rangees dans l'ordre:
    854 //|    x0,x1,x2,... ; ex0,ex1,ex2,...  ; y ; ey ; ok(0/1)
    855 //|    |<- NVar ->| + |<-   NVar   ->| + 1 +  1 +  1
    856 //|   Le vecteur ret a la taille 2*NVar+2+1
    857 //--
    858814{
    859815int i;
    … …  
    870826}
    871827
    872 //++
     828/*!
     829  Retourne la donnee `n' dans le vecteur de float `ret'
     830  (meme commentaires que pour GetVec).
     831*/
    873832r_4* GeneralFitData::GetVecR4(int n, r_4* ret)   const
    874 //
    875 //      Retourne la donnee `n' dans le vecteur de float `ret'
    876 //      (meme commentaires que pour GetVec).
    877 //--
    878833{
    879834if (ret == NULL) ret = BuffVarR4;
    … …  
    886841
    887842//////////////////////////////////////////////////////////////////////
    888 //++
    889 // int inline int GetSpaceFree() const
    890 //      Retourne la place restante dans la structure (nombre de
    891 //      donnees que l'on peut encore stoquer).
    892 //--
    893 //++
    894 // inline int  NVar()       const
    895 //      Retourne le nombre de variables Xi
    896 //--
    897 //++
    898 // inline int  NData()
    899 //      Retourne le nombre de donnees
    900 //--
    901 //++
    902 // inline int  NDataGood()  const
    903 //      Retourne le nombre de bonnes donnees (utilisees pour le fit)
    904 //--
    905 //++
    906 // inline int  NDataAlloc() const
    907 //      Retourne la place maximale allouee pour les donnees
    908 //--
    909 //++
    910 // inline unsigned short int IsValid(int i) const
    911 //      Retourne 1 si point valide, sinon 0
    912 //--
    913 //++
    914 // inline bool HasXErrors()
    915 //      Retourne ``true'' si il y a des erreurs sur les variables
    916 //      d'abscisse, ``false'' sinon.
    917 //--
    918 //++
    919 // inline double X1(int i) const
    920 //      Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
    921 //--
    922 //++
    923 // inline double X(int i) const
    924 //      Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
    925 //--
    926 //++
    927 // inline double Y(int i) const
    928 //      Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
    929 //--
    930 //++
    931 // inline double Z(int i) const
    932 //      Retourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
    933 //--
    934 //++
    935 // inline double Absc(int j,int i) const
    936 //      Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
    937 //--
    938 //++
    939 // inline double Val(int i) const
    940 //      Retourne la valeur de la Ieme donnee
    941 //--
    942 //++
    943 // inline double EX1(int i) const
    944 //      Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
    945 //--
    946 //++
    947 // inline double EX(int i) const
    948 //      Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
    949 //--
    950 //++
    951 // inline double EY(int i) const
    952 //      Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
    953 //--
    954 //++
    955 // inline double EZ(int i) const
    956 //      Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
    957 //--
    958 //++
    959 // inline double EAbsc(int j,int i) const
    960 //      Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
    961 //--
    962 //++
    963 // inline double EVal(int i) const {return mErr[i];}
    964 //      Retourne l'erreur de la Ieme donnee
    965 //--
    966 
    967 
    968 //////////////////////////////////////////////////////////////////////
    969843// ------- Implementation de  l interface NTuple  ---------
    970844
     845/*!
     846  Retourne le nombre de ligne = NData() (pour interface NTuple)
     847*/
    971848uint_4 GeneralFitData::NbLines() const
    972849{
    … …  
    974851}
    975852
    976 //++
     853/*!
     854  Retourne le nombre de colonnes du ntuple equivalent:
     855  \verbatim
     856    Exemple: on a une fonction sur un espace a 4 dimensions:
     857    "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
     858      0  1  2  3        4   5   6   7      8     9      10
     859      |        |        |           |      |     |       |       
     860      0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
     861    soit 2*nvar+3 variables/colonnes.
     862  \endverbatim
     863  (pour interface NTuple)
     864*/
    977865uint_4 GeneralFitData::NbColumns() const
    978 //
    979 //      Retourne le nombre de colonnes du ntuple equivalent:
    980 //| Exemple: on a une fonction sur un espace a 4 dimensions:
    981 //| "x0,x1,x2,x3    , ex0,ex1,ex2,ex3    , y,   ey ,    ok"
    982 //|   0  1  2  3        4   5   6   7      8     9      10
    983 //|   |        |        |           |      |     |       |       
    984 //|   0       nv-1     nv         2*nv-1  2*nv  2*nv+1  2*nv+2
    985 //| soit 2*nvar+3 variables/colonnes.
    986 //--
    987866{
    988867return(2*NVar()+3);
    989868}
    990869
     870//! Pour interface NTuple
    991871r_8 * GeneralFitData::GetLineD(int n) const
    992872{
    … …  
    994874}
    995875
     876//! Pour interface NTuple
    996877r_8 GeneralFitData::GetCell(int n, int k) const
    997878{
    … …  
    1001882}
    1002883
     884//! Pour interface NTuple
    1003885r_8 GeneralFitData::GetCell(int n, string const & nom) const
    1004886{
    … …  
    1007889}
    1008890
    1009 //++
     891/*!
     892  Retourne le minimum et le maximum de la variable `k' (pour interface NTuple).
     893*/
    1010894void GeneralFitData::GetMinMax(int k, double& min, double& max)  const
    1011 //
    1012 //      Retourne le minimum et le maximum de la variable `k'.
    1013 //--
    1014895{
    1015896int var;
    … …  
    1024905}
    1025906
     907//! Pour interface NTuple
    1026908void GeneralFitData::GetMinMax(string const & nom, double& min, double& max)   const
    1027909{
    … …  
    1030912}
    1031913
     914//! Pour interface NTuple
    1032915int GeneralFitData::ColumnIndex(string const & nom)  const
    1033916{
    … …  
    1043926}
    1044927
     928//! Pour interface NTuple
    1045929string GeneralFitData::ColumnName(int k) const
    1046930{
    … …  
    1056940}
    1057941
    1058 //++
     942/*!
     943  Retourne une chaine de caracteres avec la declaration des noms de
     944  variables. si "nomx!=NULL" , des instructions d'affectation
     945  a partir d'un tableau "nomx[i]" sont ajoutees (pour interface NTuple).
     946*/
    1059947string GeneralFitData::VarList_C(const char* nomx)  const
    1060 //
    1061 //      Retourne une chaine de caracteres avec la declaration des noms de
    1062 //      variables. si "nomx!=NULL" , des instructions d'affectation
    1063 //      a partir d'un tableau "nomx[i]" sont ajoutees.
    1064 //--
    1065948{
    1066949char buff[256];

  • trunk/SophyaLib/NTools/generaldata.h

    r552 r914  
    1919//================================================================
    2020
     21/*!
     22  Classe de stoquage de donnees a plusieurs variables avec erreur
     23  sur l'ordonnee et sur les abscisses (options) :
     24
     25  \f$ {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)} \f$
     26  \verbatim
     27   Pour memoire, structure du rangement (n=mNVar):
     28   - Valeur des abscisses mXP (idem pour mErrXP):
     29     x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
     30     |  1er point  |   |  2sd point  |  ....  | point mNData |
     31     Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
     32   - Valeur de l'ordonnee mF (idem pour mErr et mOK):
     33            f                f                      f
     34     |  1er point  |  |  2sd point  |  .... | point mNData |
     35     Donc point numero I [0,mNData[ : mF[i]
     36  \endverbatim
     37*/
     38
    2139class GeneralFitData : public AnyDataObj , public NTupleInterface {
    2240  friend class GeneralFit;
    2341  friend class ObjFileIO<GeneralFitData>;
    2442public:
    25   enum {Def_ErrF = 1, Def_ErrX = 0};
     43  //! Valeurs par defaut pour l'utilisation des erreurs
     44  enum {
     45    Def_ErrF = 1, //!< erreurs sur F par defaut
     46    Def_ErrX = 0  //!< pas d'erreurs sur les variables X,Y,... par defaut
     47    };
    2648
    2749  GeneralFitData(unsigned int nVar, unsigned int nDataAlloc, uint_2 errx=0);
    … …  
    6789  inline void Show() const {Show(cout);}
    6890
     91  //! Retourne la place restante dans la structure (nombre de donnees que l'on peut encore stoquer).
    6992  inline int GetSpaceFree() const { return mNDataAlloc - mNData; }
     93  //! Retourne le nombre de variables Xi
    7094  inline int NVar()       const {return mNVar;}
     95  //! Retourne le nombre de donnees
    7196  inline int NData()      const {return mNData;}
     97  //! Retourne le nombre de bonnes donnees (utilisees pour le fit)
    7298  inline int NDataGood()  const {return mNDataGood;}
     99  //! Retourne la place maximale allouee pour les donnees
    73100  inline int NDataAlloc() const {return mNDataAlloc;}
    74101
     102  //! Retourne 1 si point valide, sinon 0
    75103  inline unsigned short int IsValid(int i) const
    76104                {if(i>=0 && i<mNData) return mOK[i]; else return 0;}
     105  //! Retourne ``true'' si il y a des erreurs sur les variables d'abscisse, ``false'' sinon.
    77106  inline bool HasXErrors() {if(mErrXP) return true; else return false;}
    78107
     108  //! Retourne l'abscisse pour 1 dimension (y=f(x)) donnee I
    79109  inline double X1(int i) const
    80110                {if(i>=0 && i<mNData) return mXP[i]; else return 0.;}
     111  //! Retourne la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
    81112  inline double X(int i) const
    82113                {if(i>=0 && i<mNData) return mXP[i*mNVar]; else return 0.;}
     114  //! Retourne la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
    83115  inline double Y(int i) const
    84116                {if(i>=0 && i<mNData && 1<mNVar) return mXP[i*mNVar+1]; else return 0.;}
     117  //! etourne la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
    85118  inline double Z(int i) const
    86119                {if(i>=0 && i<mNData && 2<mNVar) return mXP[i*mNVar+2]; else return 0.;}
     120  //! Retourne la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
    87121  inline double Absc(int j,int i) const
    88122                {if(i>=0 && i<mNData && j<mNVar)return mXP[i*mNVar+j]; else return 0.;}
     123  //! Retourne la valeur de la Ieme donnee
    89124  inline double Val(int i) const
    90125                {if(i>=0 && i<mNData) return mF[i]; else return 0.;}
    91126
     127  //! Retourne l'erreur (dx) sur l'abscisse pour 1 dimension (y=f(x)) donnee I
    92128  inline double EX1(int i) const
    93129                {if(mErrXP && i>=0 && i<mNData) return mErrXP[i]; else return 0.;}
     130  //! Retourne l'erreur (dx) sur la 1er abscisse (X) pour (v=f(x,y,z,...)) donnee I
    94131  inline double EX(int i) const
    95132                {if(mErrXP && i>=0 && i<mNData) return mErrXP[i*mNVar]; else return 0.;}
     133  //! Retourne l'erreur (dy) sur la 2sd abscisse (Y) pour (v=f(x,y,z,...)) donnee I
    96134  inline double EY(int i) const
    97135                {if(mErrXP && i>=0 && i<mNData && 1<mNVar) return mErrXP[i*mNVar+1];
    98136                 else return 0.;}
     137  //! Retourne l'erreur (dz) sur la 3ieme abscisse (Z) pour (v=f(x,y,z,...)) donnee I
    99138  inline double EZ(int i) const
    100139                {if(mErrXP && i>=0 && i<mNData && 2<mNVar) return mErrXP[i*mNVar+2];
    101140                 else return 0.;}
     141  //! Retourne l'erreur (dxj) sur la Jieme abscisse (Xj) pour (v=f(x0,x1,x2,...)) donnee I
    102142  inline double EAbsc(int j,int i) const
    103143                {if(mErrXP && i>=0 && i<mNData && j<mNVar) return mErrXP[i*mNVar+j];
    104144                 else return 0.;}
     145  //! Retourne l'erreur de la Ieme donnee
    105146  inline double EVal(int i) const
    106147                {if(i>=0 && i<mNData) return mErr[i]; else return 0.;}
    … …  
    139180  int_4   mNDataGood;
    140181  uint_2  mOk_EXP;
    141   r_8* mXP;             // x0 y0 z0, x1 y1 z1, ..., xn yn zn
    142   r_8* mErrXP;          // Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn
    143   r_8* mF;              // F0, F1, ...., Fn
    144   r_8* mErr;            // EF0, EF1, ...., EFn
    145   uint_2* mOK; // 1 si pt valid, 0 sinon
     182  r_8* mXP;             //!< x0 y0 z0, x1 y1 z1, ..., xn yn zn
     183  r_8* mErrXP;          //!< Ex0 Ey0 Ez0, Ex1 Ey1 Ez1, ..., Exn Eyn Ezn
     184  r_8* mF;              //!< F0, F1, ...., Fn
     185  r_8* mErr;            //!< EF0, EF1, ...., EFn
     186  uint_2* mOK;          //!< 1 si pt valid, 0 sinon
    146187  r_8* BuffVar;
    147188  r_4* BuffVarR4;

  • trunk/SophyaLib/NTools/generalfit.cc

    r774 r914  
    2121//================================================================
    2222
    23 //++
    24 // Class        GeneralFunction
    25 // Lib  Outils++
    26 // include      generalfit.h
    27 //
    28 //      Classe de fonctions parametrees a plusieurs variables.
    29 //|           F[x1,x2,x3,...:a1,a2,a3,...]
    30 //--
    31 
    32 //////////////////////////////////////////////////////////////////////
    33 //++
     23//////////////////////////////////////////////////////////////////////
     24/*!
     25 Creation d'une fonction de `nVar' variables et `nPar' parametres:
     26 \f$ F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)] \f$
     27*/
    3428GeneralFunction::GeneralFunction(unsigned int nVar, unsigned int nPar)
    35 //
    36 //      Creation d'une fonction de `nVar' variables et `nPar' parametres.
    37 //|  F[x(1),x(2),x(3),...x(nVar) : a(1),a(2),a(3),...,a(nPar)]
    38 //--
    3929  : mNVar(nVar), mNPar(nPar)
    4030{
    … …  
    4535}
    4636
    47 //++
    4837GeneralFunction::~GeneralFunction()
    49 //
    50 //--
    5138{
    5239 delete[] deltaParm;
    … …  
    5542
    5643//////////////////////////////////////////////////////////////////////
    57 //++
     44/*!
     45  Valeur et Derivees de la fonction (fct virtuelle par defaut).
     46*/
    5847double GeneralFunction::Val_Der(double const xp[], double const* parm
    5948                               , double *DgDpar)
    60 //
    61 //      Valeur et Derivees de la fonction (fct virtuelle par defaut).
    62 //--
    6349{
    6450 for(int i=0;i<mNPar;i++) tmpParm[i] = parm[i];
    … …  
    7763
    7864//////////////////////////////////////////////////////////////////////
    79 //++
     65/*!
     66  Definition de la variation du parametre numPar
     67  pour calculer la derivee automatiquement.
     68*/
    8069void GeneralFunction::SetDeltaParm(int numPar, double d)
    81 //
    82 //      Definition de la variation du parametre numPar
    83 //      pour calculer la derivee automatiquement.
    84 //--
    8570{
    8671 ASSERT(numPar >= 0 && numPar < mNPar);
    … …  
    8873}
    8974
    90 //++
     75
     76/*!
     77  Idem precedente fonction mais pour tous les parametres
     78*/
    9179void GeneralFunction::SetDeltaParm(double const* dparam)
    92 //
    93 //      Idem precedente fonction mais pour tous les parametres
    94 //--
    9580{
    9681 for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
    9782}
    98 
    99 //////////////////////////////////////////////////////////////////////
    100 // Rappel des inline functions pour commentaires
    101 //++
    102 // virtual double Value(double const xp[], double const* parm)=0;
    103 //      Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
    104 //--
    105 //++
    106 // inline int     NVar() const
    107 //      Retourne le nombre de variables Xi
    108 //--
    109 //++
    110 // inline int     NPar() const
    111 //      Retourne le nombre de parametres Ai
    112 //--
    11383
    11484//================================================================
    … …  
    11686//================================================================
    11787
    118 //++
    119 // Class        GeneralFunc
    120 // Lib  Outils++
    121 // include      generalfit.h
    122 //
    123 //      Classe de fonctions parametrees a plusieurs variables
    124 //      derivant de ``GeneralFunction''. Permet de definir
    125 //      une fonction a fiter sans passer par une classe derivee
    126 //      en utilisant l'ecriture courante du C. La fonction
    127 //      retournant les derivees par rapport aux parametres du fit
    128 //      peut etre egalement fournie (optionnel).
    129 //--
    130 
    13188/////////////////////////////////////////////////////////////////
    132 //++
    133 GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar, double (*fun) (double const*, double const*)
    134                         , double (*funder) (double const*, double const*, double*) )
    135 //
    136 //      Createur, on passe le nom ``fun'' de la fonction a la mode C.
    137 //      On peut optionellement egalement passer le nom de la fonction
    138 //      ``funder'' qui retourne les valeurs des derivees par rapport
    139 //      aux parametres du fit.
    140 //--
    141 //++
    142 //| ----------------------
    143 //| Exemple d'utilisation:
    144 //| ----------------------
    145 //| include "generalfit.h"
    146 //| ...
    147 //| double   gaussc(double const* x,double const* p);
    148 //| double d_gaussc(double const* x,double const* p,double* dp);
    149 //| ...
    150 //| main {
    151 //|  ...
    152 //|  // Fit SANS calcul automatique des derivees
    153 //|  GeneralFunc      myfunc(2,7,gaussc);
    154 //|  GeneralFit       myfit(&myfunc);
    155 //|  ...
    156 //|  myfit.Fit();
    157 //|  ...
    158 //|  // Fit AVEC calcul automatique des derivees
    159 //|  GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
    160 //|  GeneralFit       myfit(&myfunc);
    161 //|  ...
    162 //|  myfit.Fit();
    163 //| }
    164 //--
    165 //++
    166 //| // Definition de la fonction a fitter a la mode C
    167 //| double gaussc(double const* x,double const* p)
    168 //| // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
    169 //| //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
    170 //| {
    171 //|  double X = (x[0]-p[1])/p[3];
    172 //|  double Y = (x[1]-p[2])/p[4];
    173 //|  return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
    174 //| }
    175 //| // Definition de la fonction des derivees / parametres
    176 //| // Cette fonction retourne aussi la valeur de la fonction a fitter.
    177 //| double d_gaussc(double const* x,double const* p,double* dp)
    178 //| {
    179 //|  dp[0] = derivee de gaussc par rapport au parametre p[0]
    180 //|  ...
    181 //|  dp[6] = derivee de gaussc par rapport au parametre p[6]
    182 //|  return gaussc(x,p);
    183 //| }
    184 //--
     89/*!
     90  Createur, on passe le nom ``fun'' de la fonction a la mode C.
     91  On peut optionellement egalement passer le nom de la fonction
     92  ``funder'' qui retourne les valeurs des derivees par rapport
     93  aux parametres du fit.
     94  \verbatim
     95    ----------------------
     96    Exemple d'utilisation:
     97    ----------------------
     98    include "generalfit.h"
     99    ...
     100    double   gaussc(double const* x,double const* p);
     101    double d_gaussc(double const* x,double const* p,double* dp);
     102    ...
     103    main {
     104     ...
     105     // Fit SANS calcul automatique des derivees
     106     GeneralFunc      myfunc(2,7,gaussc);
     107     GeneralFit       myfit(&myfunc);
     108     ...
     109     myfit.Fit();
     110     ...
     111     // Fit AVEC calcul automatique des derivees
     112     GeneralFunc      myfunc(2,7,gaussc,d_gaussc);
     113     GeneralFit       myfit(&myfunc);
     114     ...
     115     myfit.Fit();
     116    }
     117    // Definition de la fonction a fitter a la mode C
     118    double gaussc(double const* x,double const* p)
     119    // Fonction: X=(x[0]-p[1])/p[3], Y=(x[1]-p[2])/p[4],
     120    //  f = p[0]*exp{-0.5*[X^2+Y^2-2*p[5]*X*Y]} + p[6]
     121    {
     122     double X = (x[0]-p[1])/p[3];
     123     double Y = (x[1]-p[2])/p[4];
     124     return p[0]*exp(-(X*X+Y*Y-2*p[5]*X*Y)/2)+p[6];
     125    }
     126    // Definition de la fonction des derivees / parametres
     127    // Cette fonction retourne aussi la valeur de la fonction a fitter.
     128    double d_gaussc(double const* x,double const* p,double* dp)
     129    {
     130     dp[0] = derivee de gaussc par rapport au parametre p[0]
     131     ...
     132     dp[6] = derivee de gaussc par rapport au parametre p[6]
     133     return gaussc(x,p);
     134    }
     135  \endverbatim
     136*/
     137GeneralFunc::GeneralFunc(unsigned int nvar, unsigned int npar
     138             , double (*fun) (double const*, double const*)
     139             , double (*funder) (double const*, double const*, double*) )
    185140: GeneralFunction(nvar,npar), tmpFun(fun), tmpFunDer(funder)
    186141{
    … …  
    206161//================================================================
    207162
    208 //++
    209 // Class        GeneralXi2
    210 // Lib  Outils++
    211 // include      generalfit.h
     163//////////////////////////////////////////////////////////////////////
     164/*!
    212165//
    213 //      Classe de Xi2 a plusieurs parametres.
    214 //|           Xi2[a1,a2,a3,...]
    215 //--
    216 
    217 //////////////////////////////////////////////////////////////////////
    218 //++
     166  Creation d'un Xi2 de `nPar' parametres.
     167  \f$ Xi2[a(1),a(2),a(3),...,a(nPar)] \f$
     168*/
    219169GeneralXi2::GeneralXi2(unsigned int nPar)
    220 //
    221 //      Creation d'un Xi2 de `nPar' parametres.
    222 //|  Xi2[a(1),a(2),a(3),...,a(nPar)]
    223 //--
    224170  : mNPar(nPar)
    225171{
    … …  
    229175}
    230176
    231 //++
    232177GeneralXi2::~GeneralXi2()
    233 //
    234 //--
    235178{
    236179 delete[] deltaParm;
    … …  
    238181
    239182//////////////////////////////////////////////////////////////////////
    240 //++
     183/*!
     184  Derivee du Xi2 par rapport au parametre `i'
     185  pour les valeurs `parm' des parametres.
     186*/
    241187double GeneralXi2::Derivee(GeneralFitData& data, int i, double* parm)
    242 //
    243 //      Derivee du Xi2 par rapport au parametre `i'
    244 //      pour les valeurs `parm' des parametres.
    245 //--
    246188{
    247189 int dum;
    … …  
    255197}
    256198
    257 //++
     199/*!
     200  Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
     201  pour les valeurs `parm' des parametres. Attention, cette fonction
     202  calcule d/di(dC2/dj), valeur qui est numeriquement differente
     203  de d/dj(dC2/di).
     204  \verbatim
     205   
     206    **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
     207    Derivee2(k,l)= dXi2/dPk.dPl
     208                 = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
     209                          + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
     210    ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
     211       SUMi represente la somme sur les points de mesure
     212       f(x;P) represente le modele parametrique a fitter
     213       "P" represente l'ensemble des parametres et "Pi" le ieme parametre
     214    Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
     215    a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
     216    secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
     217    devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
     218    n'est pas correlee avec le modele. Le terme avec la derivee 2sd
     219    tend donc a s'annuler et peut donc etre omis.
     220    (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
     221     Calculation of the Gradient and Hessian p682,683)
     222   
     223    **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
     224    la fonction virtuelle Derivee2 et de la remplacer par:
     225    Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
     226  \endverbatim
     227*/
    258228double GeneralXi2::Derivee2(GeneralFitData& data, int i, int j, double* parm)
    259 //
    260 //      Derivee seconde du Xi2 par rapport aux parametres `i' et `j'
    261 //      pour les valeurs `parm' des parametres. Attention, cette fonction
    262 //      calcule d/di(dC2/dj), valeur qui est numeriquement differente
    263 //      de d/dj(dC2/di).
    264 //--
    265 //++
    266 //|
    267 //| **** Remarque: Derivee2 = dXi2/dPi.dPj represente le Hessien.
    268 //| Derivee2(k,l)= dXi2/dPk.dPl
    269 //|              = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]
    270 //|                       + [yi-f(xi;P)] * df(xi;P)/dPk.dPl }
    271 //| ou (xi,yi) sont les points de mesure. "Si" l'erreur sur le point i
    272 //|    SUMi represente la somme sur les points de mesure
    273 //|    f(x;P) represente le modele parametrique a fitter
    274 //|    "P" represente l'ensemble des parametres et "Pi" le ieme parametre
    275 //| Les composantes du Hessien dependent des derivees 1ere et 2sd du modele
    276 //| a fitter f(x;P) selon les parametres "Pi". La prise en compte des derivees
    277 //| secondes est un facteur destabilisant. De plus le facteur [yi-f(xi;P)]
    278 //| devant la derivee 2sd est seulement l'erreur de mesure aleatoire qui
    279 //| n'est pas correlee avec le modele. Le terme avec la derivee 2sd
    280 //| tend donc a s'annuler et peut donc etre omis.
    281 //| (cf. Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
    282 //|  Calculation of the Gradient and Hessian p682,683)
    283 //|
    284 //| **** Conseil: Il est conseille a l'utilisateur de sur-ecrire
    285 //| la fonction virtuelle Derivee2 et de la remplacer par:
    286 //| Derivee2(k,l) = 2*SUMi{1/Si^2*[df(xi;P)/dPk * df(xi;P)/dPl]}
    287 //--
    288229{
    289230 double d = deltaParm[i];
    … …  
    298239
    299240//////////////////////////////////////////////////////////////////////
    300 //++
     241/*!
     242  Definition de la variation 'd' du parametre 'numPar'
     243  pour calculer la derivee automatiquement.
     244*/
    301245void GeneralXi2::SetDeltaParm(int numPar, double d)
    302 //
    303 //      Definition de la variation du parametre numPar
    304 //      pour calculer la derivee automatiquement.
    305 //--
    306246{
    307247 ASSERT(numPar >= 0 && numPar < mNPar);
    … …  
    310250}
    311251
    312 //++
     252/*!
     253  Idem precedente fonction mais pour tous les parametres.
     254*/
    313255void GeneralXi2::SetDeltaParm(double const* dparam)
    314 //
    315 //      Idem precedente fonction mais pour tous les parametres.
    316 //--
    317256{
    318257 for(int i=0;i<mNPar;i++) deltaParm[i] = dparam[i];
    319258}
    320 
    321 //////////////////////////////////////////////////////////////////////
    322 // Rappel des inline functions pour commentaires
    323 //++
    324 // virtual double Value(GeneralFitData& data, double const* parm, int& ndataused)=0;
    325 //      Valeur du Xi2 a definir par l'utilisateur (fct virtuelle pure)
    326 //      a partir des donnees de `data'. l'utilisateur doit egalement
    327 //      retourner le nombre de points de mesure utilises dans le calcul
    328 //      du Xi2 (`ndataused').
    329 //--
    330 //++
    331 // inline int     NPar() const
    332 //      Retourne le nombre de parametres Ai.
    333 //--
    334259
    335260//================================================================
    … …  
    338263//                                Christophe 8/11/93 La Silla
    339264//                                re-codage C++ 16/01/96 Saclay
    340 
    341 //++
    342 // Class        GeneralFit
    343 // Lib          Outils++
    344 // include      generalfit.h
    345 //
    346 //      Classe de fit d'une GeneralFunction sur une GeneralFitData
    347 //--
    348 
    349 //////////////////////////////////////////////////////////////////////
    350 //++
     265//////////////////////////////////////////////////////////////////////
     266/*!
     267  Creation d'une classe de fit pour la `GeneralFunction f'.
     268*/
    351269GeneralFit::GeneralFit(GeneralFunction* f)
    352 //
    353 //      Creation d'une classe de fit pour la `GeneralFunction f'.
    354 //--
    355270  : mNVar         (f->NVar()),
    356271    mNPar         (f->NPar()),
    … …  
    385300}
    386301
    387 //++
     302/*!
     303  Creation d'une classe de fit pour le `GeneralXi2 f'.
     304  L'emploi de cette methode n'est pas conseillee car elle
     305  calcule automatiquement la derivee 2sd du Xi2 par rapport
     306  aux parametres, ce qui entraine un manque de robustesse
     307  et qui ne garanti pas que la matrice de covariance soit
     308  definie positive (il est possible de surecrire
     309  la methode virtuelle Derivee2 pour palier ce probleme).
     310*/
    388311GeneralFit::GeneralFit(GeneralXi2* f)
    389 //
    390 //      Creation d'une classe de fit pour le `GeneralXi2 f'.
    391 //      L'emploi de cette methode n'est pas conseillee car elle
    392 //      calcule automatiquement la derivee 2sd du Xi2 par rapport
    393 //      aux parametres, ce qui entraine un manque de robustesse
    394 //      et qui ne garanti pas que la matrice de covariance soit
    395 //      definie positive (il est possible de surecrire
    396 //      la methode virtuelle Derivee2 pour palier ce probleme).
    397 //--
    398312  : mNVar         (0),
    399313    mNPar         (f->NPar()),
    … …  
    485399}
    486400
    487 //++
    488401GeneralFit::~GeneralFit()
    489 //
    490 //--
    491402{
    492403 delete[] fixParam;
    … …  
    497408
    498409//////////////////////////////////////////////////////////////////////
    499 //++
     410/*!
     411  Pour ecrire les iterations dans le fichier filename
     412*/
    500413void GeneralFit::WriteStep(char *filename)
    501 //
    502 //      Pour ecrire les iterations dans le fichier filename
    503 //--
    504414{
    505415
    … …  
    513423}
    514424
    515 //++
     425/*!
     426  Niveau de debug
     427  (voir aussi la variable d'environnement PDEBUG_GENERALFIT).
     428*/
    516429void GeneralFit::SetDebug(int level)
    517 //
    518 //      Niveau de debug
    519 //      (voir aussi la variable d'environnement PDEBUG_GENERALFIT).
    520 //--
    521430{
    522431 debugLevel = ( level < 0 ) ? 0: level;
    … …  
    524433}
    525434
    526 //++
     435/*!
     436  Nombre maximum d'iterations permis.
     437*/
    527438void GeneralFit::SetMaxStep(int n)
    528 //
    529 //      Nombre maximum d'iterations permis.
    530 //--
    531439{
    532440 maxStep = ( n <= 1 ) ? 100: n;
    … …  
    534442}
    535443
    536 //++
     444/*!
     445  Facteur de multiplication/division de Lambda selon
     446  que le Chi2 a augmente ou diminue.
     447*/
    537448void GeneralFit::SetLambda_Fac(double fac)
    538 //
    539 //      Facteur de multiplication/division de Lambda selon
    540 //      que le Chi2 a augmente ou diminue.
    541 //--
    542449{
    543450  Lambda_Fac = (fac>1.) ? fac : 10.;
    544451}
    545452
    546 //++
     453/*!
     454  Critere de convergence sur le Chi2.
     455*/
    547456void GeneralFit::SetStopChi2(double s)
    548 //
    549 //      Critere de convergence sur le Chi2.
    550 //--
    551457{
    552458 stopChi2 = ( s <= 0. ) ? 0.01: s;
    … …  
    554460}
    555461
    556 //++
     462/*!
     463  Precision des calculs (cf \ref GeneralFit_Fit "descriptif general").
     464*/
    557465void GeneralFit::SetEps(double ep)
    558 //
    559 //      Precision des calculs (cf descriptif general).
    560 //--
    561466{
    562467 ep = (ep<=0.) ? EPS_FIT_MIN: ep;
    … …  
    565470}
    566471
    567 //++
     472/*!
     473  Precision des calculs pour le parametre n.
     474*/
    568475void GeneralFit::SetEps(int n,double ep)
    569 //
    570 //      Precision des calculs pour le parametre n.
    571 //--
    572476{
    573477 ASSERT(n>=0 && n<mNPar);
    … …  
    576480}
    577481
    578 //++
     482/*!
     483  Critere de convergence sur le nombre de stop en chi2
     484  dans le cas ou le chi2 augmente de moins de stopchi2
     485  (cf \ref GeneralFit_Fit "descriptif general").
     486
     487  Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
     488
     489  Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
     490  est utilisee.
     491*/
    579492void GeneralFit::SetStopMx(int nstopmx,double stopchi2)
    580 //
    581 //      Critere de convergence sur le nombre de stop en chi2
    582 //      dans le cas ou le chi2 augmente de moins de stopchi2
    583 //      (cf descriptif general).
    584 //      Si nstopmx<=0, alors ce critere de convergence n'est pas applique.
    585 //      Si stopchi2<=0, alors la valeur generale mise par SetStopChi2()
    586 //      est utilisee.
    587 //--
    588493{
    589494 nStopMx = (nstopmx>0) ? nstopmx : 0;
    … …  
    593498}
    594499
    595 //++
     500/*!
     501  Critere de convergence sur le nombre de stop en chi2
     502  dans le cas ou le chi2 diminue (cf \ref GeneralFit_Fit "descriptif general").
     503
     504  Si nstopl<=0, alors ce critere de convergence n'est pas applique.
     505*/
    596506void GeneralFit::SetStopLent(int nstoplent)
    597 //
    598 //      Critere de convergence sur le nombre de stop en chi2
    599 //      dans le cas ou le chi2 diminue (cf descriptif general).
    600 //      Si nstopl<=0, alors ce critere de convergence n'est pas applique.
    601 //--
    602507{
    603508 nStopLent = (nstoplent>0) ? nstoplent : 0;
    … …  
    606511
    607512//////////////////////////////////////////////////////////////////////
    608 //++
     513/*!
     514  Pour changer la fonction a fitter en cours de route
     515  (On ne peut passer d'un fit sur une GeneralFunction
     516  a un fit sur un GeneralXi2 sans recreer la classe).
     517*/
    609518void GeneralFit::SetFunction(GeneralFunction* f)
    610 //
    611 //      Pour changer la fonction a fitter en cours de route
    612 //      (On ne peut passer d'un fit sur une GeneralFunction
    613 //      a un fit sur un GeneralXi2 sans recreer la classe).
    614 //--
    615519{
    616520 ASSERT( mFuncXi2  == NULL );
    … …  
    622526}
    623527
    624 //++
     528/*!
     529  Pour changer le Xi2 a fitter en cours de route
     530  (On ne peut passer d'un fit sur une GeneralFunction
     531  a un fit sur un GeneralXi2 sans recreer la classe).
     532*/
    625533void GeneralFit::SetFuncXi2(GeneralXi2* f)
    626 //
    627 //      Pour changer le Xi2 a fitter en cours de route
    628 //      (On ne peut passer d'un fit sur une GeneralFunction
    629 //      a un fit sur un GeneralXi2 sans recreer la classe).
    630 //--
    631534{
    632535 ASSERT( mFunction == NULL );
    … …  
    638541
    639542//////////////////////////////////////////////////////////////////////
    640 //++
     543/*!
     544  Pour connecter une structure de donnees.
     545*/
    641546void GeneralFit::SetData(GeneralFitData* data)
    642 //
    643 //      Pour connecter une structure de donnees.
    644 //--
    645547{
    646548 ASSERT( data->NVar()==mNVar );
    … …  
    652554
    653555//////////////////////////////////////////////////////////////////////
    654 //++
     556/*!
     557  Definition du parametre "n" a fitter.
     558*/
    655559void GeneralFit::SetParam(int n,double value,double step
    656560                         ,double min,double max)
    657 //
    658 //      Definition du parametre "n" a fitter.
    659 //--
    660561{
    661562 ASSERT(n>=0 && n<mNPar);
    … …  
    679580}
    680581
    681 //++
     582/*!
     583  Definition du parametre "n" a fitter
     584*/
    682585void GeneralFit::SetParam(int n, string const& name
    683586                        ,double value,double step,double min,double max)
    684 //
    685 //      Definition du parametre "n" a fitter
    686 //--
    687587{
    688588 ASSERT(n>=0 && n<mNPar);
    … …  
    692592}
    693593
    694 //++
     594/*!
     595  Definition du parametre "n" a fitter
     596*/
    695597void GeneralFit::SetParam(int n,double value)
    696 //
    697 //      Definition du parametre "n" a fitter
    698 //--
    699598{
    700599 ASSERT(n>=0 && n<mNPar);
    … …  
    704603
    705604//////////////////////////////////////////////////////////////////////
    706 //++
     605/*!
     606  Definition du pas de depart du parametre "n"
     607  Si negatif ou nul, parametre fixe.
     608*/
    707609void GeneralFit::SetStep(int n,double step)
    708 //
    709 //      Definition du pas de depart du parametre "n"
    710 //      Si negatif ou nul, parametre fixe.
    711 //--
    712610{
    713611 ASSERT(n>=0 && n<mNPar);
    … …  
    721619}
    722620
    723 //++
     621/*!
     622  Definition du pas minimum `val' pour le parametre `i'
     623  pouvant etre utilise dans le calcul automatique des derivees
     624  (soit de la fonction, soit du Xi2 selon les parametres du fit).
     625  Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
     626  Inutile dans le cas ou les derivees sont donnees
     627  par l'utilisateur.
     628*/
    724629void GeneralFit::SetMinStepDeriv(int i,double val)
    725 //
    726 //      Definition du pas minimum `val' pour le parametre `i'
    727 //      pouvant etre utilise dans le calcul automatique des derivees
    728 //      (soit de la fonction, soit du Xi2 selon les parametres du fit).
    729 //      Si nul pas de limite, si negatif alors `EPS(i)' (cf SetEps).
    730 //      Inutile dans le cas ou les derivees sont donnees
    731 //      par l'utilisateur.
    732 //--
    733630{
    734631 ASSERT(i>=0 && i<mNPar);
    … …  
    738635}
    739636
    740 //++
     637/*!
     638  Definition du pas minimum `val' pour tout les parametres
     639  (voir description SetMinStepDeriv ci-dessus).
     640*/
    741641void GeneralFit::SetMinStepDeriv(double val)
    742 //
    743 //      Definition du pas minimum `val' pour tout les parametres
    744 //      (voir description SetMinStepDeriv ci-dessus).
    745 //--
    746642{
    747643 if(debugLevel>0) cout<<"SetMinStepDeriv "<<val<<endl;
    … …  
    750646
    751647//////////////////////////////////////////////////////////////////////
    752 //++
     648/*!
     649  Definition des bornes du parametre "n"
     650  Si max<=min, parametre non-borne.
     651*/
    753652void GeneralFit::SetBound(int n, double min, double max)
    754 //
    755 //      Definition des bornes du parametre "n"
    756 //      Si max<=min, parametre non-borne.
    757 //--
    758653{
    759654 ASSERT(n>=0 && n<mNPar && max>min);
    … …  
    770665}
    771666
    772 //++
     667/*!
     668  Pour re-borner le parametre "n" aux bornes par defaut
     669*/
    773670void GeneralFit::SetBound(int n)
    774 //
    775 //      Pour re-borner le parametre "n" aux bornes par defaut
    776 //--
    777671{
    778672 ASSERT(n>=0 && n<mNPar && maxParam(n)>minParam(n));
    … …  
    780674}
    781675
    782 //++
     676/*!
     677  Pour ne plus borner le parametre "n"
     678*/
    783679void GeneralFit::SetUnBound(int n)
    784 //
    785 //      Pour ne plus borner le parametre "n"
    786 //--
    787680{
    788681 ASSERT(n>=0 && n<mNPar);
    … …  
    796689}
    797690
    798 //++
     691/*!
     692  Pour ne plus borner tous les parametres
     693*/
    799694void GeneralFit::SetUnBound()
    800 //
    801 //      Pour ne plus borner tous les parametres
    802 //--
    803695{
    804696 for(int i=0;i<mNPar;i++) SetUnBound(i);
    … …  
    806698
    807699//////////////////////////////////////////////////////////////////////
    808 //++
     700/*!
     701  Pour fixer le parametre "n" a la valeur "v"
     702*/
    809703void GeneralFit::SetFix(int n,double v)
    810 //
    811 //      Pour fixer le parametre "n" a la valeur "v"
    812 //--
    813704{
    814705 ASSERT(n>=0 && n<mNPar);
    … …  
    825716}
    826717
    827 //++
     718/*!
     719  Pour fixer le parametre "n" a la valeur par defaut
     720*/
    828721void GeneralFit::SetFix(int n)
    829 //
    830 //      Pour fixer le parametre "n" a la valeur par defaut
    831 //--
    832722{
    833723 ASSERT(n>=0 && n<mNPar);
    … …  
    835725}
    836726
    837 //++
     727/*!
     728  Pour liberer le parametre "n"
     729*/
    838730void GeneralFit::SetFree(int n)
    839 //
    840 //      Pour liberer le parametre "n"
    841 //--
    842731{
    843732 ASSERT(n>=0 && n<mNPar);
    … …  
    855744}
    856745
    857 //++
     746/*!
     747  Pour liberer tous les parametres
     748*/
    858749void GeneralFit::SetFree()
    859 //
    860 //      Pour liberer tous les parametres
    861 //--
    862750{
    863751 for(int i=0;i<mNPar;i++) SetFree(i);
    … …  
    865753
    866754//////////////////////////////////////////////////////////////////////
    867 //++
     755/*!
     756  Retourne la valeur du parametre "n"
     757*/
    868758double GeneralFit::GetParm(int n)
    869 //
    870 //      Retourne la valeur du parametre "n"
    871 //--
    872759{
    873760 ASSERT(n>=0 && n<mNPar);
    … …  
    875762}
    876763
    877 //++
     764/*!
     765  Retourne les valeurs des parametres dans un vecteur.
     766*/
    878767Vector GeneralFit::GetParm()
    879 //
    880 //      Retourne les valeurs des parametres dans un vecteur.
    881 //--
    882768{
    883769return Param;
    884770}
    885771
    886 //++
     772/*!
     773  Retourne la valeur de l'erreur du parametre "n"
     774*/
    887775double GeneralFit::GetParmErr(int n)
    888 //
    889 //      Retourne la valeur de l'erreur du parametre "n"
    890 //--
    891776{
    892777 ASSERT(n>=0 && n<mNPar);
    … …  
    894779}
    895780
    896 //++
     781/*!
     782  Retourne la covariance pour les parametre `i' et `j'
     783*/
    897784double GeneralFit::GetCoVar(int i,int j)
    898 //
    899 //      Retourne la covariance pour les parametre `i' et `j'
    900 //--
    901785{
    902786 ASSERT(i>=0 && i<mNPar && j>=0 && j<mNPar);
    … …  
    905789
    906790//////////////////////////////////////////////////////////////////////
    907 //++
     791/*!
     792  Retourne la valeur du pas du parametre "n"
     793*/
    908794double GeneralFit::GetStep(int n)
    909 //
    910 //      Retourne la valeur du pas du parametre "n"
    911 //--
    912795{
    913796 ASSERT(n>=0 && n<mNPar);
    … …  
    915798}
    916799
    917 //++
     800/*!
     801  Retourne la valeur de la borne superieure du parametre "n"
     802*/
    918803double GeneralFit::GetMax(int n)
    919 //
    920 //      Retourne la valeur de la borne superieure du parametre "n"
    921 //--
    922804{
    923805 ASSERT(n>=0 && n<mNPar);
    … …  
    925807}
    926808
    927 //++
     809/*!
     810  Retourne la valeur de la borne inferieure du parametre "n"
     811*/
    928812double GeneralFit::GetMin(int n)
    929 //
    930 //      Retourne la valeur de la borne inferieure du parametre "n"
    931 //--
    932813{
    933814 ASSERT(n>=0 && n<mNPar);
    … …  
    936817
    937818//////////////////////////////////////////////////////////////////////
    938 //++
     819/*!
     820  Impression du status du fit
     821*/
    939822void GeneralFit::PrintStatus()
    940 //
    941 //      Impression du status du fit
    942 //--
    943823{
    944824 cout<<"GeneralFit::PrintStatus"
    … …  
    962842}
    963843
    964 //++
     844/*!
     845  Impression des resultats du fit
     846*/
    965847void GeneralFit::PrintFit()
    966 //
    967 //      Impression des resultats du fit
    968 //--
    969848{
    970849 cout<<"PrintFit: Chi2="<<Chi2
    … …  
    978857}
    979858
    980 //++
     859/*!
     860  Impression des informations relatives au parametre "n"
     861*/
    981862void GeneralFit::PrintParm(int n)
    982 //
    983 //      Impression des informations relatives au parametre "n"
    984 //--
    985863{
    986864 ASSERT(n>=0 && n<mNPar);
    … …  
    999877}
    1000878
    1001 //++
     879/*!
     880  Impression des informations relatives a tous les parametres
     881*/
    1002882void GeneralFit::PrintParm()
    1003 //
    1004 //      Impression des informations relatives a tous les parametres
    1005 //--
    1006883{
    1007884 cout<<"*** Parametres : fix bnd : par err : step min max : eps dmin\n";
    … …  
    1011888
    1012889//////////////////////////////////////////////////////////////////////
    1013 //++
     890/*!
     891  Methode de fit.
     892  \anchor GeneralFit_Fit
     893  \verbatim
     894     Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
     895             sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
     896     - Methode:   fit des moindres carres dans le cas non lineaire
     897     - Reference: Statistical and Computational Methods in Data Analysis
     898                 Siegmund Brandt, North-Holland 1970  p 204-206.
     899                 Introduction des limites pour la variation des parametres (cmv).
     900                 Increment des parametres selon la methode de Levenberg-Marquardt
     901     (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
     902      Levenberg-Marquardt Method p683)
     903     - Gestion des parametres bornes:
     904        si p est un parametre borne entre pmin et pmax, le parametre fitte est q
     905        tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
     906        ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
     907        On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
     908        et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
     909              dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
     910                                      ^ q
     911                      |               |              *| "tang()"
     912                      |               |              *|
     913                      |               |              *|
     914                      |               |             * |
     915                      |               |            *  |
     916                      |               |          *    |
     917                      |               |       *       |
     918                  Pmin|              C|   *           |Pmax
     919        --------------|---------------*---------------|--------------> p
     920                 -Pi/2|           *   |0              |Pi/2
     921                      |       *       |               |
     922                      |    *          |               |
     923                      |  *            |               |
     924                      | *             |               |
     925                      |*              |               |
     926                      |*              |               |
     927                      |*              |               |
     928                      <------------------- D --------->
     929   
     930     - Criteres de convergence, arrets standards:
     931       - SOIT: le Chi2 est descendu de moins de stopChi2
     932               entre l'iteration n et n+1
     933               (stopChi2 est change par SetStopChi2)
     934       - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
     935               2. les parametres libres ont varie de moins de Eps(i)
     936                  pendant les nStopmx dernieres iterations
     937               Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
     938               (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
     939   
     940     - Criteres de convergence, arrets par non-convergence:
     941       - plus de "maxStep" iterations.
     942   
     943     - Criteres de convergence, arrets speciaux:
     944       - Si l'utilisateur a demande explicitement la methode d'arret
     945         "SetStopLent()", arret si :
     946           1. le Chi2 est descendu et
     947           2. les parametres libres ont varies de moins de Eps
     948              pendant les nStopLent dernieres iterations.
     949              (nStopLent est change par SetStopLent, Eps par SetEps)
     950   
     951     - Remarques diverses:
     952        Les points avec erreurs <=0 ne sont pas utilises dans le fit.
     953        Les bornes des parametres ne peuvent etre atteintes
     954     - entrees:
     955        la fonction est definie par une classe GeneralFunction
     956        les donnees sont passees par une classe GeneralFitData
     957        le nombre de parametres et le nombre de variables doivent etre
     958           coherents entre GeneralFunction GeneralFitData GeneralFit
     959     - Return:
     960          la function elle meme retourne le nombre d'iterations  du fit si succes
     961          -1  : si le nombre de degre de liberte est <0
     962          -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
     963          -11 : si un element diagonal de la matrice des covariances est <=0
     964          -20 : si le fit n'a pas converge (nstep>nNstepMX)
     965          -100-N : si le parametre "N" est initialise hors limites
     966          -200-N : si le parametre "N" atteint sa limite inferieure
     967          -300-N : si le parametre "N" atteint sa limite superieure
     968  \endverbatim
     969*/
    1014970int GeneralFit::Fit()
    1015 //
    1016 //--
    1017 //++
    1018 //|  Fonction de fit de la fonction f(x,y,z,...:p1,p2,...,pn)
    1019 //|          sur les donnees x[i],y[i],z[i],...,F[i],ErrF[i]
    1020 //|  - Methode:   fit des moindres carres dans le cas non lineaire
    1021 //|  - Reference: Statistical and Computational Methods in Data Analysis
    1022 //|              Siegmund Brandt, North-Holland 1970  p 204-206.
    1023 //|              Introduction des limites pour la variation des parametres (cmv).
    1024 //|              Increment des parametres selon la methode de Levenberg-Marquardt
    1025 //|  (Numerical Recipes in C, chap 15 Modeling of Data, Nonlinear Models,
    1026 //|   Levenberg-Marquardt Method p683)
    1027 //--
    1028 //++
    1029 //|  - Gestion des parametres bornes:
    1030 //|     si p est un parametre borne entre pmin et pmax, le parametre fitte est q
    1031 //|     tel que     q = tang((p-C)/D)    ....   p = C + D*atan(q)
    1032 //|     ou   C = (pmin+pmax)/2.  et   D = (pmax-pmin)/Pi
    1033 //|     On a  dq = (1+q**2)/D * dp    ....   dp = D/(1+q**2) * dq
    1034 //|     et    dF/dq = dF/dp * dp/dq = D/(1+q**2) * dF/dp
    1035 //|           dF/dp = dF/dq * dq/dp = (1+q**2)/D * dF/dp
    1036 //|                                   ^ q
    1037 //|                   |               |              *| "tang()"
    1038 //|                   |               |              *|
    1039 //|                   |               |              *|
    1040 //|                   |               |             * |
    1041 //|                   |               |            *  |
    1042 //|                   |               |          *    |
    1043 //|                   |               |       *       |
    1044 //|               Pmin|              C|   *           |Pmax
    1045 //|     --------------|---------------*---------------|--------------> p
    1046 //|              -Pi/2|           *   |0              |Pi/2
    1047 //|                   |       *       |               |
    1048 //|                   |    *          |               |
    1049 //|                   |  *            |               |
    1050 //|                   | *             |               |
    1051 //|                   |*              |               |
    1052 //|                   |*              |               |
    1053 //|                   |*              |               |
    1054 //|                   <------------------- D --------->
    1055 //--
    1056 //++
    1057 //|  - Criteres de convergence, arrets standards:
    1058 //|    - SOIT: le Chi2 est descendu de moins de stopChi2
    1059 //|            entre l'iteration n et n+1
    1060 //|            (stopChi2 est change par SetStopChi2)
    1061 //|    - SOIT: 1. le chi2 est remonte de moins de stopChi2SMx et
    1062 //|            2. les parametres libres ont varie de moins de Eps(i)
    1063 //|               pendant les nStopmx dernieres iterations
    1064 //|            Si nStopmx<=0, alors ce critere n'est pas applique (def=3).
    1065 //|            (nStopmx,stopChi2SMx sont changes par SetStopMx, Eps par SetEps)
    1066 //|
    1067 //|  - Criteres de convergence, arrets par non-convergence:
    1068 //|    - plus de "maxStep" iterations.
    1069 //|
    1070 //|  - Criteres de convergence, arrets speciaux:
    1071 //|    - Si l'utilisateur a demande explicitement la methode d'arret
    1072 //|      "SetStopLent()", arret si :
    1073 //|        1. le Chi2 est descendu et
    1074 //|        2. les parametres libres ont varies de moins de Eps
    1075 //|           pendant les nStopLent dernieres iterations.
    1076 //|           (nStopLent est change par SetStopLent, Eps par SetEps)
    1077 //|
    1078 //--
    1079 //++
    1080 //|  - Remarques diverses:
    1081 //|     Les points avec erreurs <=0 ne sont pas utilises dans le fit.
    1082 //|     Les bornes des parametres ne peuvent etre atteintes
    1083 //|  - entrees:
    1084 //|     la fonction est definie par une classe GeneralFunction
    1085 //|     les donnees sont passees par une classe GeneralFitData
    1086 //|     le nombre de parametres et le nombre de variables doivent etre
    1087 //|        coherents entre GeneralFunction GeneralFitData GeneralFit
    1088 //|  - Return:
    1089 //|       la function elle meme retourne le nombre d'iterations  du fit si succes
    1090 //|       -1  : si le nombre de degre de liberte est <0
    1091 //|       -10 : si l'inversion de la matrice des erreurs n'a pas ete possible
    1092 //|       -11 : si un element diagonal de la matrice des covariances est <=0
    1093 //|       -20 : si le fit n'a pas converge (nstep>nNstepMX)
    1094 //|       -100-N : si le parametre "N" est initialise hors limites
    1095 //|       -200-N : si le parametre "N" atteint sa limite inferieure
    1096 //|       -300-N : si le parametre "N" atteint sa limite superieure
    1097 //--
    1098971{
    1099972 volatile double oldChi2;
    … …  
    13851258
    13861259//////////////////////////////////////////////////////////////////////
    1387 //++
     1260/*!
     1261  Recalcul du Chi2 a partir des parametres courants (`par==NULL')
     1262  ou a partir du tableau de parametres `par'.
     1263  Retourne le chi2 et le nombre de degres de liberte.
     1264  Si nddl<0 probleme.
     1265*/
    13881266double GeneralFit::ReCalChi2(int& nddl, double *par)
    1389 //
    1390 //      Recalcul du Chi2 a partir des parametres courants (`par==NULL')
    1391 //      ou a partir du tableau de parametres `par'.
    1392 //      Retourne le chi2 et le nombre de degres de liberte.
    1393 //      Si nddl<0 probleme.
    1394 //--
    13951267{
    13961268double c2 = -1.;
    … …  
    14301302
    14311303//////////////////////////////////////////////////////////////////////
    1432 //++
     1304/*!
     1305  Retourne une structure ``GeneralFitData'' contenant
     1306  les residus du fit (val-func) pour les points du fit.
     1307  Si ``clean'' est ``true''
     1308  seules les donnees valides de ``data'' sont copiees.
     1309  Si ``clean'' est ``false'' (defaut) toutes les donnees
     1310  sont copiees et la taille totale de ``data'' est allouee
     1311  meme si elle est plus grande que la taille des donnees stoquees.
     1312*/
    14331313GeneralFitData GeneralFit::DataResidus(bool clean)
    1434 //
    1435 //      Retourne une structure ``GeneralFitData'' contenant
    1436 //      les residus du fit (val-func) pour les points du fit.
    1437 //      Si ``clean'' est ``true''
    1438 //      seules les donnees valides de ``data'' sont copiees.
    1439 //      Si ``clean'' est ``false'' (defaut) toutes les donnees
    1440 //      sont copiees et la taille totale de ``data'' est allouee
    1441 //      meme si elle est plus grande que la taille des donnees stoquees.
    1442 //--
    14431314{
    14441315if(!mData || !mFunction)
    … …  
    14511322
    14521323//////////////////////////////////////////////////////////////////////
    1453 //++
     1324/*!
     1325  Retourne une structure ``GeneralFitData'' contenant
     1326  les valeurs de la fonction fittee pour les points du fit.
     1327  (voir commentaires pour ``clean'' dans ``DataResidus'')
     1328*/
    14541329GeneralFitData GeneralFit::DataFunction(bool clean)
    1455 //
    1456 //      Retourne une structure ``GeneralFitData'' contenant
    1457 //      les valeurs de la fonction fittee pour les points du fit.
    1458 //      (voir commentaires pour ``clean'' dans ``DataResidus'')
    1459 //--
    14601330{
    14611331if(!mData || !mFunction)
    … …  
    14681338
    14691339//////////////////////////////////////////////////////////////////////
    1470 //++
     1340/*!
     1341  Imprime le commentaire lie a l'erreur rc retournee par Fit()
     1342  (voir le commentaire de la methode `Fit()')
     1343*/
    14711344void GeneralFit::PrintFitErr(int rc)
    1472 //
    1473 //      Imprime le commentaire lie a l'erreur rc retournee par Fit()
    1474 //      (voir le commentaire de la methode `Fit()')
    1475 //--
    14761345{
    14771346int n;
    … …  
    16321501
    16331502//////////////////////////////////////////////////////////////////////
     1503/*!
     1504  \verbatim
     1505  C = (min+max)/2
     1506  D = (max-min)/Pi
     1507  \endverbatim
     1508*/
    16341509void GeneralFit::Set_Bound_C_D(int i)
    1635 // C = (min+max)/2
    1636 // D = (max-min)/Pi
    16371510{
    16381511  // ASSERT(i>=0 && i<mNPar);
    … …  
    16561529
    16571530//////////////////////////////////////////////////////////////////////
     1531/*!
     1532  \verbatim
     1533  tr = tan( (p-C)/D )
     1534  \endverbatim
     1535*/
    16581536double GeneralFit::p_vers_tr(int i,double p)
    1659 // tr = tan( (p-C)/D )
    16601537{
    16611538 // ASSERT(i>=0 && i<mNPar);
    … …  
    16871564
    16881565//////////////////////////////////////////////////////////////////////
     1566/*!
     1567  \verbatim
     1568  p = C+D*atan(tr)
     1569  \endverbatim
     1570*/
    16891571double GeneralFit::tr_vers_p(int i,double tr)
    1690 // p = C+D*atan(tr)
    16911572{
    16921573 // ASSERT(i>=0 && i<mNPar);
    … …  
    17181599
    17191600//////////////////////////////////////////////////////////////////////
     1601/*!
     1602  \verbatim
     1603  dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
     1604  attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
     1605  \endverbatim
     1606*/
    17201607double GeneralFit::c_dp_vers_dtr(int i,double tr)
    1721 // dtr = (1+tr**2)/D * dp = (1+tan( (p-C)/D )**2)/D * dp = coeff * dp
    1722 // attention: df/dp = (1+tr**2)/D * dF/dtr = coeff * dF/dtr
    17231608{
    17241609 // ASSERT(i>=0 && i<mNPar);
    … …  
    17501635
    17511636//////////////////////////////////////////////////////////////////////
     1637/*!
     1638  \verbatim
     1639  dp = D/(1+tr**2) * dtr = coeff * dtr
     1640  attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
     1641  \endverbatim
     1642*/
    17521643double GeneralFit::c_dtr_vers_dp(int i,double tr)
    1753 // dp = D/(1+tr**2) * dtr = coeff * dtr
    1754 // attention: df/dtr = D/(1+tr**2) * dF/dp = coeff * dF/dp
    17551644{
    17561645  // ASSERT(i>=0 && i<mNPar);
    … …  
    17761665
    17771666//////////////////////////////////////////////////////////////////////
     1667/*!
     1668  \verbatim
     1669  1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
     1670  2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
     1671  Si hors limites alors:
     1672      p-dp <= min_p : dp = (p-min_p)*dist
     1673      p+dp >= max_p : dp = (max_p-p)*dist
     1674  \endverbatim
     1675*/
    17781676int GeneralFit::put_in_limits_for_deriv(Vector const& p,Vector& dp,double dist)
    1779 // 1-/ Redefinit dp pour qu'il soit superieur a minStepDeriv
    1780 // 2-/ Redefinit dp pour que p+/-dp reste dans les limites (parametre borne)
    1781 // Si hors limites alors:
    1782 //     p-dp <= min_p : dp = (p-min_p)*dist
    1783 //     p+dp >= max_p : dp = (max_p-p)*dist
    17841677{
    17851678 int nchanged = 0;
    … …  
    18261719}
    18271720
    1828 
    1829 //////////////////////////////////////////////////////////////////////
    1830 // Rappel des inline functions pour commentaires
    1831 //++
    1832 // inline double   GetChi2()
    1833 //      Retourne le Chi2
    1834 //--
    1835 //++
    1836 // inline double   GetChi2Red() const
    1837 //      Retourne le Chi2 reduit
    1838 //--
    1839 //++
    1840 // inline int      GetNddl()    const
    1841 //      Retourne le nombre de degres de liberte
    1842 //--
    1843 //++
    1844 // inline int      GetNStep()   const
    1845 //      Retourne le nombre d'iterations
    1846 //--
    1847 //++
    1848 // inline int      GetNVar()    const
    1849 //      Retourne le nombre de variables
    1850 //--
    1851 //++
    1852 // inline int      GetNPar()    const
    1853 //      Retourne le nombre de parametres
    1854 //--
    1855 //++
    1856 // inline int      GetNFree()   const
    1857 //      Retourne le nombre de parametres libres
    1858 //--
    1859 //++
    1860 // inline int      GetNBound()  const
    1861 //      Retourne le nombre de parametres bornes
    1862 //--
    1863 //++
    1864 // inline int      GetNStop()   const
    1865 //      Retourne le nstop de convergence
    1866 //--
    1867 //++
    1868 // inline int      GetNStopLent()   const
    1869 //      Retourne le nstop de convergence lente.
    1870 //--
    1871 //++
    1872 // inline double   GetEps(int i)
    1873 //      Retourne la precision de convergence pour le parametre i.
    1874 //--
    1875 //++
    1876 // inline GeneralFunction*  GetFunction()
    1877 //      Retourne le pointeur sur la GeneralFunction utilisee.
    1878 //--
    1879 //++
    1880 // inline GeneralFitData*   GetGData()
    1881 //      Retourne le pointeur sur la GeneralFitData utilisee.
    1882 //--

  • trunk/SophyaLib/NTools/generalfit.h

    r552 r914  
    1313//================================================================
    1414
     15
     16/*!
     17  Classe de fonctions parametrees a plusieurs variables:
     18  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
     19*/
    1520class GeneralFunction {
    1621public:
    … …  
    1823  virtual ~GeneralFunction();
    1924
     25  //! Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
    2026  virtual double Value(double const xp[], double const* parm)=0;
    2127  virtual double Val_Der(double const xp[], double const* parm
    … …  
    2531  void SetDeltaParm(double const* dparam);
    2632
     33  //! Retourne le nombre de variables Xi
    2734  inline int     NVar() const {return mNVar;}
     35  //! Retourne le nombre de parametres Ai
    2836  inline int     NPar() const {return mNPar;}
    2937
    3038protected:
    31   const int mNVar;  // nombre de variables f(x,y,z,...)
    32   const int mNPar;  // nombre de parametres
     39  const int mNVar;  //!< nombre de variables f(x,y,z,...)
     40  const int mNPar;  //!< nombre de parametres
    3341
    3442  double *deltaParm;
    … …  
    4048//================================================================
    4149
     50/*!
     51  Classe de fonctions parametrees a plusieurs variables
     52  derivant de ``GeneralFunction''. Permet de definir
     53  une fonction a fiter sans passer par une classe derivee
     54  en utilisant l'ecriture courante du C. La fonction
     55  retournant les derivees par rapport aux parametres du fit
     56  peut etre egalement fournie (optionnel).
     57*/
    4258class GeneralFunc : public GeneralFunction {
    4359public:
    … …  
    6278class GeneralFitData;
    6379
     80/*!
     81  Classe de Xi2 a plusieurs parametres :
     82  \f$ Xi2[a1,a2,a3,...] \f$
     83*/
    6484class GeneralXi2 {
    6585public:
    … …  
    6787  virtual ~GeneralXi2();
    6888
     89  /*!
     90  Valeur du Xi2 a definir par l'utilisateur (fct virtuelle pure)
     91  a partir des donnees de `data'. l'utilisateur doit egalement
     92  retourner le nombre de points de mesure utilises dans le calcul
     93  du Xi2 (`ndataused').
     94  */
    6995  virtual double Value(GeneralFitData& data, double* parm, int& ndataused)=0;
    7096  virtual double Derivee(GeneralFitData& data, int i, double* parm);
    … …  
    74100  void SetDeltaParm(double const* dparam);
    75101
     102  //! Retourne le nombre de parametres Ai.
    76103  inline int     NPar() const {return mNPar;}
    77104
    78105protected:
    79   const int mNPar;  // nombre de parametres
     106  const int mNPar;  //!< nombre de parametres
    80107
    81108  double *deltaParm;
    … …  
    86113//================================================================
    87114
     115//! Classe de fit d'une GeneralFunction sur une GeneralFitData
    88116class GeneralFit {
    89117public:
    … …  
    129157  double          GetMax(int n);
    130158  double          GetMin(int n);
     159  //! Retourne le Chi2
    131160  inline double   GetChi2()    const {return Chi2;};
     161  //! Retourne le Chi2 reduit
    132162  inline double   GetChi2Red() const {
    133163                        if(mNddl<=0) return (double) mNddl;
    134164                        return Chi2/(double) mNddl;
    135165                                     };
     166  //! Retourne la precision de convergence pour le parametre i.
    136167  inline double   GetEps(int i) const {return Eps(i);};
     168  //! Retourne le nombre de degres de liberte
    137169  inline int      GetNddl()    const {return mNddl;};
     170  //! Retourne le nombre d'iterations
    138171  inline int      GetNStep()   const {return nStep;};
     172  //! Retourne le nombre de variables
    139173  inline int      GetNVar()    const {return mNVar;};
     174  //! Retourne le nombre de parametres
    140175  inline int      GetNPar()    const {return mNPar;};
     176  //! Retourne le nombre de parametres libres
    141177  inline int      GetNFree()   const {return mNParFree;};
     178  //! Retourne le nombre de parametres bornes
    142179  inline int      GetNBound()  const {return mNParBound;};
     180  //! Retourne le nstop de convergence
    143181  inline int      GetNStop()   const {return nStop;};
     182  //! Retourne le nstop de convergence lente.
    144183  inline int      GetNStopLent()   const {return nStopLent;};
     184  //! Retourne le pointeur sur la GeneralFunction utilisee.
    145185  inline GeneralFunction*  GetFunction() const {return mFunction;};
     186  //! Retourne le pointeur sur la GeneralFitData utilisee.
    146187  inline GeneralFitData*   GetGData() const {return mData;};
    147188
    … …  
    158199
    159200protected:
    160   int             mNtry;       // numero d'appel de la routine de fit.
    161   int             mNVar;       // nombre de variables f(x,y,z,...)
    162   int             mNPar;       // nombre de parametres
    163   int             mNParFree;   // nombre de parametres libres
    164   int             mNParBound;  // nombre de parametres bornes
     201  int             mNtry;       //!< numero d'appel de la routine de fit.
     202  int             mNVar;       //!< nombre de variables f(x,y,z,...)
     203  int             mNPar;       //!< nombre de parametres
     204  int             mNParFree;   //!< nombre de parametres libres
     205  int             mNParBound;  //!< nombre de parametres bornes
    165206  GeneralFunction*  mFunction;
    166207  GeneralXi2*       mFuncXi2;

  • trunk/SophyaLib/TArray/tmatrix.h

    r894 r914  
    2323  TMatrix(const TMatrix<T>& a, bool share);
    2424  TMatrix(const TArray<T>& a);
    25   TMatrix(const TArray<T>& a,  bool share, short mm=CMemoryMapping);
     25  TMatrix(const TArray<T>& a,  bool share, short mm=AutoMemoryMapping);
    2626  virtual ~TMatrix();
    2727

  • trunk/SophyaLib/TArray/triangmtx.h

    r862 r914  
    11// This may look like C code, but it is really -*- C++ -*-
    2 /*! Class for inferior triangular matrix (base class for the class Alm) */
    32
    43#ifndef TRIANGMTX_H_SEEN
    … …  
    109namespace SOPHYA {
    1110
     11//! Class for inferior triangular matrix (base class for the class Alm)
    1212template <class T>
    13 class TriangularMatrix
    14   {
    15    
    16   public :
     13class TriangularMatrix {
     14public :
    1715
     16//! Default constructor
    1817TriangularMatrix()   {};
    19   /* instanciate a triangular matrix from the number of rows */
     18//! instanciate a triangular matrix from the number of rows
    2019TriangularMatrix(int rowSize)  : long_diag_((uint_4)rowSize) {elem_.ReSize((uint_4) (rowSize*(rowSize+1)/2) ); };
     20//! Copy constructor (possibility of sharing datas)
    2121TriangularMatrix(const TriangularMatrix<T>& a,  bool share=false)  : elem_(a.elem_, share),  long_diag_(a.long_diag_) {;}
    22 /*! resize the matrix with a new number of rows */
     22
     23//! resize the matrix with a new number of rows
    2324inline void ReSizeRow(int rowSize)
    2425  {
    … …  
    2829 inline void SetTemp(bool temp=false) const {elem_.SetTemp(temp);}
    2930
     31//! Equal operator
    3032inline TriangularMatrix<T>& operator = (const TriangularMatrix<T>& a)
    3133{
    … …  
    3436  return *this;
    3537}
     38
     39//! () operator : access to elements row \b l and column \b m
    3640inline T& operator()(int l, int m)
    3741  {
    3842      return  elem_(adr_ij(l,m));
    3943  }
     44//! () operator : access to elements row \b l and column \b m
    4045inline T const& operator()(int l, int m) const
    4146  {
    4247      return *(elem_.Begin()+ adr_ij(l,m));
    4348  }
    44  inline  int_4  rowNumber() const {return (int_4)long_diag_;}
    45   private:
    46  /*! compute the address of an element in the single array representing the matrix */
     49
     50//! Return number of rows
     51inline  int_4  rowNumber() const {return (int_4)long_diag_;}
     52
     53private:
     54//! compute the address of an element in the single array representing the matrix
    4755inline uint_4 adr_ij(int i,int j) const
    4856{
    … …  
    5664}
    5765
    58  uint_4 long_diag_;
    59  NDataBlock<T> elem_;
     66uint_4 long_diag_;    //!< size of the square matrix
     67NDataBlock<T> elem_;  //!< Data block
    6068
    6169  };

  • trunk/SophyaLib/TArray/tvector.cc

    r894 r914  
    1 // $Id: tvector.cc,v 1.4 2000-04-12 17:42:30 ansari Exp $
     1// $Id: tvector.cc,v 1.5 2000-04-13 16:04:49 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    7070 */
    7171template <class T>
    72 TVector<T>::TVector(const TArray<T>& a, bool share, short mm, short lcv )
     72TVector<T>::TVector(const TArray<T>& a, bool share, short lcv, short mm)
    7373: TMatrix<T>(a, share, mm)
    7474{

  • trunk/SophyaLib/TArray/tvector.h

    r898 r914  
    1717  // Creation / destruction
    1818  TVector();
    19   TVector(uint_4 n, short lcv=ColumnVector, short mm=AutoMemoryMapping);
     19  TVector(uint_4 n, short lcv=AutoVectorType, short mm=AutoMemoryMapping);
    2020  TVector(const TVector<T>& v);
    2121  TVector(const TVector<T>& v, bool share);
    2222  TVector(const TArray<T>& a);
    23   TVector(const TArray<T>& a,  bool share, short mm=CMemoryMapping, short lcv=ColumnVector);
     23  TVector(const TArray<T>& a,  bool share, short lcv=AutoVectorType, short mm=AutoMemoryMapping);
    2424
    2525  virtual ~TVector();
    … …  
    2828  inline  TVector<T>& operator = (const TVector<T>& a)
    2929                       { Set(a);  return(*this); }
    30 
    3130
    3231  // Gestion taille/Remplissage
    … …  
    5049  // Operateur d'affectation
    5150  //! Fill the vector with Sequence \b seq
    52   inline  TMatrix<T>&  operator = (Sequence seq) { SetSeq(seq); return(*this); }
     51  inline  TVector<T>&  operator = (Sequence seq) { SetSeq(seq); return(*this); }
    5352
    5453  // Operations diverses  avec une constante
Note: See TracChangeset for help on using the changeset viewer.