---

/Go4Fit/TGo4FitData.h

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#ifndef TGO4FITDATA_H
#define TGO4FITDATA_H

#include "TArrayI.h"
#include "TArrayD.h"
#include "TArrayC.h"
#include "TH1.h"
#include "TGraph.h"
#include "TGo4FitSlot.h"
#include "TGo4FitComponent.h"
#include "TGo4FitAxisTrans.h"

class TGo4FitDataIter;

class TGo4FitData : public TGo4FitComponent {
   public:
      enum { dtHistogram = 1, dtGraph = 2 };

      TGo4FitData();

      TGo4FitData(const char* iName, const char* iTitle, Int_t iDataType = dtHistogram, Bool_t AddAmpl = kFALSE);

      virtual ~TGo4FitData();

      const Int_t GetDataType() { return fiDataType; }

      Bool_t GetUseBinScale() { return fbUseBinScale; }

      void SetUseBinScale(Bool_t iUseBinScale) { fbUseBinScale=iUseBinScale; }

      virtual Bool_t CanAmplTouch() { return kTRUE; }

      Int_t GetSigmaSource() const { return fiTakeSigmasFrom; }

      Double_t GetSigmaValue() const { return fdSigmaValue; }

      void SetSigmaSource(Int_t TakeFrom, Double_t SigmaValue = 1.)
         { fiTakeSigmasFrom = TakeFrom; if ((TakeFrom==2) && (SigmaValue>0)) fdSigmaValue = SigmaValue; }

      void SetSigmaValue(Double_t SigmaValue) { fdSigmaValue = SigmaValue; }

      void SetExcludeLessThen(Double_t limit = 0.) { fdExcludeLessThen = limit; }

      Double_t GetExcludeLessThen() const { return fdExcludeLessThen; }

      Bool_t SetNumberOfTransSlots(Int_t nslots);

      Int_t GetNumberOfTransSlots() { return fxAxisTrans.GetLast()+1; }

      TGo4FitSlot* GetAxisTransSlot(Int_t nslot);

      TGo4FitAxisTrans* GetAxisTrans(Int_t nslot);

      void SetAxisTrans(Int_t nslot, TGo4FitAxisTrans* Trans, Bool_t TransOwned = kFALSE);

      void AddAxisTrans(TGo4FitAxisTrans* Trans, Bool_t TransOwned = kFALSE);

      void SetAxisTransNeeded(Int_t nslot, Bool_t iNeeded = kFALSE);

      virtual Bool_t IsAnyDataTransform();

      virtual TGo4FitDataIter* MakeIter() { return 0; }

      TObject* CreateDrawObject(const char* ObjName);

      Bool_t DefineScaleMinMax(Int_t naxis, Double_t& min, Double_t& max);

      Int_t DefineDimensions();

      Int_t DefineBinsSize();

      Bool_t IsCompatibleData(TGo4FitData* data);

      void ApplyRangesForModelMask(TGo4FitComponent* model, Char_t* ModelMask);

      virtual void FillSlotList(TSeqCollection* list);

      virtual void Print(Option_t* option) const;

   protected:

      friend class TGo4FitModel;
      friend class TGo4Fitter;

      virtual Bool_t Initialize(Int_t UseBuffers = -1);

      virtual void Finalize();

      Bool_t BuffersAllocated() const { return (fxValues!=0) && (fxFullScale!=0); }

      Int_t GetBinsSize() const { return fiBinsSize; }

      Int_t GetScalesSize() const { return fiScalesSize; }

      Double_t* GetBinsValues() { return fxValues; }

      Double_t* GetBinsDevs() { return fxStandDev; }

      Double_t* GetBinsResult() { return fxBinsResult; }

      const Double_t* GetScaleValues(const Int_t nbin);

      const Double_t* GetWidthValues(const Int_t nbin);

      const Int_t* GetFullIndex(Int_t nbin);

      Int_t GetIndexesSize() const { return fiIndexesSize; }

