TGo4FitData.h

Go to the documentation of this file.

// $Id$
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum fuer Schwerionenforschung GmbH
//                     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 "TGo4FitComponent.h"
 
#include "TArrayI.h"
#include "TArrayD.h"
#include <memory>
#include "RVersion.h"
 
#if ROOT_VERSION_CODE < ROOT_VERSION(6,26,0)
#include "ROOT/RMakeUnique.hxx"
#endif
 
class TH1;
class TGraph;
class TGo4FitSlot;
 
class TGo4FitAxisTrans;
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();

      Int_t GetDataType() const { return fiDataType; }

      Bool_t GetUseBinScale() const { return fbUseBinScale; }

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

      Bool_t CanAmplTouch() override { 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() const { return fxAxisTrans.GetLast()+1; }

      TGo4FitSlot *GetAxisTransSlot(Int_t nslot) const;

      TGo4FitAxisTrans *GetAxisTrans(Int_t nslot) const;

      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() const;

      virtual std::unique_ptr<TGo4FitDataIter> MakeIter() { return nullptr; }

      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);

      void FillSlotList(TSeqCollection *list) override;

      void Print(Option_t *option = "") const override;
 
   protected:
 
      friend class TGo4FitModel;
      friend class TGo4Fitter;

      virtual Bool_t Initialize(Int_t UseBuffers = -1);

      virtual void Finalize();

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

      Int_t GetBinsSize() const { return fiBinsSize; }

      Int_t GetScalesSize() const { return fiScalesSize; }

      Double_t *GetBinsValues() const { return fxValues; }

      Double_t *GetBinsDevs() const { return fxStandDev; }

      Double_t *GetBinsResult() const { return fxBinsResult; }

      const Double_t *GetScaleValues(Int_t nbin) const;

      const Double_t *GetWidthValues(Int_t nbin) const;

      const Int_t *GetFullIndex(Int_t nbin) const;

      Int_t GetIndexesSize() const { return fiIndexesSize; }

      Int_t fiDataType{0};

      Bool_t fbUseBinScale{kFALSE};

      Int_t fiTakeSigmasFrom{0};

      Double_t fdSigmaValue{0};

      Double_t fdExcludeLessThen{0};

      TObjArray fxAxisTrans;
 
   private:

      void ResetAllPoinetrs();

      void ReleaseAllPointers();

      Int_t fiBinsSize{0};                       

      Int_t fiIndexesSize{0};                    

      Int_t fiScalesSize{0};                    

      Double_t *fxValues{nullptr};                    

      Double_t *fxStandDev{nullptr};                  

      Double_t *fxBinsResult{nullptr};                

      Double_t *fxFullScale{nullptr};                 

      Double_t *fxFullWidth{nullptr};                 

      Int_t *fxFullIndex{nullptr};                     
 
    ClassDefOverride(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() : nullptr; }

      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() : nullptr; }

      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{0.};                  
     Double_t fdStandardDeviation{0.};      
 
     Int_t fiNumPoint{0};                   
 
     Bool_t fbReachEnd{kFALSE};             
 
   ClassDefOverride(TGo4FitDataIter,1)
};
 
 
#endif // TGO4FITDATA_H