AliHFVnVsMassFitter.h

Go to the documentation of this file.

#ifndef ALIHFVNVSMASSFITTER_H
#define ALIHFVNVSMASSFITTER_H

#include <TObject.h>
#include <Riostream.h>
#include <TVirtualPad.h>
#include <TH1F.h>
#include "Fit/Fitter.h"
#include "Fit/Chi2FCN.h"
#include "Math/WrappedMultiTF1.h"
#include "AliHFInvMassFitter.h"

class AliHFVnVsMassFitter : public TObject {

public:
  AliHFVnVsMassFitter();
  AliHFVnVsMassFitter(TH1F* hMass, TH1F* hvn, Double_t min, Double_t max, Int_t funcMassBkg, Int_t funcMassSgn, Int_t funcvnBkg);
  ~AliHFVnVsMassFitter();

  enum ETypeOfBkg{kExpo=0, kLin=1, kPol2=2, kNoBk=3, kPow=4, kPowEx=5, kPoln=6};
  enum ETypeOfSgn{kGaus=0, k2Gaus=1};
  enum ETypeOfVnRfl{kSameVnSignal=0, kOppVnSignal=1, kSameVnBkg=2, kFreePar=3};

  Bool_t SimultaneusFit(Bool_t drawFit=kTRUE);
  void DrawHere(TVirtualPad* c);

  //setters
  void SetInitialGaussianSigma(Double_t sigma, Int_t opt) {fSigmaInit=sigma; fSigmaFixed=opt;}
  void SetInitialGaussianMean(Double_t mean, Int_t opt) {fMeanInit=mean; fMeanFixed=opt;}
  void SetInitialGaussianSigma2Gaus(Double_t sigma, Int_t opt) {fSigma2GausInit=sigma; fSigma2GausFixed=opt;}
  void SetInitialFrac2Gaus(Double_t frac, Int_t opt) {fFrac2GausInit=frac; fFrac2GausFixed=opt;}
  void SetParticlePdgMass(Double_t mass){fMassParticle=mass;}
  void SetMassSgnFunc(Int_t functype) {fMassSgnFuncType=functype;}
  void SetMassBkgFunc(Int_t functype) {fMassBkgFuncType=functype;}
  void SetVnBkgFunc(Int_t functype) {fVnBkgFuncType=functype;}
  void FixSigmaFromMassFit() {fSigmaFixedFromMassFit=kTRUE;}
  void FixMeanFromMassFit() {fMeanFixedFromMassFit=kTRUE;}
  void FixSigma2GausFromMassFit() {fSigma2GausFixedFromMassFit=kTRUE;}
  void FixFrac2GausFromMassFit() {fFrac2GausFixedFromMassFit=kTRUE;}
  void SetNSigmaForVnSB(Int_t nsigma=4) {fNSigmaForSB=nsigma;}
  void SetPolDegreeForBackgroundFit(Int_t deg){
    if(fMassBkgFuncType!=6) AliFatal("fMassBkgFuncType should be set to 6 to use higher order polynomials\n");
    fPolDegreeBkg=deg;
  }
  void SetPolDegreeForVnBackgroundFit(Int_t deg){
    if(fVnBkgFuncType!=6) AliFatal("fVnBkgFuncType should be set to 6 to use higher order polynomials\n");
    fPolDegreeVnBkg=deg;
  }
  void SetTemplateReflections(const TH1 *h, TString opt, Double_t minRange, Double_t maxRange) {
    fHistoTemplRflInit=(TH1F*)h->Clone();
    fRflOpt=opt;
    fMinRefl=minRange;
    fMaxRefl=maxRange;
    fReflections=kTRUE;
  }
  void SetInitialReflOverS(Double_t rovers){fRflOverSig=rovers;}
  void SetFixReflOverS(Double_t rovers){
    SetInitialReflOverS(rovers);
    fFixRflOverSig=kTRUE;
  }
  void SetReflVnOption(Int_t opt) {fVnRflOpt=opt;}
  void SetReflVnParLimits(Double_t min, Double_t max) {
    fVnRflLimited=kTRUE;
    fVnRflMin=min;
    fVnRflMax=max;
  }
  void IncludeSecondGausPeak(Double_t mass, Bool_t fixm, Double_t width, Bool_t fixw, Bool_t doVn){
    fSecondPeak=kTRUE; fSecMass=mass; fSecWidth=width;
    fFixSecMass=fixm;  fFixSecWidth=fixw;
    fDoSecondPeakVn=doVn;
  }
  void SetHarmonic(Int_t harmonic=2) {fHarmonic=harmonic;}

