source: Sophya/trunk/SophyaPI/PIext/piafitting.cc@ 2642

Last change on this file since 2642 was 2615, checked in by cmv, 21 years ago

using namespace sophya enleve de machdefs.h, nouveau sopnamsp.h cmv 10/09/2004
File size: 60.8 KB
Line 
1//CMVBUG reste pb suivant sous Linux-egcs (OSF1-cxx c'est ok):
2//openppf cmvwppf.ppf
3//fitw h1g g2 p:4500,45,10,900
4//delobjs h1g
5//clic sur FIT -> OK
6//clic sur FIT 2sd fois -> core dump!!!
7//
8#include <stdio.h>
9#include <stdlib.h>
10#include <ctype.h>
11#include <iostream>
12#include <typeinfo>
13
14#include "sopnamsp.h"
15#include "strutil.h"
16#include "nbtri.h"
17#include "generalfit.h"
18#include "fct1dfit.h"
19#include "fct2dfit.h"
20#include "ntuple.h"
21#include "cimage.h"
22#include "histos.h"
23#include "histos2.h"
24#include "ntuple.h"
25#include "hisprof.h"
26
27#ifdef SANS_EVOLPLANCK
28#include "matrix.h"
29#include "cvector.h"
30#else
31#include "tmatrix.h"
32#include "tvector.h"
33#include "objfitter.h"
34#endif
35
36#include "piafitting.h"
37#include "nobjmgr.h"
38#include "anydataobj.h"
39#include "pistdimgapp.h"
40
41#include "nomhistadapter.h"
42#include "nomgfdadapter.h"
43#include "nomimagadapter.h"
44#ifdef SANS_EVOLPLANCK
45#include "nommatvecadapter.h"
46#else
47#include "nomtmatvecadapter.h"
48#endif
49
50////////////////////////////////////////////////////////////////////
51////---------- Classe de fenetre de fit interactive ------------////
52////////////////////////////////////////////////////////////////////
53class PIAFitterWind : public PIWindow {
54public :
55 PIAFitterWind(PIStdImgApp* par, PIAFitter* fiter,string func);
56 virtual ~PIAFitterWind();
57 virtual void Show();
58 virtual void Process(PIMessage msg, PIMsgHandler* sender, void* data=NULL);
59 void SetState(void);
60protected :
61 PIStdImgApp* mDap;
62 PIAFitter* mFitter;
63 string mFunc;
64 PILabel** lab; int nlab;
65 PIText** txt; int ntxt;
66 PIButton** but; int nbut;
67 PICheckBox** ckb; int nckb;
68 PIOptMenu** pom; int npom;
69 bool ReFillGData,ReDecodeFunc;
70 int saveI1,saveI2, saveJ1, saveJ2;
71 double saveErrScale,saveErrMin,saveXC,saveYC;
72};
73
74////////////////////////////////////////////////////////////////////////
75// --- Generation automatique du "usage" pour helpfit:
76// 1-/ copier le texte ci-dessous de piafitting.cc dans toto
77// 2-/ cat toto | sed 's?^//?usage+="\\n?' | sed 's?$? ";?'
78// NE PAS EFFACER LA SUITE: c'est elle qui doit etre modifiee,
79// le usage du helpfit sera regenere a l'aide des commandes ci-dessus.
80////////////////////////////////////////////////////////////////////////
81//| --------------- Fit Lineaire a 1 et 2 dimensions ---------------
82//| Syntaxe:
83//| fitlin nom pnn [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...]
84//| avec:
85//| nom : cf commentaire ordre ''fit''
86//| pnn : fit polynome degre nn avec classe Poly (lineaire) 1D ou 2D
87//| o:aa,...,bb : cf commentaires ordre ''fit''
88//|
89////////////////////////////////////////////////////////////////////////
90//| --------------- Fit d'objets a 1 et 2 dimensions ---------------
91//| avec interface d'aide graphique
92//| Syntaxe:
93//| fitw nom func
94//| [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn]
95//| [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...]
96//| cf commentaire ordre ''fit''
97//|
98////////////////////////////////////////////////////////////////////////
99//| --------------- Fit d'objets a 1 et 2 dimensions ---------------
100//| Syntaxe:
101//| fit nom func
102//| [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn]
103//| [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...]
104//|----- OBJET -----
105//| nom : nom de l'objet qui peut etre:
106//| fit-1D: Vector,Histo1D,HProf ou GeneraFitData(1D)
107//| fit-2D: Matrix,Histo2D,Image<T> ou GeneraFitData(2D)
108//|
109//|----- FUNCTION -----
110//| func : pnn : fit polynome degre nn avec GeneralFit (non-lineaire) 1D ou 2D
111//| : gnn : fit gaussienne (hauteur) + polynome de degre nn 1D
112//| : g : fit gaussienne (hauteur) 1D
113//| : enn : fit exponentielle + polynome de degre nn 1D
114//| : e : fit exponentielle 1D
115//| : Gnn : fit gaussienne (volume) + polynome de degre nn 1D
116//| : G : fit gaussienne (volume) 1D
117//| : : fit gaussienne+fond (volume) 2D
118//| : Gi : fit gaussienne+fond integree (volume) 2D
119//| : d : fit DL de gaussienne+fond (volume) 2D
120//| : di : fit DL de gaussienne+fond integree (volume) 2D
121//| : D : fit DL de gaussienne+fond avec coeff variable p6 (volume) 2D
122//| : Di : fit DL de gaussienne+fond integree avec coeff variable p6 (volume) 2D
123//| : M : fit Moffat+fond (expos=p6) (volume) 2D
124//| : Mi : fit Moffat+fond integree (expos=p6) (volume) 2D
125//| : Autre : fonction definie par l'utilisateur (cf commentaires ci apres)
126//|
127//|----- INIT PARAMETRES ET ETAT DU FIT -----
128//| p : p1,...,pn : valeur d'initialisation des parametres (def=0)
129//| s : s1,...,sn : valeur des steps de depart (def=1)
130//| m : m1,...,mn : valeur des minima (def=1)
131//| M : M1,...,Mn : valeur des maxima (def=-1) (max<=min : pas de limite)
132//| f : f1,...,fn : si >=1 parametre fixe sinon libre (def=0)
133//| - Remarque: si pi,si,mi ou Mi = '!' la valeur correspondante n'est pas changee
134//|
135//|----- OPTIONS -----
136//| o : options ''o:Eaa.b,eaa.b,f,r,caa.b,Xaa.b''
137//| F : initialisation a partir des resultats et de l'etat du fit precedent
138//| (option non prioritaire sur les definitions p:,s:,m:,M:,f:o:)
139//| a : initialisation automatique des parametres du fit (si disponible)
140//| (option non prioritaire sur les definitions p:,s:,m:,M:,f:o:
141//| et sur l'initialisation pa l'option ''F'')
142//| f : generation d'un Objet identique contenant la fonction fittee
143//| r : generation d'un Objet identique contenant les residus
144//| Xaa.b : aa.b valeur du DXi2 d'arret (def=1.e-3)
145//| Naa : aa nombre maximum d'iterations (def=100)
146//| la : niveau ''a'' de print: a=niveau de print Fit1/2D
147//| da : niveau ''a'' de debug: a=niveau de GeneralFit
148//| Ii1/i2 : numeros des bins X de l'histos utilises pour le fit [i1,i2]
149//|2D Jj1/j2 : numeros des bins Y de l'histos utilises pour le fit [j1,j2]
150//| - Traitement des erreurs :
151//| Par defaut, l'erreur est celle associee a l'objet (si elle existe),
152//| elle est mise a 1 sinon.
153//| haa.b/cc.d : erreur = aa.bb*(erreur associee a l'objet cf ci-dessus)
154//| Haa.b/cc.d : erreur = aa.b*|val|
155//| eaa.b/cc.d : erreur = aa.b
156//| Eaa.b/cc.d : erreur = aa.b*sqrt(|val|)
157//| aa.b<0 (ou non precise) est equivalent aa.b=1.0
158//| cc.d non precise est equivalent a cc.d=0
159//| si cc.d>=0 si erreur>0 erreur = max(erreur,cc.d)
160//| si erreur<=0 alors erreur
161//| si cc.d<0 si erreur>0 erreur = max(erreur,|cc.d|)
162//| si erreur<=0 alors erreur=|cc.d|
163//| xaa.b : demande de centrage: on fit x-aa.b au lieu de x)
164//| x : demande de centrage: on fit x-xc au lieu de x
165//| avec xc=abscisse du ''milieu logique'' de l'objet.
166//| Actif pour exp+poly 1D, poly 1D
167//| Pour gauss+poly 1D, xc est le centre de la gaussienne.
168//|2D yaa.b et y : idem ''xaa.b et x'' mais pour y
169//|
170////////////////////////////////////////////////////////////////////////
171//| --------------- Def des fcts de fit par l'utilisateur ---------------
172//| Pour definir une fonction parametree utilisateur:
173//| Un exemple de fichier contenant des fonctions a fitter: PIext/userfitfunex.c
174//| > crfitfil nom_fichier nom_fonction nvar npar
175//| pour creer un squelette de fichier C contenant la fonction a fitter
176//| nom_fichier : nom du fichier ou est le code de la fonction
177//| c'est un fichier C de nom blabla.c
178//| nom_fonction : nom de la fonction ex: gauss2
179//| nvar : nombre de variables x[] (1D=1, 2D=2, etc...)
180//| npar : nombre de parametre p[]
181//| - La fonction est donc F(x[];p[]), soit par ex:
182//| double gauss2(double const* x,double const* p)
183//| - L'utilisateur a la possibilite de donner egalement la fonction
184//| retournant les derivees de la fonction par rapport aux parametres
185//| double gauss2_der(double const* x,double const* p,double* dp)
186//| ou dp[i] = dF(x[];p[])/dp[i]
187//| Par convention, cette fonction a le meme nom suivi de ''_der''
188//| > crfitfun nom_fichier nom_fonction nvar npar
189//| Permet de compiler le fichier ''nom_fichier'' et de linker
190//| la fonction ''nom_fonction''
191//| - Un meme fichier peut contenir plusieurs fonctions a fitter
192//|
193////////////////////////////////////////////////////////////////////////
194
195/* --Methode-- */
196PIAFitter::PIAFitter(PIACmd *piac, PIStdImgApp* app)
197: mApp(app), FWindFit(NULL)
198, mNObj(""), mAdObj(NULL), mGData(NULL), delmGData(false)
199, mNPar(0), mNVar(0), mNData(0)
200, mPar(1), mStep(1), mMin(1), mMax(1), mFix(1)
201, mParSave(1), mStepSave(1), mMinSave(1), mMaxSave(1), mFixSave(1)
202, mFit(NULL)
203, mFunction(NULL), mFName(""), mFunc(NULL)
204, mDlUFunc(NULL), mNameFitFunc(""), mFitFunc(NULL), mFitFuncDer(NULL)
205, mUFNVar(0), mUFNPar(0)
206{
207// Init et Set des options
208mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
209mParSave=0.; mStepSave=1.; mMinSave=1.; mMaxSave=-1.; mFixSave=0.;
210ResetOptions();
211mOptSave = mOpt;
212
213// enregistrement des ordres de fit
214string kw, usage, grp = "Fitting";
215
216kw = "helpfit";
217usage="";
218usage+="\n////////////////////////////////////////////////////////////////////// ";
219usage+="\n| --------------- Fit Lineaire a 1 et 2 dimensions --------------- ";
220usage+="\n| Syntaxe: ";
221usage+="\n| fitlin nom pnn [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...] ";
222usage+="\n| avec: ";
223usage+="\n| nom : cf commentaire ordre ''fit'' ";
224usage+="\n| pnn : fit polynome degre nn avec classe Poly (lineaire) 1D ou 2D ";
225usage+="\n| o:aa,...,bb : cf commentaires ordre ''fit'' ";
226usage+="\n| ";
227usage+="\n////////////////////////////////////////////////////////////////////// ";
228usage+="\n| --------------- Fit d'objets a 1 et 2 dimensions --------------- ";
229usage+="\n| avec interface d'aide graphique ";
230usage+="\n| Syntaxe: ";
231usage+="\n| fitw nom func ";
232usage+="\n| [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn] ";
233usage+="\n| [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...] ";
234usage+="\n| cf commentaire ordre ''fit'' ";
235usage+="\n| ";
236usage+="\n////////////////////////////////////////////////////////////////////// ";
237usage+="\n| --------------- Fit d'objets a 1 et 2 dimensions --------------- ";
238usage+="\n| Syntaxe: ";
239usage+="\n| fit nom func ";
240usage+="\n| [p:p1,p2,...,pn s:s1,s2,...,sn m:m1,m2,...,mn M:M1,mM2,...,Mn f:f1,...,fn] ";
241usage+="\n| [o:.aa,bb,cc, o:dd,ee,ff o:gg,hh,jj,kk etc...] ";
242usage+="\n|----- OBJET ----- ";
243usage+="\n| nom : nom de l'objet qui peut etre: ";
244usage+="\n| fit-1D: Vector,Histo1D,HProf ou GeneraFitData(1D) ";
245usage+="\n| fit-2D: Matrix,Histo2D,Image<T> ou GeneraFitData(2D) ";
246usage+="\n| ";
247usage+="\n|----- FUNCTION ----- ";
248usage+="\n| func : pnn : fit polynome degre nn avec GeneralFit (non-lineaire) 1D ou 2D ";
249usage+="\n| : gnn : fit gaussienne (hauteur) + polynome de degre nn 1D ";
250usage+="\n| : g : fit gaussienne (hauteur) 1D ";
251usage+="\n| : enn : fit exponentielle + polynome de degre nn 1D ";
252usage+="\n| : e : fit exponentielle 1D ";
253usage+="\n| : Gnn : fit gaussienne (volume) + polynome de degre nn 1D ";
254usage+="\n| : G : fit gaussienne (volume) 1D ";
255usage+="\n| : : fit gaussienne+fond (volume) 2D ";
256usage+="\n| : Gi : fit gaussienne+fond integree (volume) 2D ";
257usage+="\n| : d : fit DL de gaussienne+fond (volume) 2D ";
258usage+="\n| : di : fit DL de gaussienne+fond integree (volume) 2D ";
259usage+="\n| : D : fit DL de gaussienne+fond avec coeff variable p6 (volume) 2D ";
260usage+="\n| : Di : fit DL de gaussienne+fond integree avec coeff variable p6 (volume) 2D ";
261usage+="\n| : M : fit Moffat+fond (expos=p6) (volume) 2D ";
262usage+="\n| : Mi : fit Moffat+fond integree (expos=p6) (volume) 2D ";
263usage+="\n| : Autre : fonction definie par l'utilisateur (cf commentaires ci apres) ";
264usage+="\n| ";
265usage+="\n|----- INIT PARAMETRES ET ETAT DU FIT ----- ";
266usage+="\n| p : p1,...,pn : valeur d'initialisation des parametres (def=0) ";
267usage+="\n| s : s1,...,sn : valeur des steps de depart (def=1) ";
268usage+="\n| m : m1,...,mn : valeur des minima (def=1) ";
269usage+="\n| M : M1,...,Mn : valeur des maxima (def=-1) (max<=min : pas de limite) ";
270usage+="\n| f : f1,...,fn : si >=1 parametre fixe sinon libre (def=0) ";
271usage+="\n| - Remarque: si pi,si,mi ou Mi = '!' la valeur correspondante n'est pas changee ";
272usage+="\n| ";
273usage+="\n|----- OPTIONS ----- ";
274usage+="\n| o : options ''o:Eaa.b,eaa.b,f,r,caa.b,Xaa.b'' ";
275usage+="\n| F : initialisation a partir des resultats et de l'etat du fit precedent ";
276usage+="\n| (option non prioritaire sur les definitions p:,s:,m:,M:,f:o:) ";
277usage+="\n| a : initialisation automatique des parametres du fit (si disponible) ";
278usage+="\n| (option non prioritaire sur les definitions p:,s:,m:,M:,f:o: ";
279usage+="\n| et sur l'initialisation pa l'option ''F'') ";
280usage+="\n| f : generation d'un Objet identique contenant la fonction fittee ";
281usage+="\n| r : generation d'un Objet identique contenant les residus ";
282usage+="\n| Xaa.b : aa.b valeur du DXi2 d'arret (def=1.e-3) ";
283usage+="\n| Naa : aa nombre maximum d'iterations (def=100) ";
284usage+="\n| la : niveau ''a'' de print: a=niveau de print Fit1/2D ";
285usage+="\n| da : niveau ''a'' de debug: a=niveau de GeneralFit ";
286usage+="\n| Ii1/i2 : numeros des bins X de l'histos utilises pour le fit [i1,i2] ";
287usage+="\n|2D Jj1/j2 : numeros des bins Y de l'histos utilises pour le fit [j1,j2] ";
288usage+="\n| - Traitement des erreurs : ";
289usage+="\n| Par defaut, l'erreur est celle associee a l'objet (si elle existe), ";
290usage+="\n| elle est mise a 1 sinon. ";
291usage+="\n| haa.b/cc.d : erreur = aa.bb*(erreur associee a l'objet cf ci-dessus) ";
292usage+="\n| Haa.b/cc.d : erreur = aa.b*|val| ";
293usage+="\n| eaa.b/cc.d : erreur = aa.b ";
294usage+="\n| Eaa.b/cc.d : erreur = aa.b*sqrt(|val|) ";
295usage+="\n| aa.b<0 (ou non precise) est equivalent aa.b=1.0 ";
296usage+="\n| cc.d non precise est equivalent a cc.d=0 ";
297usage+="\n| si cc.d>=0 si erreur>0 erreur = max(erreur,cc.d) ";
298usage+="\n| si erreur<=0 alors erreur ";
299usage+="\n| si cc.d<0 si erreur>0 erreur = max(erreur,|cc.d|) ";
300usage+="\n| si erreur<=0 alors erreur=|cc.d| ";
301usage+="\n| xaa.b : demande de centrage: on fit x-aa.b au lieu de x) ";
302usage+="\n| x : demande de centrage: on fit x-xc au lieu de x ";
303usage+="\n| avec xc=abscisse du ''milieu logique'' de l'objet. ";
304usage+="\n| Actif pour exp+poly 1D, poly 1D ";
305usage+="\n| Pour gauss+poly 1D, xc est le centre de la gaussienne. ";
306usage+="\n|2D yaa.b et y : idem ''xaa.b et x'' mais pour y ";
307usage+="\n| ";
308usage+="\n////////////////////////////////////////////////////////////////////// ";
309usage+="\n| --------------- Def des fcts de fit par l'utilisateur --------------- ";
310usage+="\n| Pour definir une fonction parametree utilisateur: ";
311usage+="\n| Un exemple de fichier contenant des fonctions a fitter: PIext/userfitfunex.c ";
312usage+="\n| > crfitfil nom_fichier nom_fonction nvar npar ";
313usage+="\n| pour creer un squelette de fichier C contenant la fonction a fitter ";
314usage+="\n| nom_fichier : nom du fichier ou est le code de la fonction ";
315usage+="\n| c'est un fichier C de nom blabla.c ";
316usage+="\n| nom_fonction : nom de la fonction ex: gauss2 ";
317usage+="\n| nvar : nombre de variables x[] (1D=1, 2D=2, etc...) ";
318usage+="\n| npar : nombre de parametre p[] ";
319usage+="\n| - La fonction est donc F(x[];p[]), soit par ex: ";
320usage+="\n| double gauss2(double const* x,double const* p) ";
321usage+="\n| - L'utilisateur a la possibilite de donner egalement la fonction ";
322usage+="\n| retournant les derivees de la fonction par rapport aux parametres ";
323usage+="\n| double gauss2_der(double const* x,double const* p,double* dp) ";
324usage+="\n| ou dp[i] = dF(x[];p[])/dp[i] ";
325usage+="\n| Par convention, cette fonction a le meme nom suivi de ''_der'' ";
326usage+="\n| > crfitfun nom_fichier nom_fonction nvar npar ";
327usage+="\n| Permet de compiler le fichier ''nom_fichier'' et de linker ";
328usage+="\n| la fonction ''nom_fonction'' ";
329usage+="\n| - Un meme fichier peut contenir plusieurs fonctions a fitter ";
330usage+="\n| ";
331usage+="\n////////////////////////////////////////////////////////////////////// ";
332piac->RegisterHelp(kw,usage,grp);
333
334kw = "fit";
335usage = "Fitting function to DataObjects (Histo, Histo2D, Vector, ...)";
336usage += "\n Usage: fit nomobj func [Options]";
337usage += "\n [p:p1,...,pn s:s1,...,sn m:m1,...,mn M:M1,...,Mn o:... o:...]";
338usage += "\n Related commands: fitw fitlin crfitfun crfitfil";
339piac->RegisterCommand(kw,usage,this,grp);
340
341kw = "fitw";
342usage = "Fitting function to DataObjects with Interactive Window Help";
343usage += "\n Usage: fitw nomobj func [Options]";
344usage += "\n [p:p1,...,pn s:s1,...,sn m:m1,...,mn M:M1,...,Mn o:... o:...]";
345usage += "\n Related commands: fit fitlin crfitfun crfitfil";
346piac->RegisterCommand(kw,usage,this,grp);
347
348kw = "fitlin";
349usage = "Linear Fitting of Polynoms to DataObjects";
350usage += "\n Usage: fitlin nomobj func [o:... o:...]";
351usage += "\n Related commands: fit fitw crfitfun crfitfil";
352piac->RegisterCommand(kw,usage,this,grp);
353
354kw = "crfitfun";
355usage = "Creation et link de function utilisateur pour le fit";
356usage += "\n Usage: crfitfun file func nvar npar";
357usage += "\n Related commands: fit fitw fitlin crfitfil";
358piac->RegisterCommand(kw,usage,this,grp);
359
360kw = "crfitfil";
361usage = "Creation de fichier C pour function utilisateur du fit";
362usage += "\n Usage: crfitfil file func nvar npar";
363usage += "\n Related commands: fit fitw fitlin crfitfun";
364piac->RegisterCommand(kw,usage,this,grp);
365}
366
367/* --Methode-- */
368PIAFitter::~PIAFitter()
369{
370if(delmGData && mGData != NULL) {delete mGData; mGData=NULL; delmGData=false;}
371if(mFit != NULL) {delete mFit; mFit=NULL;}
372if(mFunction != NULL) {delete mFunction; mFunction=NULL;}
373if(mFunc != NULL) {delete mFunc; mFunc=NULL;}
374if(FWindFit != NULL) {delete FWindFit; FWindFit=NULL;}
375if(mDlUFunc != NULL) {delete mDlUFunc; mDlUFunc=NULL;}
376}
377
378/* --Methode-- */
379void PIAFitter::ResetOptions(void)
380// Reset des options
381{
382mOpt.okres = mOpt.okfun = false;
383
384mOpt.polcx = mOpt.polcy = 0;
385mOpt.xc = mOpt.yc = 0.;
386
387mOpt.stc2 = 1.e-3;
388mOpt.nstep = 100;
389
390mOpt.err_type = GeneralFitData::DefaultError;
391mOpt.err_scale = 1.; mOpt.err_min = 0.;
392
393mOpt.lp = 1; mOpt.lpg = 0;
394
395mOpt.i1 = mOpt.j1 = 0;
396mOpt.i2 = mOpt.j2 = -1;
397
398mOpt.fromlastfit = false;
399mOpt.autoinifit = false;
400}
401
402/* --Methode-- */
403void PIAFitter::DecodeOptions(string opt)
404// Decodage des options a partir des chaines de caracteres
405{
406ResetOptions();
407if(opt.length()<=0) return;
408
409size_t p,q; string dum;
410opt = "," + opt + ",";
411
412if(strstr(opt.c_str(),",F,")) // init options/param a partir du fit precedent
413 {mOpt = mOptSave; mOpt.fromlastfit = true;}
414if(strstr(opt.c_str(),",a,")) mOpt.autoinifit = true; // init auto par fit
415if(strstr(opt.c_str(),",r,")) mOpt.okres = true; // residus
416if(strstr(opt.c_str(),",f,")) mOpt.okfun = true; // fonction fittee
417if(strstr(opt.c_str(),",x")) { // Demande de centrage (fit X=x-xc)
418 mOpt.polcx = 2; // Le centrage est calcule automatiquement
419 p = opt.find(",x"); q = opt.find_first_of(',',p+1);
420 dum = opt.substr(p,q-p);
421 if(dum.length()>2) {
422 sscanf(dum.c_str(),",x%lf",&mOpt.xc);
423 mOpt.polcx = 1; // Le centrage est fixe par la valeur lue
424 }
425}
426if(strstr(opt.c_str(),",y")) { // Demande de centrage (fit Y=y-yc)
427 mOpt.polcy = 2; // Le centrage est calcule automatiquement
428 p = opt.find(",y"); q = opt.find_first_of(',',p+1);
429 dum = opt.substr(p,q-p);
430 if(dum.length()>2) {
431 sscanf(dum.c_str(),",y%lf",&mOpt.yc);
432 mOpt.polcy = 1; // Le centrage est fixe par la valeur lue
433 }
434}
435if(strstr(opt.c_str(),",h")) {
436 mOpt.err_type = GeneralFitData::DefaultError;
437 p = opt.find(",h"); q = opt.find_first_of(',',p+1);
438 dum = opt.substr(p,q-p);
439 if(dum.length()>2) sscanf(dum.c_str(),",h%lf/%lf",&mOpt.err_scale,&mOpt.err_min);
440}
441if(strstr(opt.c_str(),",H")) {
442 mOpt.err_type = GeneralFitData::ProporError;
443 p = opt.find(",H"); q = opt.find_first_of(',',p+1);
444 dum = opt.substr(p,q-p);
445 if(dum.length()>2) sscanf(dum.c_str(),",H%lf/%lf",&mOpt.err_scale,&mOpt.err_min);
446}
447if(strstr(opt.c_str(),",e")) {
448 mOpt.err_type = GeneralFitData::ConstantError;
449 p = opt.find(",e"); q = opt.find_first_of(',',p+1);
450 dum = opt.substr(p,q-p);
451 if(dum.length()>2) sscanf(dum.c_str(),",e%lf/%lf",&mOpt.err_scale,&mOpt.err_min);
452}
453if(strstr(opt.c_str(),",E")) {
454 mOpt.err_type = GeneralFitData::SqrtError;
455 p = opt.find(",E"); q = opt.find_first_of(',',p+1);
456 dum = opt.substr(p,q-p);
457 if(dum.length()>2) sscanf(dum.c_str(),",E%lf/%lf",&mOpt.err_scale,&mOpt.err_min);
458}
459if(strstr(opt.c_str(),",X")) { // Valeur du StopChi2
460 p = opt.find(",X"); q = opt.find_first_of(',',p+1);
461 dum = opt.substr(p,q-p);
462 if(dum.length()>2) sscanf(dum.c_str(),",X%lf",&mOpt.stc2);
463}
464if(strstr(opt.c_str(),",N")) { // Nombre maximum d'iterations
465 p = opt.find(",N"); q = opt.find_first_of(',',p+1);
466 dum = opt.substr(p,q-p);
467 if(dum.length()>2) sscanf(dum.c_str(),",N%d",&mOpt.nstep);
468}
469if(strstr(opt.c_str(),",l")) { // niveau de print
470 p = opt.find(",l"); q = opt.find_first_of(',',p+1);
471 dum = opt.substr(p,q-p);
472 if(dum.length()>2) sscanf(dum.c_str(),",l%d",&mOpt.lp);
473}
474if(strstr(opt.c_str(),",d")) { // niveau de debug du fit
475 p = opt.find(",d"); q = opt.find_first_of(',',p+1);
476 dum = opt.substr(p,q-p);
477 if(dum.length()>2) sscanf(dum.c_str(),",d%d",&mOpt.lpg);
478}
479if(strstr(opt.c_str(),",I")) { // intervalle de fit selon X
480 p = opt.find(",I"); q = opt.find_first_of(',',p+1);
481 dum = opt.substr(p,q-p);
482 if(dum.length()>2) sscanf(dum.c_str(),",I%d/%d",&mOpt.i1,&mOpt.i2);
483}
484if(strstr(opt.c_str(),",J")) { // intervalle de fit selon Y
485 p = opt.find(",J"); q = opt.find_first_of(',',p+1);
486 dum = opt.substr(p,q-p);
487 if(dum.length()>2) sscanf(dum.c_str(),",J%d/%d",&mOpt.j1,&mOpt.j2);
488}
489
490return;
491}
492
493/* --Methode-- */
494void PIAFitter::DecodeObject(string obj)
495// Decodage de l'objet a fitter
496{
497mNObj = "";
498NamedObjMgr omg;
499AnyDataObj* mobj = omg.GetObj(obj);
500if(mobj == NULL)
501 {cout<<"PIAFitter::DecodeObject Error , Pas d'objet de nom "<<obj<<endl;
502 return;}
503
504mNObj = obj;
505
506return;
507}
508
509/* --Methode-- */
510void PIAFitter::CheckOptions(void)
511// Check consistence des choix des options
512// ATTENTION: cette methode a besoin que l'objet a fitter soit deja lu
513{
514if(mOpt.lp<0) mOpt.lp = 0;
515if(mOpt.lpg<0) mOpt.lpg = 0;
516if(mOpt.stc2<=0.) mOpt.stc2 = 1.e-3;
517if(mOpt.nstep<2) mOpt.nstep = 100;
518return;
519}
520
521/* --Methode-- */
522void PIAFitter::PrintOptions(void)
523// Print des options
524{
525cout<<"Fit("<<mNData<<") dim="<<mNVar<<":"
526 <<" Int=["<<mOpt.i1<<","<<mOpt.i2<<"],["<<mOpt.j1<<","<<mOpt.j2<<"]"<<endl
527 <<" Cent="<<mOpt.polcx<<","<<mOpt.polcy<<","<<mOpt.xc<<"+x"<<","<<mOpt.yc<<"+y"
528 <<" TypE="<<mOpt.err_type<<","<<mOpt.err_scale<<","<<mOpt.err_min
529 <<" StpX2="<<mOpt.stc2<<" Nstep="<<mOpt.nstep<<endl
530 <<" Init.LFit="<<mOpt.fromlastfit<<" AutoIni.Fit="<<mOpt.autoinifit
531 <<" lp,lpg="<<mOpt.lp<<","<<mOpt.lpg<<endl;
532return;
533}
534
535/* --Methode-- */
536void PIAFitter::FillGData(void)
537// Fill generalfitdata pour le fit
538// ATTENTION: cette methode a besoin que les options soient decodees et checkees
539{
540if(delmGData && mGData!=NULL) {delete mGData; mGData=NULL; delmGData=false;}
541mNVar = mNData = 0;
542
543NamedObjMgr omg;
544mAdObj = omg.GetObjAdapter(mNObj); // Ne pas deleter
545if(mAdObj == NULL) {
546 cout<<"PIAFitter::DecodeObject Error , ObjAdapter==NULL for "<<mNObj<<endl;
547 return;
548}
549mGData = mAdObj->GetGeneralFitData(delmGData
550 ,mOpt.err_type,mOpt.err_scale,mOpt.err_min
551 ,mOpt.i1,mOpt.i2,mOpt.j1,mOpt.j2);
552if(mGData == NULL) {
553 cout<<"PIAFitter::DecodeObject Error , No adaptor for "<<mNObj<<endl;
554 return;
555}
556mNData = mGData->NData();
557if(mNData<=0) {
558 cout<<"No data in GeneralFitData: "<<mNData<<endl;
559 return;
560}
561mNVar = mGData->NVar();
562if(mNVar<=0 || mNVar>2) {
563 cout<<"Fit only support 1 and 2D : NVar = "<<mNVar<<endl;
564 return;
565}
566
567// Gestion du centrage automatique si demande
568GetCentering();
569
570// Prints
571if(mOpt.lp>2) {
572 mGData->PrintStatus();
573 mGData->PrintData(0);
574 mGData->PrintData(mNData-1);
575 double mini,maxi;
576 mGData->GetMnMx(2,mini,maxi);
577 cout<<"Limites ...x0 = ["<<mini<<","<<maxi<<"]"<<endl;
578 if(mNVar==2)
579 {mGData->GetMnMx(12,mini,maxi);
580 cout<<"Limites ...x1 = ["<<mini<<","<<maxi<<"]"<<endl;}
581 mGData->GetMnMx(0,mini,maxi);
582 cout<<"Limites ...y = ["<<mini<<","<<maxi<<"]"<<endl;
583 mGData->GetMnMx(1,mini,maxi);
584 cout<<"Limites ...ey = ["<<mini<<","<<maxi<<"]"<<endl;
585}
586
587return;
588}
589
590/* --Methode-- */
591void PIAFitter::GetCentering(void)
592// Calcul le centrage automatique
593{
594if(!mGData) return;
595if(mOpt.polcx==2) {
596 double mini,maxi;
597 mGData->GetMnMx(2,mini,maxi);
598 mOpt.xc=(mini+maxi)/2.;
599}
600if(mOpt.polcy==2 && mNVar>=2) {
601 double mini,maxi;
602 mGData->GetMnMx(12,mini,maxi);
603 mOpt.yc=(mini+maxi)/2.;
604}
605}
606
607/* --Methode-- */
608void PIAFitter::DecodeFunction(string func)
609// Fonction a fitter
610// ATTENTION: cette methode a besoin que les donnees soient lues
611// (pour mOpt.xc,yc et mNVar)
612{
613if(func.length()<=0)
614 {cout<<"PIAFitter::DecodeFunction Donnez un nom de fonction a fitter."<<endl;
615 return;}
616if(mFunction!=NULL) {delete mFunction; mFunction=NULL;}
617if(mFunc !=NULL) {delete mFunc; mFunc=NULL;}
618mNPar=0; mFName = "";
619
620if(func == mNameFitFunc) { // Fonction utilisateur
621 mFunc = new GeneralFunc(mUFNVar,mUFNPar,mFitFunc,mFitFuncDer);
622 mNPar = mUFNPar;
623 cout<<"Fonction utilisateur nvar="<<mUFNVar<<", npar="<<mNPar<<endl;
624} else if(func[0]=='p' && mNVar==1) { //polynome
625 int degre=0; if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
626 cout<<"Fit polynome 1D de degre "<<degre<<endl;
627 Polyn1D* myf = new Polyn1D(degre,((mOpt.polcx>0)?mOpt.xc:0.));
628 mFunction = myf; mNPar = mFunction->NPar(); mFName = func;
629
630} else if(func[0]=='e' && mNVar==1) { //exponentielle
631 int degre=-1; if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
632 cout<<"Fit d'exponentielle+polynome 1D de degre "<<degre<<endl;
633 Exp1DPol* myf;
634 if(degre>=0) myf = new Exp1DPol((unsigned int)degre,((mOpt.polcx>0)?mOpt.xc:0.));
635 else myf = new Exp1DPol(((mOpt.polcx>0)?mOpt.xc:0.));
636 mFunction = myf; mNPar = mFunction->NPar(); mFName = func;
637
638} else if(func[0]=='g' && mNVar==1) { //gaussienne en hauteur
639 int degre=-1; if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
640 cout<<"Fit de Gaussienne_en_hauteur+polynome 1D de degre "<<degre<<endl;
641 Gauss1DPol* myf;
642 if(degre>=0) myf = new Gauss1DPol((unsigned int)degre,((mOpt.polcx)?true:false));
643 else { bool bfg = (mOpt.polcx)?true:false; myf = new Gauss1DPol(bfg); }
644 mFunction = myf; mNPar = mFunction->NPar(); mFName = func;
645
646} else if(func[0]=='G' && mNVar==1) { //gaussienne en volume
647 int degre=-1; if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
648 cout<<"Fit de Gaussienne_en_volume+polynome 1D de degre "<<degre<<endl;
649 GaussN1DPol* myf;
650 if(degre>=0) myf = new GaussN1DPol((unsigned int)degre,((mOpt.polcx)?true:false));
651 else { bool bfg = (mOpt.polcx)?true:false; myf = new GaussN1DPol(bfg); }
652 mFunction = myf; mNPar = mFunction->NPar(); mFName = func;
653
654} else if(func[0]=='p' && mNVar==2) { //polynome 2D
655 int degre=0; if(func.length()>1) sscanf(func.c_str()+1,"%d",&degre);
656 cout<<"Fit polynome 2D de degre "<<degre<<endl;
657 Polyn2D* myf =
658 new Polyn2D(degre,((mOpt.polcx>0)?mOpt.xc:0.),((mOpt.polcy>0)?mOpt.yc:0.));
659 mFunction = myf; mNPar = mFunction->NPar(); mFName = func;
660
661} else if(func[0]=='G' && mNVar==2) { //gaussienne+fond en volume
662 int integ=0; if(func.length()>1) if(func[1]=='i') integ=1;
663 cout<<"Fit de Gaussienne+Fond 2D integ="<<integ<<endl;
664 if(integ) {GauRhInt2D* myf = new GauRhInt2D; mFunction = myf;}
665 else {GauRho2D* myf = new GauRho2D; mFunction = myf;}
666 mNPar = mFunction->NPar(); mFName = func;
667
668} else if(func[0]=='d' && mNVar==2) { //DL gaussienne+fond en volume
669 int integ=0; if(func.length()>1) if(func[1]=='i') integ=1;
670 cout<<"Fit de DL de Gaussienne+Fond 2D integ="<<integ<<endl;
671 if(integ) {GdlRhInt2D* myf = new GdlRhInt2D; mFunction = myf;}
672 else {GdlRho2D* myf = new GdlRho2D; mFunction = myf;}
673 mNPar = mFunction->NPar(); mFName = func;
674
675} else if(func[0]=='D' && mNVar==2) { //DL gaussienne+fond avec coeff variable p6 en volume
676 int integ=0; if(func.length()>1) if(func[1]=='i') integ=1;
677 cout<<"Fit de DL de Gaussienne+Fond avec coeff variable (p6) 2D integ="<<integ<<endl;
678 if(integ) {Gdl1RhInt2D* myf = new Gdl1RhInt2D; mFunction = myf;}
679 else {Gdl1Rho2D* myf = new Gdl1Rho2D; mFunction = myf;}
680 mNPar = mFunction->NPar(); mFName = func;
681
682} else if(func[0]=='M' && mNVar==2) { //Moffat+fond (volume)
683 int integ=0; if(func.length()>1) if(func[1]=='i') integ=1;
684 cout<<"Fit de Moffat+Fond (expos=p6) 2D integ="<<integ<<endl;
685 if(integ) {MofRhInt2D* myf = new MofRhInt2D; mFunction = myf;}
686 else {MofRho2D* myf = new MofRho2D; mFunction = myf;}
687 mNPar = mFunction->NPar(); mFName = func;
688
689} else {
690 cout<<"Fonction "<<func<<" inconnue pour la dim "<<mNVar<<endl;
691 return;
692}
693
694return;
695}
696
697/* --Methode-- */
698void PIAFitter::ReSetParam(void)
699// Pour (re)dimensionner les tableaux des parametres
700// ATTENTION: cette methode a besoin que la fonction soit connue
701{
702if(mNPar==0) return;
703mPar.Realloc(mNPar); mPar=0.;
704mStep.Realloc(mNPar); mStep=1.;
705mMin.Realloc(mNPar); mMin=1.;
706mMax.Realloc(mNPar); mMax=-1.;
707mFix.Realloc(mNPar); mFix=0.;
708return;
709}
710
711/* --Methode-- */
712void PIAFitter::AutoIniFit(void)
713// Initialisation automatique des parametres du fit
714{
715if(mFunc) { // Fonction utilisateur
716 cout<<"PIAFitter::AutoIniFit : Fonction utilisateur, pas d'init auto"<<endl;
717} else if(mFName[0]=='p' && mNVar==1) { //poly 1D
718 cout<<"PIAFitter::AutoIniFit : Auto Init type polynome 1D"<<endl;
719 IniFitP1ou2D();
720
721} else if(mFName[0]=='g' && mNVar==1) { //gauss en haut 1D
722 cout<<"PIAFitter::AutoIniFit : Auto Init type gauss_haut+pol 1D"<<endl;
723 IniFitGhP1D();
724
725} else if(mFName[0]=='G' && mNVar==1) { //gauss en vol 1D
726 cout<<"PIAFitter::AutoIniFit : Auto Init type gauss_vol+pol 1D"<<endl;
727 IniFitGvP1D();
728
729} else if(mFName[0]=='p' && mNVar==2) { //poly 2D
730 cout<<"PIAFitter::AutoIniFit : Auto Init type polynome 2D"<<endl;
731 IniFitP1ou2D();
732
733} else if((mFName[0]=='G'||mFName[0]=='d') && mNVar==2) { //gauss+fond en vol
734 cout<<"PIAFitter::AutoIniFit : Auto Init type gauss_vol+fond 2D"<<endl;
735 IniFitGv2D();
736
737} else if(mFName[0]=='D' && mNVar==2) { //DLgauss+fond en vol 2D
738 cout<<"PIAFitter::AutoIniFit : Auto Init type DLgauss_vol+fond 2D"<<endl;
739 IniFitGv2D();
740 Vector dum(mNPar);
741 dum = mPar; mPar(6)=0.5; mPar(7)=dum(6);
742 dum = mStep; mStep(6)=0.05; mStep(7)=dum(6);
743 dum = mMin; mMin(6)=0.; mMin(7)=dum(6);
744 dum = mMax; mMax(6)=10.; mMax(7)=dum(6);
745 dum = mFix; mFix(6)=1.1; mFix(7)=dum(6);
746
747} else if(mFName[0]=='M' && mNVar==2) { //Moffat+fond en vol 2D
748 cout<<"PIAFitter::AutoIniFit : Auto Init type moffat_vol+fond 2D"<<endl;
749 IniFitGv2D();
750 Vector dum(mNPar);
751 dum = mPar; mPar(6)=2.5; mPar(7)=dum(6);
752 dum = mStep; mStep(6)=0.05; mStep(7)=dum(6);
753 dum = mMin; mMin(6)=1.2; mMin(7)=dum(6);
754 dum = mMax; mMax(6)=10.; mMax(7)=dum(6);
755 dum = mFix; mFix(6)=1.1; mFix(7)=dum(6);
756
757} else {
758 cout<<"PIAFitter::AutoIniFit : Fonction "<<mFName
759 <<", \n pas d'init auto en dim "<<mNVar<<endl;
760 return;
761}
762
763return;
764}
765
766/* --Methode-- */
767void PIAFitter::InitParFromLastFit(void)
768// Initialisation du fit a partir des resultats du fit precedent
769// (Les arguments de la ligne de commande sont prioritaires)
770// ATTENTION: cette methode a besoin que la fonction soit connue
771{
772if(mNPar==0) return;
773int n = mParSave.NElts();
774if(n==0) return;
775
776for(int i=0;i<mNPar;i++) {
777 if(i>=n) break;
778 mPar(i) = mParSave(i);
779 mStep(i) = mStepSave(i);
780 mMin(i) = mMinSave(i);
781 mMax(i) = mMaxSave(i);
782 mFix(i) = mFixSave(i);
783}
784
785return;
786}
787
788/* --Methode-- */
789void PIAFitter::DecodeParam(string par,string step,string min,string max,string fix)
790// Decodage des parametres
791// ATTENTION: cette methode a besoin que la fonction soit connue
792// et que les options soient decodees
793{
794if(mNPar==0) return;
795ReSetParam();
796if(mOpt.autoinifit) AutoIniFit();
797if(mOpt.fromlastfit) InitParFromLastFit();
798Vector* v=NULL; string* s=NULL;
799for(int j=0;j<5;j++) {
800 if(j==0) {v=&mPar; s=&par;} else if(j==1) {v=&mStep; s=&step;}
801 else if(j==2) {v=&mMin; s=&min;} else if(j==3) {v=&mMax; s=&max;}
802 else if(j==4) {v=&mFix; s=&fix;}
803 if(s->length()>0) *s += ",";
804 for(int i=0;i<mNPar;i++) {
805 if(s->length()<=0) break;
806 if((*s)[0]!='!') sscanf(s->c_str(),"%lf",&(*v)(i));
807 size_t p = s->find_first_of(',') + 1;
808 if(p>=s->length()) *s = ""; else *s = s->substr(p);
809 }
810}
811return;
812}
813
814/* --Methode-- */
815int PIAFitter::DoFit(void)
816// Fit avec generalfit
817{
818if(mNPar==0) return -1000;
819if((mFunction==NULL && mFunc==NULL) || mGData==NULL) {
820 cout<<"PIAFitter::DoFit error: mFunction,mFunc="<<mFunction<<","<<mFunc
821 <<" mGData="<<mGData<<endl;
822 return -1001;
823}
824// classe GeneraFit
825if(mFit != NULL) {delete mFit; mFit= NULL;}
826if(mFunction) mFit = new GeneralFit(mFunction);
827 else if(mFunc) mFit = new GeneralFit(mFunc);
828if(!mFit) return(-1002);
829
830// Options et Set de GeneralFit
831mFit->SetDebug(mOpt.lpg);
832mFit->SetData(mGData);
833mFit->SetStopChi2(mOpt.stc2);
834mFit->SetMaxStep(mOpt.nstep);
835{for(int i=0;i<mNPar;i++) {
836 char str[10];
837 sprintf(str,"P%d",i);
838 mFit->SetParam(i,str,mPar(i),mStep(i),mMin(i),mMax(i));
839 if((int)(mFix(i)+0.001)>=1.) mFit->SetFix(i);
840}}
841if(mOpt.lp>1) mFit->PrintFit();
842
843// Fit
844#ifdef SANS_EVOLPLANCK
845mParSave = mPar; mStepSave = mStep; mFixSave = mFix;
846mMinSave = mMin; mMaxSave = mMax;
847#else
848mParSave.Clone(mPar); mStepSave.Clone(mStep); mFixSave.Clone(mFix);
849mMinSave.Clone(mMin); mMaxSave.Clone(mMax);
850#endif
851mOptSave = mOpt;
852double c2r = -1.;
853int rcfit = mFit->Fit();
854if(mOpt.lp>0) mFit->PrintFit();
855if(rcfit>0) {
856 c2r = mFit->GetChi2Red();
857 cout<<"C2r_Reduit = "<<c2r<<" nstep="<<mFit->GetNStep()<<" rc="<<rcfit<<endl;
858 for(int i=0;i<mNPar;i++) mParSave(i)=mFit->GetParm(i);
859} else {
860 cout<<"echec Fit, rc = "<<rcfit<<" nstep="<<mFit->GetNStep()<<endl;
861 mFit->PrintFitErr(rcfit);
862}
863
864return rcfit;
865}
866
867/* --Methode-- */
868void PIAFitter::FitFunRes(void)
869// Mise a disposition des resultats (fonction fitee et residus)
870{
871if(!mFit) return;
872
873NamedObjMgr omg;
874string nomresfun = "__dummy__";
875
876if(mOpt.okres) {
877 nomresfun = mNObj + "_res";
878 AnyDataObj* ob = mAdObj->FitResidusObj(*mFit);
879 if(ob) omg.AddObj(ob,nomresfun);
880}
881
882if(mOpt.okfun) {
883 nomresfun = mNObj + "_fun";
884 AnyDataObj* ob = mAdObj->FitFunctionObj(*mFit);
885 if(ob) omg.AddObj(ob,nomresfun);
886}
887
888return;
889}
890
891/* --Methode-- */
892void PIAFitter::LinFit(void)
893// Fit lineaire de polynomes
894{
895if(mFName.length()<=0)
896 {cout<<"PIAFitter::LinFit Donnez un nom de fonction a fitter."<<endl;
897 return;}
898if(!mGData)
899 {cout<<"PIAFitter::LinFit pas de Data."<<endl; return;}
900if(mFName[0]!='p')
901 {cout<<"PIAFitter::LinFit fonction non prevue "<<mFName<<endl;
902 return;}
903int degre = 0;
904if(mFName.length()>1) sscanf(mFName.c_str()+1,"%d",&degre);
905
906double xc = (mOpt.polcx>0) ? mOpt.xc : 0.;
907double yc = (mOpt.polcy>0) ? mOpt.yc : 0.;
908
909if(mNVar==1) { // Fit lineaire de polynome 1D
910 cout<<"Fit (lineaire) 1D polynome de degre "<<degre
911 <<" (xc="<<xc<<")"<<endl;
912 Poly p1(0);
913 double c2rl = mGData->PolFit(0,p1,degre,true,xc);
914 cout<<"C2r_lineaire = "<<c2rl<<endl;
915 if(mOpt.lp>0) cout<<p1<<endl;
916} else if(mNVar==2) { // Fit lineaire de polynome 2D
917 cout<<"Fit (lineaire) polynome 2D de degre "<<degre
918 <<" (xc,yc="<<xc<<","<<yc<<")"<<endl;
919 Poly2 p2(0);
920 double c2rl = mGData->PolFit(0,1,p2,degre,-1,true,xc,yc);
921 cout<<"C2r_lineaire = "<<c2rl<<endl;
922 if(mOpt.lp>0) cout<<p2<<endl;
923}
924
925return;
926}
927
928/* --Methode-- */
929void PIAFitter::LinkFitFunc(string const& fname, string const& funcname
930 ,int nvar,int npar)
931// Compilation et link dynamique de la fonction a fitter
932{
933if(nvar<1 || npar<1) return;
934if(mDlUFunc != NULL) {delete mDlUFunc; mDlUFunc=NULL;}
935mFitFunc = NULL; mFitFuncDer = NULL;
936mUFNVar= mUFNPar = 0; mNameFitFunc = "";
937
938// On compile le fichier C, on fabrique un .so et on l'ouvre
939mDlUFunc = PDynLinkMgr::BuildFromCFile(fname);
940if(mDlUFunc == NULL)
941 {cerr<<"PIAFitter::LinkFitFunc() Erreur building .so "<<endl; return;}
942
943// On recupere la fonction de fit
944mFitFunc = (DlUserFitFunc) mDlUFunc->GetFunction(funcname);
945if(mFitFunc == NULL) // Probleme, on n'a pas trouve etc ...
946 {cerr<<"PIAFitter::LinkFitFunc() Erreur linking function"<<funcname<<endl;
947 delete mDlUFunc; mDlUFunc = NULL; return;}
948
949// On recupere la fonction des derivees
950string fnameder = funcname+"_der";
951mFitFuncDer = (DlUserFitFuncDer) mDlUFunc->GetFunction(fnameder);
952if(mFitFuncDer == NULL)
953 {cout<<"PIAFitter::LinkFitFunc() No derive for"<<fnameder<<endl;}
954
955// Variables et pointeurs definissant le link a la fonction utilisateur
956mNameFitFunc = funcname;
957mUFNVar = nvar;
958mUFNPar = npar;
959cout<<"PIAFitter::LinkFitFunc() UserFitFunc="<<mNameFitFunc
960 <<" NVar="<<mUFNVar<<" NPar="<<mUFNPar<<endl;
961
962return;
963}
964
965/* --Methode-- */
966void PIAFitter::PrepareFitFuncCFile(string const& fname, string const& funcname
967 , int nvar, int npar)
968// Pour ecrire un squelette des fichier C avec pour une fonction a fitter
969{
970if(fname.length()<=0 || funcname.length()<=0 || nvar<=0 || npar <=0) {
971 cerr<<"PIAFitter::PrepareFitFuncCFile: error "
972 <<" nvar="<<nvar<<" npar="<<npar<<endl
973 <<" file_name="<<fname<<" func_name="<<funcname<<endl
974 <<" ---- No File Created ! ----"<<endl;
975 return;
976}
977
978FILE* fip = fopen(fname.c_str(),"w");
979if(fip==NULL)
980 {cerr<<"PIAFitter::PrepareFitFuncCFile: error opening file for writing\n"
981 <<fname<<endl; return;}
982
983fprintf(fip,"#include <stdio.h>\n#include <stdlib.h>\n#include <math.h>\n\n");
984fprintf(fip,"/* - many functions can be written in this file: */\n");
985fprintf(fip,"/* here is an exemple for creation of function %s */\n\n"
986 ,funcname.c_str());
987fprintf(fip,"double %s(double const* x,double const* p)\n",funcname.c_str());
988fprintf(fip,"/* Function : F(x[0-%d];p[0-%d]) */\n",nvar-1,npar-1);
989fprintf(fip,"/* variables x1=x[0],x2=x[1],...,x%d=x[%d] */\n",nvar,nvar-1);
990fprintf(fip,"/* parameters p1=p[0],p2=p[1],...,p%d=p[%d] */\n",nvar,nvar-1);
991fprintf(fip,"{\n val = F(x[];p[]);\n return(val);\n}\n\n");
992string fder = funcname + "_der";
993fprintf(fip,"/* That function is optional */\n");
994fprintf(fip,"/*\n");
995fprintf(fip,"double %s(double const* x,double const* p,double* dp)\n",fder.c_str());
996fprintf(fip,"{\n");
997for(int i=0;i<npar;i++) fprintf(fip," dp[%d] = dF(x[];p[])/dp[%d]\n",i,i);
998fprintf(fip," val = F(x[];p[]);\n return(val);\n}\n\n");
999fprintf(fip,"*/\n");
1000
1001fclose(fip);
1002}
1003
1004/* --Methode-- */
1005int PIAFitter::Execute(string& kw, vector<string>& tokens, string& toks)
1006// Execution des commandes de fit : "fit" et "fitw"
1007{
1008////// Les commandes pour creer les fonctions de fit utilisateur
1009if(kw == "crfitfil") {
1010 if (tokens.size() < 4)
1011 {cout<<"Usage:crfitfil filename funcname nvar npar"<<endl;return(-1);}
1012 int nvar = atoi(tokens[2].c_str()), npar = atoi(tokens[3].c_str());
1013 PrepareFitFuncCFile(tokens[0],tokens[1],nvar,npar);
1014 return(0);
1015} else if (kw == "crfitfun") {
1016 if (tokens.size() < 4)
1017 {cout<<"Usage:crfitfun filename funcname nvar npar"<<endl;return(-1);}
1018 int nvar = atoi(tokens[2].c_str()), npar = atoi(tokens[3].c_str());
1019 LinkFitFunc(tokens[0],tokens[1],nvar,npar);
1020 return(0);
1021}
1022
1023////// Les commandes pour fitter
1024if(tokens.size() < 2) {
1025 cout
1026 <<"Usage:fit nomobj func [Options]\n"
1027 <<" ou fitw nomobj func [Options]\n"
1028 <<" avec Options: [p:p1,...,pn s:s1,...,sn m:m1,...,mn \n"
1029 <<" M:M1,...,Mn f:f1,...,fn o:.,.,. o:.,.,.]\n"
1030 <<" ou fitlin nomobj pnn [o:.,.,. o:.,.,.]\n";
1031 return(-1);
1032}
1033
1034// decodage des arguments de la commande
1035string mSp,mSs,mSm,mSM,mSf,mSo;
1036mSp=""; mSs=""; mSm=""; mSM=""; mSf=""; mSo="";
1037if(tokens.size()>2)
1038 for(int ip=2;ip<(int)tokens.size();ip++) {
1039 if(tokens[ip].length()<=2) continue;
1040 const char *c = tokens[ip].c_str();
1041 if(c[1]!=':') continue;
1042 if(c[0]=='p') mSp=c+2;
1043 else if(c[0]=='s') mSs=c+2;
1044 else if(c[0]=='m') mSm=c+2;
1045 else if(c[0]=='M') mSM=c+2;
1046 else if(c[0]=='f') mSf=c+2;
1047 else if(c[0]=='o') {mSo += ","; mSo += c+2;}
1048 }
1049
1050// Execution des commandes
1051DecodeOptions(mSo);
1052DecodeObject(tokens[0]);
1053CheckOptions();
1054FillGData();
1055if(mOpt.lp>0) PrintOptions();
1056DecodeFunction(tokens[1]);
1057DecodeParam(mSp,mSs,mSm,mSM,mSf);
1058if(kw == "fit") {
1059 int rc = DoFit();
1060 if(rc>=0) FitFunRes();
1061} else if(kw == "fitlin") {
1062 LinFit();
1063} else if(kw == "fitw") {
1064 if(FWindFit!=NULL) {delete FWindFit; FWindFit=NULL;}
1065 FWindFit = new PIAFitterWind(mApp,this,tokens[1]);
1066 FWindFit->Show();
1067}
1068
1069return(0);
1070}
1071
1072/* --Methode-- */
1073void PIAFitter::IniFitP1ou2D(void)
1074{
1075if(mNPar==0) return;
1076mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
1077if(!mGData) return;
1078double mean,sigma;
1079int rc = mGData->GetMeanSigma(0,mean,sigma);
1080if(rc<=0) return;
1081mPar(0) = mean;
1082return;
1083}
1084
1085void PIAFitter::IniFitGhP1D(void)
1086{
1087if(mNPar==0) return;
1088mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
1089if(mNVar!=1 || mNPar<3) return;
1090double h,v,x0,y0,sx,sy,f;
1091int rc = IniFitGaus(*mGData,h,v,x0,y0,sx,sy,f);
1092if(rc!=0) return;
1093mPar(0)=h; mStep(0)=h/1000.;
1094mPar(1)=x0; mStep(1)=sx/10.;
1095mPar(2)=sx; mStep(2)=sx/10.; mMin(2)=0.; mMax(2)=20.*sx;
1096if(mNPar>3) {mPar(3)=f; mStep(3)=f/1000.;} else mPar(0)=h+f;
1097}
1098
1099void PIAFitter::IniFitGvP1D(void)
1100{
1101if(mNPar==0) return;
1102mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
1103if(mNVar!=1 || mNPar<3) return;
1104double h,v,x0,y0,sx,sy,f;
1105int rc = IniFitGaus(*mGData,h,v,x0,y0,sx,sy,f);
1106if(rc!=0) return;
1107mPar(0)=v; mStep(0)=v/1000.;
1108mPar(1)=x0; mStep(1)=sx/10.;
1109mPar(2)=sx; mStep(2)=sx/10.; mMin(2)=0.; mMax(2)=20.*sx;
1110if(mNPar>3) {mPar(3)=f; mStep(3)=f/1000.;} else mPar(0)=v+mNData*f;
1111}
1112
1113void PIAFitter::IniFitGv2D(void)
1114{
1115if(mNPar==0) return;
1116mPar=0.; mStep=1.; mMin=1.; mMax=-1.; mFix=0.;
1117if(mNVar!=2 || mNPar<6) return;
1118double h,v,x0,y0,sx,sy,f;
1119int rc = IniFitGaus(*mGData,h,v,x0,y0,sx,sy,f);
1120if(rc!=0) return;
1121mPar(0)=v; mStep(0)=v/1000.;
1122mPar(1)=x0; mStep(1)=sx/10.;
1123mPar(2)=y0; mStep(2)=sy/10.;
1124mPar(3)=sx; mStep(3)=sx/10.; mMin(3)=0.; mMax(3)=20.*sx;
1125mPar(4)=sy; mStep(4)=sy/10.; mMin(4)=0.; mMax(4)=20.*sy;
1126mPar(5)=0.; mStep(5)=0.005; mMin(5)=-1.; mMax(5)=1.;
1127if(mNPar>6) {mPar(6)=f; mStep(6)=f/1000.;} else mPar(0)=v+mNData*f;
1128}
1129
1130int PIAFitter::IniFitGaus(GeneralFitData& g,double& h,double& v
1131 ,double& x0,double& y0,double& sx,double& sy,double& f)
1132// Pour initialiser une gaussienne 1D ou 2D
1133// return code =0 si OK
1134{
1135h=v=x0=y0=sx=sy=f=0.;
1136if(!&g) return(-1);
1137int nvar = g.NVar();
1138int ndata = g.NData();
1139if(nvar<1 || 2<nvar || ndata<=0) return(-2);
1140
1141// X et Y ordonnees croissant
1142double *X=NULL, *Y=NULL;
1143X = new double[ndata];
1144if(nvar==2) Y = new double[ndata];
1145{for(int i=0;i<ndata;i++) {X[i] = g.X(i); if(Y) Y[i] = g.Y(i);}}
1146qsort(X,(size_t) ndata,sizeof(double),qSort_Dble);
1147if(Y) qsort(Y,(size_t) ndata,sizeof(double),qSort_Dble);
1148
1149// determination des zones externes=[0,1/3] et [2/3,1]
1150// et des zones internes=[1/3,2/3]
1151int k1=ndata/3,k2=2*ndata/3;
1152double xmin,xmax, ymin=-1.,ymax=1.;
1153xmin = X[k1]; xmax = X[k2];
1154if(Y) {ymin = Y[k1]; ymax = Y[k2];}
1155
1156// recherche des parametres
1157double nb=0, nc=0;
1158{for(int i=0;i<ndata;i++) {
1159 double val,x,y=0.;
1160 x = g.X(i); if(Y) y = g.Y(i); val = g.Val(i);
1161 if(xmin<x && x<xmax && ymin<y && y<ymax) { // c'est le centre
1162 if(nc==0 || val>h) {h=val; x0=x; y0=y;}
1163 v += val; nc++;
1164 } else {f += val; nb++;} // c'est le bord
1165
1166}}
1167if(nb==0 || nc==0) {delete [] X; if(Y) delete [] Y; return(-3);}
1168
1169// Calcul des parametres
1170f /= (double) nb; h -= f; v -= f*nc;
1171sx = (xmax-xmin)/2.; if(Y) sy = (ymax-ymin)/2.;
1172
1173delete [] X; if(Y) delete [] Y;
1174return(0);
1175}
1176
1177
1178////////////////////////////////////////////////////////////////////
1179////---------- Classe de fenetre de fit interactive ------------////
1180////////////////////////////////////////////////////////////////////
1181
1182/* --Methode-- */
1183PIAFitterWind::PIAFitterWind(PIStdImgApp* par, PIAFitter* fiter,string func)
1184: PIWindow((PIMsgHandler*)par, "PIAFitter", PIWK_normal, 240, 240, 150, 150)
1185, mDap(par), mFitter(fiter), mFunc(func)
1186, ReFillGData(false), ReDecodeFunc(false)
1187, saveI1(0), saveI2(0), saveJ1(0), saveJ2(0)
1188, saveErrScale(1.),saveErrMin(0.), saveXC(0.), saveYC(0.)
1189{
1190#ifdef SANS_EVOLPLANCK
1191COMPATIBLE_ASSERT(mFitter);
1192#else
1193ASSERT(mFitter);
1194#endif
1195
1196int npar = mFitter->mNPar;
1197
1198// Alloc de la taille
1199nlab = 15+npar; lab = new PILabel*[nlab]; {for(int i=0;i<nlab;i++) lab[i]=NULL;}
1200ntxt = 15+4*npar; txt = new PIText*[ntxt]; {for(int i=0;i<ntxt;i++) txt[i]=NULL;}
1201nbut = 6; but = new PIButton*[nbut]; {for(int i=0;i<nbut;i++) but[i]=NULL;}
1202nckb = 2+npar; ckb = new PICheckBox*[nckb]; {for(int i=0;i<nckb;i++) ckb[i]=NULL;}
1203npom = 3; pom = new PIOptMenu*[npom]; {for(int i=0;i<npom;i++) pom[i]=NULL;}
1204
1205// On definit la taille a partir de la taille par defaut des composantes
1206// bsx,bsy = environ 6 lettres
1207int bsx,bsy;
1208par->PrefCompSize(bsx, bsy);
1209int spx = (bsx>=10) ? bsx/10 : 1; // intervalle entre lettres X
1210int spy = (bsy>=6) ? bsy/6 : 1; // intervalle entre lettres Y
1211
1212int wszx = (5*bsx+5*spx)+spx;
1213int wszy = 8*(bsy+spy)+npar*(bsy+spy)+2*spy;
1214SetSize(wszx, wszy);
1215int cpx,cpy;
1216
1217// new ligne
1218cpx = spx; cpy = spy;
1219string dum = "Object: "+mFitter->mNObj+" , Fun: ";
1220if(mFitter->mFunc) dum+=mFitter->mNameFitFunc; else dum+=mFitter->mFName;
1221lab[0] = new PILabel(this,dum.c_str(),4*bsx,bsy,cpx,cpy);
1222lab[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1223
1224// new ligne
1225cpx = spx; cpy += bsy+spy;
1226but[0] = new PIButton(this,"Fr.Last",111,bsx,bsy,cpx,cpy);
1227but[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1228cpx += bsx+spx;
1229but[1] = new PIButton(this,"Default",222,bsx,bsy,cpx,cpy);
1230but[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1231cpx += bsx+spx;
1232ckb[0] = new PICheckBox(this,"Gen Fun",1001,bsx,bsy,cpx,cpy);
1233ckb[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1234cpx += bsx+2*spx;
1235ckb[1] = new PICheckBox(this,"Res",1002,bsx,bsy,cpx,cpy);
1236ckb[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1237
1238// new ligne
1239cpx = spx; cpy += bsy+spy;
1240pom[0] = new PIOptMenu(this,"Err def",1.25*bsx,bsy,cpx,cpy);
1241 pom[0]->AppendItem("Err def",2101);
1242 pom[0]->AppendItem("Err cste",2102);
1243 pom[0]->AppendItem("Err sqrt",2103);
1244 pom[0]->AppendItem("Err prop",2104);
1245 pom[0]->SetValue(2101);
1246pom[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1247cpx += int(1.25*bsx+spx);
1248lab[1] = new PILabel(this,"E_Scale",bsx, bsy, cpx, cpy);
1249lab[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1250cpx += bsx+spx;
1251txt[0] = new PIText(this,"",bsx,bsy,cpx,cpy);
1252txt[0]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1253cpx += bsx+spx;
1254lab[2] = new PILabel(this,"E_Min",0.75*bsx,bsy,cpx,cpy);
1255lab[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1256cpx += int(0.75*bsx+spx);
1257txt[1] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1258txt[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1259
1260// new ligne
1261cpx = spx; cpy += bsy+spy;
1262lab[3] = new PILabel(this,"Prt,dbg",bsx,bsy,cpx,cpy);
1263lab[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1264cpx += bsx+spx;
1265txt[2] = new PIText(this,"",0.5*bsx,bsy,cpx,cpy);
1266txt[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1267cpx += int(0.5*bsx+spx);
1268lab[4] = new PILabel(this,"Stop X2",bsx,bsy,cpx,cpy);
1269lab[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1270cpx += bsx+spx;
1271txt[3] = new PIText(this,"",bsx,bsy,cpx,cpy);
1272txt[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1273cpx += bsx+spx;
1274lab[5] = new PILabel(this,"Iter",0.5*bsx, bsy, cpx, cpy);
1275lab[5]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1276cpx += int(0.5*bsx+spx);
1277txt[4] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1278txt[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1279
1280// new ligne
1281cpx = spx; cpy += bsy+spy;
1282lab[6] = new PILabel(this,"Range X",bsx,bsy,cpx,cpy);
1283lab[6]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1284cpx += bsx+spx;
1285txt[5] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1286txt[5]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1287cpx += int(0.75*bsx+spx);
1288txt[6] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1289txt[6]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1290cpx += int(0.75*bsx+spx);
1291lab[7] = new PILabel(this,"Y",bsx/2,bsy,cpx,cpy);
1292lab[7]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1293cpx += int(bsx/2.+spx);
1294txt[7] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1295txt[7]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1296cpx += int(0.75*bsx+spx);
1297txt[8] = new PIText(this,"",0.75*bsx,bsy,cpx,cpy);
1298txt[8]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1299
1300// new ligne
1301cpx = spx; cpy += bsy+spy;
1302lab[8] = new PILabel(this,"Cent",bsx/2,bsy,cpx,cpy);
1303lab[8]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1304cpx += int(bsx/2.+spx);
1305pom[1] = new PIOptMenu(this,"X.No",1.25*bsx,bsy,cpx,cpy);
1306 pom[1]->AppendItem("X.No",2001);
1307 pom[1]->AppendItem("X.Value",2002);
1308 pom[1]->AppendItem("X.Auto",2003);
1309 pom[1]->SetValue(2001);
1310pom[1]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1311cpx += int(1.25*bsx+spx);
1312txt[9] = new PIText(this,"",bsx,bsy,cpx,cpy);
1313txt[9]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1314cpx += bsx+spx;
1315pom[2] = new PIOptMenu(this,"Y.No",1.25*bsx,bsy,cpx,cpy);
1316 pom[2]->AppendItem("Y.No",2011);
1317 pom[2]->AppendItem("Y.Value",2012);
1318 pom[2]->AppendItem("Y.Auto",2013);
1319 pom[2]->SetValue(2011);
1320pom[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1321cpx += int(1.25*bsx+spx);
1322txt[10] = new PIText(this,"",bsx,bsy,cpx,cpy);
1323txt[10]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1324
1325// new ligne
1326cpx = spx; cpy += bsy+spy;
1327but[2] = new PIButton(this, "Dismiss",777,bsx,bsy,cpx,cpy);
1328but[2]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1329cpx += bsx+spx;
1330but[3] = new PIButton(this, "Check",666,bsx,bsy,cpx,cpy);
1331but[3]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1332cpx += bsx+spx;
1333but[4] = new PIButton(this, "Fit",333,bsx,bsy,cpx,cpy);
1334but[4]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1335cpx += bsx+spx;
1336but[5] = new PIButton(this, "Ini Auto",444,bsx,bsy,cpx,cpy);
1337but[5]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1338
1339// new ligne
1340cpx = spx; cpy += bsy+spy;
1341lab[9] = new PILabel(this,"Par",bsx/2,bsy,cpx,cpy);
1342lab[9]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1343cpx += int(bsx/2.+spx);
1344lab[10] = new PILabel(this,"Fx",bsx/3,bsy,cpx,cpy);
1345lab[10]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1346cpx += int(bsx/3.+spx);
1347lab[11] = new PILabel(this,"Init",bsx,bsy,cpx,cpy);
1348lab[11]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1349cpx += bsx+spx;
1350lab[12] = new PILabel(this,"Step",bsx,bsy,cpx,cpy);
1351lab[12]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1352cpx += bsx+spx;
1353lab[13] = new PILabel(this,"Min",bsx,bsy,cpx,cpy);
1354lab[13]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1355cpx += bsx+spx;
1356lab[14] = new PILabel(this,"Max",bsx,bsy,cpx,cpy);
1357lab[14]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1358
1359// new lines: Parametres (npar lignes)
1360if(npar>0) {
1361 for(int i=0;i<npar;i++) {
1362 cpx = spx; cpy += bsy+spy;
1363 char str[8]; sprintf(str,"P%d",i);
1364 lab[15+i] = new PILabel(this,str,bsx/2,bsy,cpx,cpy);
1365 lab[15+i]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1366 cpx += int(bsx/2.+spx);
1367 // Attention pas de message entre 1500 et 2000 (permet 500 parametres!)
1368 ckb[2+i] = new PICheckBox(this,"",1500+i,bsx/3,bsy,cpx,cpy+spy);
1369 ckb[2+i]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1370 cpx+=int(bsx/3.+spx);
1371 for(int j=0;j<4;j++) {
1372 txt[15+4*i+j] = new PIText(this,"",bsx,bsy,cpx,cpy);
1373 txt[15+4*i+j]->SetBinding(PIBK_elastic,PIBK_elastic, PIBK_elastic,PIBK_elastic);
1374 cpx += bsx+spx;
1375 }
1376 }
1377}
1378
1379return;
1380}
1381
1382/* --Methode-- */
1383PIAFitterWind::~PIAFitterWind()
1384{
1385int i;
1386for(i=0;i<nlab;i++) if(lab[i]) {delete lab[i]; lab[i]=NULL;}
1387for(i=0;i<ntxt;i++) if(txt[i]) {delete txt[i]; txt[i]=NULL;}
1388for(i=0;i<nbut;i++) if(but[i]) {delete but[i]; but[i]=NULL;}
1389for(i=0;i<nckb;i++) if(ckb[i]) {delete ckb[i]; ckb[i]=NULL;}
1390for(i=0;i<npom;i++) if(pom[i]) {delete pom[i]; pom[i]=NULL;}
1391if(lab) {delete lab; lab=NULL; nlab=0;}
1392if(txt) {delete txt; txt=NULL; ntxt=0;}
1393if(but) {delete but; but=NULL; nbut=0;}
1394if(ckb) {delete ckb; ckb=NULL; nckb=0;}
1395if(pom) {delete pom; pom=NULL; npom=0;}
1396}
1397
1398/* --Methode-- */
1399void PIAFitterWind::Show()
1400{
1401//mDap->SetBlocked();
1402SetState();
1403PIWindow::Show();
1404return;
1405}
1406
1407/* --Methode-- */
1408void PIAFitterWind::SetState(void)
1409// Ecriture et positionnement des ckb et txt
1410{
1411int npar = mFitter->mNPar;
1412
1413// Les menus d'options
1414if(mFitter->mOpt.err_type==GeneralFitData::DefaultError) pom[0]->SetValue(2101);
1415if(mFitter->mOpt.err_type==GeneralFitData::ConstantError) pom[0]->SetValue(2102);
1416if(mFitter->mOpt.err_type==GeneralFitData::SqrtError) pom[0]->SetValue(2103);
1417if(mFitter->mOpt.err_type==GeneralFitData::ProporError) pom[0]->SetValue(2104);
1418
1419// Les check-boxes
1420ckb[0]->SetState(mFitter->mOpt.okfun);
1421ckb[1]->SetState(mFitter->mOpt.okres);
1422if(npar>0)
1423 for(int i=0;i<npar;i++) ckb[2+i]->SetState((mFitter->mFix(i)>=1.)?true:false);
1424
1425// Les champs textes
1426char str[128]; string dum;
1427sprintf(str,"%g",mFitter->mOpt.err_scale); dum=str; txt[0]->SetText(dum);
1428sprintf(str,"%g",mFitter->mOpt.err_min); dum=str; txt[1]->SetText(dum);
1429sprintf(str,"%d,%d",mFitter->mOpt.lp,mFitter->mOpt.lpg); dum=str; txt[2]->SetText(dum);
1430sprintf(str,"%g",mFitter->mOpt.stc2); dum=str; txt[3]->SetText(dum);
1431sprintf(str,"%d",mFitter->mOpt.nstep); dum=str; txt[4]->SetText(dum);
1432sprintf(str,"%d",mFitter->mOpt.i1); dum=str; txt[5]->SetText(dum);
1433sprintf(str,"%d",mFitter->mOpt.i2); dum=str; txt[6]->SetText(dum);
1434sprintf(str,"%d",mFitter->mOpt.j1); dum=str; txt[7]->SetText(dum);
1435sprintf(str,"%d",mFitter->mOpt.j2); dum=str; txt[8]->SetText(dum);
1436sprintf(str,"%g",mFitter->mOpt.xc); dum=str; txt[9]->SetText(dum);
1437sprintf(str,"%g",mFitter->mOpt.yc); dum=str; txt[10]->SetText(dum);
1438if(npar>0) {
1439 for(int i=0;i<npar;i++) {
1440 sprintf(str,"%g",mFitter->mPar(i)); dum=str; txt[15+4*i+0]->SetText(dum);
1441 sprintf(str,"%g",mFitter->mStep(i)); dum=str; txt[15+4*i+1]->SetText(dum);
1442 sprintf(str,"%g",mFitter->mMin(i)); dum=str; txt[15+4*i+2]->SetText(dum);
1443 sprintf(str,"%g",mFitter->mMax(i)); dum=str; txt[15+4*i+3]->SetText(dum);
1444 }
1445}
1446
1447return;
1448}
1449
1450/* --Methode-- */
1451void PIAFitterWind::Process(PIMessage msg, PIMsgHandler* sender, void* data)
1452{
1453int lp = (mFitter->mOpt.lp>2)?1:0;
1454int npar = mFitter->mNPar;
1455
1456// Decodage des messages, init et dismiss
1457msg = UserMsg(msg);
1458if(msg ==777) {
1459 if(lp) cout<<"Dismiss"<<endl;
1460 //mDap->SetReady();
1461 Hide();
1462 return;
1463}
1464
1465// L'objet existe t-il encore?
1466NamedObjMgr omg;
1467if(omg.GetObj(mFitter->mNObj) == NULL) {
1468 cout<<"PIAFitterWind::Process Error , Pas d'objet de nom "
1469 <<mFitter->mNObj<<endl;
1470 return;
1471}
1472
1473// On recupere les champs textes
1474string dum; char str[128];
1475// Attention gestion du type d'erreur (scale et min)
1476dum=txt[0]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1477 sscanf(str,"%lf",&(mFitter->mOpt.err_scale));
1478 if(saveErrScale!=mFitter->mOpt.err_scale) {
1479 if(lp) cout<<"ErrScale changed: "<<mFitter->mOpt.err_scale<<endl;
1480 ReFillGData = true;
1481 saveErrScale = mFitter->mOpt.err_scale;
1482 }
1483dum=txt[1]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1484 sscanf(str,"%lf",&(mFitter->mOpt.err_min));
1485 if(saveErrMin!=mFitter->mOpt.err_min) {
1486 if(lp) cout<<"ErrMin changed: "<<mFitter->mOpt.err_min<<endl;
1487 ReFillGData = true;
1488 saveErrMin = mFitter->mOpt.err_min;
1489 }
1490dum=txt[2]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1491 sscanf(str,"%d,%d",&(mFitter->mOpt.lp),&(mFitter->mOpt.lpg));
1492dum=txt[3]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1493 sscanf(str,"%lf",&(mFitter->mOpt.stc2));
1494dum=txt[4]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1495 sscanf(str,"%d",&(mFitter->mOpt.nstep));
1496// Attention si les valeurs de mOpt.i1/.i2/.j1/.j2 ont ete changees
1497dum=txt[5]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1498 sscanf(str,"%d",&(mFitter->mOpt.i1));
1499dum=txt[6]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1500 sscanf(str,"%d",&(mFitter->mOpt.i2));
1501dum=txt[7]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1502 sscanf(str,"%d",&(mFitter->mOpt.j1));
1503dum=txt[8]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1504 sscanf(str,"%d",&(mFitter->mOpt.j2));
1505 if(saveI1!=mFitter->mOpt.i1 || saveI2!=mFitter->mOpt.i2 ||
1506 saveJ1!=mFitter->mOpt.j1 || saveJ2!=mFitter->mOpt.j2 ) {
1507 if(lp)
1508 cout<<"Range changed: I("<<saveI1<<","<<saveI2
1509 <<") -> I("<<mFitter->mOpt.i1<<","<<mFitter->mOpt.i2
1510 <<") ou J("<<saveJ1<<","<<saveJ2
1511 <<") -> J("<<mFitter->mOpt.j1<<","<<mFitter->mOpt.j2
1512 <<")"<<endl;
1513 ReFillGData = true;
1514 saveI1=mFitter->mOpt.i1; saveI2=mFitter->mOpt.i2;
1515 saveJ1=mFitter->mOpt.j1; saveJ2=mFitter->mOpt.j2;
1516 }
1517dum=txt[9]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1518 sscanf(str,"%lf",&(mFitter->mOpt.xc));
1519dum=txt[10]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1520 sscanf(str,"%lf",&(mFitter->mOpt.yc));
1521 if(saveXC!=mFitter->mOpt.xc || saveYC!=mFitter->mOpt.yc) {
1522 if(lp) cout<<"mOpt.xc,yc changed: "<<mFitter->mOpt.xc
1523 <<" , "<<mFitter->mOpt.xc<<endl;
1524 ReDecodeFunc = true;
1525 saveXC = mFitter->mOpt.xc; saveYC = mFitter->mOpt.yc;
1526 }
1527
1528if(npar>0) {
1529 for(int i=0;i<npar;i++) {
1530 dum=txt[15+4*i+0]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1531 sscanf(str,"%lf",&(mFitter->mPar(i)));
1532 dum=txt[15+4*i+1]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1533 sscanf(str,"%lf",&(mFitter->mStep(i)));
1534 dum=txt[15+4*i+2]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1535 sscanf(str,"%lf",&(mFitter->mMin(i)));
1536 dum=txt[15+4*i+3]->GetText(); strcpy(str,dum.c_str()); strip(str,'B',' ');
1537 sscanf(str,"%lf",&(mFitter->mMax(i)));
1538 }
1539}
1540
1541// Decodage des messages, suite
1542if(msg ==666) {
1543 if(lp) cout<<"Check"<<endl;
1544 mFitter->CheckOptions();
1545 if(ReFillGData) mFitter->FillGData();
1546 ReFillGData = false;
1547 if(ReDecodeFunc) mFitter->DecodeFunction(mFunc);
1548 ReDecodeFunc = false;
1549}
1550else if(msg ==111) {
1551 if(lp) cout<<"Update from last"<<endl;
1552 mFitter->mOpt = mFitter->mOptSave;
1553 mFitter->ReSetParam();
1554 mFitter->InitParFromLastFit();
1555 ReFillGData = ReDecodeFunc = true;
1556}
1557else if(msg ==222) {
1558 if(lp) cout<<"Default options/par"<<endl;
1559 mFitter->ResetOptions();
1560 mFitter->ReSetParam();
1561 ReFillGData = ReDecodeFunc = true;
1562}
1563else if(msg ==333) {
1564 if(lp) cout<<"Do the fit"<<endl;
1565 mFitter->CheckOptions();
1566 if(ReFillGData) mFitter->FillGData();
1567 ReFillGData = false;
1568 if(ReDecodeFunc) mFitter->DecodeFunction(mFunc);
1569 ReDecodeFunc = false;
1570 int rc = mFitter->DoFit();
1571 if(rc>=0) mFitter->FitFunRes();
1572}
1573else if(msg ==444) {
1574 if(lp) cout<<"Automatic initialisation"<<endl;
1575 mFitter->AutoIniFit();
1576}
1577else if(msg==1001) {
1578 if(ckb[0]->GetState()) {
1579 if(lp) cout<<"Gen fitted function"<<endl;
1580 mFitter->mOpt.okfun = true;
1581 } else if(!ckb[0]->GetState()) {
1582 if(lp) cout<<"No Gen fitted function"<<endl;
1583 mFitter->mOpt.okfun = false;
1584 }
1585}
1586else if(msg==1002) {
1587 if(ckb[1]->GetState()) {
1588 if(lp) cout<<"Gen fitted residus"<<endl;
1589 mFitter->mOpt.okres = true;
1590 } else if(!ckb[1]->GetState()) {
1591 if(lp) cout<<"No Gen fitted residus"<<endl;
1592 mFitter->mOpt.okres = false;
1593 }
1594}
1595else if(2101<=msg && msg<=2104) {
1596 if(msg==2101)
1597 {mFitter->mOpt.err_type = GeneralFitData::DefaultError; dum="DefaultError";}
1598 if(msg==2102)
1599 {mFitter->mOpt.err_type = GeneralFitData::ConstantError; dum="ConstantError";}
1600 if(msg==2103)
1601 {mFitter->mOpt.err_type = GeneralFitData::SqrtError; dum="SqrtError";}
1602 if(msg==2104)
1603 {mFitter->mOpt.err_type = GeneralFitData::ProporError; dum="ProporError";}
1604 if(lp) cout<<"Err_type="<<dum
1605 <<" Err_scale="<<mFitter->mOpt.err_scale
1606 <<" Err_min="<<mFitter->mOpt.err_min<<endl;
1607 ReFillGData = true;
1608}
1609else if(2001<=msg && msg<=2003) {
1610 mFitter->mOpt.polcx = msg-2001;
1611 if(lp) cout<<"Centrage X polcx="<<mFitter->mOpt.polcx
1612 <<" xc="<<mFitter->mOpt.xc<<endl;
1613 mFitter->GetCentering();
1614 ReDecodeFunc = true;
1615}
1616else if(2011<=msg && msg<=2013) {
1617 mFitter->mOpt.polcy = msg-2011;
1618 if(lp) cout<<"Centrage Y polcy="<<mFitter->mOpt.polcy
1619 <<" yc="<<mFitter->mOpt.yc<<endl;
1620 mFitter->GetCentering();
1621 ReDecodeFunc = true;
1622}
1623else if(msg>=1500 && msg<2000) {
1624 int ip = msg-1500;
1625 if(ckb[2+ip]->GetState()) {
1626 if(lp) cout<<"Fix Param "<<ip<<endl;
1627 mFitter->mFix(ip) = 1.001;
1628 } else if(!ckb[2+ip]->GetState()) {
1629 if(lp) cout<<"Not Fix Param "<<ip<<endl;
1630 mFitter->mFix(ip) = 0.;
1631 }
1632}
1633
1634mFitter->CheckOptions();
1635SetState();
1636if(mFitter->mOpt.lp>1) mFitter->PrintOptions();
1637
1638return;
1639}
Note: See TracBrowser for help on using the repository browser.