GSI Object Oriented Online Offline (Go4) GO4-6.4.0
Loading...
Searching...
No Matches
TGo4FitModel.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 "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
28TGo4FitAssignment::TGo4FitAssignment(const char *DataName) : TNamed(DataName, "")
29{
30}
31
33{
34 if (fxRatio)
35 delete fxRatio;
36 if (fxModelMask)
37 delete[] fxModelMask;
38 if (fxModelBins)
39 delete[] fxModelBins;
40}
41
43{
44 return !fxRatio ? 1. : fxRatio->GetValue();
45}
46
47void TGo4FitAssignment::Print(Option_t *option) const
48{
49 std::cout << " " << GetName();
50}
51
52// **************************************************************************************************
53
60
61TGo4FitModel::TGo4FitModel(const char *iName, const char *iTitle, Bool_t MakeAmplitude)
62 : TGo4FitComponent(iName, iTitle), fiMinIntegrDepth(0), fiMaxIntegrDepth(0), fdIntegrEps(0.), fbAbsoluteEps(kFALSE),
64 fbNeedToRebuild(kFALSE), fxAllPars(nullptr), fxAllParsValues(nullptr)
65{
66 fxAssigments.SetOwner(kTRUE);
67 if (MakeAmplitude)
69}
70
75
77{
78 Int_t res = TGo4FitParsList::NumPars();
79 if (NumAssigments() > 0)
80 res += NumAssigments() - 1;
81 return res;
82}
83
85{
86 Int_t numpars = TGo4FitParsList::NumPars();
87 if (n < numpars)
88 return TGo4FitParsList::Get(n);
89 n -= numpars - 1;
90 return (n >= 0) && (n < NumAssigments()) ? GetAssigment(n)->fxRatio : nullptr;
91}
92
93void TGo4FitModel::AssignToData(const char *DataName, Double_t RatioValue, Bool_t FixRatio)
94{
95 if (!FindAssigment(DataName)) {
96 TGo4FitAssignment *ass = new TGo4FitAssignment(DataName);
97 if (NumAssigments() > 0) {
98 ass->fxRatio =
99 new TGo4FitParameter(GetRatioName(NumAssigments()), "Amplitude ratio to first data", RatioValue);
100 ass->fxRatio->SetOwner(this);
101 if (FixRatio)
102 ass->fxRatio->SetFixed(kTRUE);
103 }
104 fxAssigments.Add(ass);
105 }
106}
107
108void TGo4FitModel::ChangeDataNameInAssignments(const char *oldname, const char *newname)
109{
110 TGo4FitAssignment *ass = FindAssigment(oldname);
111 if (ass)
112 ass->SetName(newname);
113}
114
115void TGo4FitModel::ClearAssignmentTo(const char *DataName)
116{
117 TGo4FitAssignment *ass = FindAssigment(DataName);
118 if (!ass)
119 return;
120
121 fxAssigments.Remove(ass);
122 delete ass;
123 fxAssigments.Compress();
124
125 for (Int_t n = 0; n < NumAssigments(); n++) {
126 ass = GetAssigment(n);
127 if (!ass->fxRatio)
128 continue;
129 if (n == 0) {
130 delete ass->fxRatio;
131 ass->fxRatio = nullptr;
132 } else
133 ass->fxRatio->SetName(GetRatioName(n + 1));
134 }
135}
136
138{
139 fxAssigments.Clear();
140 fxAssigments.Compress();
141}
142
144{
145 if (!data)
146 return;
147 TGo4FitAssignment *ass = FindAssigment(data->GetName());
148 if (ass)
149 ass->fxData = data;
150}
151
153{
155 return ass ? ass->fxData : nullptr;
156}
157
158Bool_t TGo4FitModel::GetPosition(Int_t naxis, Double_t &pos)
159{
160 if (GetPosPar(naxis)) {
161 pos = GetPosPar(naxis)->GetValue();
162 return kTRUE;
163 }
164 return kFALSE;
165}
166
167Bool_t TGo4FitModel::SetPosition(Int_t naxis, Double_t pos)
168{
169 if (GetPosPar(naxis)) {
170 GetPosPar(naxis)->SetValue(pos);
171 return kTRUE;
172 }
173 return kFALSE;
174}
175
176Bool_t TGo4FitModel::GetWidth(Int_t naxis, Double_t &width)
177{
178 if (GetWidthPar(naxis)) {
179 width = GetWidthPar(naxis)->GetValue();
180 return kTRUE;
181 }
182 return kFALSE;
183}
184
185Bool_t TGo4FitModel::SetWidth(Int_t naxis, Double_t width)
186{
187 if (GetWidthPar(naxis)) {
188 GetWidthPar(naxis)->SetValue(width);
189 return kTRUE;
190 }
191 return kFALSE;
192}
193
194void TGo4FitModel::SetIntegrationsProperty(Int_t iMinIntegrDepth, Int_t iMaxIntegrDepth, Double_t iIntegrEps,
195 Bool_t iAbsoluteEps, Bool_t iIntegrScaling)
196{
197 fiMinIntegrDepth = iMinIntegrDepth;
198 fiMaxIntegrDepth = iMaxIntegrDepth;
199 fdIntegrEps = iIntegrEps;
200 fbAbsoluteEps = iAbsoluteEps;
201 fbIntegrScaling = iIntegrScaling;
202 if (fdIntegrEps <= 0.)
204}
205
207{
208 if (fxAllPars) {
209 delete fxAllPars;
210 fxAllPars = nullptr;
211 }
212 if (fxAllParsValues) {
213 delete fxAllParsValues;
214 fxAllParsValues = nullptr;
215 }
216}
217
218Bool_t TGo4FitModel::Initialize(Int_t UseBuffers)
219{
220 Bool_t use = ((UseBuffers < 0) && GetUseBuffers()) || (UseBuffers > 0);
221 for (Int_t n = 0; n < NumAssigments(); n++) {
223 if (!ass->fxData) {
224 std::cout << "Data " << ass->GetName() << " not assigned to model " << GetName() << std::endl;
225 continue;
226 }
227
228 if (use && ass->fxData->BuffersAllocated()) {
229 if (IsAnyRangeLimits()) {
230 ass->fxModelMask = new Char_t[ass->fxData->GetBinsSize()];
232 }
233
234 ass->fxModelBins = new Double_t[ass->fxData->GetBinsSize()];
235 }
236 }
237
239
240 if (use) {
242
243 fxAllPars = new TGo4FitParsList(kFALSE);
245
246 fxAllParsValues = new TArrayD(fxAllPars->NumPars());
247 fxAllPars->GetParsValues(fxAllParsValues->GetArray());
248 }
249
250 return kTRUE;
251}
252
254{
256 fxCurrentPars.Set(0);
257 for (Int_t n = 0; n < NumAssigments(); n++) {
259 if (ass->fxModelMask) {
260 delete[] ass->fxModelMask;
261 ass->fxModelMask = nullptr;
262 }
263 if (ass->fxModelBins) {
264 delete[] ass->fxModelBins;
265 ass->fxModelBins = nullptr;
266 }
267 }
268}
269
271{
272 Bool_t res = (NumAssigments() > 0);
273 for (Int_t n = 0; n < NumAssigments(); n++)
274 res = res && (GetAssigment(n)->fxModelBins != nullptr);
275 return res;
276}
277
278Double_t *TGo4FitModel::GetModelBins(const char *DataName) const
279{
280 TGo4FitAssignment *ass = FindAssigment(DataName);
281 return ass ? ass->fxModelBins : nullptr;
282}
283
284Double_t TGo4FitModel::EvaluateAndIntegrate(Int_t NumScales, const Double_t *Scales, const Double_t *Widths)
285{
286 if ((NumScales < 1) || !Scales)
287 return 0.;
288
289 if ((fiMinIntegrDepth > 0) && (fiMaxIntegrDepth > 0) && Widths) {
290 TArrayI IntegrIndexes(NumScales);
291 TArrayD ScaleValues(NumScales, Scales);
292 TArrayD WidthValues(NumScales, Widths);
293 TArrayD dScaleValues(NumScales);
294
295 Int_t *dindx = IntegrIndexes.GetArray();
296 Double_t *vector = ScaleValues.GetArray();
297 Double_t *width = WidthValues.GetArray();
298 Double_t *dvector = dScaleValues.GetArray();
299
300 Int_t n = 0;
301
302 // set value and range for current point of model
303 for (n = 0; n < NumScales; n++)
304 vector[n] -= 0.5 * width[n];
305
306 // include left bound of interval
307 Double_t TotalSum = EvalN(vector);
308 Int_t TotalNumPnt = 1;
309
310 Int_t IntegrDepth = 0;
311 Int_t NumStep = 1;
312 Double_t Step = 1.0;
313 Bool_t stopcondition = kFALSE;
314
315 // cycle over integration depths
316 do {
317
318 IntegrIndexes.Reset(0);
319 Double_t Sum = 0.;
320 Int_t NumPnt = 0;
321
322 // run over all integration points
323 do {
324 for (n = 0; n < NumScales; n++)
325 dvector[n] = vector[n] + Step * width[n] * (dindx[n] + 0.5);
326
327 Sum += EvalN(dvector);
328 NumPnt++;
329
330 n = 0;
331 do {
332 dindx[n]++;
333 if (dindx[n] < NumStep)
334 break;
335 dindx[n] = 0;
336 n++;
337 } while (n < NumScales);
338 } while (n < NumScales);
339
340 // check stop condition for integrations depth
341 stopcondition = kFALSE;
342 if (IntegrDepth >= fiMinIntegrDepth) {
343 if (IntegrDepth >= fiMaxIntegrDepth)
344 stopcondition = kTRUE;
345 else {
346 Double_t v1 = TotalSum / TotalNumPnt;
347 Double_t v2 = Sum / NumPnt;
348 Double_t v = TMath::Abs(v1 - v2);
349 if (!fbAbsoluteEps) {
350 if ((v1 != 0.) || (v2 != 0.))
351 v = v / (TMath::Abs(v1) + TMath::Abs(v2));
352 else
353 v = 0.;
354 }
355 if (v <= fdIntegrEps)
356 stopcondition = kTRUE;
357 }
358 }
359 TotalSum += Sum;
360 TotalNumPnt += NumPnt;
361 IntegrDepth++;
362 NumStep *= 2;
363 Step = Step / 2.;
364 } while (!stopcondition);
365
366 Double_t value = 0;
367 if (TotalNumPnt > 0)
368 value = TotalSum / TotalNumPnt;
369 if (fbIntegrScaling)
370 for (n = 0; n < NumScales; n++)
371 value *= width[n];
372 return value;
373 } else
374 return EvalN(Scales);
375}
376
377Double_t TGo4FitModel::EvaluateAtPoint(TGo4FitData *data, Int_t nbin, Bool_t UseRanges)
378{
379 if (!data)
380 return 0.;
381 const Double_t *scales = data->GetScaleValues(nbin);
382 Int_t scalessize = data->GetScalesSize();
383 if (UseRanges && !CheckRangeConditions(scales, scalessize))
384 return 0.;
385 return EvaluateAndIntegrate(scalessize, scales, data->GetWidthValues(nbin));
386}
387
388Double_t TGo4FitModel::EvaluateAtPoint(std::unique_ptr<TGo4FitDataIter> &iter, Bool_t UseRanges)
389{
390 if (!iter)
391 return 0;
392 const Double_t *scales = iter->Scales();
393 Int_t scalessize = iter->ScalesSize();
394 if (UseRanges && !CheckRangeConditions(scales, scalessize))
395 return 0.;
396 return EvaluateAndIntegrate(scalessize, scales, iter->Widths());
397}
398
399void TGo4FitModel::RebuildShape(Bool_t ForceBuild)
400{
401 if (!fxAllPars || !fxAllParsValues)
402 return;
403
404 Bool_t fill = ForceBuild || fbNeedToRebuild;
405 if (!fill)
406 for (Int_t n = 0; n < fxAllPars->NumPars(); n++) {
407 if (n == GetAmplIndex())
408 continue;
409 if ((*fxAllParsValues)[n] != fxAllPars->GetPar(n)->GetValue()) {
410 fill = kTRUE;
411 break;
412 }
413 }
414
415 if (fill)
416 for (Int_t n = 0; n < NumAssigments(); n++) {
418
419 if (!ass->fxData || !ass->fxModelBins)
420 continue;
421
422 TGo4FitData *data = ass->fxData;
423
424 if (!BeforeEval(data->GetScalesSize()))
425 continue;
426
427 Int_t size = data->GetBinsSize();
428 Double_t *bins = ass->fxModelBins;
429 Char_t *mask = ass->fxModelMask;
430 Double_t ratio = ass->RatioValue();
431
432 for (Int_t nbin = 0; nbin < size; nbin++) {
433 if (mask && (mask[nbin] == 0))
434 continue;
435 bins[nbin] = ratio * EvaluateAtPoint(data, nbin, kFALSE);
436 }
437
438 AfterEval();
439 }
440
441 for (Int_t n = 0; n < fxAllPars->NumPars(); n++)
442 (*fxAllParsValues)[n] = fxAllPars->GetPar(n)->GetValue();
443
444 fbNeedToRebuild = kFALSE;
445}
446
448{
449 if (!data || !data->BuffersAllocated())
450 return kFALSE;
451
452 Double_t *result = data->GetBinsResult();
453 if (!result)
454 return kFALSE;
455 Int_t size = data->GetBinsSize();
456
457 Double_t *modelbins = GetModelBins(data->GetName());
458 if (modelbins) {
459 Double_t ampl = GetAmplValue();
460 for (Int_t nbin = 0; nbin < size; nbin++)
461 result[nbin] += ampl * modelbins[nbin];
462 return kTRUE;
463 }
464
465 if (!BeforeEval(data->GetScalesSize()))
466 return kFALSE;
467
468 Double_t ampl = GetAmplValue() * GetRatioValueFor(data->GetName());
469
470 for (Int_t nbin = 0; nbin < size; nbin++)
471 result[nbin] += ampl * EvaluateAtPoint(data, nbin);
472
473 AfterEval();
474
475 return kTRUE;
476}
477
478Bool_t TGo4FitModel::BeforeEval(Int_t ndim)
479{
480 fxCurrentPars.Set(NumPars());
481 GetParsValues(fxCurrentPars.GetArray());
483 if (GetAmplPar())
485 return kTRUE;
486}
487
488Double_t TGo4FitModel::EvalN(const Double_t *v)
489{
490 return UserFunction((Double_t *)v, fxCurrentParsArray);
491}
492
493Double_t TGo4FitModel::Evaluate(Double_t x)
494{
495 Double_t zn = 0.;
496 if (BeforeEval(1)) {
497 zn = GetAmplValue() * EvalN(&x);
498 AfterEval();
499 }
500 return zn;
501}
502
503Double_t TGo4FitModel::Evaluate(Double_t x, Double_t y)
504{
505 Double_t zn = 0.;
506 if (BeforeEval(2)) {
507 Double_t vector[2] = {x, y};
508 zn = GetAmplValue() * EvalN(vector);
509 AfterEval();
510 }
511 return zn;
512}
513
514Double_t TGo4FitModel::Evaluate(Double_t x, Double_t y, Double_t z)
515{
516 Double_t zn = 0.;
517 if (BeforeEval(3)) {
518 Double_t vector[3] = {x, y, z};
519 zn = GetAmplValue() * EvalN(vector);
520 AfterEval();
521 }
522 return zn;
523}
524
525Double_t TGo4FitModel::Evaluate(Double_t *v, Int_t ndim)
526{
527 Double_t zn = 0.;
528 if (BeforeEval(ndim)) {
529 zn = GetAmplValue() * EvalN(v);
530 AfterEval();
531 }
532 return zn;
533}
534
536{
537 return 0;
538}
539
540const Int_t *TGo4FitModel::GetDataFullIndex(TGo4FitData *data, Int_t nbin)
541{
542 return data ? data->GetFullIndex(nbin) : nullptr;
543}
544
546{
547 return data ? data->GetIndexesSize() : 0;
548}
549
551{
552 for (Int_t n = 0; n < NumAssigments(); n++)
553 if (strcmp(DataName, GetAssigment(n)->GetName()) == 0)
554 return GetAssigment(n);
555 return nullptr;
556}
557
559{
560 TString res;
561 res.Form("Ratio%d", n);
562 return res;
563}
564
565Double_t TGo4FitModel::GetRatioValueFor(const char *DataName)
566{
567 TGo4FitAssignment *ass = FindAssigment(DataName);
568 return ass ? ass->RatioValue() : 1.;
569}
570
571void TGo4FitModel::Print(Option_t *option) const
572{
574 std::cout << " Assigned to: ";
575 fxAssigments.Print(option);
576 std::cout << std::endl;
577 if ((fiMinIntegrDepth > 0) && (fiMaxIntegrDepth > 0)) {
578 std::cout << " Integration property: depths from " << fiMinIntegrDepth << " to " << fiMaxIntegrDepth;
579 if (fbAbsoluteEps)
580 std::cout << " absolute";
581 else
582 std::cout << " relative";
583 std::cout << " error " << fdIntegrEps << std::endl;
584 }
585}
586
587void TGo4FitModel::Streamer(TBuffer &b)
588{
589 if (b.IsReading()) {
590 TGo4FitModel::Class()->ReadBuffer(b, this);
591 for (Int_t n = 0; n < NumAssigments(); n++)
592 if (GetAssigment(n)->fxRatio)
593 GetAssigment(n)->fxRatio->SetOwner(this);
594 } else {
595 TGo4FitModel::Class()->WriteBuffer(b, this);
596 }
597}
Internal class, used for assignment of model component to data.
virtual ~TGo4FitAssignment()
Destroys TGo4FitAssignment object.
TGo4FitData * fxData
Pointer on assigned data.
TGo4FitAssignment()
Default constructor.
TGo4FitParameter * fxRatio
Parameter for ratio value.
Double_t RatioValue()
Char_t * fxModelMask
Array of boolean values, selected model bins.
Double_t * fxModelBins
Array of model bins for assigned data.
void Print(Option_t *option="") const override
Print information about object on standard output.
TGo4FitParameter * GetAmplPar()
Return amplitude parameter object.
Bool_t CheckRangeConditions(const Double_t *values, Int_t numaxis)
Check all range conditions for specified point.
Bool_t GetUseBuffers() const
Returns flag of usage of additional buffers.
void CollectParsTo(TGo4FitParsList &list) override
Collect all parameters to provided parameters list object.
Int_t GetAmplIndex() const
Returns index of amplitude parameter.
TGo4FitParameter * NewAmplitude(const char *Name=nullptr, Double_t iValue=0., Bool_t IsFixed=kFALSE, Int_t AtIndx=0)
Create amplitude parameter with specified properties.
TGo4FitComponent()
Default constructor.
Bool_t IsAnyRangeLimits() const
Return kTRUE, if any range conditions were introduced.
Double_t GetAmplValue()
Return value of amplitude parameter.
void Print(Option_t *option="") const override
Print info about object on standard output.
Basic abstract class for representing data, which should be fitted.
Definition TGo4FitData.h:39
const Double_t * GetWidthValues(Int_t nbin) const
Return scales width values for specified index from buffer.
const Double_t * GetScaleValues(Int_t nbin) const
Return scale values for specified index from buffer.
Double_t * GetBinsResult() const
Returns pointer on buffer with complete model of data bins.
Bool_t BuffersAllocated() const
Checks, if buffers allocated for data.
Int_t GetBinsSize() const
Return number of data bins in buffers.
Int_t GetIndexesSize() const
Returns dimension of indexes arrays.
const Int_t * GetFullIndex(Int_t nbin) const
Return indexes values for specified data bin from buffer.
Int_t GetScalesSize() const
Returns number of axis values for each point.
void ApplyRangesForModelMask(TGo4FitComponent *model, Char_t *ModelMask)
Exclude points from model according model range conditions.
void ClearAssignments()
Remove all assignments.
Bool_t fbAbsoluteEps
States, if integration precision absolute or relative.
TArrayD fxCurrentPars
Array of values of parameters.
Double_t * GetModelBins(const char *DataName) const
Get model bins for specified data (if exists)
void SetNeedToRebuild()
Sets flag, that shape bins should be refilled next time, when RebuildShape() routine will be called.
Double_t * fxCurrentParsArray
Pointer on array of parameters values.
virtual Double_t EvalN(const Double_t *v)
Calculates value of model according current parameters values and provided axes values.
Bool_t AddModelToDataResult(TGo4FitData *data)
Evaluate model values for all data point and add them to result buffer.
Double_t fdIntegrEps
Integration precision.
void ConnectToDataIfAssigned(TGo4FitData *data)
Check, if model assigned to such a data (via name) and store pointer on this data object.
Bool_t BuffersAllocated() const
Checks if model allocate buffers for calculations.
virtual void Finalize()
Deletes all buffers, created during initialization.
virtual Bool_t SetPosition(Int_t naxis, Double_t pos)
Sets position of model component, if possible.
virtual Bool_t Initialize(Int_t UseBuffers=-1)
Initialize model object.
void Print(Option_t *option="") const override
Print information about model object on standard output.
virtual Double_t UserFunction(Double_t *, Double_t *)
Another place, where user specific code can be placed for model values calculation.
TGo4FitAssignment * FindAssigment(const char *DataName) const
Find assignment to given data.
TString GetRatioName(Int_t n)
Set name of ratio parameter.
virtual TGo4FitParameter * GetWidthPar(Int_t naxis=0)
Return parameter (if exist), which represent width of model component for given axis.
void RemoveAllPars()
Clear all buffers, allocated during initialization.
virtual Bool_t BeforeEval(Int_t ndim)
Prepares (if necessary) some intermediate variables to be able calculate values of model via EvalN() ...
virtual ~TGo4FitModel()
Delete TGo4FitModel object.
Double_t EvaluateAndIntegrate(Int_t NumScales, const Double_t *Scales, const Double_t *Widths)
Make integration of model inside given point, if integration specified.
Int_t fiGroupIndex
Store group index of specified model.
Int_t NumPars() override
Return number of parameters in list.
virtual Bool_t GetWidth(Int_t naxis, Double_t &width)
Returns with of model component, if exists.
virtual Bool_t GetPosition(Int_t naxis, Double_t &pos)
Return position of model, if exists.
virtual Double_t EvaluateAtPoint(TGo4FitData *data, Int_t nbin, Bool_t UseRanges=kTRUE)
Evaluate model value for specified data point.
void ChangeDataNameInAssignments(const char *oldname, const char *newname)
Change name of data in assignments.
Bool_t fbNeedToRebuild
Internal flag.
TGo4FitParsList * fxAllPars
List of all parameters, associated not only with component directly but also with encapsulated object...
Int_t fiMaxIntegrDepth
Maximum integration depth.
Bool_t fbIntegrScaling
Scale integral to integration volume.
Int_t GetDataIndexesSize(TGo4FitData *data)
void RebuildShape(Bool_t ForceBuild=kFALSE)
Recalculates shape of object.
virtual Double_t Integral()
Calculates integral of model component.
virtual Double_t Evaluate(Double_t x)
Calculates value of model for given x value.
TGo4FitParameter * Get(Int_t n) override
void AssignToData(const char *DataName, Double_t RatioValue=1., Bool_t FixRatio=kFALSE)
Assign model to specified data object.
const Int_t * GetDataFullIndex(TGo4FitData *data, Int_t nbin)
TGo4FitModel()
Default constructor.
virtual void AfterEval()
Clear buffers, which were created by BeforeEval() method.
TGo4FitAssignment * GetAssigment(Int_t n)
Return TGo4FitAssignment object with given index.
virtual TGo4FitParameter * GetPosPar(Int_t naxis=0)
Return parameter (if exist), which represent position of model for given axis.
void SetIntegrationsProperty(Int_t iMinIntegrDepth, Int_t iMaxIntegrDepth=0, Double_t iIntegrEps=0., Bool_t iAbsoluteEps=kFALSE, Bool_t iIntegrScaling=kFALSE)
Set integration properties.
TObjArray fxAssigments
List of TGo4FitAssignment objects.
TGo4FitData * GetAssignedConnection(Int_t n)
Return pointer on assigned data.
Int_t fiMinIntegrDepth
Minimum depth of integration.
TArrayD * fxAllParsValues
Double_t GetRatioValueFor(const char *DataName)
Returns ratio value for specified data object.
virtual Bool_t SetWidth(Int_t naxis, Double_t width)
Sets width of model component, if possible.
void ClearAssignmentTo(const char *DataName)
Remove assignment to given data (if exists).
Int_t NumAssigments() const
Returns number of assignment for this model.
void SetOwner(TNamed *iOwner)
Sets owner of object.
Model and data objects parameter.
Double_t GetValue() const
Return parameter value.
void SetValue(Double_t iValue)
Set parameter value.
void SetFixed(Bool_t iFixed)
Set status of parameter fixed or not.
void GetParsValues(Double_t *pars)
Copy values of all parameters in list to provided array.
virtual TGo4FitParameter * Get(Int_t n)
TGo4FitParsList()
Default constructor.
virtual Int_t NumPars()
Return number of parameters in list.