Context Navigation

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

Visit:

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: