GSI Object Oriented Online Offline (Go4)  GO4-6.1.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4FitModel.cxx
Go to the documentation of this file.
1 // $Id: TGo4FitModel.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 "TGo4FitModel.h"
15 
16 #include <iostream>
17 
18 #include "TBuffer.h"
19 #include "TArrayD.h"
20 #include "TArrayI.h"
21 #include "TClass.h"
22 
23 #include "TGo4FitData.h"
24 #include "TGo4FitParameter.h"
25 
27  TNamed(), fxRatio(0), fxData(0), fxModelMask(0), fxModelBins(0) {
28 }
29 
30 TGo4FitAssignment::TGo4FitAssignment(const char* DataName) :
31  TNamed(DataName,""),
32  fxRatio(0), fxData(0), fxModelMask(0), fxModelBins(0) {
33 }
34 
36  if (fxRatio) delete fxRatio;
37  if (fxModelMask) delete[] fxModelMask;
38  if (fxModelBins) delete[] fxModelBins;
39 }
40 
42  return (fxRatio==0) ? 1. : fxRatio->GetValue();
43 }
44 
45 void TGo4FitAssignment::Print(Option_t* option) const
46 {
47  std::cout << " " << GetName();
48 }
49 
50 // **************************************************************************************************
51 
53  fiMinIntegrDepth(0), fiMaxIntegrDepth(0), fdIntegrEps(0.), fbAbsoluteEps(kFALSE), fbIntegrScaling(kFALSE),
54  fxAssigments(), fiGroupIndex(-1),
55  fxCurrentPars(), fxCurrentParsArray(0),
56  fbNeedToRebuild(kFALSE), fxAllPars(0), fxAllParsValues(0) {
57 }
58 
59 TGo4FitModel::TGo4FitModel(const char* iName, const char* iTitle, Bool_t MakeAmplitude) :
60  TGo4FitComponent(iName,iTitle),
61  fiMinIntegrDepth(0), fiMaxIntegrDepth(0), fdIntegrEps(0.), fbAbsoluteEps(kFALSE), fbIntegrScaling(kFALSE),
62  fxAssigments(), fiGroupIndex(-1),
63  fxCurrentPars(), fxCurrentParsArray(0),
64  fbNeedToRebuild(kFALSE), fxAllPars(0), fxAllParsValues(0) {
65  fxAssigments.SetOwner(kTRUE);
66  if (MakeAmplitude) NewAmplitude();
67 }
68 
70  RemoveAllPars();
71 }
72 
74  Int_t res = TGo4FitParsList::NumPars();
75  if (NumAssigments()>0) res += NumAssigments()-1;
76  return res;
77 }
78 
80  Int_t numpars = TGo4FitParsList::NumPars();
81  if (n<numpars) return TGo4FitParsList::Get(n);
82  n-=numpars-1;
83  return (n>=0) && (n<NumAssigments()) ? GetAssigment(n)->fxRatio : 0;
84 }
85 
86 void TGo4FitModel::AssignToData(const char* DataName, Double_t RatioValue, Bool_t FixRatio) {
87  if (FindAssigment(DataName)==0) {
88  TGo4FitAssignment* ass = new TGo4FitAssignment(DataName);
89  if (NumAssigments()>0) {
91  "Amplitude ratio to first data",
92  RatioValue);
93  ass->fxRatio->SetOwner(this);
94  if (FixRatio) ass->fxRatio->SetFixed(kTRUE);
95  }
96  fxAssigments.Add(ass);
97  }
98 }
99 
100 void TGo4FitModel::ChangeDataNameInAssignments(const char* oldname, const char* newname) {
101  TGo4FitAssignment* ass = FindAssigment(oldname);
102  if (ass) ass->SetName(newname);
103 }
104 
105 void TGo4FitModel::ClearAssignmentTo(const char* DataName) {
106  TGo4FitAssignment* ass = FindAssigment(DataName);
107  if (ass==0) return;
108 
109  fxAssigments.Remove(ass);
110  delete ass;
111  fxAssigments.Compress();
112 
113  for (Int_t n=0;n<NumAssigments();n++) {
114  ass = GetAssigment(n);
115  if (ass->fxRatio==0) continue;
116  if (n==0) {
117  delete ass->fxRatio;
118  ass->fxRatio = 0;
119  } else
120  ass->fxRatio->SetName(GetRatioName(n+1));
121  }
122 }
123 
125  fxAssigments.Clear();
126  fxAssigments.Compress();
127 }
128 
130  if (data==0) return;
131  TGo4FitAssignment* ass = FindAssigment(data->GetName());
132  if ( ass != 0 ) ass->fxData = data;
133 }
134 
137  if(ass) return ass->fxData;
138  else return 0;
139 }
140 
141 Bool_t TGo4FitModel::GetPosition(Int_t naxis, Double_t& pos) {
142  if(GetPosPar(naxis)) {
143  pos = GetPosPar(naxis)->GetValue();
144  return kTRUE;
145  } else return kFALSE;
146 }
147 
148 Bool_t TGo4FitModel::SetPosition(Int_t naxis, Double_t pos) {
149  if(GetPosPar(naxis)) {
150  GetPosPar(naxis)->SetValue(pos);
151  return kTRUE;
152  } else return kFALSE;
153 }
154 
155 Bool_t TGo4FitModel::GetWidth(Int_t naxis, Double_t& width) {
156  if(GetWidthPar(naxis)) {
157  width = GetWidthPar(naxis)->GetValue();
158  return kTRUE;
159  } else return kFALSE;
160 }
161 
162 Bool_t TGo4FitModel::SetWidth(Int_t naxis, Double_t width) {
163  if(GetWidthPar(naxis)) {
164  GetWidthPar(naxis)->SetValue(width);
165  return kTRUE;
166  } else return kFALSE;
167 }
168 
169 void TGo4FitModel::SetIntegrationsProperty(Int_t iMinIntegrDepth, Int_t iMaxIntegrDepth, Double_t iIntegrEps, Bool_t iAbsoluteEps, Bool_t iIntegrScaling) {
170  fiMinIntegrDepth = iMinIntegrDepth;
171  fiMaxIntegrDepth = iMaxIntegrDepth;
172  fdIntegrEps = iIntegrEps;
173  fbAbsoluteEps = iAbsoluteEps;
174  fbIntegrScaling = iIntegrScaling;
175  if (fdIntegrEps<=0.)
177 }
178 
180  if (fxAllPars) { delete fxAllPars; fxAllPars=0; }
182 }
183 
184 Bool_t TGo4FitModel::Initialize(Int_t UseBuffers) {
185  Bool_t use = ((UseBuffers<0) && GetUseBuffers()) || (UseBuffers>0);
186  for(Int_t n=0;n<NumAssigments();n++) {
188  if (ass->fxData==0) {
189  std::cout << "Data " << ass->GetName() << " not assigned to model " << GetName() << std::endl;
190  continue;
191  }
192 
193  if (use && ass->fxData->BuffersAllocated()) {
194  if (IsAnyRangeLimits()) {
195  ass->fxModelMask = new Char_t[ass->fxData->GetBinsSize()];
196  ass->fxData->ApplyRangesForModelMask(this,ass->fxModelMask);
197  }
198 
199  ass->fxModelBins = new Double_t[ass->fxData->GetBinsSize()];
200  }
201  }
202 
204 
205  if (use) {
206  RemoveAllPars();
207 
208  fxAllPars = new TGo4FitParsList(kFALSE);
210 
211  fxAllParsValues = new TArrayD(fxAllPars->NumPars());
213  }
214 
215  return kTRUE;
216 }
217 
219  RemoveAllPars();
220  fxCurrentPars.Set(0);
221  for(Int_t n=0;n<NumAssigments();n++) {
223  if (ass->fxModelMask) { delete[] ass->fxModelMask; ass->fxModelMask = 0; }
224  if (ass->fxModelBins) { delete[] ass->fxModelBins; ass->fxModelBins = 0; }
225  }
226 }
227 
229  Bool_t res = (NumAssigments()>0);
230  for(Int_t n=0;n<NumAssigments();n++)
231  res = res && (GetAssigment(n)->fxModelBins!=0);
232  return res;
233 }
234 
235 Double_t* TGo4FitModel::GetModelBins(const char* DataName) const {
236  TGo4FitAssignment* ass = FindAssigment(DataName);
237  return ass != 0 ? ass->fxModelBins : 0;
238 }
239 
240 Double_t TGo4FitModel::EvaluateAndIntegrate(Int_t NumScales, const Double_t* Scales, const Double_t* Widths) {
241  if ((NumScales<1) || (Scales==0)) return 0.;
242 
243  if ( (fiMinIntegrDepth>0) && (fiMaxIntegrDepth>0) && (Widths!=0)) {
244  TArrayI IntegrIndexes(NumScales);
245  TArrayD ScaleValues(NumScales, Scales);
246  TArrayD WidthValues(NumScales, Widths);
247  TArrayD dScaleValues(NumScales);
248 
249  Int_t* dindx = IntegrIndexes.GetArray();
250  Double_t* vector = ScaleValues.GetArray();
251  Double_t* width = WidthValues.GetArray();
252  Double_t* dvector = dScaleValues.GetArray();
253 
254  Int_t n=0;
255 
256  // set value and range for current point of model
257  for(n=0;n<NumScales;n++)
258  vector[n] -= 0.5*width[n];
259 
260  // include left bound of interval
261  Double_t TotalSum = EvalN(vector);
262  Int_t TotalNumPnt = 1;
263 
264  Int_t IntegrDepth = 0;
265  Int_t NumStep = 1;
266  Double_t Step = 1.0;
267  Bool_t stopcondition = kFALSE;
268 
269  // cycle over integration depths
270  do {
271 
272  IntegrIndexes.Reset(0);
273  Double_t Sum = 0.;
274  Int_t NumPnt = 0;
275 
276  // run over all integration points
277  do {
278  for(n=0;n<NumScales;n++)
279  dvector[n] = vector[n]+Step*width[n]*(dindx[n]+0.5);
280 
281  Sum+=EvalN(dvector);
282  NumPnt++;
283 
284  n=0;
285  do {
286  dindx[n]++;
287  if (dindx[n]<NumStep) break;
288  dindx[n]=0; n++;
289  } while (n<NumScales);
290  } while (n<NumScales);
291 
292  // check stop condition for integrations depth
293  stopcondition = kFALSE;
294  if (IntegrDepth>=fiMinIntegrDepth) {
295  if (IntegrDepth>=fiMaxIntegrDepth) stopcondition = kTRUE; else {
296  Double_t v1 = TotalSum/TotalNumPnt;
297  Double_t v2 = Sum/NumPnt;
298  Double_t v = TMath::Abs(v1-v2);
299  if (!fbAbsoluteEps) {
300  if ((v1!=0) || (v2!=0)) v=v/(TMath::Abs(v1)+TMath::Abs(v2));
301  else v=0.;
302  }
303  if (v<=fdIntegrEps) stopcondition = kTRUE;
304  }
305  }
306  TotalSum+=Sum;
307  TotalNumPnt+=NumPnt;
308  IntegrDepth++;
309  NumStep*=2;
310  Step = Step/2.;
311  } while (!stopcondition);
312 
313  Double_t value = 0;
314  if (TotalNumPnt>0) value = TotalSum / TotalNumPnt;
315  if (fbIntegrScaling)
316  for(n=0;n<NumScales;n++) value*=width[n];
317  return value;
318  } else return EvalN(Scales);
319 }
320 
321 Double_t TGo4FitModel::EvaluateAtPoint(TGo4FitData* data, Int_t nbin, Bool_t UseRanges) {
322  if (data==0) return 0.;
323  const Double_t* scales = data->GetScaleValues(nbin);
324  Int_t scalessize = data->GetScalesSize();
325  if (UseRanges && !CheckRangeConditions(scales, scalessize)) return 0.;
326  return EvaluateAndIntegrate(scalessize, scales, data->GetWidthValues(nbin));
327 }
328 
329 Double_t TGo4FitModel::EvaluateAtPoint(TGo4FitDataIter* iter, Bool_t UseRanges) {
330  if (iter==0) return 0;
331  const Double_t* scales = iter->Scales();
332  Int_t scalessize = iter->ScalesSize();
333  if (UseRanges && !CheckRangeConditions(scales, scalessize)) return 0.;
334  return EvaluateAndIntegrate(scalessize, scales, iter->Widths());
335 }
336 
337 void TGo4FitModel::RebuildShape(Bool_t ForceBuild) {
338  if ((fxAllPars==0) || (fxAllParsValues==0)) return;
339 
340  Bool_t fill = ForceBuild || fbNeedToRebuild;
341  if (!fill)
342  for(Int_t n=0;n<fxAllPars->NumPars();n++) {
343  if (n==GetAmplIndex()) continue;
344  if ((*fxAllParsValues)[n] != fxAllPars->GetPar(n)->GetValue()) {
345  fill = kTRUE;
346  break;
347  }
348  }
349 
350  if(fill)
351  for(Int_t n=0;n<NumAssigments();n++) {
353 
354  if ((ass->fxData==0) || (ass->fxModelBins==0)) continue;
355 
356  TGo4FitData* data = ass->fxData;
357 
358  if (!BeforeEval(data->GetScalesSize())) continue;
359 
360  Int_t size = data->GetBinsSize();
361  Double_t* bins = ass->fxModelBins;
362  Char_t* mask = ass->fxModelMask;
363  Double_t ratio = ass->RatioValue();
364 
365  for(Int_t nbin=0;nbin<size;nbin++) {
366  if ((mask!=0) && (mask[nbin]==0)) continue;
367  bins[nbin] = ratio * EvaluateAtPoint(data, nbin, kFALSE);
368  }
369 
370  AfterEval();
371  }
372 
373 
374  for(Int_t n=0;n<fxAllPars->NumPars();n++)
375  (*fxAllParsValues)[n] = fxAllPars->GetPar(n)->GetValue();
376 
377  fbNeedToRebuild = kFALSE;
378 }
379 
381  if ((data==0) || (!data->BuffersAllocated())) return kFALSE;
382 
383  Double_t* result = data->GetBinsResult();
384  if (result==0) return kFALSE;
385  Int_t size = data->GetBinsSize();
386 
387  Double_t* modelbins = GetModelBins(data->GetName());
388  if (modelbins) {
389  Double_t ampl = GetAmplValue();
390  for (Int_t nbin=0;nbin<size;nbin++)
391  result[nbin] += ampl * modelbins[nbin];
392  return kTRUE;
393  }
394 
395  if (!BeforeEval(data->GetScalesSize())) return kFALSE;
396 
397  Double_t ampl = GetAmplValue() * GetRatioValueFor(data->GetName());
398 
399  for(Int_t nbin=0;nbin<size;nbin++)
400  result[nbin] += ampl * EvaluateAtPoint(data, nbin);
401 
402  AfterEval();
403 
404  return kTRUE;
405 }
406 
407 Bool_t TGo4FitModel::BeforeEval(Int_t ndim) {
408  fxCurrentPars.Set(NumPars());
409  GetParsValues(fxCurrentPars.GetArray());
410  fxCurrentParsArray = fxCurrentPars.GetArray();
411  if (GetAmplPar()!=0) fxCurrentParsArray++;
412  return kTRUE;
413 }
414 
415 Double_t TGo4FitModel::EvalN(const Double_t* v) {
416  return UserFunction((Double_t*)v, fxCurrentParsArray);
417 }
418 
419 Double_t TGo4FitModel::Evaluate(Double_t x) {
420  Double_t zn = 0.;
421  if (BeforeEval(1)) {
422  zn = GetAmplValue() * EvalN(&x);
423  AfterEval();
424  }
425  return zn;
426 }
427 
428 Double_t TGo4FitModel::Evaluate(Double_t x, Double_t y) {
429  Double_t zn = 0.;
430  if (BeforeEval(2)) {
431  Double_t vector[2] = {x,y};
432  zn = GetAmplValue() * EvalN(vector);
433  AfterEval();
434  }
435  return zn;
436 }
437 
438 Double_t TGo4FitModel::Evaluate(Double_t x, Double_t y, Double_t z) {
439  Double_t zn = 0.;
440  if (BeforeEval(3)) {
441  Double_t vector[3] = {x,y,z};
442  zn = GetAmplValue() * EvalN(vector);
443  AfterEval();
444  }
445  return zn;}
446 
447 Double_t TGo4FitModel::Evaluate(Double_t* v, Int_t ndim) {
448  Double_t zn = 0.;
449  if (BeforeEval(ndim)) {
450  zn = GetAmplValue() * EvalN(v);
451  AfterEval();
452  }
453  return zn;
454 }
455 
457  return 0;
458 }
459 
460 
461 const Int_t* TGo4FitModel::GetDataFullIndex(TGo4FitData* data, Int_t nbin) {
462  return data==0 ? 0 : data->GetFullIndex(nbin);
463 }
464 
466  return data==0 ? 0 : data->GetIndexesSize();
467 }
468 
469 TGo4FitAssignment* TGo4FitModel::FindAssigment(const char* DataName) const {
470  for (Int_t n=0;n<NumAssigments();n++)
471  if (strcmp(DataName, GetAssigment(n)->GetName()) == 0)
472  return GetAssigment(n);
473  return 0;
474 }
475 
477 {
478  TString res;
479  res.Form("Ratio%d",n);
480  return res;
481 }
482 
483 Double_t TGo4FitModel::GetRatioValueFor(const char* DataName) {
484  TGo4FitAssignment* ass = FindAssigment(DataName);
485  return (ass==0) ? 1. : ass->RatioValue();
486 }
487 
488 void TGo4FitModel::Print(Option_t* option) const {
489  TGo4FitComponent::Print(option);
490  std::cout << " Assigned to: ";
491  fxAssigments.Print(option);
492  std::cout << std::endl;
493  if ( (fiMinIntegrDepth>0) && (fiMaxIntegrDepth>0) ) {
494  std::cout << " Integration property: depths from " << fiMinIntegrDepth << " to " << fiMaxIntegrDepth;
495  if (fbAbsoluteEps) std::cout << " absolute"; else std::cout << " relative";
496  std::cout << " error " << fdIntegrEps << std::endl;
497  }
498 }
499 
500 void TGo4FitModel::Streamer(TBuffer& b) {
501  if (b.IsReading()) {
502 
503  TGo4FitModel::Class()->ReadBuffer(b, this);
504 
505  for (Int_t n=0;n<NumAssigments();n++)
506  if (GetAssigment(n)->fxRatio)
507  GetAssigment(n)->fxRatio->SetOwner(this);
508 
509  } else {
510  TGo4FitModel::Class()->WriteBuffer(b, this);
511  }
512 }
TString GetRatioName(Int_t n)
TArrayD fxCurrentPars
Definition: TGo4FitModel.h:416
Bool_t fbAbsoluteEps
Definition: TGo4FitModel.h:373
Int_t fiMaxIntegrDepth
Definition: TGo4FitModel.h:363
Int_t GetDataIndexesSize(TGo4FitData *data)
Double_t RatioValue()
virtual Double_t Evaluate(Double_t x)
virtual void Print(Option_t *option) const
Double_t * fxCurrentParsArray
Definition: TGo4FitModel.h:421
Bool_t CheckRangeConditions(const Double_t *values, Int_t numaxis)
virtual void Finalize()
void ClearAssignments()
Bool_t fbIntegrScaling
Definition: TGo4FitModel.h:378
Char_t * fxModelMask
Definition: TGo4FitModel.h:65
const Int_t * GetFullIndex(Int_t nbin)
virtual ~TGo4FitAssignment()
TGo4FitAssignment * FindAssigment(const char *DataName) const
TGo4FitData * fxData
Definition: TGo4FitModel.h:60
TGo4FitParameter * GetPar(Int_t n)
virtual TGo4FitParameter * GetWidthPar(Int_t naxis=0)
Definition: TGo4FitModel.h:349
void AssignToData(const char *DataName, Double_t RatioValue=1., Bool_t FixRatio=kFALSE)
Double_t * GetModelBins(const char *DataName) const
Int_t GetAmplIndex() const
virtual Bool_t SetPosition(Int_t naxis, Double_t pos)
void RemoveAllPars()
virtual Double_t Integral()
void ClearAssignmentTo(const char *DataName)
TGo4FitParameter * NewAmplitude(const char *Name=0, Double_t iValue=0., Bool_t IsFixed=kFALSE, Int_t AtIndx=0)
void SetOwner(TNamed *iOwner)
Definition: TGo4FitNamed.h:58
virtual Double_t EvaluateAtPoint(TGo4FitData *data, Int_t nbin, Bool_t UseRanges=kTRUE)
const Double_t * Widths() const
Definition: TGo4FitData.h:504
TObjArray fxAssigments
Definition: TGo4FitModel.h:406
Double_t fdIntegrEps
Definition: TGo4FitModel.h:368
virtual Bool_t GetPosition(Int_t naxis, Double_t &pos)
virtual Int_t NumPars()
Bool_t fbNeedToRebuild
Definition: TGo4FitModel.h:426
Double_t * GetBinsResult()
Definition: TGo4FitData.h:267
virtual TGo4FitParameter * Get(Int_t n)
void ChangeDataNameInAssignments(const char *oldname, const char *newname)
Bool_t BuffersAllocated() const
Definition: TGo4FitData.h:238
TGo4FitData * GetAssignedConnection(Int_t n)
virtual Double_t UserFunction(Double_t *, Double_t *)
Definition: TGo4FitModel.h:328
const Double_t * GetScaleValues(const Int_t nbin)
Double_t * fxModelBins
Definition: TGo4FitModel.h:72
virtual ~TGo4FitModel()
void SetNeedToRebuild()
Definition: TGo4FitModel.h:321
virtual void Print(Option_t *option) const
virtual Bool_t Initialize(Int_t UseBuffers=-1)
TGo4FitAssignment * GetAssigment(Int_t n)
Definition: TGo4FitModel.h:390
Int_t GetBinsSize() const
Definition: TGo4FitData.h:243
virtual Bool_t BeforeEval(Int_t ndim)
TGo4FitParameter * fxRatio
Definition: TGo4FitModel.h:55
void ConnectToDataIfAssigned(TGo4FitData *data)
virtual Bool_t SetWidth(Int_t naxis, Double_t width)
void SetIntegrationsProperty(Int_t iMinIntegrDepth, Int_t iMaxIntegrDepth=0, Double_t iIntegrEps=0., Bool_t iAbsoluteEps=kFALSE, Bool_t iIntegrScaling=kFALSE)
virtual void AfterEval()
Definition: TGo4FitModel.h:253
virtual Bool_t GetWidth(Int_t naxis, Double_t &width)
TGo4FitParsList * fxAllPars
Definition: TGo4FitModel.h:431
Int_t NumAssigments() const
Definition: TGo4FitModel.h:124
virtual void Print(Option_t *option) const
Double_t EvaluateAndIntegrate(Int_t NumScales, const Double_t *Scales, const Double_t *Widths)
virtual void CollectParsTo(TGo4FitParsList &list)
void SetValue(Double_t iValue)
virtual TGo4FitParameter * GetPosPar(Int_t naxis=0)
Definition: TGo4FitModel.h:343
Double_t GetValue() const
Bool_t BuffersAllocated() const
Int_t fiMinIntegrDepth
Definition: TGo4FitModel.h:358
const Double_t * Scales() const
Definition: TGo4FitData.h:479
Int_t GetScalesSize() const
Definition: TGo4FitData.h:249
void RebuildShape(Bool_t ForceBuild=kFALSE)
virtual TGo4FitParameter * Get(Int_t n)
void SetFixed(Bool_t iFixed)
Bool_t AddModelToDataResult(TGo4FitData *data)
void GetParsValues(Double_t *pars)
TArrayD * fxAllParsValues
Definition: TGo4FitModel.h:433
Double_t GetRatioValueFor(const char *DataName)
void ApplyRangesForModelMask(TGo4FitComponent *model, Char_t *ModelMask)
Int_t GetIndexesSize() const
Definition: TGo4FitData.h:291
const Int_t * GetDataFullIndex(TGo4FitData *data, Int_t nbin)
virtual Double_t EvalN(const Double_t *v)
virtual Int_t NumPars()
const Double_t * GetWidthValues(const Int_t nbin)
Int_t ScalesSize() const
Definition: TGo4FitData.h:474
TGo4FitParameter * GetAmplPar()