FdDoubleBumpFinderKG/ProfileFitter.h

Go to the documentation of this file.

#ifndef _FdDoubleBumpFinderKG_ProfileFitter_h_
#define _FdDoubleBumpFinderKG_ProfileFitter_h_

#include "ProfileFitFunctions.h"

#include <vector>
#include <cstddef>

class TMinuit;

namespace profileFit {

  class ProfileFitter {
    
    
  public:
    
    ProfileFitter();
    ~ProfileFitter();
    
    void SetVerbosity(int v) { fVerbosity=v; }

    void SetFunctionType(EFitFunctionType type) 
    { fFunctionType = type; }
    
    // size threshold for fit
    void SetThreshold(double t) { fThreshold=t; }
    // variance of size values
    void SetVariance(double v) { fVariance=v; }

    const std::vector<double>& GetFitParameters() const
    { return fFitParameters; }
    const std::vector<double>& GetFitErrors() const
    { return fFitErrors; }
    double GetChi2() const { return fChi2; }
    unsigned int GetNdf() const { return fNdof; }
    int GetStatus() const { return fStatus;}

    bool Fit();

    void SetStartParameters(const std::vector<double> & start,
                            const std::vector<double> & step) {
      fStartParameters = start;
      fStepParameters  = step;
      fLimitsUp.clear();
      fLimitsDown.clear();
    }

    void SetStartParameters(const std::vector<double> & start,
                            const std::vector<double> & step,
                            const std::vector<double> & limitsDown,
                            const std::vector<double> & limitsUp) {
      fStartParameters = start;
      fStepParameters  = step;
      fLimitsUp = limitsUp;
      fLimitsDown = limitsDown;
    }

    template<typename T>
      void SetData(const int n,
                   const T* depth,
                   const T* size,
                   const T* sizeError=0) {
      fDepth.resize(n);
      fSize.resize(n);
      copy(depth,depth+n,fDepth.begin());
      copy(size,size+n,fSize.begin());
      if ( sizeError ) {
        fSizeError.resize(n);
        copy(sizeError,sizeError+n,fSizeError.begin());
      }
      else
        fSizeError.clear();

    }
    
  private:

    bool GHFit();
    bool DoubleGHFit();
    bool GaussInAgeFit();
    std::pair<double, double> FindMaximum() const;
    void InitMinuit(TMinuit&) const;
    bool Minimize(TMinuit&);
    void UserStartInit(TMinuit& theMinuit);

    static void GHFitFunction(int&,double* const,double&, 
                              double* const, const int);
    static void DoubleGHFitFunction(int&,double* const,double&, 
                                    double* const, const int);
    static void GaussInAgeFitFunction(int&,double* const,double&, 
                                      double* const, const int);

    int fVerbosity;
    double fChi2;
    int fStatus;

    static unsigned int fNdof;
    static double fVariance;
    static double fThreshold;
    static EFitFunctionType fFunctionType;
    static std::vector<double> fDepth;
    static std::vector<double> fSize;
    static std::vector<double> fSizeError;
    static bool fIsConstrained;
    std::vector<double> fFitParameters;
    std::vector<double> fFitErrors;
    std::vector<double> fStartParameters;
    std::vector<double> fStepParameters;
    std::vector<double> fLimitsUp;
    std::vector<double> fLimitsDown;
    
  };
}
#endif