AliHFMultiTrials.h

Go to the documentation of this file.

#ifndef ALIHFMULTITRIALS_H
#define ALIHFMULTITRIALS_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 AliHFMassFitterVAR;


class AliHFMultiTrials : public TNamed {

 public:
  AliHFMultiTrials();
  virtual ~AliHFMultiTrials();

  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;
  }

  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 SetUseLikelihoodWithWeightsFit(){fFitOption=2;}
  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 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;
  TH1F* SetTemplateRefl(const TH1F *hTemplRefl);

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

  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};

 private:

  Bool_t CreateHistos();
  TH1F* RebinHisto(TH1D* hOrig, Int_t reb, Int_t firstUse) const;
  void BinCount(TH1F* h, TF1* fB, Int_t rebin, Double_t minMass, Double_t maxMass, Double_t& count, Double_t& ecount) const;
  Bool_t DoFitWithPol3Bkg(TH1F* histoToFit, Double_t  hmin, Double_t  hmax,
        Int_t theCase);

  AliHFMultiTrials(const AliHFMultiTrials &source);
  AliHFMultiTrials& operator=(const AliHFMultiTrials& 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 fUseFixSigUpFreeMean;    
  Bool_t fUseFixSigDownFreeMean;  
  Bool_t fUseFreeS;              
  Bool_t fUseFixedMeanFreeS;     
  Bool_t fUseFixSigFreeMean;     
  Bool_t fUseFixSigFixMean;      

  Bool_t fSaveBkgVal;   

  Bool_t fDrawIndividualFits; 

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

  TH1F* fHistoRawYieldDistBinCAll; 
  TH2F* fHistoRawYieldTrialBinCAll; 

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

  TH1F** fHistoRawYieldDistBinC;  
  TH2F** fHistoRawYieldTrialBinC; 
  TH1F *fhTemplRefl;        
  Float_t fFixRefloS;
  TNtuple* fNtupleMultiTrials; 

  Double_t fMinYieldGlob;   
  Double_t fMaxYieldGlob;   

  std::vector<AliHFMassFitterVAR*> fMassFitters; 

  ClassDef(AliHFMultiTrials,5); 
};

#endif