GSI Object Oriented Online Offline (Go4) GO4-6.4.0
Loading...
Searching...
No Matches
TGo4FitParsList.cxx
Go to the documentation of this file.
1// $Id$
2//-----------------------------------------------------------------------
3// The GSI Online Offline Object Oriented (Go4) Project
4// Experiment Data Processing at EE department, GSI
5//-----------------------------------------------------------------------
6// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
7// Planckstr. 1, 64291 Darmstadt, Germany
8// Contact: http://go4.gsi.de
9//-----------------------------------------------------------------------
10// This software can be used under the license agreements as stated
11// in Go4License.txt file which is part of the distribution.
12//-----------------------------------------------------------------------
13
14#include "TGo4FitParsList.h"
15
16#include <iostream>
17
18#include "TBuffer.h"
19#include "TClass.h"
20#include "TStyle.h"
21#include "TString.h"
22
23#include "TGo4FitParameter.h"
24
26
28{
29 fxPars.SetOwner(IsParsOwned);
30}
31
32TGo4FitParsList::TGo4FitParsList(const char *Name, const char *Title, Bool_t IsParsOwned)
33 : TGo4FitNamed(Name, Title), fxPars(), fbCanRollbackPars(kFALSE)
34{
35 fxPars.SetOwner(IsParsOwned);
36}
37
39
41{
42 for (Int_t i = 0; i < NumPars(); i++)
43 if (GetPar(i) == par)
44 return i;
45 return -1;
46}
47
48Double_t TGo4FitParsList::GetParValue(const char *ParName)
49{
50 auto par = Find(ParName);
51 return par ? par->GetValue() : 0.;
52}
53
54Bool_t TGo4FitParsList::SetParValue(const char *ParName, Double_t iValue)
55{
56 auto par = Find(ParName);
57 if (par) {
58 par->SetValue(iValue);
59 return kTRUE;
60 }
61 return kFALSE;
62}
63
65{
66 for (Int_t i = 0; i < NumPars(); i++)
67 pars[i] = Get(i)->GetValue();
68}
69
71{
72 if (pars)
73 for (Int_t i = 0; i < NumPars(); i++)
74 Get(i)->SetValue(pars[i]);
75}
76
77Double_t TGo4FitParsList::GetParError(const char *ParName)
78{
79 TGo4FitParameter *par = Find(ParName);
80 return par ? par->GetError() : 0.;
81}
82
83Bool_t TGo4FitParsList::SetParError(const char *ParName, Double_t iError)
84{
85 auto par = Find(ParName);
86 if (par) {
87 par->SetError(iError);
88 return kTRUE;
89 }
90 return kFALSE;
91}
92
93Bool_t TGo4FitParsList::SetParFixed(const char *ParName, Bool_t iFixed)
94{
95 auto par = Find(ParName);
96 if (par) {
97 par->SetFixed(iFixed);
98 return kTRUE;
99 }
100 return kFALSE;
101}
102
103Bool_t TGo4FitParsList::GetParFixed(const char *ParName)
104{
105 auto par = Find(ParName);
106 return par ? par->GetFixed() : kFALSE;
107}
108
110{
111 Int_t res = 0;
112 for (Int_t n = 0; n < NumPars(); n++)
113 if (Get(n)->GetFixed())
114 res++;
115 return res;
116}
117
119{
120 return NumPars() - NumFixedPars();
121}
122
123Bool_t TGo4FitParsList::SetParRange(const char *ParName, Double_t RangeMin, Double_t RangeMax)
124{
125 auto par = Find(ParName);
126 if (par) {
127 par->SetRange(RangeMin, RangeMax);
128 return kTRUE;
129 }
130 return kFALSE;
131}
132
133Bool_t TGo4FitParsList::GetParRange(const char *ParName, Double_t &RangeMin, Double_t &RangeMax)
134{
135 auto par = Find(ParName);
136 return par ? par->GetRange(RangeMin, RangeMax) : kFALSE;
137}
138
139Bool_t TGo4FitParsList::SetParEpsilon(const char *ParName, Double_t Epsilon)
140{
141 TGo4FitParameter *par = Find(ParName);
142 if (par) {
143 par->SetEpsilon(Epsilon);
144 return kTRUE;
145 }
146 return kFALSE;
147}
148
149Bool_t TGo4FitParsList::GetParEpsilon(const char *ParName, Double_t &Epsilon)
150{
151 TGo4FitParameter *par = Find(ParName);
152 return par ? par->GetEpsilon(Epsilon) : kFALSE;
153}
154
155void TGo4FitParsList::SetParName(Int_t n, const char *name)
156{
157 if (Get(n))
158 Get(n)->SetName(name);
159}
160
161const char *TGo4FitParsList::GetParName(Int_t n)
162{
163 if (Get(n))
164 return Get(n)->GetName();
165 return nullptr;
166}
167
169{
170 if (Get(n))
171 return Get(n)->GetFullName();
172 return nullptr;
173}
174
175void TGo4FitParsList::SetParsNames(const char *name0, const char *name1, const char *name2, const char *name3,
176 const char *name4, const char *name5, const char *name6, const char *name7,
177 const char *name8, const char *name9)
178{
179 SetParName(0, name0);
180 SetParName(1, name1);
181 SetParName(2, name2);
182 SetParName(3, name3);
183 SetParName(4, name4);
184 SetParName(5, name5);
185 SetParName(6, name6);
186 SetParName(7, name7);
187 SetParName(8, name8);
188 SetParName(9, name9);
189}
190
191void TGo4FitParsList::SetParsValues(Double_t par0, Double_t par1, Double_t par2, Double_t par3, Double_t par4,
192 Double_t par5, Double_t par6, Double_t par7, Double_t par8, Double_t par9)
193{
194 if (Get(0))
195 Get(0)->SetValue(par0);
196 if (Get(1))
197 Get(1)->SetValue(par1);
198 if (Get(2))
199 Get(2)->SetValue(par2);
200 if (Get(3))
201 Get(3)->SetValue(par3);
202 if (Get(4))
203 Get(4)->SetValue(par4);
204 if (Get(5))
205 Get(5)->SetValue(par5);
206 if (Get(6))
207 Get(6)->SetValue(par6);
208 if (Get(7))
209 Get(7)->SetValue(par7);
210 if (Get(8))
211 Get(8)->SetValue(par8);
212 if (Get(9))
213 Get(9)->SetValue(par9);
214}
215
217{
218 for (Int_t i = 0; i < NumPars(); i++)
219 Get(i)->MemorizeValue();
220 fbCanRollbackPars = kTRUE;
221}
222
224{
225 for (Int_t i = 0; i < NumPars(); i++)
226 Get(i)->RememberValue();
227}
228
230{
231 for (Int_t i = 0; i < NumPars(); i++)
232 if (!Get(i)->GetFixed())
233 return kFALSE;
234 return kTRUE;
235}
236
237void TGo4FitParsList::Print(Option_t *option) const
238{
239 TGo4FitParsList *lst = (TGo4FitParsList *)this;
240 if ((lst->NumPars() > 0) && fxPars.IsOwner()) {
241 std::cout << " List of parameters:" << std::endl;
242 for (Int_t n = 0; n < lst->NumPars(); n++)
243 lst->GetPar(n)->Print(option);
244 }
245}
246
248{
249 std::cout << std::endl << "*** LIST OF PARAMETERS VALUE ***" << std::endl;
250
252
253 int maxparlen = 14;
254 for (Int_t np = 0; np < l->NumPars(); np++) {
255 int len = strlen(l->GetParFullName(np));
256 if (len > maxparlen)
257 maxparlen = len;
258 }
259
260 TString tt =
261 TString::Format("%s%ds %s%s %s%s", "%", maxparlen, "%", gStyle->GetStatFormat(), "%", gStyle->GetStatFormat());
262
263 for (Int_t n = 0; n < l->NumPars(); n++)
264 std::cout << TString::Format(tt.Data(), l->GetParFullName(n), l->GetPar(n)->GetValue(), l->GetPar(n)->GetError())
265 << std::endl;
266}
267
269{
270 for (Int_t i = 0; i < NumPars(); i++)
271 Get(i)->SetOwner(iOwner);
272}
273
274TGo4FitParameter *TGo4FitParsList::CreatePar(const char *ParName, const char *Title, Double_t iValue)
275{
276 auto par = Find(ParName);
277 return par ? par : AddPar(new TGo4FitParameter(ParName, Title, iValue));
278}
279
281{
282 for (Int_t i = 0; i < NumPars(); i++)
283 if (strcmp(Get(i)->GetName(), ParName) == 0)
284 return Get(i);
285
286 for (Int_t i = 0; i < NumPars(); i++)
287 if (strcmp(Get(i)->GetFullName(), ParName) == 0)
288 return Get(i);
289
290 return nullptr;
291}
292
293TGo4FitParameter *TGo4FitParsList::Find(const char *OwnerFullName, const char *ParName)
294{
295 for (Int_t i = 0; i < NumPars(); i++) {
296 TGo4FitParameter *par = Get(i);
297 if (!par->GetOwner())
298 continue;
299 if ((strcmp(par->GetOwnerFullName(), OwnerFullName) == 0) && (strcmp(par->GetName(), ParName) == 0))
300 return par;
301 }
302 return nullptr;
303}
304
306{
307 for (Int_t i = 0; i < NumPars(); i++)
308 if (Get(i) == par)
309 return par;
310 return nullptr;
311}
312
314{
315 if ((indx >= 0) && (indx < NumPars()))
316 return RemovePar(Get(indx));
317 return kFALSE;
318}
319
320Bool_t TGo4FitParsList::RemovePar(const char *name)
321{
322 return RemovePar(FindPar(name));
323}
324
326{
327 if (fxPars.FindObject(par)) {
328 fbCanRollbackPars = kFALSE;
329 fxPars.Remove(par);
330 if (fxPars.IsOwner())
331 delete par;
332 return kTRUE;
333 }
334 return kFALSE;
335}
336
338{
339 for (Int_t i = 0; i < NumPars(); i++) {
340 TGo4FitParameter *par = Get(i);
341 if (list.GetParIndex(par) < 0)
342 list.AddPar(par);
343 }
344}
345
347{
348 for (Int_t i = 0; i < NumPars(); i++)
349 Get(i)->ClearBlocked();
350}
351
353{
354 fxPars.Clear();
355 fbCanRollbackPars = kFALSE;
356}
357
359{
360 fxPars.AddLast(par);
361 if (par && fxPars.IsOwner())
362 par->SetOwner(this);
363 fbCanRollbackPars = kFALSE;
364 return par;
365}
366
368{
369 if (indx < 0)
370 fxPars.AddLast(par);
371 else
372 fxPars.AddAt(par, indx);
373 if (par && fxPars.IsOwner())
374 par->SetOwner(this);
375 fbCanRollbackPars = kFALSE;
376 return par;
377}
378
379void TGo4FitParsList::Streamer(TBuffer &b)
380{
381 if (b.IsReading()) {
382 TGo4FitParsList::Class()->ReadBuffer(b, this);
383 Bool_t IsOwner;
384 b >> IsOwner;
385 if (IsOwner) {
386 fxPars.Streamer(b);
387 SetParsOwner(this);
388 }
389 } else {
390 TGo4FitParsList::Class()->WriteBuffer(b, this);
391 b << fxPars.IsOwner();
392 if (fxPars.IsOwner())
393 fxPars.Streamer(b);
394 }
395}
void SetOwner(TNamed *iOwner)
Sets owner of object.
const char * GetOwnerFullName()
Return full name of owner.
TNamed * GetOwner()
Return owner of object.
TGo4FitNamed()
Default constructor.
const char * GetFullName()
Returns full name of object.
Model and data objects parameter.
void RememberValue()
Restore value, which was previously memorized.
void SetEpsilon(Double_t iEpsilon)
Return epsilon value of parameter.
Bool_t GetEpsilon(Double_t &eps) const
Return value of parameter epsilon.
Double_t GetValue() const
Return parameter value.
Double_t GetError() const
Get value of parameter error.
void Print(Option_t *option="") const override
Print TGo4FitParameter object to standard output.
void SetValue(Double_t iValue)
Set parameter value.
void MemorizeValue()
Memorize value of parameter.
void ClearBlocked()
Release blocking of parameter.
Bool_t IsAllParsFixed()
Returns true, if all parameters in list fixed;.
Bool_t SetParValue(const char *ParName, Double_t iValue)
Set value of parameter with given name.
void SetParsNames(const char *name0="Par0", const char *name1="Par1", const char *name2="Par2", const char *name3="Par3", const char *name4="Par4", const char *name5="Par5", const char *name6="Par6", const char *name7="Par7", const char *name8="Par8", const char *name9="Par9")
Set names of first 10 parameters.
TOrdCollection fxPars
TGo4FitParameter * FindPar(const char *ParName)
Find parameter object with given name.
Double_t GetParValue(const char *ParName)
Return value of parameter with given name.
Bool_t RemoveParByIndex(Int_t indx)
virtual Bool_t SetParRange(const char *ParName, Double_t RangeMin, Double_t RangeMax)
Set range limits for parameter with given name.
virtual Bool_t GetParFixed(const char *ParName)
Return status for parameter with given name, is it fixed or not.
Int_t GetParIndex(const TGo4FitParameter *par)
Return index of given parameter in list.
virtual Bool_t GetParRange(const char *ParName, Double_t &RangeMin, Double_t &RangeMax)
Get range limits for parameter with given name.
TGo4FitParameter * Find(const char *ParName)
void SetParsValues(Double_t *pars)
Set value for all parameters from array.
virtual void CollectParsTo(TGo4FitParsList &list)
Add all parameters to provided TGo4FitParsList object.
void GetParsValues(Double_t *pars)
Copy values of all parameters in list to provided array.
void SetParsOwner(TGo4FitNamed *iOwner)
Bool_t RemovePar(const char *name)
Remove parameter from list with given name.
virtual Bool_t GetParEpsilon(const char *ParName, Double_t &Epsilon)
Get epsilon value for parameter with given name.
const char * GetParFullName(Int_t n)
Return full name of parameter with given index.
Bool_t SetParError(const char *ParName, Double_t iError)
Set error value for parameter with given name.
virtual Bool_t SetParFixed(const char *ParName, Bool_t iFixed=kTRUE)
Set for parameter with given name, is it fixed or not.
Int_t NumFixedPars()
Return number of fixed pars.
Double_t GetParError(const char *ParName)
Get error value for parameter with given name.
virtual TGo4FitParameter * Get(Int_t n)
const char * GetParName(Int_t n)
Return name of parameter with given index.
virtual void MemorizePars()
Memorize values of all parameters.
void Print(Option_t *option="") const override
Default print method.
TGo4FitParsList()
Default constructor.
TGo4FitParameter * GetPar(Int_t n)
Return parameter according given index.
void ClearPars()
Remove all parameters from list.
virtual void RememberPars()
Restore parameters values, which were stored by MemorizePars() routine;.
void PrintPars() const
Print only value and error of all parameters in list.
Int_t NumFreePars()
Return number of free pars.
TGo4FitParameter * CreatePar(const char *ParName, const char *Title, Double_t iValue=0)
Create new TGo4FitParameter object with given name, title and parameter value, and put this object to...
virtual Int_t NumPars()
Return number of parameters in list.
virtual ~TGo4FitParsList()
Destroy TGo4FitParsList object.
virtual Bool_t SetParEpsilon(const char *ParName, Double_t Epsilon)
Set epsilon value for parameter with given name.
void SetParName(Int_t n, const char *name)
Set new name for parameter object with provided index.
TGo4FitParameter * InsertPar(TGo4FitParameter *par, Int_t indx)
TGo4FitParameter * AddPar(TGo4FitParameter *par)
Bool_t fbCanRollbackPars
If true, parameters can be safely rollback.
int l