AliHFInvMassFitter.h

Go to the documentation of this file.

#ifndef ALIHFINVMASSFITTER_H
#define ALIHFINVMASSFITTER_H

/* Copyright(c) 1998-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */




#include <TNamed.h>
#include "AliLog.h"

class TF1;
class TH1F;

class AliHFInvMassFitter : public TNamed {
 public:

  enum ETypeOfBkg{ kExpo=0, kLin=1, kPol2=2, kNoBk=3, kPow=4, kPowEx=5};
  enum ETypeOfSgn{ kGaus=0, k2Gaus=1  };
  AliHFInvMassFitter();
  AliHFInvMassFitter(const TH1F* histoToFit, Double_t minvalue, Double_t maxvalue, Int_t fittypeb=kExpo, Int_t fittypes=kGaus);
  ~AliHFInvMassFitter();

  void     SetHistogramFit(const TH1F* histoToFit){
    if (fHistoInvMass) delete fHistoInvMass;
    fHistoInvMass=(TH1F*)histoToFit->Clone("fHistoInvMass");
    fHistoInvMass->SetDirectory(0);
  }
  void     SetRangeFit(Double_t minvalue, Double_t maxvalue){
    fMinMass=minvalue; fMaxMass=maxvalue;
  }   
  void     SetFitFunctions(Int_t fittypeb, Int_t fittypes){
    fTypeOfFit4Bkg=fittypeb; fTypeOfFit4Sgn=fittypes;
    SetNumberOfParams();
  }

  void SetUseLikelihoodFit(){fFitOption="L,E";}
  void SetUseLikelihoodWithWeightsFit(){fFitOption="WL,E";}
  void SetUseChi2Fit(){fFitOption="E";}
  void SetFitOption(TString opt){fFitOption=opt.Data();};
  void SetParticlePdgMass(Double_t mass){fMassParticle=mass;}
  Double_t GetParticlePdgMass(){return fMassParticle;}
  void SetPolDegreeForBackgroundFit(Int_t deg){
    if(fTypeOfFit4Bkg!=6) AliFatal("fTypeOfFit4Bkg should be set to 6 to use higher order polynomials\n");
    fPolDegreeBkg=deg;
    SetNumberOfParams();
  }
  void SetInitialGaussianMean(Double_t mean) {fMass=mean;} 
  void SetInitialGaussianSigma(Double_t sigma) {fSigmaSgn=sigma;} 
  void SetFixGaussianMean(Double_t mean){
    SetInitialGaussianMean(mean); 
    fFixedMean=kTRUE;
  }
  void SetFixGaussianSigma(Double_t sigma){
    SetInitialGaussianSigma(sigma); 
    fFixedSigma=kTRUE;
  }
  void SetFixSignalYield(Double_t yield){
    fFixedRawYield=yield;
  }
  void SetNSigma4SideBands(Double_t ns=4.){
    fNSigma4SideBands=ns;
  }
  TH1F* SetTemplateReflections(const TH1 *h, TString opt,Double_t minRange,Double_t maxRange);
  void SetInitialReflOverS(Double_t rovers){fRflOverSig=rovers;}
  void     SetFixReflOverS(Double_t rovers){
    SetInitialReflOverS(rovers);
    fFixRflOverSig=kTRUE;
  }
  void SetSmoothReflectionTemplate(Bool_t opt){fSmoothRfl=opt;}

