AliHFInvMassMultiTrialFit.h

Go to the documentation of this file.

#ifndef ALIHFINVMASSMULTITRIALFIT_H
#define ALIHFINVMASSMULTITRIALFIT_H
/* Copyright(c) 2008-2019, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

#include <TNamed.h>
#include <TString.h>
#include <TPad.h>
#include <set>
#include <vector>

class TNtuple;
class AliHFInvMassFitter;


class AliHFInvMassMultiTrialFit : public TNamed {

 public:
  AliHFInvMassMultiTrialFit();
  virtual ~AliHFInvMassMultiTrialFit();

  void ConfigureRebinSteps(Int_t nSteps, Int_t*  values){
    if(fRebinSteps) delete [] fRebinSteps;
    fNumOfRebinSteps=nSteps;
    fRebinSteps = new Int_t[fNumOfRebinSteps];
    for(Int_t ib=0; ib<fNumOfRebinSteps; ib++) fRebinSteps[ib]=values[ib];
  }

  void SetNumOfFirstBinSteps(Int_t nfst){
    fNumOfFirstBinSteps=nfst;
  }

  void ConfigureLowLimFitSteps(Int_t nSteps, Double_t*  values){
    if(fLowLimFitSteps) delete [] fLowLimFitSteps;
    fNumOfLowLimFitSteps=nSteps;
    fLowLimFitSteps = new Double_t[fNumOfLowLimFitSteps];
    for(Int_t ib=0; ib<fNumOfLowLimFitSteps; ib++) fLowLimFitSteps[ib]=values[ib];
  }

  void ConfigureUpLimFitSteps(Int_t nSteps, Double_t*  values){
    if(fUpLimFitSteps) delete [] fUpLimFitSteps;
    fNumOfUpLimFitSteps=nSteps;
    fUpLimFitSteps = new Double_t[fNumOfUpLimFitSteps];
    for(Int_t ib=0; ib<fNumOfUpLimFitSteps; ib++) fUpLimFitSteps[ib]=values[ib];
  }

  void ConfigurenSigmaBinCSteps(Int_t nSteps, Double_t*  values){
    if(fnSigmaBinCSteps) delete [] fnSigmaBinCSteps;
    fNumOfnSigmaBinCSteps=nSteps;
    fnSigmaBinCSteps = new Double_t[fNumOfnSigmaBinCSteps];
    for(Int_t ib=0; ib<fNumOfnSigmaBinCSteps; ib++) fnSigmaBinCSteps[ib]=values[ib];
  }

  void GetGlobalMinMaxYield(Double_t& min, Double_t& max) {
    min = fMinYieldGlob;
    max = fMaxYieldGlob;
  }
  TNtuple* GetNtupleMultiTrials(){return fNtupleMultiTrials;}
  TNtuple* GetNtupleBinCounting(){return fNtupleBinCount;}

  void SetMass(Double_t mass){fMassD=mass;}
  void SetSigmaGaussMC(Double_t sig){fSigmaGausMC=sig;}
  void SetSigmaMCVariation(Double_t var=0.15){fSigmaMCVariation=var;}

  void SetSuffixForHistoNames(const Char_t* name){
    fSuffix=name;
  }
  void SetUseChi2Fit(){fFitOption=1;}
  void SetUseLogLikelihoodFit(){fFitOption=0;}


  void SetUseExpoBackground(Bool_t opt=kTRUE){fUseExpoBkg=opt;}
  void SetUseLinBackground(Bool_t opt=kTRUE){fUseLinBkg=opt;}
  void SetUsePol2Background(Bool_t opt=kTRUE){fUsePol2Bkg=opt;}
  void SetUsePol3Background(Bool_t opt=kTRUE){fUsePol3Bkg=opt;}
  void SetUsePol4Background(Bool_t opt=kTRUE){fUsePol4Bkg=opt;}
  void SetUsePol5Background(Bool_t opt=kTRUE){fUsePol5Bkg=opt;}
  void SetUsePowerLawBackground(Bool_t opt=kTRUE){fUsePowLawBkg=opt;}
  void SetUsePowerLawTimesExpoBackground(Bool_t opt=kTRUE){fUsePowLawTimesExpoBkg=opt;}

  void SetUse2GausSignal(Bool_t opt=kTRUE, Double_t fixsig=-1., Double_t fixfrac=-1.){
    fUse2GausSignal=opt;
    fFixSecondGausSig=fixsig;
    fFixSecondGausFrac=fixfrac;
  }
  void SetUse2GausSigmaRatioSignal(Bool_t opt=kTRUE, Double_t fixrat=-1., Double_t fixfrac=-1.){
    fUse2GausSigmaRatioSignal=opt;
    fFixSecondGausSigRat=fixrat;
    fFixSecondGausFrac=fixfrac;
  }

  void SetUseFixSigUpFreeMean(Bool_t opt=kTRUE) {fUseFixSigUpFreeMean=opt;}
  void SetUseFixSigDownFreeMean(Bool_t opt=kTRUE) {fUseFixSigDownFreeMean=opt;}
  void SetUseFreeS(Bool_t opt=kTRUE) {fUseFreeS=opt;}
  void SetUseFixedMeanFreeS(Bool_t opt=kTRUE) {fUseFixedMeanFreeS=opt;}
  void SetUseFixSigFreeMean(Bool_t opt=kTRUE) {fUseFixSigFreeMean=opt;}
  void SetUseFixSigFixMean(Bool_t opt=kTRUE) {fUseFixSigFixMean=opt;}

  void SetSaveBkgValue(Bool_t opt=kTRUE, Double_t nsigma=3) {fSaveBkgVal=opt; fnSigmaForBkgEval=nsigma;}

  void SetDrawIndividualFits(Bool_t opt=kTRUE){fDrawIndividualFits=opt;}

  Bool_t DoMultiTrials(TH1D* hInvMassHisto, TPad* thePad=0x0);
  void SaveToRoot(TString fileName, TString option="recreate") const;
  void DrawHistos(TCanvas* cry) const;
  void SetTemplatesForReflections(const TH1F *hTemplRefl, const TH1F *hTemplSig);

  void SetFixRefoS(Float_t refloS){fFixRefloS=refloS;}

  void IncludeSecondGausPeak(Double_t mass, Bool_t fixm, Double_t width, Bool_t fixw){
    fUseSecondPeak=kTRUE;
    fMassSecondPeak=mass;   fFixMassSecondPeak=fixm;
    fSigmaSecondPeak=width; fFixSigmaSecondPeak=fixw;
  }

  void AddInvMassFitSaveAsFormat(std::string format) { fInvMassFitSaveAsFormats.insert(format); }
  void DisableInvMassFitSaveAs() { fInvMassFitSaveAsFormats.clear(); }


  enum EBkgFuncCases{ kExpoBkg, kLinBkg, kPol2Bkg, kPol3Bkg, kPol4Bkg, kPol5Bkg, kPowBkg, kPowTimesExpoBkg, kNBkgFuncCases };
  enum EFitParamCases{ kFixSigFreeMean, kFixSigUpFreeMean, kFixSigDownFreeMean, kFreeSigFreeMean, kFixSigFixMean, kFreeSigFixMean, kNFitConfCases};
  enum ESigFuncCases{ kGaus, k2Gaus, k2GausSigmaRatioPar, kNSigFuncCases};

 private:

  Bool_t CreateHistos();
  Bool_t DoFitWithPol3Bkg(TH1F* histoToFit, Double_t  hmin, Double_t  hmax,
        Int_t theCase);

  AliHFInvMassMultiTrialFit(const AliHFInvMassMultiTrialFit &source);
  AliHFInvMassMultiTrialFit& operator=(const AliHFInvMassMultiTrialFit& source);

  std::set<std::string> fInvMassFitSaveAsFormats; 
  Int_t fNumOfRebinSteps; 
  Int_t* fRebinSteps;     //[fNumOfRebinSteps] values of rebin
  Int_t fNumOfFirstBinSteps; 
  Int_t fNumOfLowLimFitSteps; 
  Double_t* fLowLimFitSteps; //[fNumOfLowLimFitSteps] values of low limits for fit
  Int_t fNumOfUpLimFitSteps; 
  Double_t* fUpLimFitSteps; //[fNumOfUpLimFitSteps] values of up limits for fit
  Int_t fNumOfnSigmaBinCSteps; 
  Double_t* fnSigmaBinCSteps; //[fNumOfnSigmaBinCSteps] values of nsigma for bin count
  Double_t fnSigmaForBkgEval; //value of sigma in which to extract bkg value

  Double_t fSigmaGausMC; 
  Double_t fSigmaMCVariation; 
  Double_t fMassD;       
  TString fSuffix;       
  Int_t fFitOption;      
  Bool_t fUseExpoBkg;    
  Bool_t fUseLinBkg;    
  Bool_t fUsePol2Bkg;    
  Bool_t fUsePol3Bkg;    
  Bool_t fUsePol4Bkg;    
  Bool_t fUsePol5Bkg;    
  Bool_t fUsePowLawBkg;  
  Bool_t fUsePowLawTimesExpoBkg;  
  Bool_t fUse2GausSignal;   
  Bool_t fUse2GausSigmaRatioSignal;   
  Double_t fFixSecondGausSig;     
  Double_t fFixSecondGausFrac;    
  Double_t fFixSecondGausSigRat;  
  Bool_t fUseFixSigUpFreeMean;    
  Bool_t fUseFixSigDownFreeMean;  
  Bool_t fUseFreeS;              
  Bool_t fUseFixedMeanFreeS;     
  Bool_t fUseFixSigFreeMean;     
  Bool_t fUseFixSigFixMean;      

  Bool_t   fUseSecondPeak;      
  Double_t fMassSecondPeak;     
  Double_t fSigmaSecondPeak;    
  Bool_t   fFixMassSecondPeak;  
  Bool_t   fFixSigmaSecondPeak; 

  Bool_t fSaveBkgVal;   

  Bool_t fDrawIndividualFits; 

  TH1F* fHistoRawYieldDistAll;  
  TH1F* fHistoRawYieldTrialAll; 
  TH1F* fHistoSigmaTrialAll;    
  TH1F* fHistoMeanTrialAll;     
  TH1F* fHistoChi2TrialAll;     
  TH1F* fHistoSignifTrialAll;     
  TH1F* fHistoBkgTrialAll;     
  TH1F* fHistoBkgInBinEdgesTrialAll;    

  TH1F* fHistoRawYieldDistBinC0All; 
  TH2F* fHistoRawYieldTrialBinC0All; 
  TH1F* fHistoRawYieldDistBinC1All; 
  TH2F* fHistoRawYieldTrialBinC1All; 

  TH1F** fHistoRawYieldDist;  
  TH1F** fHistoRawYieldTrial; 
  TH1F** fHistoSigmaTrial;    
  TH1F** fHistoMeanTrial;     
  TH1F** fHistoChi2Trial;     
  TH1F** fHistoSignifTrial;     
  TH1F** fHistoBkgTrial;     
  TH1F** fHistoBkgInBinEdgesTrial;    

  TH1F** fHistoRawYieldDistBinC0;  
  TH2F** fHistoRawYieldTrialBinC0; 
  TH1F** fHistoRawYieldDistBinC1;  
  TH2F** fHistoRawYieldTrialBinC1; 

  TH1F *fhTemplRefl;        
  TH1F *fhTemplSign;        
  Float_t fFixRefloS;
  TNtuple* fNtupleMultiTrials; 
  TNtuple* fNtupleBinCount;   

  Double_t fMinYieldGlob;   
  Double_t fMaxYieldGlob;   

  std::vector<AliHFInvMassFitter*> fMassFitters; 

  ClassDef(AliHFInvMassMultiTrialFit,4); 
};

#endif