  //getters
  Double_t GetVn() const {return fVn;}
  Double_t GetVnUncertainty() const {return fVnUncertainty;}
  Double_t GetMean() const {return fMean;}
  Double_t GetMeanUncertainty() const {return fMeanUncertainty;}
  Double_t GetSigma() const {return fSigma;}
  Double_t GetSigmaUncertainty() const {return fSigmaUncertainty;}
  Double_t GetRawYield() const {return fRawYield;}
  Double_t GetRawYieldUncertainty() const {return fRawYieldUncertainty;}
  Double_t GetChiSquare() const {return fChiSquare;}
  Int_t GetNDF() const {return fNDF;}
  Double_t GetReducedChiSquare() const {return fChiSquare/fNDF;}
  Double_t GetFitProbability() const {return fProb;}
  Double_t GetParticlePdgMass() const {return fMassParticle;}
  TH1F* GetTemplateReflections() {
    if(fHistoTemplRfl) {return (TH1F*)fHistoTemplRfl->Clone();}
    else if(fHistoTemplRflInit) {return (TH1F*)fHistoTemplRflInit->Clone();}
    else {return 0;}
  }
  void Signal(Double_t nOfSigma,Double_t &signal,Double_t &errsignal) const;
  void Signal(Double_t min,Double_t max,Double_t &signal,Double_t &errsignal) const;
  void Background(Double_t nOfSigma, Double_t &background,Double_t &errbackground) const;
  void Background(Double_t min, Double_t max, Double_t &background,Double_t &errbackground) const;
  void Significance(Double_t nOfSigma, Double_t &significance,Double_t &errsignificance) const;
  void Significance(Double_t min, Double_t max, Double_t &significance,Double_t &errsignificance) const;
  TF1* GetMassTotFitFunc() {
    if(fMassTotFunc) return fMassTotFunc;
    else return 0x0;
  }
  TF1* GetVnVsMassTotFitFunc() {
    if(fVnTotFunc) return fVnTotFunc;
    else return 0x0;
  }

  //struct for global chi2 (for simultaneus fit)
  struct AliHFGlobalChi2 {
    AliHFGlobalChi2(ROOT::Math::IMultiGenFunction & f1,ROOT::Math::IMultiGenFunction & f2) : fChi2_1(&f1), fChi2_2(&f2) {}

    double operator() (const double *par) const {
        return (*fChi2_1)(par) + (*fChi2_2)(par);
    }
    const  ROOT::Math::IMultiGenFunction * fChi2_1;
    const  ROOT::Math::IMultiGenFunction * fChi2_2;
  };

private:

  Double_t GetGausPDF(Double_t x, Double_t mean, Double_t sigma);
  Double_t GetExpoPDF(Double_t x, Double_t slope, Bool_t isnorm=kTRUE);
  Double_t GetPolPDF(Double_t x, Double_t *pars, Int_t order, Bool_t isnorm=kTRUE);
  Double_t GetPowerFuncPDF(Double_t x, Double_t *pars);
  Double_t GetPowerExpoPDF(Double_t x, Double_t *pars);
  Double_t GetHigherPolFuncPDF(Double_t x, Double_t *pars, Int_t Ndeg, Bool_t isnorm=kTRUE);
  Double_t MassSignal(Double_t *m, Double_t *pars);
  Double_t MassBkg(Double_t *m, Double_t *pars);
  Double_t MassRfl(Double_t *m,Double_t *par);
  Double_t MassBkgRfl(Double_t *m,Double_t *par);
  Double_t MassSecondPeak(Double_t *m,Double_t *par);
  Double_t vnBkgFunc(Double_t *m, Double_t *pars);
  Double_t MassFunc(Double_t *m, Double_t *pars);
  Double_t vnFunc(Double_t *m, Double_t *pars);

