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, k2GausSigmaRatioPar=2 };
  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 SetInitialSecondGaussianSigma(Double_t sigma) {fSigmaSgn2Gaus=sigma;}
  void SetInitialFrac2Gaus(Double_t frac) {fFrac2Gaus=frac;}
  void SetInitialRatio2GausSigma(Double_t fracsigma) {fRatio2GausSigma=fracsigma;}
  void SetFixGaussianMean(Double_t mean){
    SetInitialGaussianMean(mean); 
    fFixedMean=kTRUE;
  }
  void SetFixGaussianSigma(Double_t sigma){
    SetInitialGaussianSigma(sigma);
    fFixedSigma=kTRUE;
  }
  void SetFixSecondGaussianSigma(Double_t sigma){
    if(fTypeOfFit4Sgn!=k2Gaus) AliFatal("fTypeOfFit4Sgn should be set to k2Gaus to fix ratio between gaussians\n");
    SetInitialSecondGaussianSigma(sigma);
    fFixedSigma2Gaus=kTRUE;
  }
  void SetFixFrac2Gaus(Double_t frac){
    if(fTypeOfFit4Sgn!=k2Gaus && fTypeOfFit4Sgn!=k2GausSigmaRatioPar) AliFatal("fTypeOfFit4Sgn should be set to k2Gaus to fix relative integral of two gaussians\n");
    SetInitialFrac2Gaus(frac);
    fFixedFrac2Gaus=kTRUE;
  }
  void SetFixRatio2GausSigma(Double_t sigmafrac){
    if(fTypeOfFit4Sgn!=k2GausSigmaRatioPar) AliFatal("fTypeOfFit4Sgn should be set to k2GausSigmaRatioPar to fix ratio between gaussian sigmas\n");
    SetInitialRatio2GausSigma(sigmafrac);
    fFixedRatio2GausSigma=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;          
  Double_t  fSigmaSgn2Gaus;        
  Bool_t    fFixedMean;            
  Bool_t    fFixedSigma;           
  Bool_t    fFixedSigma2Gaus;      
  Double_t  fFixedRawYield;        
  Double_t  fFrac2Gaus;            
  Bool_t    fFixedFrac2Gaus;       
  Double_t  fRatio2GausSigma;       
  Bool_t    fFixedRatio2GausSigma;  
  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,5); 
};

#endif