Changeset 926 in Sophya


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

documentation cmv 13/4/00

Location:
trunk/SophyaLib
Files:
36 edited

Legend:

Unmodified
Added
Removed

  • trunk/SophyaLib/HiStats/hisprof.cc

    r914 r926  
    66#include "perrors.h"
    77
     8/*!
     9  \class SOPHYA::HProf
     10  \ingroup HiStats
     11  Classe de profil d'histogrammes.
     12*/
    813
    914/********* Methode *********/

  • trunk/SophyaLib/HiStats/hisprof.h

    r920 r926  
    1010namespace SOPHYA {
    1111
    12 /*!
    13   \class SOPHYA::HProf
    14   \ingroup HiStats
    15   Classe de profil d'histogrammes.
    16 */
     12//! 1 dimension profile histograms
    1713class HProf : public Histo {
    1814  friend class ObjFileIO<HProf>;

  • trunk/SophyaLib/HiStats/histinit.h

    r763 r926  
    1111namespace SOPHYA {
    1212
     13//! Histograms initiator
    1314class HiStatsInitiator : public NToolsInitiator {
    1415private:

  • trunk/SophyaLib/HiStats/histos.cc

    r914 r926  
    11//
    2 // $Id: histos.cc,v 1.2 2000-04-13 16:04:11 ansari Exp $
     2// $Id: histos.cc,v 1.3 2000-04-13 18:38:32 ansari Exp $
    33//
    44
    … …  
    1212#include "strutil.h"
    1313#include "generalfit.h"
     14
     15/*!
     16  \class SOPHYA::Histo
     17  \ingroup HiStats
     18  Classe d'histogrammes 1D
     19*/
    1420
    1521/********* Methode *********/

  • trunk/SophyaLib/HiStats/histos.h

    r920 r926  
    11// This may look like C code, but it is really -*- C++ -*-
    22//
    3 // $Id: histos.h,v 1.3 2000-04-13 16:41:43 ansari Exp $
     3// $Id: histos.h,v 1.4 2000-04-13 18:38:33 ansari Exp $
    44//
    55
    … …  
    1919class GeneralFit;
    2020
    21 
    22 /*!
    23   \class SOPHYA::Histo
    24   \ingroup HiStats
    25   Classe d'histogrammes 1D
    26 */
     21//! 1 dimension histograms
    2722class Histo : public AnyDataObj {
    2823  friend class ObjFileIO<Histo>;

  • trunk/SophyaLib/HiStats/histos2.cc

    r914 r926  
    1515#include "histos2.h"
    1616#include "generalfit.h"
     17
     18/*!
     19  \class SOPHYA::Histo2D
     20  \ingroup HiStats
     21  Classe d'histogrammes 2D
     22  \verbatim
     23    Remarque sur les indices:
     24     H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
     25     v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
     26     On fait une correspondance directe i<->ii et j<->jj
     27     ce qui, en representation classique des histos2D et des matrices
     28     entraine une inversion x<->y cad une symetrie / diagonale principale
     29     H(0,...)  represente ^         mais v(0,...) represente
     30                          |x.......               |xxxxxxxx|
     31                          |x.......               |........|
     32                          |x.......               |........|
     33                          |x.......               |........|
     34                          |x.......               |........|
     35                          --------->
     36                          colonne no 1            ligne no 1
     37  \endverbatim
     38*/
    1739
    1840///////////////////////////////////////////////////////////////////

  • trunk/SophyaLib/HiStats/histos2.h

    r920 r926  
    2222class GeneralFit;
    2323
    24 
    25 /*!
    26   \class SOPHYA::Histo2D
    27   \ingroup HiStats
    28   Classe d'histogrammes 2D
    29   \verbatim
    30     Remarque sur les indices:
    31      H(i,j)   -> i  = coord x (0<i<nx),     j  = coord y (0<j<ny)
    32      v(ii,jj) -> ii = ligne (0<i<NRows()),  jj = colonne (0<i<NCol())
    33      On fait une correspondance directe i<->ii et j<->jj
    34      ce qui, en representation classique des histos2D et des matrices
    35      entraine une inversion x<->y cad une symetrie / diagonale principale
    36      H(0,...)  represente ^         mais v(0,...) represente
    37                           |x.......               |xxxxxxxx|
    38                           |x.......               |........|
    39                           |x.......               |........|
    40                           |x.......               |........|
    41                           |x.......               |........|
    42                           --------->
    43                           colonne no 1            ligne no 1
    44   \endverbatim
    45 */
     24//! 2 dimensions histograms
    4625class Histo2D : public AnyDataObj {
    4726  friend class ObjFileIO<Histo2D>;

  • 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:

  • trunk/SophyaLib/TArray/basarr.cc

    r894 r926  
    77#include "pexceptions.h"
    88#include "basarr.h"
     9
     10/*!
     11  \class SOPHYA::BaseArray
     12  \ingroup TArray
     13  Base class for template arrays
     14  No data are connected to this class.
     15
     16  Define base methods, enum and defaults for TArray , TMatrix and TVector.
     17*/
    918
    1019// Variables statiques globales

  • trunk/SophyaLib/TArray/basarr.h

    r920 r926  
    2121//   ------------ classe template Array -----------
    2222//! Base class for template arrays
    23 /*!
    24   \class SOPHYA::BaseArray
    25   \ingroup TArray
    26   No data are connected to this class.
    27 
    28   Define base methods, enum and defaults for TArray , TMatrix and TVector.
    29 */
    3023class BaseArray : public AnyDataObj {
    3124public:

  • trunk/SophyaLib/TArray/fioarr.cc

    r894 r926  
    1111//   Les objets delegues pour la gestion de persistance
    1212// --------------------------------------------------------
     13/*!
     14  \class SOPHYA::FIO_TArray
     15  \ingroup TArray
     16  Class for persistent management of TArray
     17
     18  This class manage also persistence for TMatrix and TVector.
     19  \sa TArray TMatrix TVector.
     20 */
    1321///////////////////////////////////////////////////////////
    1422

  • trunk/SophyaLib/TArray/fioarr.h

    r920 r926  
    1616/////////////////////////////////////////////////////////////////////////
    1717//! Class for persistent management of TArray
    18 /*!
    19   \class SOPHYA::FIO_TArray
    20   \ingroup TArray
    21   This class manage also persistence for TMatrix and TVector.
    22   \sa TArray TMatrix TVector.
    23  */
    2418template <class T>
    2519class FIO_TArray : public  PPersist  {

  • trunk/SophyaLib/TArray/matharr.cc

    r894 r926  
    1010// ----------------------------------------------------
    1111
     12/*!
     13  \class SOPHYA::MathArray
     14  \ingroup TArray
     15  Class for simple mathematical operation on arrays
     16  \warning Instanciated only for \b real and \b double (r_4, r_8) type arrays
     17*/
    1218
    1319//! Apply Function In Place (function double version)

  • trunk/SophyaLib/TArray/matharr.h

    r920 r926  
    1313
    1414//! Class for simple mathematical operation on arrays
    15 /*!
    16   \class SOPHYA::MathArray
    17   \ingroup TArray
    18   \warning Instanciated only for \b real and \b double (r_4, r_8) type arrays
    19 */
    2015template <class T>
    2116class MathArray {

  • trunk/SophyaLib/TArray/sopemtx.cc

    r813 r926  
    1414// -------------------------------------------------------------
    1515////////////////////////////////////////////////////////////////
    16 /////////////////////////////////////////////////////////////////////////
    17 // Classe de lignes/colonnes de matrices
    18 enum TRCKind {TmatrixRow=0, TmatrixCol=1, TmatrixDiag=2};
     16
     17//! Class of line, column or diagonal of a TMatrix
     18/*!
     19  A TMatrixRC represents a line, a column or the diagonal of a TMatrix
     20 */
    1921template <class T>
    2022class TMatrixRC {
    2123public:
     24  //! Define type of TMatrixRC
     25  enum TRCKind {
     26    TmatrixRow=0,  //!< TMatrixRC ligne
     27    TmatrixCol=1,  //!< TMatrixRC column
     28    TmatrixDiag=2  //!< TMatrixRC diagonal
     29  };
    2230  TMatrixRC();
    2331  TMatrixRC(TMatrix<T>& m, TRCKind kind, uint_4 index=0);
    … …  
    3947  static T* Org(const TMatrix<T>&, TRCKind rckind, uint_4 ind=0);
    4048
     49  //! Return the kind of TMatrix (line,column,diagonal)
    4150  TRCKind Kind() const { return kind; }
    4251  uint_4 NElts() const;
    … …  
    6776  static void Swap(TMatrixRC<T>& rc1, TMatrixRC<T>& rc2);
    6877
     78  //! Define Absolute value for uint_1
    6979  inline static double Abs_Value(uint_1 v) {return (double) v;}
     80  //! Define Absolute value for uint_2
    7081  inline static double Abs_Value(uint_2 v) {return (double) v;}
     82  //! Define Absolute value for int_2
    7183  inline static double Abs_Value(int_2 v)  {return (v>0)? (double) v: (double) -v;}
     84  //! Define Absolute value for int_4
    7285  inline static double Abs_Value(int_4 v)  {return (v>0)? (double) v: (double) -v;}
     86  //! Define Absolute value for int_8
    7387  inline static double Abs_Value(int_8 v)  {return (v>0)? (double) v: (double) -v;}
     88  //! Define Absolute value for uint_4
    7489  inline static double Abs_Value(uint_4 v) {return (double) v;}
     90  //! Define Absolute value for uint_8
    7591  inline static double Abs_Value(uint_8 v) {return (double) v;}
     92  //! Define Absolute value for r_4
    7693  inline static double Abs_Value(r_4 v)    {return (double) fabsf(v);}
     94  //! Define Absolute value for r_8
    7795  inline static double Abs_Value(r_8 v)    {return fabs(v);}
    78   inline static double Abs_Value(complex<float> v)
     96  //! Define Absolute value for complex r_4
     97  inline static double Abs_Value(complex<r_4> v)
    7998                {return sqrt(v.real()*v.real()+v.imag()*v.imag());}
    80   inline static double Abs_Value(complex<double> v)
     99  //! Define Absolute value for complex r_8
     100  inline static double Abs_Value(complex<r_8> v)
    81101                {return sqrt(v.real()*v.real()+v.imag()*v.imag());}
    82102
    83103protected:
    84   TMatrix<T>* matrix;
    85   T*          data;
    86   int_4       index;
    87   uint_4      step;
    88   TRCKind     kind;
     104  TMatrix<T>* matrix;  //!< pointer to the TMatrix
     105  T*          data;    //!< pointer to the beginnig of interesting datas
     106  int_4       index;   //!< index of the line/column
     107  uint_4      step;    //!< step of the line/column
     108  TRCKind     kind;    //!< type: line, column or diagonal
    89109};
    90110
    91111
    92 
     112//! Multiply two TMatrixRC
    93113template <class T>
    94114inline T operator * (const TMatrixRC<T>& a, const TMatrixRC<T>& b)
    … …  
    103123  }
    104124
    105 
     125//! Get the step in datas for a TMatrix for type rckind (line/col/diag)
    106126template <class T>
    107127inline uint_4 TMatrixRC<T>::Step(const TMatrix<T>& m, TRCKind rckind)
    … …  
    111131    return 0; }
    112132
     133/*! Get the origin of datas for a TMatrix for type rckind and
     134  number index (line/col/diag). ex: origine for line "index". */
    113135template <class T>
    114136inline T* TMatrixRC<T>::Org(const TMatrix<T>& m, TRCKind rckind, uint_4 index)
    … …  
    118140    return NULL; }
    119141
     142//! return number of elements for a TMatrixRC
    120143template <class T> inline uint_4 TMatrixRC<T>::NElts() const
    121144  { if (!matrix) return 0;
    … …  
    125148    return 0; }
    126149
     150//! access of element \b i
    127151template <class T>
    128152inline T& TMatrixRC<T>::operator()(uint_4 i) {return data[i*step];}
     153//! access of element \b i
    129154template <class T>
    130155inline T  TMatrixRC<T>::operator()(uint_4 i) const {return data[i*step];}
    131156
    132157////////////////////////////////////////////////////////////////
    133 // Typedef pour simplifier et compatibilite Peida
     158//! Typedef to simplifier TMatrixRC<r_8>
    134159typedef TMatrixRC<r_8> MatrixRC;
    135160
    136161
     162//! Default constructor
    137163template <class T> TMatrixRC<T>::TMatrixRC()
    138164: matrix(NULL), data(NULL), index(0), step(0)
    139165{}
    140166
     167//! Constructor
     168/*!
     169  \param m : matrix
     170  \param rckind : select line, column or diagonal
     171  \param ind : number of the line or column
     172*/
    141173template <class T> TMatrixRC<T>::TMatrixRC(TMatrix<T>& m,TRCKind rckind,uint_4 ind)
    142174: matrix(&m), data(Org(m,rckind,ind)),
    … …  
    150182// Acces aux rangees et colonnes de matrices
    151183
     184//! Return TMatrixRC for line \b r of matrix \b m
    152185template <class T>
    153186TMatrixRC<T> TMatrixRC<T>::Row(TMatrix<T> & m, uint_4 r)
    … …  
    157190}
    158191
     192//! Return TMatrixRC for column \b r of matrix \b m
    159193template <class T>
    160194TMatrixRC<T> TMatrixRC<T>::Col(TMatrix<T> & m, uint_4 c)
    … …  
    164198}
    165199
     200//! Return TMatrixRC for diagonal of matrix \b m
    166201template <class T>
    167202TMatrixRC<T> TMatrixRC<T>::Diag(TMatrix<T> & m)
    … …  
    197232// }
    198233
    199  
     234//! Set column \b c for this TMatrixRC
    200235template <class T> int_4 TMatrixRC<T>::SetCol(int_4 c)
    201236{
    … …  
    209244}
    210245
     246//! Set line \b r for this TMatrixRC
    211247template <class T> int_4 TMatrixRC<T>::SetRow(int_4 r)
    212248{
    … …  
    220256}
    221257
     258//! Set line diaginal for this TMatrixRC
    222259template <class T> int_4 TMatrixRC<T>::SetDiag()
    223260{
    … …  
    232269}
    233270
    234 
     271//! Operator =
    235272template <class T> TMatrixRC<T>& TMatrixRC<T>::operator = (const TMatrixRC<T>& rc)
    236273{
    … …  
    271308// }
    272309
    273 
     310//! Operator to multiply by constant \b x
    274311template <class T> TMatrixRC<T>& TMatrixRC<T>::operator *= (T x)
    275312{
    … …  
    278315}
    279316
     317//! Operator to divide by constant \b x
    280318template <class T> TMatrixRC<T>& TMatrixRC<T>::operator /= (T x)
    281319{
    … …  
    298336// }
    299337
     338//! Linear combination
     339/*!
     340  Do : \f$ MRC(i) = MRC(i)*a + rc(i)*b \f$
     341  \return *this
     342 */
    300343template <class T>
    301344TMatrixRC<T>& TMatrixRC<T>::LinComb(T a, T b, const TMatrixRC<T>& rc, uint_4 first)
    … …  
    309352}
    310353
     354//! Linear combination
     355/*!
     356  Do : \f$ MRC(i) = MRC(i) + rc(i)*b \f$
     357 */
    311358template <class T>
    312359TMatrixRC<T>& TMatrixRC<T>::LinComb(T b, const TMatrixRC<T>& rc, uint_4 first)
    … …  
    320367}
    321368
     369//! Find maximum absolute value in TMatrixRC, search begin at \b first
    322370template <class T> uint_4 TMatrixRC<T>::IMaxAbs(uint_4 first)
    323371{
    … …  
    333381}
    334382
     383//! Print on stream \b os
    335384template <class T>
    336385void TMatrixRC<T>::Print(ostream & os) const
    … …  
    346395}
    347396
     397//! Swap two TMatrixRC of the same kind
    348398template <class T>
    349399void TMatrixRC<T>::Swap(TMatrixRC<T>& rc1, TMatrixRC<T>& rc2)
    … …  
    359409
    360410
    361 
    362 
    363411////////////////////////////////////////////////////////////////
     412// -------------------------------------------------------------
     413//   La classe de calcul simple sur les TMatrix
     414// -------------------------------------------------------------
     415////////////////////////////////////////////////////////////////
     416
    364417//**** Pour inversion
    365418#ifndef M_LN2
    … …  
    373426#endif
    374427
     428//! Gaussian pivoting
     429/*!
     430  Diagonalize matrix \b a, doing the same opreations on matrix \b b
     431  \return determinat of \b a
     432 */ 
    375433template <class T>
    376434T SimpleMatrixOperation<T>::GausPiv(TMatrix<T>& a, TMatrix<T>& b)
    … …  
    394452double nrm = sqrt(vmin*vmax);
    395453if(nrm > 1.e5 || nrm < 1.e-5) {
    396   a /= nrm;
    397   b /= nrm;
     454  a /= (T) nrm;
     455  b /= (T) nrm;
    398456  //cout << "normalisation matrice " << nrm << endl;
    399457} else nrm=1;
    400458
    401 double det = 1.0;
     459T det = 1;
    402460if(nrm != 1) {
    403461  double ld = a.NRows() * log(nrm);
    … …  
    405463   // cerr << "TMatrix warning, overflow for det" << endl;
    406464  } else {
    407     det = exp(ld);
    408   }
    409 }
    410 
    411 TMatrixRC<T> pivRowa(a,TmatrixRow);
    412 TMatrixRC<T> pivRowb(b,TmatrixRow);
     465    det = (T) exp(ld);
     466  }
     467}
     468
     469TMatrixRC<T> pivRowa(a,TMatrixRC<T>::TmatrixRow);
     470TMatrixRC<T> pivRowb(b,TMatrixRC<T>::TmatrixRow);
    413471
    414472for(uint_4 k=0; k<n-1; k++) {
    … …  
    422480    TMatrixRC<T>::Swap(bIPiv,bK);
    423481  }
    424   double pivot = a(k,k);
    425   if (fabs(pivot) < 1.e-50) return 0.0;
     482  T pivot = a(k,k);
     483  if( TMatrixRC<T>::Abs_Value(pivot) < 1.e-50 ) return (T) 0;
    426484  //det *= pivot;
    427485  pivRowa.SetRow(k); // to avoid constructors
    428486  pivRowb.SetRow(k);
    429487  for (uint_4 i=k+1; i<n; i++) {
    430     double r = -a(i,k)/pivot;
     488    T r = -a(i,k)/pivot;
    431489    TMatrixRC<T>::Row(a, i).LinComb(r, pivRowa); // + rapide que -= r * pivRowa
    432490    TMatrixRC<T>::Row(b, i).LinComb(r, pivRowb);
    … …  
    437495// on remonte
    438496for(uint_4 kk=n-1; kk>0; kk--) {
    439   double pivot = a(kk,kk);
    440   if (fabs(pivot) <= 1.e-50) return 0.0;
     497  T pivot = a(kk,kk);
     498  if( TMatrixRC<T>::Abs_Value(pivot) <= 1.e-50 ) return (T) 0;
    441499  pivRowa.SetRow(kk); // to avoid constructors
    442500  pivRowb.SetRow(kk);
    443501  for(uint_4 jj=0; jj<kk; jj++) {
    444     double r = -a(jj,kk)/pivot;
     502    T r = -a(jj,kk)/pivot;
    445503    TMatrixRC<T>::Row(a, jj).LinComb(r, pivRowa);
    446504    TMatrixRC<T>::Row(b, jj).LinComb(r, pivRowb);
    … …  
    449507
    450508for(uint_4 l=0; l<n; l++) {
    451   if (fabs((double)a(l,l)) <= 1.e-50) return 0.0;
     509  if( TMatrixRC<T>::Abs_Value(a(l,l)) <= 1.e-50 ) return (T) 0;
    452510  TMatrixRC<T>::Row(b, l) /= a(l,l);
    453511}
    … …  
    456514}
    457515
     516//! Return the inverse matrix of \b A
    458517template <class T>
    459518TMatrix<T> SimpleMatrixOperation<T>::Inverse(TMatrix<T> const & A)
    460 // Inversion
    461519{
    462520TMatrix<T> a(A);
    463521TMatrix<T> b(a.NCols(),a.NRows());  b = IdentityMatrix(1.);
    464 if(fabs((double)GausPiv(a,b)) < 1.e-50)
    465   throw(MathExc("TMatrix Inverse() Singular OMatrix"));
     522if( TMatrixRC<T>::Abs_Value(GausPiv(a,b)) < 1.e-50)
     523  throw(MathExc("TMatrix Inverse() Singular Matrix"));
    466524return b;
    467525}
    468526
     527
     528////////////////////////////////////////////////////////////////
     529// -------------------------------------------------------------
     530//   La classe fit lineaire
     531// -------------------------------------------------------------
     532////////////////////////////////////////////////////////////////
    469533
    470534LinFitter::LinFitter()
    … …  
    626690#pragma define_template TMatrixRC<r_4>
    627691#pragma define_template TMatrixRC<r_8>
     692#pragma define_template TMatrixRC< complex<r_4> >
     693#pragma define_template TMatrixRC< complex<r_8> >
    628694#pragma define_template SimpleMatrixOperation<int_4>
    629695#pragma define_template SimpleMatrixOperation<r_4>
    630696#pragma define_template SimpleMatrixOperation<r_8>
     697#pragma define_template SimpleMatrixOperation< complex<r_4> >
     698#pragma define_template SimpleMatrixOperation< complex<r_8> >
    631699#endif
    632700
    … …  
    636704template class TMatrixRC<r_4>;
    637705template class TMatrixRC<r_8>;
     706template class TMatrixRC< complex<r_4> >;
     707template class TMatrixRC< complex<r_8> >;
    638708template class SimpleMatrixOperation<int_4>;
    639709template class SimpleMatrixOperation<r_4>;
    640710template class SimpleMatrixOperation<r_8>;
     711template class SimpleMatrixOperation< complex<r_4> >;
     712template class SimpleMatrixOperation< complex<r_8> >;
    641713#endif

  • trunk/SophyaLib/TArray/sopemtx.h

    r850 r926  
    77#include "tvector.h"
    88
     9// doivent imperativement reste avant le namespace SOPHYA !
     10/*!
     11  \class SOPHYA::SimpleMatrixOperation
     12  \ingroup TArray
     13  Class for simple operation on TMatrix
     14  \sa TMatrix TArray
     15  */
     16/*!
     17  \class SOPHYA::LinFitter
     18  \ingroup TArray
     19  Class for linear fitting
     20  \sa TMatrix TArray
     21  */
     22
    923namespace SOPHYA {
    1024
    11 
    12 
    1325////////////////////////////////////////////////////////////////
     26//! Class for simple operation on TMatrix
    1427template <class T>
    1528class SimpleMatrixOperation {
    1629public:
    17   // Pivot de Gauss : diagonalise la matrice A, en effectuant les memes
    18   // operations sur la matrice B
    1930  static TMatrix<T> Inverse(TMatrix<T> const & A);
    2031  static T GausPiv(TMatrix<T>& A, TMatrix<T>& B);
    2132};
    2233
     34////////////////////////////////////////////////////////////////
    2335// Resolution du systeme A*C = B
     36//! Solve A*C = B for C in place and return determinant
     37/*! \ingroup TArray \fn LinSolveInPlace */
     38inline r_4 LinSolveInPlace(TMatrix<r_4>& a, TVector<r_4>& b)
     39{
     40if(a.NCols() != b.NRows() || a.NCols() != a.NRows())
     41  throw(SzMismatchError("LinSolveInPlace(TMatrix<r_4>,TVector<r_4>) size mismatch"));
     42return SimpleMatrixOperation<r_4>::GausPiv(a,b);
     43}
     44
     45//! Solve A*X = B in place and return determinant
     46/*! \ingroup TArray \fn LinSolveInPlace */
    2447inline r_8 LinSolveInPlace(TMatrix<r_8>& a, TVector<r_8>& b)
    2548{
    … …  
    2952}
    3053
    31 // Resolution du systeme A*C = B, avec C retourne dans B
    32 inline r_8 LinSolve(const TMatrix<r_8>& a, const TVector<r_8>& b, TVector<r_8>& c)
    33 {
     54//! Solve A*X = B in place and return determinant
     55/*! \ingroup TArray \fn LinSolveInPlace */
     56inline complex<r_4> LinSolveInPlace(TMatrix< complex<r_4> >& a, TVector< complex<r_4> >& b)
     57{
    3458if(a.NCols() != b.NRows() || a.NCols() != a.NRows())
    35   throw(SzMismatchError("LinSolve(TMatrix<r_8>,TVector<r_8>) size mismatch"));
    36 c = b;
    37 TMatrix<r_8> a1(a);
    38 return SimpleMatrixOperation<r_8>::GausPiv(a1,c);
     59  throw(SzMismatchError("LinSolveInPlace(TMatrix< complex<r_4> >,TVector< complex<r_4> >) size mismatch"));
     60return SimpleMatrixOperation< complex<r_4> >::GausPiv(a,b);
    3961}
    4062
    41 inline r_4 LinSolve(const TMatrix<r_4>& a, const TVector<r_4>& b, TVector<r_4>& c)
    42 {
     63//! Solve A*X = B in place and return determinant
     64/*! \ingroup TArray \fn LinSolveInPlace */
     65inline complex<r_8> LinSolveInPlace(TMatrix< complex<r_8> >& a, TVector< complex<r_8> >& b)
     66{
    4367if(a.NCols() != b.NRows() || a.NCols() != a.NRows())
    44   throw(SzMismatchError("LinSolve(TMatrix<r_4>,TVector<r_4>) size mismatch"));
    45 c = b;
    46 TMatrix<r_4> a1(a);
    47 return SimpleMatrixOperation<r_4>::GausPiv(a1,c);
     68  throw(SzMismatchError("LinSolveInPlace(TMatrix< complex<r_8> >,TVector< complex<r_8> >) size mismatch"));
     69return SimpleMatrixOperation< complex<r_8> >::GausPiv(a,b);
    4870}
    4971
    50 // Inverse d'une matrice
    51 inline TMatrix<r_8> Inverse(TMatrix<r_8> const & A)
    52 {
    53   return SimpleMatrixOperation<r_8>::Inverse(A);
     72////////////////////////////////////////////////////////////////
     73// Resolution du systeme A*C = B, avec C retourne dans B
     74//! Solve A*C = B and return C and determinant
     75/*! \ingroup TArray \fn LinSolve */
     76inline r_4 LinSolve(const TMatrix<r_4>& a, const TVector<r_4>& b, TVector<r_4>& c) {
     77  if(a.NCols()!=b.NRows() || a.NCols()!=a.NRows())
     78    throw(SzMismatchError("LinSolve(TMatrix<r_4>,TVector<r_4>) size mismatch"));
     79    c = b; TMatrix<r_4> a1(a);
     80  return SimpleMatrixOperation<r_4>::GausPiv(a1,c);
    5481}
    5582
    56 inline TMatrix<r_4> Inverse(TMatrix<r_4> const & A)
    57 {
    58   return SimpleMatrixOperation<r_4>::Inverse(A);
     83//! Solve A*C = B and return C and determinant
     84/*! \ingroup TArray \fn LinSolve */
     85inline r_8 LinSolve(const TMatrix<r_8>& a, const TVector<r_8>& b, TVector<r_8>& c) {
     86  if(a.NCols()!=b.NRows() || a.NCols()!=a.NRows())
     87    throw(SzMismatchError("LinSolve(TMatrix<r_8>,TVector<r_8>) size mismatch"));
     88    c = b; TMatrix<r_8> a1(a);
     89  return SimpleMatrixOperation<r_8>::GausPiv(a1,c);
    5990}
    6091
     92//! Solve A*C = B and return C and determinant
     93/*! \ingroup TArray \fn LinSolve */
     94inline complex<r_4> LinSolve(const TMatrix< complex<r_4> >& a, const TVector< complex<r_4> >& b, TVector< complex<r_4> >& c) {
     95  if(a.NCols()!=b.NRows() || a.NCols()!=a.NRows())
     96    throw(SzMismatchError("LinSolve(TMatrix< complex<r_4> >,TVector< complex<r_4> >) size mismatch"));
     97    c = b; TMatrix< complex<r_4> > a1(a);
     98  return SimpleMatrixOperation< complex<r_4> >::GausPiv(a1,c);
     99}
     100
     101//! Solve A*C = B and return C and determinant
     102/*! \ingroup TArray \fn LinSolve */
     103inline complex<r_8> LinSolve(const TMatrix< complex<r_8> >& a, const TVector< complex<r_8> >& b, TVector< complex<r_8> >& c) {
     104  if(a.NCols()!=b.NRows() || a.NCols()!=a.NRows())
     105    throw(SzMismatchError("LinSolve(TMatrix< complex<r_8> >,TVector< complex<r_8> >) size mismatch"));
     106    c = b; TMatrix< complex<r_8> > a1(a);
     107  return SimpleMatrixOperation< complex<r_8> >::GausPiv(a1,c);
     108}
     109
     110////////////////////////////////////////////////////////////////
     111// Inverse d'une matrice
     112//! To inverse a TMatrix
     113/*! \ingroup TArray \fn Inverse */
     114inline TMatrix<r_4> Inverse(TMatrix<r_4> const & A)
     115  {return SimpleMatrixOperation<r_4>::Inverse(A);}
     116//! To inverse a TMatrix
     117/*! \ingroup TArray \fn Inverse */
     118inline TMatrix<r_8> Inverse(TMatrix<r_8> const & A)
     119  {return SimpleMatrixOperation<r_8>::Inverse(A);}
     120//! To inverse a TMatrix
     121/*! \ingroup TArray \fn Inverse */
     122inline TMatrix< complex<r_4> > Inverse(TMatrix< complex<r_4> > const & A)
     123  {return SimpleMatrixOperation< complex<r_4> >::Inverse(A);}
     124//! To inverse a TMatrix
     125/*! \ingroup TArray \fn Inverse */
     126inline TMatrix< complex<r_8> > Inverse(TMatrix< complex<r_8> > const & A)
     127  {return SimpleMatrixOperation< complex<r_8> >::Inverse(A);}
    61128
    62129//--------------------------------------
    … …  
    64131//--------------------------------------
    65132
     133//!  Class for linear fitting
    66134class LinFitter {
    67135public :

  • trunk/SophyaLib/TArray/tarray.cc

    r922 r926  
    99#include "tarray.h"
    1010
    11 
    12 
     11/*!
     12  \class SOPHYA::TArray
     13  \ingroup TArray
     14  Class for template arrays
     15
     16  This class implements arrays of dimensions up to
     17  \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS"
     18*/
    1319
    1420// -------------------------------------------------------

  • trunk/SophyaLib/TArray/tarray.h

    r920 r926  
    2424
    2525//! Class for template arrays
    26 /*!
    27   \class SOPHYA::TArray
    28   \ingroup TArray
    29   This class implements arrays of dimensions up to
    30   \ref BASEARRAY_MAXNDIMS "BASEARRAY_MAXNDIMS"
    31 */
    3226template <class T>
    3327class TArray : public BaseArray {

  • trunk/SophyaLib/TArray/tarrinit.cc

    r920 r926  
    1010*/
    1111
    12 int TArrayInitiator::FgInit = 0;
    13 
    1412/*!
    1513  \class SOPHYA::TArrayInitiator
    … …  
    1715  Array Matrices and Vector initiator
    1816*/
     17
     18int TArrayInitiator::FgInit = 0;
     19
    1920TArrayInitiator::TArrayInitiator()
    2021  : SophyaInitiator()

  • trunk/SophyaLib/TArray/tarrinit.h

    r894 r926  
    1111namespace SOPHYA {
    1212
    13 //! Class to initialize the TArray's classes
     13//! Array Matrices and Vector initiator
    1414class TArrayInitiator : public SophyaInitiator {
    1515private:

  • trunk/SophyaLib/TArray/tmatrix.cc

    r894 r926  
    1 // $Id: tmatrix.cc,v 1.6 2000-04-12 17:42:21 ansari Exp $
     1// $Id: tmatrix.cc,v 1.7 2000-04-13 18:39:14 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    77#include "tmatrix.h"
    88
    9 
    10 
     9/*!
     10  \class SOPHYA::TMatrix
     11  \ingroup TArray
     12  Class of matrixes
     13  \sa TArray
     14 */
    1115
    1216////////////////////////////////////////////////////////////////

  • trunk/SophyaLib/TArray/tmatrix.h

    r920 r926  
    99namespace SOPHYA {
    1010
    11 //! Class of matrixes
    12 /*!
    13   \class SOPHYA::TMatrix
    14   \ingroup TArray
    15   \sa TArray
    16  */
    17 
     11//! Class of matrices
    1812template <class T>
    1913class TMatrix : public TArray<T> {

  • trunk/SophyaLib/TArray/triangmtx.h

    r920 r926  
    77#include "pexceptions.h"
    88
     9// doit etre mis en dehors du namespace
     10/*!
     11  \class SOPHYA::TriangularMatrix
     12  \ingroup TArray
     13  Class for inferior triangular matrix (base class for the class Alm)
     14*/
     15
    916namespace SOPHYA {
    1017
    1118//! Class for inferior triangular matrix (base class for the class Alm)
    12 /*!
    13   \class SOPHYA::TriangularMatrix
    14   \ingroup TArray
    15   Class for triangular matrices
    16 */
    1719template <class T>
    1820class TriangularMatrix {

  • trunk/SophyaLib/TArray/tvector.cc

    r914 r926  
    1 // $Id: tvector.cc,v 1.5 2000-04-13 16:04:49 ansari Exp $
     1// $Id: tvector.cc,v 1.6 2000-04-13 18:39:16 ansari Exp $
    22//                         C.Magneville          04/99
    33#include "machdefs.h"
    … …  
    55#include "pexceptions.h"
    66#include "tvector.h"
     7
     8/*!
     9  \class SOPHYA::TVector
     10  \ingroup TArray
     11  Class of vector (line or column)
     12  \sa TMatrix TArray
     13  */
    714
    815////////////////////////////////////////////////////////////////

  • trunk/SophyaLib/TArray/tvector.h

    r920 r926  
    99
    1010//! Class of vector (line or column)
    11 /*!
    12   \class SOPHYA::TVector
    13   \ingroup TArray
    14   \sa TMatrix TArray
    15   */
    1611template <class T>
    1712class TVector : public TMatrix<T> {

  • trunk/SophyaLib/TArray/utilarr.cc

    r894 r926  
    99
    1010//////////////////////////////////////////////////////////
     11/*!
     12  \class SOPHYA::RandomSequence
     13  \ingroup TArray
     14  Class to generate a random sequence of values
     15*/
     16
    1117//! Constructor
    1218/*!
    … …  
    3238
    3339//////////////////////////////////////////////////////////
     40/*!
     41  \class SOPHYA::Sequence
     42  \ingroup TArray
     43  Class to generate a sequence of values
     44*/
     45
    3446//! Constructor
    3547/*!
    … …  
    88100
    89101//////////////////////////////////////////////////////////
     102/*!
     103  \class SOPHYA::Range
     104  \ingroup TArray
     105  Class to define a range of indexes
     106*/
     107
    90108//! Constructor
    91109/*!
    … …  
    126144
    127145//////////////////////////////////////////////////////////
     146/*!
     147  \class SOPHYA::IdentityMatrix
     148  \ingroup TArray
     149  Class to define an identity matrix
     150*/
     151
    128152//! Constructor of a (n,n) diagonal matrix with value diag on the diagonal
    129153IdentityMatrix::IdentityMatrix(double diag, uint_4 n)

  • trunk/SophyaLib/TArray/utilarr.h

    r920 r926  
    2020//////////////////////////////////////////////////////////
    2121//! Class to generate a random sequence of values
    22 /*!
    23   \class SOPHYA::RandomSequence
    24   \ingroup TArray
    25 */
    2622class RandomSequence {
    2723public:
    … …  
    4238//////////////////////////////////////////////////////////
    4339//! Class to generate a sequence of values
    44 /*!
    45   \class SOPHYA::Sequence
    46   \ingroup TArray
    47 */
    4840class Sequence {
    4941public:
    … …  
    6658//////////////////////////////////////////////////////////
    6759//! Class to define a range of indexes
    68 /*!
    69   \class SOPHYA::Range
    70   \ingroup TArray
    71 */
    7260class Range {
    7361public:
    … …  
    9078//////////////////////////////////////////////////////////
    9179//! Class to define an identity matrix
    92 /*!
    93   \class SOPHYA::IdentityMatrix
    94   \ingroup TArray
    95 */
    9680class IdentityMatrix {
    9781public:
Note: See TracChangeset for help on using the changeset viewer.