      Int_t fiDataType;

      Bool_t fbUseBinScale;

      Int_t fiTakeSigmasFrom;

      Double_t fdSigmaValue;

      Double_t fdExcludeLessThen;


      TObjArray fxAxisTrans;

   private:

      void ResetAllPoinetrs();

      void ReleaseAllPointers();

      Int_t fiBinsSize;                       

      Int_t fiIndexesSize;                    

      Int_t fiScalesSize;                    

      Double_t* fxValues;                    

      Double_t* fxStandDev;                  

      Double_t* fxBinsResult;                

      Double_t* fxFullScale;                 

      Double_t* fxFullWidth;                 

      Int_t* fxFullIndex;                     

      /*#  TGo4FitAxisTrans AxisTrans; */

      /*#  TGo4FitSlot lnkTGo4FitData; */


    ClassDef(TGo4FitData,1)
};

class TGo4FitDataIter : public TObject {
   public:

      TGo4FitDataIter();

      virtual ~TGo4FitDataIter();

      virtual Bool_t Reset(Bool_t UseRanges = kTRUE);

      virtual Bool_t Next(Bool_t UseRanges = kTRUE);

      Bool_t HasIndexes() const { return IndexesSize() > 0; }

      Int_t IndexesSize() const { return fxIndexes.GetSize(); }

      const Int_t* Indexes() const { return fxIndexes.GetArray(); }

      Bool_t DefineIndexesLimits(TArrayI& Limits);

      Int_t ScalesSize() const { return fxScales.GetSize(); }

      const Double_t* Scales() const { return fxScales.GetSize() > 0 ? fxScales.GetArray() : 0; }

      Double_t x() const { return fxScales.GetSize() > 0 ? fxScales[0] : 0.; }

      Double_t y() const { return fxScales.GetSize() > 1 ? fxScales[1] : 0.; }

      Double_t z() const { return fxScales.GetSize() > 2 ? fxScales[2] : 0.; }

      Bool_t HasWidths() const { return fxWidths.GetSize() > 0; }

      const Double_t* Widths() const { return fxWidths.GetSize() > 0 ? fxWidths.GetArray() : 0; }
      
      Double_t xWidths() const;

      Double_t Value() const { return fdValue; }

      Double_t StandardDeviation() const { return fdStandardDeviation; }

      Int_t Point() const { return fiNumPoint; }

     Bool_t CheckPointForRange();

      Int_t CountPoints(Bool_t UseRanges = kTRUE);

      Bool_t ReachEnd() const { return fbReachEnd; }

      TH1* CreateHistogram(const char* HistoName, Bool_t UseRanges = kFALSE, Bool_t SetBins = kFALSE);

      TGraph* CreateGraph(const char* GraphName, Bool_t UseRanges = kFALSE, Bool_t SetBins = kFALSE);

      TObject* CreateDrawObject(const char* ObjName);

   protected:

     virtual TGo4FitData* GetData() const = 0;

     virtual Bool_t StartReset() = 0;

     virtual Bool_t ReadCurrentPoint() = 0;

     virtual Bool_t ShiftToNextPoint() = 0;

     Bool_t ReserveArrays(Int_t NumDimen, Int_t NumOwnAxis, Bool_t HasWidth);

     void TransformScales(Double_t* scales);

     Bool_t ProduceScales(const Int_t* index, const Double_t* ownscales, const Double_t* ownwidths);

     Bool_t NextIndex(TArrayI& Index, TArrayI& Limits);

     Bool_t GetDeviation();

     TArrayI fxIndexes;                     

     TArrayD fxScales;                      
     TArrayD fxWidths;                      
     Double_t fdValue;                      
     Double_t fdStandardDeviation;          

     Int_t fiNumPoint;                      

     Bool_t fbReachEnd;                     

   ClassDef(TGo4FitDataIter,1)
};


#endif // TGO4FITDATA_H

//----------------------------END OF GO4 SOURCE FILE ---------------------

---