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