GSI Object Oriented Online Offline (Go4)  GO4-6.1.4
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
TGo4FitData.cxx
Go to the documentation of this file.
1 // $Id: TGo4FitData.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 "TGo4FitData.h"
15 
16 #include <iostream>
17 
18 #include "TBuffer.h"
19 #include "TMath.h"
20 #include "TH1.h"
21 #include "TH2.h"
22 #include "TH3.h"
23 #include "TGraph.h"
24 #include "TClass.h"
25 
26 #include "TGo4FitAxisTrans.h"
27 
28 
30  fiDataType(0), fbUseBinScale(kFALSE), fiTakeSigmasFrom(1), fdSigmaValue(1.), fdExcludeLessThen(0.),
31  fxAxisTrans() {
33 }
34 
35 TGo4FitData::TGo4FitData(const char* iName, const char* iTitle, Int_t iDataType, Bool_t AddAmpl) :
36  TGo4FitComponent(iName,iTitle), fiDataType(iDataType),
37  fbUseBinScale(kFALSE), fiTakeSigmasFrom(1), fdSigmaValue(1.), fdExcludeLessThen(0.),
38  fxAxisTrans() {
39 
41 
42  if(AddAmpl) NewAmplitude("Ampl",1.0,kTRUE);
43 
44  fxAxisTrans.SetOwner(kTRUE);
45 }
46 
49 }
50 
51 
52 Bool_t TGo4FitData::SetNumberOfTransSlots(Int_t nslots) {
53  Int_t oldnum = GetNumberOfTransSlots();
54  if ( (nslots<0) || (nslots == oldnum) ) return kFALSE;
55 
56  if (oldnum<nslots)
57  for(Int_t n=oldnum;n<nslots;n++) {
58  TString name("Trans");
59  name+=n;
60  fxAxisTrans.Add(new TGo4FitSlot(name.Data(),"Axis transformation", this, TGo4FitAxisTrans::Class(), kFALSE));
61  }
62  else
63  for (Int_t n=oldnum;n>nslots;n--) {
64  TObject* slot = fxAxisTrans.Last();
65  fxAxisTrans.Remove(slot);
66  fxAxisTrans.Compress();
67  delete slot;
68  }
70  return kTRUE;
71 }
72 
74 {
75  return (nslot>=0) && (nslot<=fxAxisTrans.GetLast()) ? dynamic_cast<TGo4FitSlot*> (fxAxisTrans[nslot]) : 0;
76 }
77 
79 {
80  TGo4FitSlot* slot = GetAxisTransSlot(nslot);
81  return (slot==0) ? 0 : dynamic_cast<TGo4FitAxisTrans*> (slot->GetObject());
82 }
83 
84 void TGo4FitData::SetAxisTrans(Int_t nslot, TGo4FitAxisTrans *Trans, Bool_t TransOwned)
85 {
86  if (nslot<0) return;
87  if(nslot>=GetNumberOfTransSlots())
88  SetNumberOfTransSlots(nslot+1);
89  ((TGo4FitSlot*) (fxAxisTrans[nslot]))->SetObject(Trans,TransOwned);
90 }
91 
92 void TGo4FitData::AddAxisTrans(TGo4FitAxisTrans* Trans, Bool_t TransOwned) {
93  Int_t nslot = GetNumberOfTransSlots();
94  SetNumberOfTransSlots(nslot+1);
95  ((TGo4FitSlot*) (fxAxisTrans[nslot]))->SetObject(Trans,TransOwned);
96 }
97 
98 void TGo4FitData::SetAxisTransNeeded(Int_t nslot, Bool_t iNeeded) {
99  if( iNeeded && (nslot>=GetNumberOfTransSlots()))
100  SetNumberOfTransSlots(nslot+1);
101  if ((nslot>=0) && (nslot<GetNumberOfTransSlots()))
102  ((TGo4FitSlot*) (fxAxisTrans[nslot]))->SetNeeded(iNeeded);
103 }
104 
106  if (GetUseBinScale() || (GetExcludeLessThen()>0)) return kTRUE;
107  for (Int_t n=0;n<GetNumberOfTransSlots();n++)
108  if (GetAxisTrans(n)) return kTRUE;
109  return kFALSE;
110 }
111 
112 TObject* TGo4FitData::CreateDrawObject(const char* ObjName) {
113  TGo4FitDataIter* iter = MakeIter();
114  if (iter==0) return 0;
115  TObject* obj = iter->CreateDrawObject(ObjName);
116  delete iter;
117  return obj;
118 }
119 
120 Bool_t TGo4FitData::Initialize(Int_t UseBuffers) {
121 
122  TGo4FitDataIter* iter = MakeIter();
123  if (iter==0) return kFALSE;
124 
125  fiBinsSize = iter->CountPoints(kTRUE);
126 
127  fiIndexesSize = iter->IndexesSize();
128  fiScalesSize = iter->ScalesSize();
129 
130  Bool_t use = ((UseBuffers<0) && GetUseBuffers()) || (UseBuffers>0);
131 
132  if (use)
133  for(Int_t n=0; n<GetNumberOfTransSlots();n++) {
134  TGo4FitAxisTrans* trans = GetAxisTrans(n);
135  if (trans && !trans->IsAllParsFixed()) {
136  use = kFALSE;
137  break;
138  }
139  }
140 
141  if (use) {
142 
143  fxValues = new Double_t[fiBinsSize];
144  fxStandDev = new Double_t[fiBinsSize];
145  fxBinsResult = new Double_t[fiBinsSize];
146 
147  if (iter->HasIndexes()) fxFullIndex = new Int_t[fiBinsSize*fiIndexesSize];
148  fxFullScale = new Double_t[fiBinsSize*fiScalesSize];
149  if (iter->HasWidths()) fxFullWidth = new Double_t [fiBinsSize*fiScalesSize];
150 
151  Int_t nbin = 0;
152  if (iter->Reset()) do {
153 
154  fxValues[nbin] = iter->Value();
155  fxStandDev[nbin] = iter->StandardDeviation();
156 
157  if(fxFullIndex)
158  for(Int_t n=0;n<fiIndexesSize;n++)
159  fxFullIndex[nbin*fiIndexesSize+n] = iter->Indexes()[n];
160 
161  if(fxFullScale)
162  for(Int_t naxis = 0;naxis<fiScalesSize;naxis++)
163  fxFullScale[nbin*fiScalesSize+naxis] = iter->Scales()[naxis];
164 
165  if(fxFullWidth && iter->HasWidths())
166  for(Int_t naxis = 0;naxis<fiScalesSize;naxis++)
167  fxFullWidth[nbin*fiScalesSize+naxis] = iter->Widths()[naxis];
168 
169  nbin++;
170  } while (iter->Next());
171  }
172 
173  delete iter;
174 
175  return kTRUE;
176 }
177 
180 }
181 
183  fiBinsSize = 0;
184  fiIndexesSize = 0;
185  fiScalesSize = 0;
186 
187  fxValues = 0;
188  fxStandDev = 0;
189  fxBinsResult = 0;
190 
191  fxFullScale = 0;
192  fxFullWidth = 0;
193 
194  fxFullIndex = 0;
195 }
196 
198  if (fxValues) delete[] fxValues;
199 
200  if (fxStandDev) delete[] fxStandDev;
201 
202  if (fxBinsResult) delete[] fxBinsResult;
203 
204  if (fxFullIndex) delete[] fxFullIndex;
205 
206  if (fxFullScale) delete[] fxFullScale;
207 
208  if (fxFullWidth) delete[] fxFullWidth;
209 
211 }
212 
213 Bool_t TGo4FitData::DefineScaleMinMax(Int_t naxis, Double_t& min, Double_t& max) {
214  TGo4FitDataIter* iter = MakeIter();
215  if (iter==0) return kFALSE;
216  Bool_t res = kFALSE;
217  if (iter->Reset(kFALSE) && (iter->ScalesSize()<=naxis)) {
218  min = iter->Scales()[naxis]; max = min;
219  do {
220  Double_t value = iter->Scales()[naxis];
221  if (value<min) min = value; else
222  if (value>max) max = value;
223  } while (iter->Next(kFALSE));
224  res = kTRUE;
225  }
226 
227  delete iter;
228  return res;
229 }
230 
232  TGo4FitDataIter* iter = MakeIter();
233  if (iter==0) return 0;
234  Int_t res = 0;
235  if (iter->Reset(kFALSE)) res = iter->IndexesSize();
236  delete iter;
237  return res;
238 }
239 
241 {
242  TGo4FitDataIter* iter = MakeIter();
243  if (iter==0) return 0;
244 
245  Int_t res = iter->CountPoints(kTRUE);
246  delete iter;
247 
248  return res;
249 }
250 
251 const Double_t* TGo4FitData::GetScaleValues(const Int_t nbin)
252 {
253  if(fxFullScale) return &(fxFullScale[nbin*GetScalesSize()]);
254  else return 0;
255 }
256 
257 const Double_t* TGo4FitData::GetWidthValues(const Int_t nbin)
258 {
259  if(fxFullWidth) return &(fxFullWidth[nbin*GetScalesSize()]);
260  else return 0;
261 }
262 
263 const Int_t* TGo4FitData::GetFullIndex(Int_t nbin)
264 {
265  if (fxFullIndex) return &(fxFullIndex[nbin*GetIndexesSize()]);
266  else return 0;
267 }
268 
270 {
271  if (data==0) return kFALSE;
272  TGo4FitDataIter* iter = data->MakeIter();
273  if (iter==0) return kFALSE;
274 
275  Bool_t res = kFALSE;
276  if (iter->Reset(kFALSE)) res = (iter->IndexesSize()==GetIndexesSize()) && (GetIndexesSize()>0);
277  delete iter;
278 
279  return res;
280 }
281 
283 {
284 
285  if (ModelMask==0) return;
286 
287  if (BuffersAllocated())
288  for(Int_t nbin=0;nbin<GetBinsSize();nbin++) {
289  const Double_t* values = GetScaleValues(nbin);
290 
291  Bool_t res = model->CheckRangeConditions(values, GetScalesSize());
292 
293  ModelMask[nbin] = res ? 1 : 0;
294  }
295  else {
296  TGo4FitDataIter* iter = MakeIter();
297  Int_t nbin = 0;
298  if (iter->Reset()) do {
299  Bool_t res = model->CheckRangeConditions(iter->Scales(), iter->ScalesSize());
300  ModelMask[nbin] = res ? 1 : 0;
301  nbin++;
302  } while (iter->Next());
303  }
304 }
305 
306 void TGo4FitData::FillSlotList(TSeqCollection* list)
307 {
309  for(Int_t n=0;n<=fxAxisTrans.GetLast();n++)
310  list->Add(fxAxisTrans[n]);
311 }
312 
313 void TGo4FitData::Print(Option_t* option) const
314 {
315  TGo4FitComponent::Print(option);
316  std::cout << " Data type: ";
317  switch(fiDataType) {
318  case 1: std::cout << "histogram" << std::endl; break;
319  case 2: std::cout << "graph" << std::endl; break;
320  default: std::cout << fiDataType << std::endl;
321  }
322  std::cout << " Use bin scale: " << fbUseBinScale << std::endl;
323  std::cout << " Take sigmas from: " ;
324  switch(GetSigmaSource()) {
325  case 0: std::cout << "none" << std::endl; break;
326  case 1: std::cout << "data" << std::endl; break;
327  case 2: std::cout << "const value " << GetSigmaValue() << std::endl; break;
328  }
329  std::cout << " Exclude bins less then: " << GetExcludeLessThen() << std::endl;
330  std::cout << " Axis transformation data: " << std::endl;
331  fxAxisTrans.Print(option);
332 }
333 
334 void TGo4FitData::Streamer(TBuffer& b)
335 {
336  if (b.IsReading()) {
337 
338  TGo4FitData::Class()->ReadBuffer(b, this);
339 
340  for(Int_t n=0;n<=fxAxisTrans.GetLast();n++) {
341  TGo4FitSlot* dc = (TGo4FitSlot*) fxAxisTrans[n];
342  dc->SetDefaults(this, TGo4FitAxisTrans::Class());
343  }
344 
345  } else {
346  TGo4FitData::Class()->WriteBuffer(b, this);
347  }
348 }
349 
350 // *******************************************************************************************
351 
352 
354  fxIndexes(), fxScales(), fxWidths(), fdValue(0.), fdStandardDeviation(1.), fiNumPoint(0), fbReachEnd(kTRUE) {
355 }
356 
358 }
359 
360 Bool_t TGo4FitDataIter::ReserveArrays(Int_t NumDimen, Int_t NumOwnAxis, Bool_t HasWidth) {
361  TGo4FitData* data = GetData();
362  if (data==0) return kFALSE;
363 
364  fxIndexes.Set(NumDimen); fxIndexes.Reset(0);
365 
366  Int_t size = 0;
367  if (data->GetUseBinScale()) size = NumDimen;
368  else size = NumOwnAxis;
369 
370  if (size<=0) return kFALSE;
371 
372  fxScales.Set(size); fxScales.Reset(0.);
373  if (HasWidth) { fxWidths.Set(size); fxWidths.Reset(1.); }
374  else fxWidths.Set(0);
375 
376  return kTRUE;
377 }
378 
379 void TGo4FitDataIter::TransformScales(Double_t* scales)
380 {
381  TGo4FitData* data = GetData();
382  for(Int_t nslot=0;nslot<data->GetNumberOfTransSlots();nslot++) {
383  TGo4FitAxisTrans* trans = data->GetAxisTrans(nslot);
384  if (trans) trans->Transformation(scales, ScalesSize());
385  }
386 }
387 
388 Bool_t TGo4FitDataIter::ProduceScales(const Int_t* index, const Double_t* ownscales, const Double_t* ownwidths)
389 {
390  TGo4FitData* data = GetData();
391  if (data==0) return kFALSE;
392 
393  if ( (data->GetUseBinScale()) || (ownscales==0) ) {
394  if (index==0) return kFALSE;
395  Double_t add = (data->GetDataType() == TGo4FitData::dtHistogram) ? .5 : 0.;
396  for(Int_t n=0;n<fxScales.GetSize();n++)
397  fxScales[n] = index[n] + add;
398  fxWidths.Reset(1.);
399  } else {
400  for(Int_t n=0; n<fxScales.GetSize();n++)
401  fxScales[n] = ownscales[n];
402  if (ownwidths!=0)
403  for(Int_t n=0; n<fxWidths.GetSize();n++)
404  fxWidths[n] = ownwidths[n];
405  }
406 
407  if (data->GetNumberOfTransSlots()>0) {
408  if (fxWidths.GetSize()==ScalesSize()) {
409  TArrayD arr1(ScalesSize()), arr2(ScalesSize());
410  for(Int_t n=0;n<ScalesSize();n++) {
411  arr1[n] = fxScales[n]-fxWidths[n]/2.;
412  arr2[n] = fxScales[n]+fxWidths[n]/2.;
413  }
414  TransformScales(arr1.GetArray());
415  TransformScales(arr2.GetArray());
416  for(Int_t n=0;n<ScalesSize();n++)
417  fxWidths[n] = TMath::Abs(arr2[n]-arr1[n]);
418  }
419 
420  TransformScales(fxScales.GetArray());
421  }
422 
423  return kTRUE;
424 }
425 
426 Bool_t TGo4FitDataIter::NextIndex(TArrayI& Index, TArrayI& Limits) {
427  Int_t n=0;
428  while (n<Index.GetSize()) {
429  Index[n]++;
430  if (Index[n]<Limits[n]) return kTRUE;
431  Index[n] = 0; n++;
432  }
433  return kFALSE;
434 }
435 
437  TGo4FitData* data = GetData();
438  if (data==0) return kFALSE;
439  if (data->GetSigmaSource()==2) {
441  return kTRUE;
442  } else return kFALSE;
443 }
444 
446  TGo4FitData* data = GetData();
447  if (data==0) return kFALSE;
448  if (Value()<data->GetExcludeLessThen()) return kFALSE;
449  return data->CheckRangeConditions(Scales(),ScalesSize());
450 }
451 
452 Bool_t TGo4FitDataIter::Reset(Bool_t UseRanges) {
453  fbReachEnd = kTRUE;
454 
455  if (!StartReset()) return kFALSE;
456 
457  fiNumPoint = 0;
458 
459  if (!ReadCurrentPoint()) return kFALSE;
460  if (!UseRanges) { fbReachEnd = kFALSE; return kTRUE; }
461 
462  while (!CheckPointForRange()) {
463  if (!ShiftToNextPoint()) return kFALSE;
464  if (!ReadCurrentPoint()) return kFALSE;
465  }
466 
467  fbReachEnd = kFALSE;
468  return kTRUE;
469 }
470 
471 Bool_t TGo4FitDataIter::Next(Bool_t UseRanges) {
472  fiNumPoint++;
473 
474  if (fbReachEnd || (GetData()==0)) { fbReachEnd = kTRUE; return kFALSE; }
475 
476  do {
477  if (!ShiftToNextPoint()) { fbReachEnd = kTRUE; return kFALSE; }
478 
479  if (!ReadCurrentPoint()) { fbReachEnd = kTRUE; return kFALSE; }
480 
481  if (!UseRanges) return kTRUE;
482 
483  } while (!CheckPointForRange());
484 
485  return kTRUE;
486 }
487 
488 Double_t TGo4FitDataIter::xWidths() const
489 {
490  double res = 1.;
491  if(HasWidths())
492  for(int n=0;n<fxWidths.GetSize();n++)
493  res=res*fxWidths[n];
494  return res;
495 }
496 
497 Int_t TGo4FitDataIter::CountPoints(Bool_t UseRanges) {
498  if (!Reset(UseRanges)) return 0;
499  Int_t cnt=0;
500  do {
501  cnt+=1;
502  } while (Next(UseRanges)) ;
503  return cnt;
504 }
505 
506 Bool_t TGo4FitDataIter::DefineIndexesLimits(TArrayI& Limits) {
507  if (!Reset(kFALSE)) return kFALSE;
508  if (IndexesSize()<=0) return kFALSE;
509  Limits.Set(IndexesSize()); Limits.Reset(0);
510  do {
511  for(Int_t n=0;n<IndexesSize();n++)
512  if (Indexes()[n]>Limits[n]) Limits[n] = Indexes()[n];
513  } while(Next(kFALSE));
514  return kTRUE;
515 }
516 
517 TH1* TGo4FitDataIter::CreateHistogram(const char* HistoName, Bool_t UseRanges, Bool_t SetBins) {
518  TArrayI Limits;
519  if (!DefineIndexesLimits(Limits)) return 0;
520  if (!HasIndexes() || (IndexesSize()!=ScalesSize()) || !HasWidths()) return 0;
521 
522  Int_t NumDim = IndexesSize();
523  if (NumDim>3) NumDim=3;
524 
525  Double_t* dummy = 0;
526  TH1* histo = 0;
527  switch(NumDim) {
528  case 1: histo = new TH1D(HistoName, "result", Limits[0]+1, dummy); break;
529  case 2: histo = new TH2D(HistoName, "result", Limits[0]+1, dummy, Limits[1]+1, dummy); break;
530  case 3: histo = new TH3D(HistoName, "result", Limits[0]+1, dummy, Limits[1]+1, dummy, Limits[2]+1, dummy); break;
531  default: return 0;
532  }
533 
534  histo->SetDirectory(0);
535 
536  Double_t* Axises[3];
537  for (Int_t n=0;n<NumDim;n++)
538  Axises[n] = new Double_t[Limits[n]+2];
539 
540  Double_t ampl = GetData()->GetAmplValue();
541 
542  if (Reset(UseRanges)) do {
543  if (SetBins)
544  switch (NumDim) {
545  case 1: histo->SetBinContent(Indexes()[0]+1, ampl*Value()); break;
546  case 2: histo->SetBinContent(Indexes()[0]+1, Indexes()[1]+1, ampl*Value()); break;
547  case 3: histo->SetBinContent(Indexes()[0]+1, Indexes()[1]+1, Indexes()[2]+1, ampl*Value()); break;
548  }
549  for(Int_t n=0;n<NumDim;n++) {
550  Int_t indx = Indexes()[n];
551  Axises[n][indx] = Scales()[n]-Widths()[n]/2.;
552  Axises[n][indx+1] = Scales()[n]+Widths()[n]/2.;
553  }
554  } while(Next(UseRanges));
555 
556  histo->GetXaxis()->Set(Limits[0]+1,Axises[0]);
557  if (NumDim>1) histo->GetYaxis()->Set(Limits[1]+1,Axises[1]);
558  if (NumDim>2) histo->GetZaxis()->Set(Limits[2]+1,Axises[2]);
559 
560  for (Int_t n=0;n<NumDim;n++)
561  delete[] Axises[n];
562 
563  return histo;
564 }
565 
566 TGraph* TGo4FitDataIter::CreateGraph(const char* GraphName, Bool_t UseRanges, Bool_t SetBins) {
567  Int_t NumPoints = CountPoints(UseRanges);
568  if ((NumPoints<=0) || (ScalesSize()<1)) return 0;
569 
570  TGraph* gr = new TGraph(NumPoints);
571  gr->SetName(GraphName);
572  if (Reset(UseRanges)) do {
573  (gr->GetX())[Point()] = x();
574  if (SetBins)
575  (gr->GetY())[Point()] = GetData()->GetAmplValue() * Value();
576  } while(Next(UseRanges));
577 
578  return gr;
579 }
580 
581 TObject* TGo4FitDataIter::CreateDrawObject(const char* ObjName) {
582  if (!Reset(kFALSE)) return 0;
583  if (HasIndexes() && (IndexesSize()==ScalesSize()) && HasWidths()) return CreateHistogram(ObjName, kFALSE, kTRUE);
584  else return CreateGraph(ObjName, kFALSE, kTRUE);
585 }
Bool_t DefineScaleMinMax(Int_t naxis, Double_t &min, Double_t &max)
Int_t fiBinsSize
Definition: TGo4FitData.h:346
Double_t xWidths() const
TArrayD fxWidths
Definition: TGo4FitData.h:620
TH1 * CreateHistogram(const char *HistoName, Bool_t UseRanges=kFALSE, Bool_t SetBins=kFALSE)
void SetUpdateSlotList()
Bool_t ProduceScales(const Int_t *index, const Double_t *ownscales, const Double_t *ownwidths)
TArrayI fxIndexes
Definition: TGo4FitData.h:617
Double_t fdStandardDeviation
Definition: TGo4FitData.h:622
virtual void Print(Option_t *option) const
Bool_t HasWidths() const
Definition: TGo4FitData.h:499
TGo4FitSlot * SetObject(TObject *obj, Bool_t iOwned=kFALSE)
virtual Bool_t IsAnyDataTransform()
Bool_t CheckRangeConditions(const Double_t *values, Int_t numaxis)
virtual void Print(Option_t *option) const
Double_t x() const
Definition: TGo4FitData.h:484
Double_t * fxBinsResult
Definition: TGo4FitData.h:371
Double_t * fxFullScale
Definition: TGo4FitData.h:378
Bool_t SetNumberOfTransSlots(Int_t nslots)
Definition: TGo4FitData.cxx:52
Int_t fiScalesSize
Definition: TGo4FitData.h:356
const Int_t * GetFullIndex(Int_t nbin)
virtual TGo4FitDataIter * MakeIter()
Definition: TGo4FitData.h:165
virtual void Finalize()
Int_t fiDataType
Definition: TGo4FitData.h:297
TObject * CreateDrawObject(const char *ObjName)
void ReleaseAllPointers()
Bool_t DefineIndexesLimits(TArrayI &Limits)
Int_t GetSigmaSource() const
Definition: TGo4FitData.h:83
void TransformScales(Double_t *scales)
TGraph * CreateGraph(const char *GraphName, Bool_t UseRanges=kFALSE, Bool_t SetBins=kFALSE)
Bool_t NextIndex(TArrayI &Index, TArrayI &Limits)
Int_t GetNumberOfTransSlots()
Definition: TGo4FitData.h:126
TGo4FitSlot * GetAxisTransSlot(Int_t nslot)
Definition: TGo4FitData.cxx:73
virtual Bool_t Initialize(Int_t UseBuffers=-1)
Double_t GetSigmaValue() const
Definition: TGo4FitData.h:89
TGo4FitParameter * NewAmplitude(const char *Name=0, Double_t iValue=0., Bool_t IsFixed=kFALSE, Int_t AtIndx=0)
void ResetAllPoinetrs()
virtual Bool_t Reset(Bool_t UseRanges=kTRUE)
Int_t DefineBinsSize()
const Double_t * Widths() const
Definition: TGo4FitData.h:504
Bool_t IsCompatibleData(TGo4FitData *data)
Bool_t GetUseBinScale() const
Definition: TGo4FitData.h:62
Int_t Point() const
Definition: TGo4FitData.h:524
virtual ~TGo4FitDataIter()
virtual Bool_t StartReset()=0
Bool_t BuffersAllocated() const
Definition: TGo4FitData.h:238
virtual ~TGo4FitData()
Definition: TGo4FitData.cxx:47
const Double_t * GetScaleValues(const Int_t nbin)
Int_t CountPoints(Bool_t UseRanges=kTRUE)
Double_t * fxStandDev
Definition: TGo4FitData.h:366
Int_t GetBinsSize() const
Definition: TGo4FitData.h:243
virtual Bool_t Next(Bool_t UseRanges=kTRUE)
virtual TGo4FitData * GetData() const =0
TObject * CreateDrawObject(const char *ObjName)
Int_t GetDataType() const
Definition: TGo4FitData.h:57
Bool_t ReserveArrays(Int_t NumDimen, Int_t NumOwnAxis, Bool_t HasWidth)
virtual void FillSlotList(TSeqCollection *lst)
virtual void FillSlotList(TSeqCollection *list)
TGo4FitAxisTrans * GetAxisTrans(Int_t nslot)
Definition: TGo4FitData.cxx:78
Int_t DefineDimensions()
void SetAxisTrans(Int_t nslot, TGo4FitAxisTrans *Trans, Bool_t TransOwned=kFALSE)
Definition: TGo4FitData.cxx:84
Bool_t GetDeviation()
Bool_t fbUseBinScale
Definition: TGo4FitData.h:303
Bool_t HasIndexes() const
Definition: TGo4FitData.h:454
Int_t fiIndexesSize
Definition: TGo4FitData.h:351
void SetDefaults(TNamed *iOwner, TClass *iClass)
Definition: TGo4FitSlot.cxx:68
Double_t Value() const
Definition: TGo4FitData.h:514
const Int_t * Indexes() const
Definition: TGo4FitData.h:464
const Double_t * Scales() const
Definition: TGo4FitData.h:479
void AddAxisTrans(TGo4FitAxisTrans *Trans, Bool_t TransOwned=kFALSE)
Definition: TGo4FitData.cxx:92
virtual Bool_t ShiftToNextPoint()=0
Int_t GetScalesSize() const
Definition: TGo4FitData.h:249
virtual void Transformation(Double_t *scales, Int_t naxis)=0
virtual Bool_t ReadCurrentPoint()=0
Double_t GetExcludeLessThen() const
Definition: TGo4FitData.h:112
TObject * GetObject() const
Int_t IndexesSize() const
Definition: TGo4FitData.h:459
Double_t StandardDeviation() const
Definition: TGo4FitData.h:519
Bool_t CheckPointForRange()
TObjArray fxAxisTrans
Definition: TGo4FitData.h:324
void ApplyRangesForModelMask(TGo4FitComponent *model, Char_t *ModelMask)
Int_t GetIndexesSize() const
Definition: TGo4FitData.h:291
Int_t * fxFullIndex
Definition: TGo4FitData.h:392
Double_t * fxValues
Definition: TGo4FitData.h:361
const Double_t * GetWidthValues(const Int_t nbin)
TArrayD fxScales
Definition: TGo4FitData.h:619
Double_t * fxFullWidth
Definition: TGo4FitData.h:385
void SetAxisTransNeeded(Int_t nslot, Bool_t iNeeded=kFALSE)
Definition: TGo4FitData.cxx:98
Int_t ScalesSize() const
Definition: TGo4FitData.h:474