GSI Object Oriented Online Offline (Go4)  GO4-6.2.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4FitParsList.cxx
Go to the documentation of this file.
1 // $Id: TGo4FitParsList.cxx 2749 2020-04-16 10:05:15Z linev $
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  TGo4FitNamed(), fxPars(), fbCanRollbackPars(kFALSE)
27 {
28 
29 }
30 
31 TGo4FitParsList::TGo4FitParsList(Bool_t IsParsOwned) :
32  TGo4FitNamed(), fxPars(), fbCanRollbackPars(kFALSE)
33 {
34  fxPars.SetOwner(IsParsOwned);
35 }
36 
37 TGo4FitParsList::TGo4FitParsList(const char* Name, const char* Title, Bool_t IsParsOwned) :
38  TGo4FitNamed(Name,Title), fxPars(), fbCanRollbackPars(kFALSE)
39 {
40  fxPars.SetOwner(IsParsOwned);
41 }
42 
44 {
45 }
46 
48 {
49  for(Int_t i=0;i<NumPars();i++)
50  if(GetPar(i)==par) return i;
51  return -1;
52 }
53 
54 Double_t TGo4FitParsList::GetParValue(const char* ParName)
55 {
56  TGo4FitParameter* par = Find(ParName);
57  if(par) return par->GetValue();
58  else return 0.;
59 }
60 
61 Bool_t TGo4FitParsList::SetParValue(const char* ParName, Double_t iValue)
62 {
63  TGo4FitParameter* par = Find(ParName);
64  if(par) { par->SetValue(iValue); return kTRUE; }
65  else return kFALSE;
66 }
67 
68 void TGo4FitParsList::GetParsValues(Double_t* pars)
69 {
70  for(Int_t i=0;i<NumPars();i++)
71  pars[i] = Get(i)->GetValue();
72 }
73 
74 void TGo4FitParsList::SetParsValues(Double_t* pars)
75 {
76  if (pars)
77  for(Int_t i=0;i<NumPars();i++)
78  Get(i)->SetValue(pars[i]);
79 }
80 
81 Double_t TGo4FitParsList::GetParError(const char* ParName)
82 {
83  TGo4FitParameter* par = Find(ParName);
84  if(par) return par->GetError();
85  else return 0.;
86 }
87 
88 Bool_t TGo4FitParsList::SetParError(const char* ParName, Double_t iError)
89 {
90  TGo4FitParameter* par = Find(ParName);
91  if(par) { par->SetError(iError); return kTRUE; }
92  else return kFALSE;
93 }
94 
95 Bool_t TGo4FitParsList::SetParFixed(const char* ParName, Bool_t iFixed)
96 {
97  TGo4FitParameter* par = Find(ParName);
98  if(par) { par->SetFixed(iFixed); return kTRUE; }
99  else return kFALSE;
100 }
101 
102 Bool_t TGo4FitParsList::GetParFixed(const char* ParName)
103 {
104  TGo4FitParameter* par = Find(ParName);
105  if(par) return par->GetFixed();
106  else return kFALSE;
107 }
108 
110 {
111  Int_t res = 0;
112  for (Int_t n=0; n<NumPars(); n++)
113  if (Get(n)->GetFixed()) res++;
114  return res;
115 }
116 
118 {
119  return NumPars()-NumFixedPars();
120 }
121 
122 
123 Bool_t TGo4FitParsList::SetParRange(const char* ParName, Double_t RangeMin, Double_t RangeMax)
124 {
125  TGo4FitParameter* par = Find(ParName);
126  if(par) { par->SetRange(RangeMin,RangeMax); return kTRUE; }
127  else return kFALSE;
128 }
129 
130 Bool_t TGo4FitParsList::GetParRange(const char* ParName, Double_t& RangeMin, Double_t& RangeMax)
131 {
132  TGo4FitParameter* par = Find(ParName);
133  if(par) return par->GetRange(RangeMin,RangeMax);
134  else return kFALSE;
135 }
136 
137 Bool_t TGo4FitParsList::SetParEpsilon(const char* ParName, Double_t Epsilon)
138 {
139  TGo4FitParameter* par = Find(ParName);
140  if(par) { par->SetEpsilon(Epsilon); return kTRUE; }
141  else return kFALSE;
142 }
143 
144 Bool_t TGo4FitParsList::GetParEpsilon(const char* ParName, Double_t& Epsilon)
145 {
146  TGo4FitParameter* par = Find(ParName);
147  if(par) return par->GetEpsilon(Epsilon);
148  else return kFALSE;
149 }
150 
151 void TGo4FitParsList::SetParName(Int_t n, const char* name)
152 {
153  if(Get(n)) Get(n)->SetName(name);
154 }
155 
156 const char* TGo4FitParsList::GetParName(Int_t n)
157 {
158  if(Get(n)) return Get(n)->GetName();
159  else return 0;
160 }
161 
163 {
164  if(Get(n)) return Get(n)->GetFullName();
165  else return 0;
166 }
167 
168 void TGo4FitParsList::SetParsNames(const char* name0, const char* name1, const char* name2, const char* name3, const char* name4,
169  const char* name5, const char* name6, const char* name7, const char* name8, const char* name9) {
170  SetParName(0,name0);
171  SetParName(1,name1);
172  SetParName(2,name2);
173  SetParName(3,name3);
174  SetParName(4,name4);
175  SetParName(5,name5);
176  SetParName(6,name6);
177  SetParName(7,name7);
178  SetParName(8,name8);
179  SetParName(9,name9);
180 }
181 
182 void TGo4FitParsList::SetParsValues(Double_t par0, Double_t par1, Double_t par2, Double_t par3, Double_t par4,
183  Double_t par5, Double_t par6, Double_t par7, Double_t par8, Double_t par9) {
184  if(Get(0)) Get(0)->SetValue(par0);
185  if(Get(1)) Get(1)->SetValue(par1);
186  if(Get(2)) Get(2)->SetValue(par2);
187  if(Get(3)) Get(3)->SetValue(par3);
188  if(Get(4)) Get(4)->SetValue(par4);
189  if(Get(5)) Get(5)->SetValue(par5);
190  if(Get(6)) Get(6)->SetValue(par6);
191  if(Get(7)) Get(7)->SetValue(par7);
192  if(Get(8)) Get(8)->SetValue(par8);
193  if(Get(9)) Get(9)->SetValue(par9);
194 }
195 
197 {
198  for(Int_t i=0;i<NumPars();i++)
199  Get(i)->MemorizeValue();
200  fbCanRollbackPars = kTRUE;
201 }
202 
204 {
205  for(Int_t i=0;i<NumPars();i++)
206  Get(i)->RememberValue();
207 }
208 
210 {
211  for(Int_t i=0;i<NumPars();i++)
212  if (!Get(i)->GetFixed()) return kFALSE;
213  return kTRUE;
214 }
215 
216 void TGo4FitParsList::Print(Option_t* option) const
217 {
218  TGo4FitParsList* lst = (TGo4FitParsList*) this;
219  if ((lst->NumPars()>0) && fxPars.IsOwner()) {
220  std::cout << " List of parameters:" << std::endl;
221  for(Int_t n=0;n<lst->NumPars();n++)
222  lst->GetPar(n)->Print(option);
223  }
224 }
225 
227 {
228  std::cout << std::endl << "*** LIST OF PARAMETERS VALUE ***" << std::endl;
229 
230  TGo4FitParsList* l = (TGo4FitParsList*) this;
231 
232  int maxparlen = 14;
233  for(Int_t np=0;np<l->NumPars();np++) {
234  int len = strlen(l->GetParFullName(np));
235  if (len>maxparlen) maxparlen = len;
236  }
237 
238  TString tt = TString::Format("%s%ds %s%s %s%s","%",maxparlen,"%",gStyle->GetStatFormat(),"%",gStyle->GetStatFormat());
239 
240  for(Int_t n=0;n<l->NumPars();n++)
241  std::cout << Form(tt.Data(), l->GetParFullName(n), l->GetPar(n)->GetValue(), l->GetPar(n)->GetError()) << std::endl;
242 }
243 
245 {
246  for(Int_t i=0;i<NumPars();i++)
247  Get(i)->SetOwner(iOwner);
248 }
249 
250 TGo4FitParameter* TGo4FitParsList::CreatePar(const char* ParName, const char* Title, Double_t iValue)
251 {
252  if (Find(ParName)==0) return AddPar(new TGo4FitParameter(ParName,Title,iValue));
253  else return Find(ParName);
254 }
255 
257 {
258  for(Int_t i=0;i<NumPars();i++)
259  if (strcmp(Get(i)->GetName(),ParName)==0) return Get(i);
260 
261  for(Int_t i=0;i<NumPars();i++)
262  if (strcmp(Get(i)->GetFullName(),ParName)==0) return Get(i);
263 
264  return 0;
265 }
266 
267 TGo4FitParameter* TGo4FitParsList::Find(const char* OwnerFullName, const char* ParName)
268 {
269  for(Int_t i=0;i<NumPars();i++) {
270  TGo4FitParameter* par = Get(i);
271  if (par->GetOwner()==0) continue;
272  if ( (strcmp(par->GetOwnerFullName(),OwnerFullName)==0) &&
273  (strcmp(par->GetName(),ParName)==0) ) return par;
274  }
275  return 0;
276 }
277 
279 {
280  for(Int_t i=0;i<NumPars();i++)
281  if (Get(i)==par) return par;
282  return 0;
283 }
284 
286 {
287  if((indx>=0) && (indx<NumPars())) return RemovePar(Get(indx));
288  else return kFALSE;
289 }
290 
291 Bool_t TGo4FitParsList::RemovePar(const char* name)
292 {
293  return RemovePar(FindPar(name));
294 }
295 
297 {
298  if (fxPars.FindObject(par)) {
299  fbCanRollbackPars = kFALSE;
300  fxPars.Remove(par);
301  if (fxPars.IsOwner()) delete par;
302  return kTRUE;
303  } else return kFALSE;
304 }
305 
307 {
308  for(Int_t i=0;i<NumPars();i++) {
309  TGo4FitParameter* par = Get(i);
310  if (list.GetParIndex(par)<0) list.AddPar(par);
311  }
312 }
313 
315 {
316  for(Int_t i=0;i<NumPars();i++)
317  Get(i)->ClearBlocked();
318 }
319 
321 {
322  fxPars.Clear();
323  fbCanRollbackPars = kFALSE;
324 }
325 
326 
328 {
329  fxPars.AddLast(par);
330  if ((par!=0) && fxPars.IsOwner()) par->SetOwner(this);
331  fbCanRollbackPars = kFALSE;
332  return par;
333 }
334 
336 {
337  if (indx<0) fxPars.AddLast(par);
338  else fxPars.AddAt(par,indx);
339  if ((par!=0) && fxPars.IsOwner()) par->SetOwner(this);
340  fbCanRollbackPars = kFALSE;
341  return par;
342 }
343 
344 void TGo4FitParsList::Streamer(TBuffer& b)
345 {
346  if (b.IsReading()) {
347  TGo4FitParsList::Class()->ReadBuffer(b, this);
348  Bool_t IsOwner;
349  b >> IsOwner;
350  if (IsOwner) {
351  fxPars.Streamer(b);
352  SetParsOwner(this);
353  }
354  } else {
355  TGo4FitParsList::Class()->WriteBuffer(b, this);
356  b << fxPars.IsOwner();
357  if (fxPars.IsOwner())
358  fxPars.Streamer(b);
359  }
360 }
Bool_t SetParValue(const char *ParName, Double_t iValue)
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")
Bool_t GetFixed() const
TGo4FitParameter * InsertPar(TGo4FitParameter *par, Int_t indx)
virtual Bool_t SetParFixed(const char *ParName, Bool_t iFixed=kTRUE)
void SetParName(Int_t n, const char *name)
Double_t GetParError(const char *ParName)
TGo4FitParameter * CreatePar(const char *ParName, const char *Title, Double_t iValue=0)
virtual Bool_t GetParEpsilon(const char *ParName, Double_t &Epsilon)
TGo4FitParameter * GetPar(Int_t n)
virtual void MemorizePars()
Bool_t GetRange(Double_t &min, Double_t &max) const
virtual void Print(Option_t *option) const
int l
Definition: f_mbs_status.c:31
const char * GetFullName()
void SetParsOwner(TGo4FitNamed *iOwner)
void SetOwner(TNamed *iOwner)
Definition: TGo4FitNamed.h:58
TOrdCollection fxPars
virtual Bool_t SetParRange(const char *ParName, Double_t RangeMin, Double_t RangeMax)
virtual Int_t NumPars()
Bool_t SetParError(const char *ParName, Double_t iError)
virtual Bool_t SetParEpsilon(const char *ParName, Double_t Epsilon)
Bool_t RemovePar(const char *name)
const char * GetParFullName(Int_t n)
TGo4FitParameter * FindPar(const char *ParName)
Double_t GetError() const
Bool_t GetEpsilon(Double_t &eps) const
virtual Bool_t GetParRange(const char *ParName, Double_t &RangeMin, Double_t &RangeMax)
TGo4FitParameter * Find(const char *ParName)
virtual void Print(Option_t *option) const
TNamed * GetOwner()
Definition: TGo4FitNamed.h:63
Bool_t RemoveParByIndex(Int_t indx)
Int_t GetParIndex(const TGo4FitParameter *par)
virtual Bool_t GetParFixed(const char *ParName)
void SetValue(Double_t iValue)
Double_t GetValue() const
virtual void RememberPars()
virtual ~TGo4FitParsList()
const char * GetOwnerFullName()
void SetEpsilon(Double_t iEpsilon)
void PrintPars() const
virtual TGo4FitParameter * Get(Int_t n)
void SetFixed(Bool_t iFixed)
void GetParsValues(Double_t *pars)
virtual void CollectParsTo(TGo4FitParsList &list)
TGo4FitParameter * AddPar(TGo4FitParameter *par)
void SetRange(Double_t iRangeMin, Double_t iRangeMax)
Double_t GetParValue(const char *ParName)
const char * GetParName(Int_t n)
void SetError(Double_t iError)
void SetParsValues(Double_t *pars)