  void IncludeSecondGausPeak(Double_t mass, Bool_t fixm, Double_t width, Bool_t fixw){
    fSecondPeak=kTRUE; fSecMass=mass; fSecWidth=width;
    fFixSecMass=fixm;  fFixSecWidth=fixw;
  }
  Double_t GetRawYield()const {return fRawYield;}
  Double_t GetRawYieldError()const {return fRawYieldErr;}
  Double_t GetMean() const {return fMass;}
  Double_t GetMeanUncertainty() const {return fMassErr;}
  Double_t GetSigma()const {return fSigmaSgn;}
  Double_t GetSigmaUncertainty()const { return fSigmaSgnErr;}
  Double_t GetReflOverSig()const{
    if(fRflFunc) return fRflFunc->GetParameter(0);
    else return 0;
  }
  Double_t GetReflOverSigUncertainty()const{
    if(fRflFunc) return fRflFunc->GetParError(0);
    else return 0;
  }
  TF1*     GetBackgroundFullRangeFunc(){return fBkgFunc;}
  TF1*     GetBackgroundRecalcFunc(){return fBkgFuncRefit;}
  TF1*     GetBkgPlusReflFunc(){return fBkRFunc;}
  TF1*     GetSignalFunc(){return fSigFunc;}
  TF1*     GetMassFunc(){return fTotFunc;}
  Double_t GetChiSquare() const{
    if(fTotFunc) return fTotFunc->GetChisquare();
    else return -1;
  }
  Double_t GetReducedChiSquare() const{
    if(fTotFunc) return fTotFunc->GetChisquare()/fTotFunc->GetNDF();
    else return -1;
  }
  Double_t GetFitProbability() const{
    if(fTotFunc) return fTotFunc->GetProb();
    else return -1;
  }
  TH1F*    GetHistoClone() const{
    TH1F* hout=(TH1F*)fHistoInvMass->Clone(Form("%scloned",fHistoInvMass->GetName()));
    return hout;
  }
  Double_t GetRawYieldBinCounting(Double_t& errRyBC, Double_t nSigma=3., Int_t option=0, Int_t pdgCode=0) const;
  Double_t GetRawYieldBinCounting(Double_t& errRyBC, Double_t minMass, Double_t maxMass, Int_t option=0) const;
  Int_t   MassFitter(Bool_t draw=kTRUE);
  Double_t FitFunction4Sgn (Double_t* x, Double_t* par);
  Double_t FitFunction4Bkg (Double_t* x, Double_t* par);
  Double_t FitFunction4Refl(Double_t *x,Double_t *par);
  Double_t FitFunction4BkgAndRefl(Double_t *x,Double_t *par);
  Double_t FitFunction4SecPeak (Double_t* x, Double_t* par);
  Double_t FitFunction4Mass (Double_t* x, Double_t* par);
  virtual  void     Signal(Double_t nOfSigma,Double_t &signal,Double_t &errsignal) const;
  virtual  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 DrawHere(TVirtualPad* c, Double_t nsigma=3,Int_t writeFitInfo=1);
  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;
  TH1F* GetResidualsAndPulls(TH1 *hPulls=0x0,TH1 *hResidualTrend=0x0,TH1 *hPullsTrend=0x0,Double_t minrange=0,Double_t maxrange=-1);
  void PrintFunctions();

 private:
  AliHFInvMassFitter(const AliHFInvMassFitter &source);
  AliHFInvMassFitter& operator=(const AliHFInvMassFitter& source); 

  void  SetNumberOfParams();
  Double_t  CheckForSignal(Double_t mean, Double_t sigma);
  TF1*  CreateBackgroundFitFunction(TString fname, Double_t integral);
  TF1*  CreateSignalFitFunction(TString fname, Double_t integral);
  TF1*  CreateSecondPeakFunction(TString fname, Double_t integral);
  TF1* CreateReflectionFunction(TString fname);
  TF1* CreateBackgroundPlusReflectionFunction(TString fname);
  TF1* CreateTotalFitFunction(TString fname);
  Bool_t PrepareHighPolFit(TF1 *fback);
  Double_t BackFitFuncPolHelper(Double_t *x,Double_t *par);

  void DrawFit();

  TH1F*     fHistoInvMass;     
  Double_t  fMinMass;          
  Double_t  fMaxMass;          
  Int_t     fTypeOfFit4Bkg;    
  Int_t     fPolDegreeBkg;     
  Int_t     fCurPolDegreeBkg;  
  Double_t  fMassParticle;     
  Int_t     fTypeOfFit4Sgn;    
  Double_t  fMass;             
  Double_t  fMassErr;          
  Double_t  fSigmaSgn;         
  Double_t  fSigmaSgnErr;      
  Bool_t    fFixedMean;        
  Bool_t    fFixedSigma;       
  Double_t  fFixedRawYield;    
  Int_t     fNParsSig;         
  Int_t     fNParsBkg;         
  Bool_t    fOnlySideBands;    
  Double_t  fNSigma4SideBands; 
  TString   fFitOption;        
  Double_t  fRawYield;         
  Double_t  fRawYieldErr;      
  TF1*      fSigFunc;          
  TF1*      fBkgFuncSb;        
  TF1*      fBkgFunc;          
  TF1*      fBkgFuncRefit;     
  Bool_t    fReflections;      
  Int_t     fNParsRfl;         
  Double_t  fRflOverSig;       
  Bool_t    fFixRflOverSig;    
  TH1F*     fHistoTemplRfl;    
  Bool_t    fSmoothRfl;        
  Double_t  fRawYieldHelp;     
  TF1*      fRflFunc;          
  TF1*      fBkRFunc;          
  Bool_t    fSecondPeak;       
  Int_t     fNParsSec          ;
  Double_t  fSecMass;          
  Double_t  fSecWidth;         
  Bool_t    fFixSecMass;       
  Bool_t    fFixSecWidth;      
  TF1*      fSecFunc;          
  TF1*      fTotFunc;          

  ClassDef(AliHFInvMassFitter,3); 
};

#endif