Changeset 926 in Sophya for trunk/SophyaLib/NTools


Ignore:
Timestamp:
Apr 13, 2000, 8:39:39 PM (25 years ago)
Author:
ansari
Message:

documentation cmv 13/4/00

Location:
trunk/SophyaLib/NTools
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/NTools/fct1dfit.cc

    r514 r926  
    1818
    1919/////////////////////////////////////////////////////////////////
    20 //++
    21 // Module       Classes de fonctions 1D
    22 // Lib  Outils++
    23 // include      fct1dfit.h
    24 //--
    25 /////////////////////////////////////////////////////////////////
    26 
    27 /////////////////////////////////////////////////////////////////
    28 //++
    29 // Titre        Gauss1DPol
    30 // \index{Gauss1DPol}
    31 //
    32 //|  Gaussienne+polynome:
    33 //|  Si polcenter=true: xc=(x-par[1]), sinon xc=x
    34 //|  f(x) = par[0]*exp[-0.5*( (x-par[1]) / par[2] )**2 ]
    35 //|        +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
    36 //|  NDegPol = degre du polynome, si <0 pas de polynome
    37 //--
    38 /////////////////////////////////////////////////////////////////
    39 
    40 //++
     20/*!
     21  \class SOPHYA::Gauss1DPol
     22  \ingroup NTools
     23  \anchor Gauss1DPol
     24  \verbatim
     25     Gaussienne+polynome:
     26     Si polcenter=true: xc=(x-par[1]), sinon xc=x
     27     f(x) = par[0]*exp[-0.5*( (x-par[1]) / par[2] )**2 ]
     28           +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
     29     NDegPol = degre du polynome, si <0 pas de polynome
     30  \endverbatim
     31*/
    4132Gauss1DPol::Gauss1DPol(unsigned int ndegpol,bool polcenter)
    42 //
    43 //      Createur.
    44 //--
    4533: GeneralFunction(1,ndegpol+4), NDegPol(ndegpol), PolCenter(polcenter)
    4634{
    4735}
    4836
    49 //++
    5037Gauss1DPol::Gauss1DPol(bool polcenter)
    51 //
    52 //      Createur.
    53 //--
    5438: GeneralFunction(1,3), NDegPol(-1), PolCenter(polcenter)
    5539{
    … …  
    10791
    10892/////////////////////////////////////////////////////////////////
    109 //++
    110 // Titre        GaussN1DPol
    111 // \index{GaussN1DPol}
    112 //
    113 //| Gaussienne_Normalisee+polynome (par[0]=Volume:
    114 //|  Si polcenter=true: xc=(x-par[1]), sinon xc=x
    115 //|  f(x) = par[0]/(sqrt(2*Pi)*par[2])*exp[-0.5*((x-par[1])/par[2])**2 ]
    116 //|        +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
    117 //|  NDegPol = degre du polynome, si <0 pas de polynome
    118 //--
    119 /////////////////////////////////////////////////////////////////
    120 
    121 //++
     93/*!
     94  \class SOPHYA::GaussN1DPol
     95  \ingroup NTools
     96  \anchor GaussN1DPol
     97  \verbatim
     98    Gaussienne_Normalisee+polynome (par[0]=Volume:
     99     Si polcenter=true: xc=(x-par[1]), sinon xc=x
     100     f(x) = par[0]/(sqrt(2*Pi)*par[2])*exp[-0.5*((x-par[1])/par[2])**2 ]
     101           +par[3] + par[4]*xc + .... + par[3+NDegPol]*xc**NDegPol
     102     NDegPol = degre du polynome, si <0 pas de polynome
     103  \endverbatim
     104*/
    122105GaussN1DPol::GaussN1DPol(unsigned int ndegpol,bool polcenter)
    123 //
    124 //      Createur.
    125 //--
    126106: GeneralFunction(1,ndegpol+4), NDegPol(ndegpol), PolCenter(polcenter)
    127107{
    128108}
    129109
    130 //++
    131110GaussN1DPol::GaussN1DPol(bool polcenter)
    132 //
    133 //      Createur.
    134 //--
    135111: GeneralFunction(1,3), NDegPol(-1), PolCenter(polcenter)
    136112{
    … …  
    189165
    190166/////////////////////////////////////////////////////////////////
    191 //++
    192 // Titre        Exp1DPol
    193 // \index{Exp1DPol}
    194 //
    195 //|  Exponentielle+polynome:
    196 //|  xx = x - X_Center
    197 //|  f(x) = exp[par[0]+par[1]*xx]
    198 //|        +par[2] + par[3]*xx + .... + par[2+NDegPol]*xx**NDegPol
    199 //|  NDegPol = degre du polynome, si <0 pas de polynome
    200 //--
    201 /////////////////////////////////////////////////////////////////
    202 
    203 //++
     167/*!
     168  \class SOPHYA::Exp1DPol
     169  \ingroup NTools
     170  \anchor Exp1DPol
     171  \verbatim
     172     Exponentielle+polynome:
     173     xx = x - X_Center
     174     f(x) = exp[par[0]+par[1]*xx]
     175           +par[2] + par[3]*xx + .... + par[2+NDegPol]*xx**NDegPol
     176     NDegPol = degre du polynome, si <0 pas de polynome
     177  \endverbatim
     178*/
    204179Exp1DPol::Exp1DPol(unsigned int ndegpol,double x0)
    205 //
    206 //      Createur.
    207 //--
    208180: GeneralFunction(1,ndegpol+3), NDegPol(ndegpol), X_Center(x0)
    209181{
    210182}
    211183
    212 //++
    213184Exp1DPol::Exp1DPol(double x0)
    214 //
    215 //      Createur.
    216 //--
    217185: GeneralFunction(1,2), NDegPol(-1), X_Center(x0)
    218186{
    … …  
    259227
    260228/////////////////////////////////////////////////////////////////
    261 //++
    262 // Titre        Polyn1D
    263 // \index{Polyn1D}
    264 //
    265 //| polynome 1D:
    266 //|  xx = x - X_Center
    267 //|  f(x) = par[0] + par[1]*xx + .... + par[NDegPol+1]*xx**NDegPol
    268 //|  NDegPol = degre du polynome
    269 //--
    270 /////////////////////////////////////////////////////////////////
    271 
    272 //++
     229/*!
     230  \class SOPHYA::Polyn1D
     231  \ingroup NTools
     232  \anchor Polyn1D
     233  \verbatim
     234    polynome 1D:
     235     xx = x - X_Center
     236     f(x) = par[0] + par[1]*xx + .... + par[NDegPol+1]*xx**NDegPol
     237     NDegPol = degre du polynome
     238  \endverbatim
     239*/
    273240Polyn1D::Polyn1D(unsigned int ndegpol,double x0)
    274 //
    275 //      Createur.
    276 //--
    277241: GeneralFunction(1,ndegpol+1), NDegPol(ndegpol), X_Center(x0)
    278242{
    … …  
    309273
    310274/////////////////////////////////////////////////////////////////
    311 //++
    312 // Titre        HarmonieNu
    313 // \index{HarmonieNu}
    314 //
    315 //| Analyse harmonique:
    316 //|  f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*par(0)*(t-t0)]
    317 //|                + Sum[par(2k+1)*sin(2*pi*k*par(0)*(t-t0)]
    318 //|  la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
    319 //|  avec la convention   k=1  pour le fondamental
    320 //|                       k>1  pour le (k-1)ieme harmonique
    321 //--
    322 //++
    323 //|  par(0) = inverse de la periode (frequence)
    324 //|  par(1) = terme constant
    325 //|  par(2), par(3) = termes devant le cosinus et le sinus
    326 //|                   du fondamental
    327 //|  par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
    328 //|                   et le sinus de l'harmonique m (m>=1).
    329 //|  NHarm() = nombre d'harmoniques a fitter.
    330 //|  T0() = centrage des temps, ce n'est pas un parametre du fit.
    331 //      `Conseil:' Avant de faire un fit avec les `NHarm()'
    332 //      harmoniques, il est preferable de faire un pre-fit
    333 //      ou seuls les parametres 1,2 et 3 sont libres et d'injecter
    334 //      le resultat du fit sur ces 3 parametres comme valeurs
    335 //      de depart pour le fit global avec les `NHarm()' harmoniques.
    336 //      De toute facon, le fit ne marchera que si la periode
    337 //      est initialisee de facon tres precise.
    338 //--
    339 /////////////////////////////////////////////////////////////////
    340 
    341 //++
     275/*!
     276  \class SOPHYA::HarmonieNu
     277  \ingroup NTools
     278  \anchor HarmonieNu
     279  \verbatim
     280    Analyse harmonique:
     281     f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*par(0)*(t-t0)]
     282                   + Sum[par(2k+1)*sin(2*pi*k*par(0)*(t-t0)]
     283     la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
     284     avec la convention   k=1  pour le fondamental
     285                          k>1  pour le (k-1)ieme harmonique
     286     par(0) = inverse de la periode (frequence)
     287     par(1) = terme constant
     288     par(2), par(3) = termes devant le cosinus et le sinus
     289                      du fondamental
     290     par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
     291                      et le sinus de l'harmonique m (m>=1).
     292     NHarm() = nombre d'harmoniques a fitter.
     293     T0() = centrage des temps, ce n'est pas un parametre du fit.
     294        `Conseil:' Avant de faire un fit avec les `NHarm()'
     295        harmoniques, il est preferable de faire un pre-fit
     296        ou seuls les parametres 1,2 et 3 sont libres et d'injecter
     297        le resultat du fit sur ces 3 parametres comme valeurs
     298        de depart pour le fit global avec les `NHarm()' harmoniques.
     299        De toute facon, le fit ne marchera que si la periode
     300        est initialisee de facon tres precise.
     301  \endverbatim
     302*/
    342303HarmonieNu::HarmonieNu(unsigned int nharm,double t0)
    343 //
    344 //      Createur.
    345 //--
    346304: GeneralFunction(1,4+2*nharm), NHarm(nharm), T0(t0)
    347305{
    … …  
    384342
    385343/////////////////////////////////////////////////////////////////
    386 //++
    387 // Titre        HarmonieT
    388 // \index{HarmonieT}
    389 //
    390 //| Analyse harmonique:
    391 //|  f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*(t-t0)/par(0)]
    392 //|                + Sum[par(2k+1)*sin(2*pi*k*(t-t0)/par(0)]
    393 //|  la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
    394 //|  avec la convention   k=1  pour le fondamental
    395 //|                       k>1  pour le (k-1)ieme harmonique
    396 //--
    397 //++
    398 //|  par(0) = periode
    399 //|  par(1) = terme constant
    400 //|  par(2), par(3) = termes devant le cosinus et le sinus
    401 //|                   du fondamental
    402 //|  par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
    403 //|                   et le sinus de l'harmonique m (m>=1).
    404 //|  NHarm() = nombre d'harmoniques a fitter.
    405 //|  T0() = centrage des temps, ce n'est pas un parametre du fit.
    406 //--
    407 /////////////////////////////////////////////////////////////////
    408 
    409 //++
     344/*!
     345  \class SOPHYA::HarmonieT
     346  \ingroup NTools
     347  \anchor HarmonieT
     348  \verbatim
     349    Analyse harmonique:
     350     f(t) = par(1) + Sum[par(2k)  *cos(2*pi*k*(t-t0)/par(0)]
     351                   + Sum[par(2k+1)*sin(2*pi*k*(t-t0)/par(0)]
     352     la somme Sum porte sur l'indice k qui varie de [1,NHarm()+1]
     353     avec la convention   k=1  pour le fondamental
     354                          k>1  pour le (k-1)ieme harmonique
     355     par(0) = periode
     356     par(1) = terme constant
     357     par(2), par(3) = termes devant le cosinus et le sinus
     358                      du fondamental
     359     par(2(m+1)), par(2(m+1)+1) = termes devant le cosinus
     360                      et le sinus de l'harmonique m (m>=1).
     361     NHarm() = nombre d'harmoniques a fitter.
     362     T0() = centrage des temps, ce n'est pas un parametre du fit.
     363  \endverbatim
     364*/
    410365HarmonieT::HarmonieT(unsigned int nharm,double t0)
    411 //
    412 //      Createur.
    413 //--
    414366: GeneralFunction(1,4+2*nharm), NHarm(nharm), T0(t0)
    415367{
    … …  
    455407
    456408/////////////////////////////////////////////////////////////////
    457 //++
    458 // Module       Classes de fonctions 2D
    459 // Lib  Outils++
    460 // include      fct1dfit.h
    461 //--
    462 /////////////////////////////////////////////////////////////////
    463 
    464 /////////////////////////////////////////////////////////////////
    465 //++
    466 // Titre        Polyn2D
    467 // \index{Polyn2D}
    468 //
    469 //| polynome 2D de degre total degre:
    470 //|  NDegPol = degre du polynome (note N dans la suite)
    471 //|  x = x - X_Center,  y = y - Y_Center
    472 //|  f(x,y) = p[0] +sum(k=1,n){ sum(i=0,k){ p[ki]*x^i*y^(k-i) }}
    473 //|  Il y a k+1 termes de degre k  (ex: x^i*y^(k-i))
    474 //|  terme de degre k avec x^i: p[ki] avec  ki = k*(k+1)/2 + i
    475 //| C'est a dire:
    476 //| deg0:   p0
    477 //| deg1: + p1*y + p2*x
    478 //| deg2: + p3*y^2 + p4*x*y + p5*x^2
    479 //| deg3: + p6*y^3 + p7*x*y^2 + p8*x^2*y + p9*x^3
    480 //| deg4: + p10*y^4 + p11*x*y^3 + p12*x^2*y^2 + p13*x^3*y + p14*x^4
    481 //| deg5: + p15*y^5 + ...                       ... + ... + p20*x^5
    482 //| ...
    483 //| degk: + p[k*(k+1)/2]*y^k + ...           ... + p[k*(k+3)/2]*x^k
    484 //| ...
    485 //| degn: + p[n*(n+1)/2]*y^n + ...           ... + p[n*(n+3)/2]*x^n
    486 //--
    487 /////////////////////////////////////////////////////////////////
    488 
    489 //++
     409/*!
     410  \class SOPHYA::Polyn2D
     411  \ingroup NTools
     412  \anchor Polyn2D
     413  \verbatim
     414    polynome 2D de degre total degre:
     415     NDegPol = degre du polynome (note N dans la suite)
     416     x = x - X_Center,  y = y - Y_Center
     417     f(x,y) = p[0] +sum(k=1,n){ sum(i=0,k){ p[ki]*x^i*y^(k-i) }}
     418     Il y a k+1 termes de degre k  (ex: x^i*y^(k-i))
     419     terme de degre k avec x^i: p[ki] avec  ki = k*(k+1)/2 + i
     420    C'est a dire:
     421    deg0:   p0
     422    deg1: + p1*y + p2*x
     423    deg2: + p3*y^2 + p4*x*y + p5*x^2
     424    deg3: + p6*y^3 + p7*x*y^2 + p8*x^2*y + p9*x^3
     425    deg4: + p10*y^4 + p11*x*y^3 + p12*x^2*y^2 + p13*x^3*y + p14*x^4
     426    deg5: + p15*y^5 + ...                       ... + ... + p20*x^5
     427    ...
     428    degk: + p[k*(k+1)/2]*y^k + ...           ... + p[k*(k+3)/2]*x^k
     429    ...
     430    degn: + p[n*(n+1)/2]*y^n + ...           ... + p[n*(n+3)/2]*x^n
     431  \endverbatim
     432*/
    490433Polyn2D::Polyn2D(unsigned int ndegpol,double x0,double y0)
    491 //
    492 //      Createur.
    493 //--
    494434: GeneralFunction(2,ndegpol*(ndegpol+3)/2+1), NDegPol(ndegpol), X_Center(x0), Y_Center(y0)
    495435{

  • trunk/SophyaLib/NTools/fct1dfit.h

    r552 r926  
    1111
    1212//////////////////////////////////////////////////////////////////
     13//! Gaussienne + polynome
    1314class Gauss1DPol : public GeneralFunction {
    1415public:
    … …  
    2829
    2930//////////////////////////////////////////////////////////////////
     31//! Gaussienne_Normalisee+polynome
    3032class GaussN1DPol : public GeneralFunction {
    3133public:
    … …  
    4547
    4648//////////////////////////////////////////////////////////////////
     49//! Exponentielle + polynome
    4750class Exp1DPol : public GeneralFunction {
    4851public:
    … …  
    6366
    6467//////////////////////////////////////////////////////////////////
     68//! polynome 1D
    6569class Polyn1D : public GeneralFunction {
    6670public:
    … …  
    8084
    8185//////////////////////////////////////////////////////////////////
     86//! Analyse harmonique
    8287class HarmonieNu : public GeneralFunction {
    8388public:
    … …  
    98103
    99104//////////////////////////////////////////////////////////////////
     105//! Analyse harmonique
    100106class HarmonieT : public GeneralFunction {
    101107public:
    … …  
    120126
    121127//////////////////////////////////////////////////////////////////
     128//! polynome 2D
    122129class Polyn2D : public GeneralFunction {
    123130public:

  • trunk/SophyaLib/NTools/fct2dfit.cc

    r514 r926  
    2222
    2323/////////////////////////////////////////////////////////////////
    24 //++
    25 // Class        GeneralPSF2D
    26 // Lib  Outils++
    27 // include      fct2dfit.h
    28 //
    29 //      Classe de definition d'une PSF 2D a nPar parametres
    30 //      Pour definir une PSF, il faut creer une classe qui herite
    31 //      de ``GeneralPSF2D'' (cf par exemple GauRho2D...).
    32 //      La disposition des parametres definissant la PSF est indifferente,
    33 //      toutefois il est conseille de suivre l'ordre:
    34 //--
    35 //++
    36 //  - PSF 2D a NPar parametres:
    37 //  p[0] = Volume (ou hauteur)
    38 //  p[1] = centre X0, p[2] = centre Y0
    39 //  p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
    40 //  p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
    41 //                  (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
    42 //  p[NPar-1] = Fond
    43 //--
    44 //++
    45 //      L'emploi de certaines classes comme par exemple ``GenMultiPSF2D''
    46 //      necessite de suivre rigoureusement l'ordre indique ci-dessus
    47 //      pour les parametres.
    48 //--
    49 
    50 //++
     24/*!
     25  \class SOPHYA::GeneralPSF2D
     26  \ingroup NTools
     27  \anchor GeneralPSF2D
     28   Classe de definition d'une PSF 2D a nPar parametres
     29   Pour definir une PSF, il faut creer une classe qui herite
     30   de ``GeneralPSF2D'' (cf par exemple GauRho2D...).
     31   La disposition des parametres definissant la PSF est indifferente,
     32   toutefois il est conseille de suivre l'ordre:
     33  \verbatim
     34   - PSF 2D a NPar parametres:
     35   p[0] = Volume (ou hauteur)
     36   p[1] = centre X0, p[2] = centre Y0
     37   p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
     38   p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
     39                   (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
     40   p[NPar-1] = Fond
     41  \endverbatim
     42   L'emploi de certaines classes comme par exemple ``GenMultiPSF2D''
     43   necessite de suivre rigoureusement l'ordre indique ci-dessus
     44   pour les parametres.
     45*/
     46
    5147GeneralPSF2D::GeneralPSF2D(unsigned int nPar)
    52 //
    53 //--
    5448: GeneralFunction(2,nPar), VolEps(1.e-4)
    5549{
    … …  
    6155}
    6256
    63 //++
     57/*!
     58  \verbatim
     59    ValueH = hauteur*forme(x,y)+fond tq forme(0,0)=1.
     60        alors que Value = volume*forme(x,y)+fond tq volume(forme)=1.
     61    Dans notre convention le dernier parametre est le fond,
     62    le premier le volume et les 2 suivants le centrage x0,y0
     63    ---> Ici parm[0] = hauteur
     64  \endverbatim
     65 */
    6466double GeneralPSF2D::ValueH(double const xp[], double const* parm)
    65 //
    66 //| ValueH = hauteur*forme(x,y)+fond tq forme(0,0)=1.
    67 //|     alors que Value = volume*forme(x,y)+fond tq volume(forme)=1.
    68 //| Dans notre convention le dernier parametre est le fond,
    69 //| le premier le volume et les 2 suivants le centrage x0,y0
    70 //| ---> Ici parm[0] = hauteur
    71 //--
    7267{
    7368double x0[2];
    … …  
    8277}
    8378
    84 //++
     79/*!
     80  \verbatim
     81    Cette fonction calcule le volume d'une PSF de hauteur=1
     82    avec une precision de "VolEps"
     83    dans le but de connaitre le coefficient permettant
     84    de convertir le volume d'une PSF en son amplitude
     85    ou vice-versa: " volume = VolPSF * hauteur "
     86     L'integration se fait 1/4 de pixel par 1/4 de pixel
     87     ATTENTION: Il s'agit de PSF donc x,y,x0,y0,Sigma.. sont en pixels
     88  \endverbatim
     89 */
    8590double GeneralPSF2D::VolPSF(double const* parm)
    86 //
    87 //| Cette fonction calcule le volume d'une PSF de hauteur=1
    88 //| avec une precision de "VolEps"
    89 //| dans le but de connaitre le coefficient permettant
    90 //| de convertir le volume d'une PSF en son amplitude
    91 //| ou vice-versa: " volume = VolPSF * hauteur "
    92 //|  L'integration se fait 1/4 de pixel par 1/4 de pixel
    93 //|  ATTENTION: Il s'agit de PSF donc x,y,x0,y0,Sigma.. sont en pixels
    94 //--
    9591{
    9692 double x[2],step;
    … …  
    135131}
    136132
    137 //++
     133//! Definition des defauts des parametres
    138134void GeneralPSF2D::DefaultParam(double *parm)
    139 //
    140 //      Definition des defauts des parametres
    141 //--
    142135{
    143136  for (int i=0; i<mNPar; i++) parm[i] = 0.;
    … …  
    145138}
    146139
    147 //++
     140//! Definition de la precision sur le calcul du volume
    148141void GeneralPSF2D::SetVolEps(double const prec)
    149 //
    150 //      Definition de la precision sur le calcul du volume
    151 //--
    152142{
    153143  VolEps = prec;
    … …  
    159149
    160150/////////////////////////////////////////////////////////////////
    161 //++
    162 // Class        GenMultiPSF2D
    163 // Lib  Outils++
    164 // include      fct2dfit.h
    165 //
    166 //      Classe de definition d'un ensemble de PSF2D
    167 //      pour fiter simultanement plusieurs etoiles et un fond constant.
    168 //      Les parametres de forme de la PSF (Sx, Sy, Rho etc... et Fond)
    169 //      sont les memes pour toutes les etoiles, seuls le centre
    170 //      (X0,Y0) et le volume (ou la hauteur) V varient pour chaque etoile.
    171 //      La disposition des parametres definissant la PSF generique
    172 //      est obligatoirement la suivante:
    173 //--
    174 //++
    175 //|  - PSF 2D a NPar parametres:
    176 //|  p[0] = Volume (ou hauteur)
    177 //|  p[1] = centre X0, p[2] = centre Y0
    178 //|  p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
    179 //|  p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
    180 //|                  (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
    181 //|  p[NPar-1] = Fond
    182 //|
    183 //--
    184 //++
    185 //|  - La Multi-PSF a ses parametres arranges dans l'ordre suivant:
    186 //|    Soit NStar le nombre d'etoiles a fiter simultanement
    187 //|         NP = le nombre de parametres de la PSF 2D generique
    188 //|    On a NF = NP-7 parametres de forme supplementaires
    189 //|         (ex: nf=0 pour GauRho2D, nf=1 pour MofRho2D)
    190 //|  p[0],p[1],p[2] = V0,X0,Y0 pour la premiere etoile
    191 //|  p[3],p[4],p[5] = V1,X1,Y1 pour la deuxieme etoile
    192 //|  ...
    193 //|  p[3*i],p[3*i+1],p[3*i+2] = Vi,Xi,Yi pour la (i+1) ieme etoile
    194 //|  ...
    195 //|  p[m*i],p[m*i+1],p[m*i+2] = Vm,Xm,Ym   ;   m = NStar-1
    196 //|                       pour la NStar ieme et derniere etoile
    197 //|  p[3*NStar],p[3*NStar+1],p[3*NStar+2] = SigmaX, SigmaY et Rho
    198 //|  p[3*NStar+3],...,p[3*NStar+2+NF] = parametres de forme
    199 //|                        supplementaires pour definir la PSF 2D
    200 //|  p[3*NStar+2+NF+1] = Fond
    201 //--
    202 
    203 //++
     151/*!
     152  \class SOPHYA::GenMultiPSF2D
     153  \ingroup NTools
     154  \anchor GenMultiPSF2D
     155   Classe de definition d'un ensemble de PSF2D
     156   pour fiter simultanement plusieurs etoiles et un fond constant.
     157   Les parametres de forme de la PSF (Sx, Sy, Rho etc... et Fond)
     158   sont les memes pour toutes les etoiles, seuls le centre
     159   (X0,Y0) et le volume (ou la hauteur) V varient pour chaque etoile.
     160   La disposition des parametres definissant la PSF generique
     161   est obligatoirement la suivante:
     162  \verbatim
     163     - PSF 2D a NPar parametres:
     164     p[0] = Volume (ou hauteur)
     165     p[1] = centre X0, p[2] = centre Y0
     166     p[3] = SigmaX   , p[4] = SigmaY,    p[5] = Rho
     167     p[6],p[7],... = autres parametres (eventuels) definissant la PSF.
     168                     (ex: pour la Moffat p[6] = exposant Beta et NPar=8).
     169     p[NPar-1] = Fond
     170   
     171     - La Multi-PSF a ses parametres arranges dans l'ordre suivant:
     172       Soit NStar le nombre d'etoiles a fiter simultanement
     173            NP = le nombre de parametres de la PSF 2D generique
     174       On a NF = NP-7 parametres de forme supplementaires
     175            (ex: nf=0 pour GauRho2D, nf=1 pour MofRho2D)
     176     p[0],p[1],p[2] = V0,X0,Y0 pour la premiere etoile
     177     p[3],p[4],p[5] = V1,X1,Y1 pour la deuxieme etoile
     178     ...
     179     p[3*i],p[3*i+1],p[3*i+2] = Vi,Xi,Yi pour la (i+1) ieme etoile
     180     ...
     181     p[m*i],p[m*i+1],p[m*i+2] = Vm,Xm,Ym   ;   m = NStar-1
     182                          pour la NStar ieme et derniere etoile
     183     p[3*NStar],p[3*NStar+1],p[3*NStar+2] = SigmaX, SigmaY et Rho
     184     p[3*NStar+3],...,p[3*NStar+2+NF] = parametres de forme
     185                           supplementaires pour definir la PSF 2D
     186     p[3*NStar+2+NF+1] = Fond
     187  \endverbatim
     188*/
     189
     190/*!
     191  Createur. ``psf2d'' est le nom de la PSF generique a utiliser,
     192  et ``nstar'' est le nombre d'etoiles a fiter simultanement.
     193  */
    204194GenMultiPSF2D::GenMultiPSF2D(GeneralPSF2D* psf2d,unsigned int nstar)
    205 //
    206 //      Createur. ``psf2d'' est le nom de la PSF generique a utiliser,
    207 //      et ``nstar'' est le nombre d'etoiles a fiter simultanement.
    208 //--
    209195  : GeneralPSF2D((psf2d!=NULL) ? 3*nstar+4+psf2d->NPar()-7: 0)
    210196  , mPsf2D(psf2d), mNStar(nstar)
    … …  
    299285
    300286/////////////////////////////////////////////////////////////////
    301 //++
    302 // Module       Classes de PSF 2D
    303 // Lib  Outils++
    304 // include      fct2dfit.h
    305 //--
    306 /////////////////////////////////////////////////////////////////
    307 
    308 /////////////////////////////////////////////////////////////////
    309 //++
    310 // Titre        GauRho2D
    311 // \index{GauRho2D}
    312 //
    313 //| gaussienne+fond 2D
    314 //| Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
    315 //|   sigx,sigy,rho = sigma et rho de la gaussienne
    316 //|   x0,y0 = centre de la gaussienne
    317 //|  PSF(x,y) = N * exp[ - 1/2 (X**2 + Y**2 -2*rho*X*Y) ]
    318 //|           avec X = (x-x0)/sigx et Y = (y-y0)/sigy
    319 //|                N = sqrt(1-rho**2)/(2*Pi*sigx*sigy)
    320 //|  le volume de cette gaussienne est V=1.
    321 //|  F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
    322 //--
    323 //++
    324 //| -*- Remarque: De la facon dont est ecrite la PSF gaussienne
    325 //| sigx,sigy representent les sigmas des gaussiennes 1D
    326 //| qui sont les coupes de la gaussienne 2D pour y=0 et x=0.
    327 //| Les moments centres d'ordre 2 sont
    328 //|   sx = sigx/sqrt(1-ro^2) et sy = sigy/sqrt(1-ro^2)
    329 //--
    330 /////////////////////////////////////////////////////////////////
    331 
    332 //++
     287/*!
     288  \class SOPHYA::GauRho2D
     289  \ingroup NTools
     290  \anchor GauRho2D
     291  \verbatim
     292    gaussienne+fond 2D
     293    Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
     294      sigx,sigy,rho = sigma et rho de la gaussienne
     295      x0,y0 = centre de la gaussienne
     296     PSF(x,y) = N * exp[ - 1/2 (X**2 + Y**2 -2*rho*X*Y) ]
     297              avec X = (x-x0)/sigx et Y = (y-y0)/sigy
     298                   N = sqrt(1-rho**2)/(2*Pi*sigx*sigy)
     299     le volume de cette gaussienne est V=1.
     300     F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
     301    -*- Remarque: De la facon dont est ecrite la PSF gaussienne
     302    sigx,sigy representent les sigmas des gaussiennes 1D
     303    qui sont les coupes de la gaussienne 2D pour y=0 et x=0.
     304    Les moments centres d'ordre 2 sont
     305      sx = sigx/sqrt(1-ro^2) et sy = sigy/sqrt(1-ro^2)
     306  \endverbatim
     307*/
     308/////////////////////////////////////////////////////////////////
     309
    333310GauRho2D::GauRho2D()
    334 //
    335 //      Createur
    336 //--
    337311: GeneralPSF2D(7)
    338312{
    … …  
    409383
    410384/////////////////////////////////////////////////////////////////
    411 //++
    412 // Titre        GauRhInt2D
    413 // \index{GauRhInt2D}
    414 //
    415 //| Cette fonction calcule une approximation a l'integrale d'une
    416 //| gaussienne 2D sur un carre de longueur unite (x,y-05 -> x,y+0.5)
    417 //--
    418 /////////////////////////////////////////////////////////////////
    419 
    420 //++
     385/*!
     386  \class SOPHYA::GauRhInt2D
     387  \ingroup NTools
     388  \anchor GauRhInt2D
     389  \verbatim
     390    Cette fonction calcule une approximation a l'integrale d'une
     391    gaussienne 2D sur un carre de longueur unite (x,y-05 -> x,y+0.5)
     392  \endverbatim
     393  \sa GauRho2D
     394*/
     395/////////////////////////////////////////////////////////////////
     396
    421397GauRhInt2D::GauRhInt2D()
    422 //
    423 //      Createur
    424 //--
    425398: GeneralPSF2D(7)
    426399{
    … …  
    519492
    520493/////////////////////////////////////////////////////////////////
    521 //++
    522 // Titre        GdlRho2D
    523 // \index{GdlRho2D}
    524 //
    525 //| Cette fonction calcule une gaussienne 2D de volume 1 approchee
    526 //|  par son developpement limite au 3ieme ordre (see dophot)
    527 //|  Meme commentaire que GauRho2D, cf plus haut sauf que:
    528 //|  Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
    529 //|    z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
    530 //|    PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 + B6/6 *z**6 ]
    531 //|               N = KB4B6
    532 //|    le coefficient KB4B6 etant trop dur a calculer analytiquement
    533 //|    Il doit etre calcule numeriquement et entre dans ce programme
    534 //|  ATTENTION: dans cette routine B4 et B6 sont imposes et pas fites!
    535 //|  - DL de la gaussienne:  B4=1., B6=1., KB4B6=0.13688679
    536 //|  le volume de cette gaussienne est V=1.
    537 //|  F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
    538 //--
    539 /////////////////////////////////////////////////////////////////
    540 
    541 //++
     494/*!
     495  \class SOPHYA::GdlRho2D
     496  \ingroup NTools
     497  \anchor GdlRho2D
     498  \verbatim
     499    Cette fonction calcule une gaussienne 2D de volume 1 approchee
     500     par son developpement limite au 3ieme ordre (see dophot)
     501     Meme commentaire que GauRho2D, cf plus haut sauf que:
     502     Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=fond
     503       z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
     504       PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 + B6/6 *z**6 ]
     505                  N = KB4B6
     506       le coefficient KB4B6 etant trop dur a calculer analytiquement
     507       Il doit etre calcule numeriquement et entre dans ce programme
     508     ATTENTION: dans cette routine B4 et B6 sont imposes et pas fites!
     509     - DL de la gaussienne:  B4=1., B6=1., KB4B6=0.13688679
     510     le volume de cette gaussienne est V=1.
     511     F(x,y) = Par[0]*PSF(x,y)+Par[6] (volume=Par[0],fond=Par[6])
     512  \endverbatim
     513*/
     514/////////////////////////////////////////////////////////////////
     515
    542516GdlRho2D::GdlRho2D()
    543 //
    544 //      Createur
    545 //--
    546517: GeneralPSF2D(7)
    547518{
    … …  
    617588
    618589/////////////////////////////////////////////////////////////////
    619 //++
    620 // Titre        GdlRhInt2D
    621 // \index{GdlRhInt2D}
    622 //
    623 //      fonction integree de GdlRho2d
    624 //--
    625 /////////////////////////////////////////////////////////////////
    626 
    627 //++
     590/*!
     591  \class SOPHYA::GdlRhInt2D
     592  \ingroup NTools
     593  \anchor GdlRhInt2D
     594  Fonction integree de GdlRho2d
     595  \sa GdlRho2D
     596*/
     597/////////////////////////////////////////////////////////////////
     598
    628599GdlRhInt2D::GdlRhInt2D()
    629 //
    630 //      Createur
    631 //--
    632600: GeneralPSF2D(7)
    633601{
    … …  
    732700
    733701/////////////////////////////////////////////////////////////////
    734 //++
    735 // Titre        Gdl1Rho2D
    736 // \index{Gdl1Rho2D}
    737 //
    738 //| Cette fonction calcule une gaussienne 2D approchee
    739 //| par son developpement limite au 2sd ordre (see dophot)
    740 //| Meme commentaire que GauRho2D, cf plus haut sauf que:
    741 //|   z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
    742 //|   PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 ]
    743 //|   Le coefficient B4 est fitte (6ieme parametres)
    744 //| ATTENTION: les normalisations N dependent de B4
    745 //|  1-/ B4 est suppose etre toujours positif pour que la PSF tendent
    746 //|      vers 0+ quand z2 tend vers l'infini
    747 //|  2-/ Il y a 3 cas de calcul de K(B4) = int(PSF(x,y)) de 0 a l'infini
    748 //|             0<B4<1/2, 1/2<B4, et B4=1/2
    749 //|      mais pour des raisons d'analyse
    750 //|      numerique j'ai pris 3 intervalles:
    751 //|             0.<B4<0.499, 0.501<B4, 0.499<=B4<=0.501
    752 //|      dans le 3ieme intervalle, comme K est continue est derivable
    753 //|      en B4=1/2, j'ai represente K par la droite tangeante
    754 //|      ce qui, apres verification dans paw est une tres bonne approx.
    755 //|      (je tiens les calculs a disposition.. me demander)
    756 //|  Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=B4 [7]=fond
    757 //|  F(x,y) = Par[0]*PSF(x,y)+Par[7]
    758 //--
    759 /////////////////////////////////////////////////////////////////
    760 
    761 //++
     702/*!
     703  \class SOPHYA::Gdl1Rho2D
     704  \ingroup NTools
     705  \anchor Gdl1Rho2D
     706  \verbatim
     707    Cette fonction calcule une gaussienne 2D approchee
     708    par son developpement limite au 2sd ordre (see dophot)
     709    Meme commentaire que GauRho2D, cf plus haut sauf que:
     710      z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
     711      PSF(x,y) = N / [ 1 + z**2 + B4/2 *z**4 ]
     712      Le coefficient B4 est fitte (6ieme parametres)
     713    ATTENTION: les normalisations N dependent de B4
     714     1-/ B4 est suppose etre toujours positif pour que la PSF tendent
     715         vers 0+ quand z2 tend vers l'infini
     716     2-/ Il y a 3 cas de calcul de K(B4) = int(PSF(x,y)) de 0 a l'infini
     717                0<B4<1/2, 1/2<B4, et B4=1/2
     718         mais pour des raisons d'analyse
     719         numerique j'ai pris 3 intervalles:
     720                0.<B4<0.499, 0.501<B4, 0.499<=B4<=0.501
     721         dans le 3ieme intervalle, comme K est continue est derivable
     722         en B4=1/2, j'ai represente K par la droite tangeante
     723         ce qui, apres verification dans paw est une tres bonne approx.
     724         (je tiens les calculs a disposition.. me demander)
     725     Par [0]=vol [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho [6]=B4 [7]=fond
     726     F(x,y) = Par[0]*PSF(x,y)+Par[7]
     727  \endverbatim
     728*/
     729/////////////////////////////////////////////////////////////////
     730
    762731Gdl1Rho2D::Gdl1Rho2D()
    763 //
    764 //      Createur
    765 //--
    766732: GeneralPSF2D(8)
    767733{
    … …  
    894860
    895861/////////////////////////////////////////////////////////////////
    896 //++
    897 // Titre        Gdl1RhInt2D
    898 // \index{Gdl1RhInt2D}
    899 //
    900 //      fonction integree de Gdl1Rho2D
    901 //--
    902 /////////////////////////////////////////////////////////////////
    903 
    904 //++
     862/*!
     863  \class SOPHYA::Gdl1RhInt2D
     864  \ingroup NTools
     865  \anchor Gdl1RhInt2D
     866  Fonction integree de Gdl1Rho2D
     867  \sa Gdl1Rho2D
     868*/
     869/////////////////////////////////////////////////////////////////
     870
    905871Gdl1RhInt2D::Gdl1RhInt2D()
    906 //
    907 //      Createur
    908 //--
    909872: GeneralPSF2D(8)
    910873{
    … …  
    10581021
    10591022/////////////////////////////////////////////////////////////////
    1060 //++
    1061 // Titre        Gdl2Rho2D
    1062 // \index{Gdl2Rho2D}
    1063 //
    1064 //| Cette fonction calcule une gaussienne 2D de hauteur 1 approchee
    1065 //| par son developpement limite ordre 3 (see dophot)
    1066 //| Meme commentaire que GauRho2D, cf plus haut sauf que:
    1067 //|   z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
    1068 //|   Z**2 = B2*z2
    1069 //|   PSF(x,y) = h / [ 1 + Z**2 + B4**2/2 *Z**4 + B6**2/6 *Z**6 ]
    1070 //|   B2,B4,B6 peuvent etre fittes
    1071 //| - DL de la gaussienne:  B2=B4=B6=1.
    1072 //|  Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
    1073 //|      [6]=B4 [7]=B6 [8]=B2 [9]= fond
    1074 //|  F(x,y) = Par[0]*PSF(x,y)+Par[9]
    1075 //--
    1076 /////////////////////////////////////////////////////////////////
    1077 
    1078 
    1079 //++
     1023/*!
     1024  \class SOPHYA::Gdl2Rho2D
     1025  \ingroup NTools
     1026  \anchor Gdl2Rho2D
     1027  \verbatim
     1028    Cette fonction calcule une gaussienne 2D de hauteur 1 approchee
     1029    par son developpement limite ordre 3 (see dophot)
     1030    Meme commentaire que GauRho2D, cf plus haut sauf que:
     1031      z**2 = 1/2 (X**2 + Y**2 -2*rho*X*Y)
     1032      Z**2 = B2*z2
     1033      PSF(x,y) = h / [ 1 + Z**2 + B4**2/2 *Z**4 + B6**2/6 *Z**6 ]
     1034      B2,B4,B6 peuvent etre fittes
     1035    - DL de la gaussienne:  B2=B4=B6=1.
     1036     Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
     1037         [6]=B4 [7]=B6 [8]=B2 [9]= fond
     1038     F(x,y) = Par[0]*PSF(x,y)+Par[9]
     1039  \endverbatim
     1040*/
     1041/////////////////////////////////////////////////////////////////
     1042
    10801043Gdl2Rho2D::Gdl2Rho2D()
    1081 //
    1082 //      Createur
    1083 //--
    10841044: GeneralPSF2D(10)
    10851045{
    … …  
    11631123
    11641124/////////////////////////////////////////////////////////////////
    1165 //++
    1166 // Titre        Gdl2RhInt2D
    1167 // \index{Gdl2RhInt2D}
    1168 //
    1169 //      fonction integree de Gdl2Rho2d
    1170 //--
    1171 /////////////////////////////////////////////////////////////////
    1172 
    1173 //++
     1125/*!
     1126  \class SOPHYA::Gdl2RhInt2D
     1127  \ingroup NTools
     1128  \anchor Gdl2RhInt2D
     1129  Fonction integree de Gdl2Rho2d
     1130  \sa Gdl2Rho2D
     1131*/
     1132/////////////////////////////////////////////////////////////////
     1133
    11741134Gdl2RhInt2D::Gdl2RhInt2D()
    1175 //
    1176 //      Createur
    1177 //--
    11781135: GeneralPSF2D(10)
    11791136{
    … …  
    12821239
    12831240/////////////////////////////////////////////////////////////////
    1284 //++
    1285 // Titre        MofRho2D
    1286 // \index{MofRho2D}
    1287 //
    1288 //| Cette fonction calcule une Moffat 2D
    1289 //|   Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
    1290 //|       [6]=Gm [7]= fond
    1291 //|  PSF(x,y)  = valeur de la Moffat normalisee a un volume = 1
    1292 //|  PSF(x,y) = N / [ 1. +  0.5*(X**2 + Y**2 -2*rho*X*Y) ]**Gm
    1293 //|           avec X = (x-x0)/sigx et Y = (y-y0)/sigy et Gm>1
    1294 //|                N = (1-Gm)*sqrt(1-rho**2)/(2*Pi*sigx*sigy)
    1295 //|  le volume de cette Moffat est V=1.
    1296 //|  F(x,y) = Par[0]*PSF(x,y)+Par[7]
    1297 //--
    1298 /////////////////////////////////////////////////////////////////
    1299 
    1300 //++
     1241/*!
     1242  \class SOPHYA::MofRho2D
     1243  \ingroup NTools
     1244  \anchor MofRho2D
     1245  \verbatim
     1246    Cette fonction calcule une Moffat 2D
     1247      Par [0]=hauteur [1]=x0 [2]=y0 [3]=sigx [4]=sigy [5]=rho
     1248          [6]=Gm [7]= fond
     1249     PSF(x,y)  = valeur de la Moffat normalisee a un volume = 1
     1250     PSF(x,y) = N / [ 1. +  0.5*(X**2 + Y**2 -2*rho*X*Y) ]**Gm
     1251              avec X = (x-x0)/sigx et Y = (y-y0)/sigy et Gm>1
     1252                   N = (1-Gm)*sqrt(1-rho**2)/(2*Pi*sigx*sigy)
     1253     le volume de cette Moffat est V=1.
     1254     F(x,y) = Par[0]*PSF(x,y)+Par[7]
     1255  \endverbatim
     1256*/
     1257/////////////////////////////////////////////////////////////////
     1258
    13011259MofRho2D::MofRho2D()
    1302 //
    1303 //      Createur
    1304 //--
    13051260: GeneralPSF2D(8)
    13061261{
    … …  
    13811336
    13821337/////////////////////////////////////////////////////////////////
    1383 //++
    1384 // Titre        MofRhInt2D
    1385 // \index{MofRhInt2D}
    1386 //
    1387 //      fonction integree de MofRho2d
    1388 //--
    1389 /////////////////////////////////////////////////////////////////
    1390 
    1391 //++
     1338/*!
     1339  \class SOPHYA::MofRhInt2D
     1340  \ingroup NTools
     1341  \anchor MofRhInt2D
     1342  Fonction integree de MofRho2d
     1343  \sa MofRho2D
     1344*/
     1345/////////////////////////////////////////////////////////////////
     1346
    13921347MofRhInt2D::MofRhInt2D()
    1393 //
    1394 //      Createur
    1395 //--
    13961348: GeneralPSF2D(8)
    13971349{
    … …  
    15121464
    15131465/////////////////////////////////////////////////////////////////
    1514 //++
    1515 // Titre        X2-GauRho2D
    1516 // \index{X2-GauRho2D}
    1517 //
    1518 //      Chi2 pour une Gaussienne+fond 2D (voir detail dans GauRho2D).
    1519 //--
    1520 /////////////////////////////////////////////////////////////////
    1521 
    1522 //++
    1523 // X2-GauRho2D::X2-GauRho2D()
    1524 //      Createur
    1525 //--
     1466/*!
     1467  \class SOPHYA::X2_GauRho2D
     1468  \ingroup NTools
     1469  \anchor X2_GauRho2D
     1470   Chi2 pour une Gaussienne+fond 2D (voir detail dans GauRho2D).
     1471*/
     1472/////////////////////////////////////////////////////////////////
     1473
    15261474X2_GauRho2D::X2_GauRho2D()
    15271475: GeneralXi2(7)

  • trunk/SophyaLib/NTools/fct2dfit.h

    r552 r926  
    1010//================================================================
    1111
     12//! Classe de definition d'une PSF 2D a nPar parametres
    1213class GeneralPSF2D : public GeneralFunction {
    1314public:
    … …  
    2829//================================================================
    2930
     31//! Classe de definition d'un ensemble de PSF2D
    3032class GenMultiPSF2D : public GeneralPSF2D {
    3133public:
    … …  
    5153
    5254//////////////////////////////////////////////////////////////////
     55//! gaussienne + fond 2D
    5356class GauRho2D : public GeneralPSF2D {
    5457public:
    … …  
    6467
    6568//////////////////////////////////////////////////////////////////
     69//! gaussienne integree + fond 2D
    6670class GauRhInt2D : public GeneralPSF2D {
    6771public:
    … …  
    7781
    7882//////////////////////////////////////////////////////////////////
     83//! gaussienne 2D de volume 1 approchee par dl au 3ieme ordre
    7984class GdlRho2D : public GeneralPSF2D {
    8085public:
    … …  
    9095
    9196//////////////////////////////////////////////////////////////////
     97//! gaussienne integree 2D de volume 1 approchee par dl au 3ieme ordre
    9298class GdlRhInt2D : public GeneralPSF2D {
    9399public:
    … …  
    103109
    104110//////////////////////////////////////////////////////////////////
     111//! gaussienne 2D de volume 1 approchee par dl au 2sd ordre
    105112class Gdl1Rho2D : public GeneralPSF2D {
    106113public:
    … …  
    116123
    117124//////////////////////////////////////////////////////////////////
     125//! gaussienne ontegree 2D de volume 1 approchee par dl au 2sd ordre
    118126class Gdl1RhInt2D : public GeneralPSF2D {
    119127public:
    … …  
    129137
    130138//////////////////////////////////////////////////////////////////
     139//! gaussienne 2D de hauteur 1 approchee dl 3ieme
    131140class Gdl2Rho2D : public GeneralPSF2D {
    132141public:
    … …  
    141150
    142151//////////////////////////////////////////////////////////////////
     152//! gaussienne integree 2D de hauteur 1 approchee dl 3ieme
    143153class Gdl2RhInt2D : public GeneralPSF2D {
    144154public:
    … …  
    153163
    154164//////////////////////////////////////////////////////////////////
     165//! Moffat 2D
    155166class MofRho2D : public GeneralPSF2D {
    156167public:
    … …  
    166177
    167178//////////////////////////////////////////////////////////////////
     179//! Moffat integree 2D
    168180class MofRhInt2D : public GeneralPSF2D {
    169181public:
    … …  
    183195
    184196//////////////////////////////////////////////////////////////////
     197//! Chi2 pour une Gaussienne+fond 2D
    185198class X2_GauRho2D : public GeneralXi2 {
    186199public:

  • trunk/SophyaLib/NTools/generaldata.cc

    r914 r926  
    1818// GeneralFitData
    1919//================================================================
     20
     21/*!
     22  \class SOPHYA::GeneralFitData
     23  \ingroup NTools
     24  Classe de stoquage de donnees a plusieurs variables avec erreur
     25  sur l'ordonnee et sur les abscisses (options) :
     26
     27  \f$ {x0(i),Ex0(i), x1(i),Ex1(i), x2(i),Ex2(i) ... ; Y(i),EY(i)} \f$
     28  \verbatim
     29   Pour memoire, structure du rangement (n=mNVar):
     30   - Valeur des abscisses mXP (idem pour mErrXP):
     31     x0,x1,x2,...,xn   x0,x1,x2,...,xn  ....  x0,x1,x2,....,xn
     32     |  1er point  |   |  2sd point  |  ....  | point mNData |
     33     Donc abscisse J=[0,mNVar[ du point numero I=[0,mNData[: mXP[I*mNVar+J]
     34   - Valeur de l'ordonnee mF (idem pour mErr et mOK):
     35            f                f                      f
     36     |  1er point  |  |  2sd point  |  .... | point mNData |
     37     Donc point numero I [0,mNData[ : mF[i]
     38  \endverbatim
     39*/
    2040
    2141//////////////////////////////////////////////////////////////////////

  • trunk/SophyaLib/NTools/generaldata.h

    r914 r926  
    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 
     21//! Classe de stoquage de donnees a plusieurs variables avec erreur
    3922class GeneralFitData : public AnyDataObj , public NTupleInterface {
    4023  friend class GeneralFit;

  • trunk/SophyaLib/NTools/generalfit.cc

    r914 r926  
    2020// GeneralFunction
    2121//================================================================
     22
     23/*!
     24  \class SOPHYA::GeneralFunction
     25  \ingroup NTools
     26   Classe de fonctions parametrees a plusieurs variables:
     27  \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
     28*/
    2229
    2330//////////////////////////////////////////////////////////////////////
    … …  
    8592// GeneralFunc
    8693//================================================================
     94
     95/*!
     96  \class SOPHYA::GeneralFunc
     97  \ingroup NTools
     98  Classe de fonctions parametrees a plusieurs variables
     99  derivant de ``GeneralFunction''. Permet de definir
     100  une fonction a fiter sans passer par une classe derivee
     101  en utilisant l'ecriture courante du C. La fonction
     102  retournant les derivees par rapport aux parametres du fit
     103  peut etre egalement fournie (optionnel).
     104*/
    87105
    88106/////////////////////////////////////////////////////////////////
    … …  
    161179//================================================================
    162180
     181/*!
     182  \class SOPHYA::GeneralXi2
     183  \ingroup NTools
     184  Classe de Xi2 a plusieurs parametres :
     185  \f$ Xi2[a1,a2,a3,...] \f$
     186*/
     187
    163188//////////////////////////////////////////////////////////////////////
    164189/*!
    … …  
    263288//                                Christophe 8/11/93 La Silla
    264289//                                re-codage C++ 16/01/96 Saclay
     290
     291/*!
     292  \class SOPHYA::GeneralFit
     293  \ingroup NTools
     294  Classe de fit d'une GeneralFunction sur une GeneralFitData
     295  */
     296
    265297//////////////////////////////////////////////////////////////////////
    266298/*!

  • trunk/SophyaLib/NTools/generalfit.h

    r914 r926  
    1313//================================================================
    1414
    15 
    16 /*!
    17   Classe de fonctions parametrees a plusieurs variables:
    18   \f$ F[x1,x2,x3,...:a1,a2,a3,...] \f$
    19 */
     15//! Classe de fonctions parametrees a plusieurs variables
    2016class GeneralFunction {
    2117public:
    … …  
    2521  //! Valeur de la fonction a definir par l'utilisateur (fct virtuelle pure)
    2622  virtual double Value(double const xp[], double const* parm)=0;
     23  //! Valeur de la fonction derivee selon les parametres pouvant etre redefinie
    2724  virtual double Val_Der(double const xp[], double const* parm
    2825                        , double* DgDpar);
    … …  
    4845//================================================================
    4946
    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 */
     47//! Classe de fonctions parametrees a plusieurs variables type C
    5848class GeneralFunc : public GeneralFunction {
    5949public:
    … …  
    7868class GeneralFitData;
    7969
    80 /*!
    81   Classe de Xi2 a plusieurs parametres :
    82   \f$ Xi2[a1,a2,a3,...] \f$
    83 */
     70//! Classe de Xi2 a plusieurs parametres
    8471class GeneralXi2 {
    8572public:

  • trunk/SophyaLib/NTools/ntoolsinit.cc

    r757 r926  
    1212#include "datime.h"
    1313
     14/*!
     15   \defgroup NTools NTools module
     16   This module contains various tools for Sophya.
     17*/
     18
    1419int NToolsInitiator::FgInit = 0;
    1520
     21/*!
     22  \class SOPHYA::NToolsInitiator
     23  \ingroup NTools
     24  Tools initiator
     25*/
    1626NToolsInitiator::NToolsInitiator()
    1727  : TArrayInitiator()

  • trunk/SophyaLib/NTools/ntoolsinit.h

    r757 r926  
    1111namespace SOPHYA {
    1212
     13//! Tools initiator
    1314class NToolsInitiator : public TArrayInitiator {
    1415private:
Note: See TracChangeset for help on using the changeset viewer.