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

Last change on this file since 390 was 390, checked in by ercodmgr, 26 years ago

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