  void DefineNumberOfParameters();
  Bool_t MassPrefit();
  Bool_t VnSBPrefit();
  void DrawFit();
  void SetParNames();

  TH1F*               fMassHisto;                   
  TH1F*               fVnVsMassHisto;               
  Int_t               fMassSgnFuncType;             
  Int_t               fMassBkgFuncType;             
  Int_t               fVnBkgFuncType;               
  TF1*                fMassFuncFromPrefit;          
  TF1*                fMassBkgFunc;                 
  TF1*                fMassSgnFunc;                 
  TF1*                fMassTotFunc;                 
  TF1*                fVnBkgFuncSb;                 
  TF1*                fVnBkgFunc;                   
  TF1*                fVnTotFunc;                   
  AliHFInvMassFitter* fMassFitter;                  
  Double_t            fMassMin;                     
  Double_t            fMassMax;                     
  Double_t            fVn;                          
  Double_t            fVnUncertainty;               
  Double_t            fSigma;                       
  Double_t            fSigmaUncertainty;            
  Double_t            fMean;                        
  Double_t            fMeanUncertainty;             
  Double_t            fRawYield;                    
  Double_t            fRawYieldUncertainty;         
  Double_t            fChiSquare;                   
  Int_t               fNDF;                         
  Double_t            fProb;                        
  Int_t               fNSigmaForSB;                 
  Double_t            fSigmaInit;                   
  Double_t            fMeanInit;                    
  Double_t            fSigma2GausInit;              
  Double_t            fFrac2GausInit;               
  Bool_t              fMeanFixedFromMassFit;        
  Bool_t              fSigmaFixedFromMassFit;       
  Bool_t              fSigma2GausFixedFromMassFit;  
  Bool_t              fFrac2GausFixedFromMassFit;   
  Double_t            fMassParticle;                
  Int_t               fNParsMassSgn;                
  Int_t               fNParsMassBkg;                
  Int_t               fNParsVnBkg;                  
  Int_t               fNParsVnSgn;                  
  Int_t               fNParsVnSecPeak;              
  Int_t               fNParsVnRfl;                  
  Int_t               fSigmaFixed;                  
  Int_t               fMeanFixed;                   
  Int_t               fSigma2GausFixed;             
  Int_t               fFrac2GausFixed;              
  Int_t               fPolDegreeBkg;                
  Int_t               fPolDegreeVnBkg;              
  Bool_t              fReflections;                 
  Int_t               fNParsRfl;                    
  Double_t            fRflOverSig;                  
  Bool_t              fFixRflOverSig;               
  TH1F*               fHistoTemplRfl;               
  TH1F*               fHistoTemplRflInit;           
  TF1*                fMassRflFunc;                 
  TF1*                fMassBkgRflFunc;              
  TString             fRflOpt;                      
  Double_t            fMinRefl;                     
  Double_t            fMaxRefl;                     
  Bool_t              fSmoothRfl;                   
  Double_t            fRawYieldHelp;                
  Int_t               fVnRflOpt;                    
  Bool_t              fVnRflLimited;                
  Double_t            fVnRflMin;                    
  Double_t            fVnRflMax;                    
  Bool_t              fSecondPeak;                  
  TF1*                fMassSecPeakFunc;             
  Int_t               fNParsSec;                    
  Double_t            fSecMass;                     
  Double_t            fSecWidth;                    
  Bool_t              fFixSecMass;                  
  Bool_t              fFixSecWidth;                 
  Double_t            fVnSecPeak;                   
  Bool_t              fDoSecondPeakVn;              
  Double_t            fVnSecPeakUncertainty;        
  Int_t               fHarmonic;                    

  ClassDef(AliHFVnVsMassFitter,4);
};
#endif //ALIHFVNVSMASSFITTER