TGo4FitModel.h

Go to the documentation of this file.

// $Id: TGo4FitModel.h 1927 2016-06-30 08:03:38Z linev $
//-----------------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//         Experiment Data Processing at EE department, GSI
//-----------------------------------------------------------------------
// Copyright (C) 2000- GSI Helmholtzzentrum für 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();

       virtual void Print(Option_t* option) const;

       TGo4FitParameter* fxRatio;

       TGo4FitData* fxData;         

       Char_t* fxModelMask;         

       Double_t* fxModelBins;       

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

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

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

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

      virtual void Print(Option_t* option) const;

      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() { return (fiMinIntegrDepth>0) || (fiMaxIntegrDepth>0); }

      virtual Bool_t BeforeEval(Int_t ndim);

      virtual Double_t EvalN(const Double_t* v);

      virtual void AfterEval() { return; }

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

      virtual Double_t EvaluateAtPoint(TGo4FitDataIter* iter, Bool_t UseRanges = kTRUE);

      Bool_t AddModelToDataResult(TGo4FitData* data);

      virtual Int_t NumPars();

   protected:

      friend class TGo4Fitter;


      virtual TGo4FitParameter* Get(Int_t n);

      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;

      Int_t fiMaxIntegrDepth;

      Double_t fdIntegrEps;

      Bool_t fbAbsoluteEps;

      Bool_t fbIntegrScaling;

   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;

      TArrayD fxCurrentPars;            

      Double_t* fxCurrentParsArray;     

      Bool_t fbNeedToRebuild;                 

      TGo4FitParsList* fxAllPars;              

      TArrayD* fxAllParsValues;                

   ClassDef(TGo4FitModel,1)
};

#endif // TGO4FITMODEL_H