TGo4FitModel.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 TGO4FITMODEL_H
#define TGO4FITMODEL_H
 
#include "TNamed.h"
#include "TGo4FitComponent.h"
 
class TGo4FitParameter;
class TGo4FitData;
class TGo4FitDataIter;

class TGo4FitAssignment : public TNamed {
    public:

       TGo4FitAssignment();

       TGo4FitAssignment(const char *DataName);

       virtual ~TGo4FitAssignment();
 
       Double_t RatioValue();

       void Print(Option_t *option = "") const override;

       TGo4FitParameter *fxRatio{nullptr};

       TGo4FitData *fxData{nullptr};         

       Char_t *fxModelMask{nullptr};         

       Double_t *fxModelBins{nullptr};       
 
    ClassDefOverride(TGo4FitAssignment,1);
};
 

class TGo4FitModel : public TGo4FitComponent {
   public:

      TGo4FitModel();

      TGo4FitModel(const char *iName, const char *iTitle, Bool_t MakeAmplitude = kFALSE);

      virtual ~TGo4FitModel();

      void SetGroupIndex(Int_t index = -1) { fiGroupIndex = index; }

      void SetBackgroundGroupIndex() { fiGroupIndex = 0; }

      Int_t GetGroupIndex() const { return fiGroupIndex; }

      Int_t NumAssigments() const { return fxAssigments.GetLast()+1; }

      const char *AssignmentName(Int_t n) { return GetAssigment(n) ? GetAssigment(n)->GetName() : nullptr; }

      void AssignToData(const char *DataName, Double_t RatioValue = 1., Bool_t FixRatio = kFALSE);

      Bool_t IsAssignTo(const char *DataName) const { return FindAssigment(DataName) != nullptr; }

      void ChangeDataNameInAssignments(const char *oldname, const char *newname);

      void ClearAssignmentTo(const char *DataName);
      void ClearAssigmentTo(const char *DataName) { ClearAssignmentTo(DataName); }

      void ClearAssignments();

      void ConnectToDataIfAssigned(TGo4FitData *data);

      Double_t GetRatioValueFor(const char *DataName);

      void Print(Option_t *option = "") const override;

      virtual Double_t Evaluate(Double_t x);

      virtual Double_t Evaluate(Double_t x, Double_t y);

      virtual Double_t Evaluate(Double_t x, Double_t y, Double_t z);

      virtual Double_t Evaluate(Double_t *v, Int_t ndim);

      virtual Double_t Integral();

      virtual Bool_t GetPosition(Int_t naxis, Double_t& pos);

      virtual Bool_t SetPosition(Int_t naxis, Double_t pos);

      virtual Bool_t GetWidth(Int_t naxis, Double_t& width);

      virtual Bool_t SetWidth(Int_t naxis, Double_t width);

      void SetIntegrationsProperty(Int_t iMinIntegrDepth, Int_t iMaxIntegrDepth = 0, Double_t iIntegrEps = 0., Bool_t iAbsoluteEps = kFALSE, Bool_t iIntegrScaling = kFALSE);

      Bool_t NeedIntegration() const { return (fiMinIntegrDepth > 0) || (fiMaxIntegrDepth > 0); }

      virtual Bool_t BeforeEval(Int_t ndim);

      virtual Double_t EvalN(const Double_t *v);

      virtual void AfterEval() {}

      virtual Double_t EvaluateAtPoint(TGo4FitData *data, Int_t nbin, Bool_t UseRanges = kTRUE);

      virtual Double_t EvaluateAtPoint(std::unique_ptr<TGo4FitDataIter> &iter, Bool_t UseRanges = kTRUE);

      Bool_t AddModelToDataResult(TGo4FitData *data);
 
      Int_t NumPars() override;
 
   protected:
 
      friend class TGo4Fitter;
 
 
      TGo4FitParameter *Get(Int_t n) override;

      Double_t EvaluateAndIntegrate(Int_t NumScales, const Double_t *Scales, const Double_t *Widths);

      virtual Bool_t Initialize(Int_t UseBuffers = -1);

      virtual void Finalize();

      TGo4FitData *GetAssignedConnection(Int_t n);

      Bool_t BuffersAllocated() const;

      void RebuildShape(Bool_t ForceBuild = kFALSE);

      Double_t *GetModelBins(const char *DataName) const;

      void SetNeedToRebuild() { fbNeedToRebuild = kTRUE; }

      virtual Double_t UserFunction(Double_t *, Double_t *) { return 0.; }

      virtual Int_t GetPosParIndex(Int_t) { return -1; }

      virtual Int_t GetWidthParIndex(Int_t) { return -1; }

      virtual TGo4FitParameter *GetPosPar(Int_t naxis = 0)
        { return Get(GetPosParIndex(naxis)); }

      virtual TGo4FitParameter *GetWidthPar(Int_t naxis = 0)
        { return Get(GetWidthParIndex(naxis)); }
 
      const Int_t *GetDataFullIndex(TGo4FitData *data, Int_t nbin);
      Int_t GetDataIndexesSize(TGo4FitData *data);

      Int_t fiMinIntegrDepth{0};

      Int_t fiMaxIntegrDepth{0};

      Double_t fdIntegrEps{0};

      Bool_t fbAbsoluteEps{kFALSE};

      Bool_t fbIntegrScaling{kFALSE};
 
   private:

      void RemoveAllPars();

      TGo4FitAssignment* GetAssigment(Int_t n) { return (TGo4FitAssignment*) fxAssigments[n]; }
      TGo4FitAssignment* GetAssigment(Int_t n) const { return (TGo4FitAssignment*) fxAssigments[n]; }

      TGo4FitAssignment* FindAssigment(const char *DataName) const;

      TString GetRatioName(Int_t n);

      TObjArray fxAssigments;

      Int_t fiGroupIndex{0};

      TArrayD fxCurrentPars;            

      Double_t *fxCurrentParsArray{nullptr};     

      Bool_t fbNeedToRebuild{kFALSE};                 

      TGo4FitParsList* fxAllPars{nullptr};              
 
      TArrayD* fxAllParsValues{nullptr};                
 
   ClassDefOverride(TGo4FitModel,1)
};
 
#endif // TGO4FITMODEL_H