ROOT logo
AliRoot » PWGHF » VERTEXINGHF » AliHFPtSpectrum

class AliHFPtSpectrum: public TNamed

 Class AliHFPtSpectrum
 Base class for feed-down corrections on heavy-flavour decays
 computes the cross-section via one of the three implemented methods:
   0) Consider no feed-down prediction
   1) Subtract the feed-down with the "fc" method
       Yield = Reco * fc;  where fc = 1 / ( 1 + (eff_b/eff_c)*(N_b/N_c) ) ;
   2) Subtract the feed-down with the "Nb" method
       Yield = Reco - Feed-down (exact formula on the function implementation)

  (the corrected yields per bin are divided by the bin-width)


  In HIC you can also evaluate how the feed-down correction is influenced by an energy loss hypothesis:
      Raa(c-->D) / Raa(b-->D) defined here as Rcb for the "fc" method
      Raa(b-->D) defined here as Rb for the "Nb" method

 Author: Z.Conesa, zconesa@in2p3.fr

Function Members (Methods)

public:
AliHFPtSpectrum(const AliHFPtSpectrum& rhs)
AliHFPtSpectrum(const char* name = "AliHFPtSpectrum", const char* title = "HF feed down correction class", Int_t option = 1)
virtual~AliHFPtSpectrum()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTNamed::Clear(Option_t* option = "")
virtual TObject*TNamed::Clone(const char* newname = "") const
virtual Int_tTNamed::Compare(const TObject* obj) const
voidComputeHFPtSpectrum(Double_t deltaY = 1.0, Double_t branchingRatioC = 1.0, Double_t branchingRatioBintoFinalDecay = 1.0)
voidComputeSystUncertainties(AliHFSystErr* systematics, Bool_t combineFeedDown)
virtual voidTNamed::Copy(TObject& named) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
voidDrawSpectrum(TGraphAsymmErrors* gPrediction)
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
voidEstimateAndSetDirectEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco)
voidEstimateAndSetFeedDownEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco)
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual voidTNamed::FillBuffer(char*& buffer)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
Int_tFindTH2YBin(TH2D* histo, Float_t yvalue)
TGraphAsymmErrors*GetCrossSectionFromYieldSpectrum() const
TGraphAsymmErrors*GetCrossSectionFromYieldSpectrumConservative() const
TGraphAsymmErrors*GetCrossSectionFromYieldSpectrumExtreme() const
TH1D*GetDirectAccEffCorrection() const
TH1D*GetDirectStatEffUncOnFc() const
TH1D*GetDirectStatEffUncOnSigma() const
TH1D*GetDirectTheoreticalLowerLimitSpectrum() const
TH1D*GetDirectTheoreticalSpectrum() const
TH1D*GetDirectTheoreticalUpperLimitSpectrum() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TH1D*GetFeedDownAccEffCorrection() const
TGraphAsymmErrors*GetFeedDownCorrectedSpectrum() const
TGraphAsymmErrors*GetFeedDownCorrectedSpectrumConservative() const
TGraphAsymmErrors*GetFeedDownCorrectedSpectrumExtreme() const
TGraphAsymmErrors*GetFeedDownCorrectionFcConservative() const
TGraphAsymmErrors*GetFeedDownCorrectionFcExtreme() const
TH1D*GetFeedDownStatEffUncOnFc() const
TH1D*GetFeedDownStatEffUncOnSigma() const
TH1D*GetFeedDownTheoreticalLowerLimitSpectrum() const
TH1D*GetFeedDownTheoreticalSpectrum() const
TH1D*GetFeedDownTheoreticalUpperLimitSpectrum() const
TH1D*GetHistoCrossSectionDataSystematics() const
TH1D*GetHistoCrossSectionFromYieldSpectrum() const
TH2D*GetHistoCrossSectionFromYieldSpectrumVsEloss() const
TH1D*GetHistoFeedDownCorrectedSpectrum() const
TH2D*GetHistoFeedDownCorrectedSpectrumVsEloss() const
TH1D*GetHistoFeedDownCorrectionFc() const
TH2D*GetHistoFeedDownCorrectionFcVsEloss() const
TH1D*GetHistoLowerLimitCrossSectionFromYieldSpectrum() const
TH1D*GetHistoLowerLimitFeedDownCorrectedSpectrum() const
TH1D*GetHistoLowerLimitFeedDownCorrectionFc() const
TH1D*GetHistoUpperLimitCrossSectionFromYieldSpectrum() const
TH1D*GetHistoUpperLimitFeedDownCorrectedSpectrum() const
TH1D*GetHistoUpperLimitFeedDownCorrectionFc() const
virtual const char*TObject::GetIconName() const
virtual const char*TNamed::GetName() const
TNtuple*GetNtupleCrossSectionVsEloss()
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual const char*TNamed::GetTitle() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTNamed::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
Bool_tIsElossHypothesisCalculated()
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTNamed::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliHFPtSpectrum&operator=(const AliHFPtSpectrum& source)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
TH1D*ReweightHisto(TH1D* hToReweight, TH1D* hReference)
TH1D*ReweightRecHisto(TH1D* hRecToReweight, TH1D* hMCToReweight, TH1D* hMCReference)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSetAccEffCorrection(TH1D* hDirectEff, TH1D* hFeedDownEff)
voidSetAccEffPercentageUncertainty(Double_t globalEffUnc, Double_t globalBCEffRatioUnc)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetComputeAsymmetricUncertainties(Bool_t flag)
voidSetComputeElossHypothesis(Bool_t flag)
voidSetDirectAccEffCorrection(TH1D* hDirectEff)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetFeedDownCalculationOption(Int_t option)
voidSetFeedDownMCptDistributionsBounds(TH1D* hFeedDownMax, TH1D* hFeedDownMin)
voidSetFeedDownMCptSpectra(TH1D* hFeedDown)
voidSetfIsStatUncEff(Bool_t flag)
voidSetIsEventPlaneAnalysis(Bool_t flag)
voidSetIsParticlePlusAntiParticleYield(Bool_t flag)
voidSetLuminosity(Double_t luminosity, Double_t unc)
voidSetMCptDistributionsBounds(TH1D* hDirectMax, TH1D* hDirectMin, TH1D* hFeedDownMax, TH1D* hFeedDownMin)
voidSetMCptSpectra(TH1D* hDirect, TH1D* hFeedDown)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidSetNormalization(Double_t normalization)
voidSetNormalization(Int_t nevents, Double_t sigma)
voidSetNormalization(Int_t nevents, Double_t sigma, Double_t sigmaunc)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetReconstructedSpectrum(TH1D* hRec)
voidSetReconstructedSpectrumSystematics(TGraphAsymmErrors* gRec)
voidSetTabParameter(Double_t tabvalue, Double_t uncertainty)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidSetTriggerEfficiency(Double_t efficiency, Double_t unc)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector&)
virtual Int_tTNamed::Sizeof() const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
voidCalculateCorrectedSpectrumNoFeedDown()
voidCalculateFeedDownCorrectedSpectrumFc()
voidCalculateFeedDownCorrectedSpectrumNb(Double_t deltaY, Double_t branchingRatioBintoFinalDecay)
voidCalculateFeedDownCorrectionFc()
Bool_tCheckHistosConsistency(TH1D* h1, TH1D* h2)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
TH1D*EstimateEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco, const char* name)
Bool_tInitialize()
voidTObject::MakeZombie()
TH1D*RebinTheoreticalSpectra(TH1D* hTheory, const char* name)
voidResetStatUncEff()

Data Members

protected:
Bool_tfAsymUncertaintiesflag: asymmetric uncertainties are (1) or not (0) considered
Int_tfFeedDownOptionfeed-down correction flag: 0=none, 1=fc, 2=Nb
Double_tfGlobalEfficiencyUncertainties[2]uncertainties on the efficiency [0]=c, b, [1]=b/c
Bool_tfIsEventPlaneflag : when the analysis is done for In/Out of plane, divide the B-prediction by two
Bool_tfIsStatUncEffflag : consider (1) or not (0) the stat unc on the efficiencies
Double_tfLuminosity[2]analyzed luminosity & uncertainty
TStringTNamed::fNameobject identifier
Int_tfNevtsnb of analyzed events
Int_tfParticleAntiParticle1: only one sign, 2: yield is for particle+anti-particle
Bool_tfPbPbElossHypothesisflag: whether to do estimates vs Ratio(c/b eloss) hypothesis
Double_t*fPtBinLimits[fnPtBins+1] limits of the pt intervals
Double_t*fPtBinWidths[fnPtBins] width of the pt intervals
Double_tfTab[2]Tab parameter and its uncertainty
TStringTNamed::fTitleobject title
Double_tfTrigEfficiency[2]trigger efficiency & uncertainty
TGraphAsymmErrors*fgFcConservativeExtreme correction as TGraphAsymmErrors
TGraphAsymmErrors*fgFcExtremeExtreme correction as TGraphAsymmErrors
TGraphAsymmErrors*fgRECSystematicsall reconstructed D Systematic uncertainties
TGraphAsymmErrors*fgSigmaCorrCorrected cross-section as TGraphAsymmErrors (syst but feed-down)
TGraphAsymmErrors*fgSigmaCorrConservativeConservative corrected cross-section as TGraphAsymmErrors (syst from feed-down)
TGraphAsymmErrors*fgSigmaCorrExtremeExtreme corrected cross-section as TGraphAsymmErrors (syst from feed-down)
TGraphAsymmErrors*fgYieldCorrCorrected yield as TGraphAsymmErrors (syst but feed-down)
TGraphAsymmErrors*fgYieldCorrConservativeConservative corrected yield as TGraphAsymmErrors (syst from feed-down)
TGraphAsymmErrors*fgYieldCorrExtremeExtreme corrected yield as TGraphAsymmErrors (syst from feed-down)
TH1D*fhDirectEffptc-->D Acceptance and efficiency correction
TH1D*fhDirectMCptInput MC c-->D spectra
TH1D*fhDirectMCptMaxInput MC maximum c-->D spectra
TH1D*fhDirectMCptMinInput MC minimum c-->D spectra
TH1D*fhFcCorrection histo fc = 1 / ( 1 + (eff_b/eff_c)*(N_b/N_c) )
TH1D*fhFcMaxMaximum fc histo
TH1D*fhFcMinMinimum fc histo
TH2D*fhFcRcbCorrection histo fc vs the Ratio(c/b eloss)
TH1D*fhFeedDownEffptb-->D Acceptance and efficiency correction
TH1D*fhFeedDownMCptInput MC b-->D spectra
TH1D*fhFeedDownMCptMaxInput MC maximum b-->D spectra
TH1D*fhFeedDownMCptMinInput MC minimum b-->D spectra
TH1D*fhRECptall reconstructed D
TH1D*fhSigmaCorrCorrected cross-section (stat unc. only)
TH1D*fhSigmaCorrDataSystCorrected cross-section (syst. unc. from data only)
TH1D*fhSigmaCorrMaxMaximum corrected cross-section
TH1D*fhSigmaCorrMinMinimum corrected cross-section
TH2D*fhSigmaCorrRcbCorrected cross-section (stat unc. only) vs the Ratio(c/b eloss)
TH1D*fhStatUncEffbFDUncertainty on the feed-down correction due to the feed-down efficiency statistical uncertainty
TH1D*fhStatUncEffbSigmaUncertainty on the cross-section due to the feed-down efficiency statistical uncertainty
TH1D*fhStatUncEffcFDUncertainty on the feed-down correction due to the prompt efficiency statistical uncertainty
TH1D*fhStatUncEffcSigmaUncertainty on the cross-section due to the prompt efficiency statistical uncertainty
TH1D*fhYieldCorrCorrected yield (stat unc. only)
TH1D*fhYieldCorrMaxMaximum corrected yield
TH1D*fhYieldCorrMinMinimum corrected yield
TH2D*fhYieldCorrRcbCorrected yield (stat unc. only) vs the Ratio(c/b eloss)
TNtuple*fnHypothesisNtuple of the calculation vs the Ratio(c/b eloss)
Int_tfnPtBinsnumber of pt bins
TNtuple*fnSigmaNtuple of the calculation vs the Ratio(c/b eloss)

Class Charts

Inheritance Chart:
TNamed
AliHFPtSpectrum

Function documentation

AliHFPtSpectrum(const char* name = "AliHFPtSpectrum", const char* title = "HF feed down correction class", Int_t option = 1)
 Default constructor

AliHFPtSpectrum(const AliHFPtSpectrum& rhs)
 Copy constructor

AliHFPtSpectrum & operator=(const AliHFPtSpectrum& source)
 Assignment operator

~AliHFPtSpectrum()
 Destructor

TH1D * RebinTheoreticalSpectra(TH1D* hTheory, const char* name)
 Function to rebin the theoretical spectrum
  with respect to the real-data reconstructed spectrum binning

void SetMCptSpectra(TH1D* hDirect, TH1D* hFeedDown)
 Set the MonteCarlo or Theoretical spectra
  both for direct and feed-down contributions

void SetFeedDownMCptSpectra(TH1D* hFeedDown)
 Set the MonteCarlo or Theoretical spectra
  for feed-down contribution

void SetMCptDistributionsBounds(TH1D* hDirectMax, TH1D* hDirectMin, TH1D* hFeedDownMax, TH1D* hFeedDownMin)
 Set the maximum and minimum MonteCarlo or Theoretical spectra
  both for direct and feed-down contributions
 used in case uncertainties are asymmetric and ca not be on the "basic histograms"

void SetFeedDownMCptDistributionsBounds(TH1D* hFeedDownMax, TH1D* hFeedDownMin)
 Set the maximum and minimum MonteCarlo or Theoretical spectra
   for feed-down contributions
 used in case uncertainties are asymmetric and can not be on the "basic histogram"

void SetDirectAccEffCorrection(TH1D* hDirectEff)
 Set the Acceptance and Efficiency corrections
   for the direct contribution

void SetAccEffCorrection(TH1D* hDirectEff, TH1D* hFeedDownEff)
 Set the Acceptance and Efficiency corrections
  both for direct and feed-down contributions

void SetReconstructedSpectrum(TH1D* hRec)
 Set the reconstructed spectrum

void SetReconstructedSpectrumSystematics(TGraphAsymmErrors* gRec)
 Set the reconstructed spectrum (uncorrected yield) systematic uncertainties

void ComputeHFPtSpectrum(Double_t deltaY = 1.0, Double_t branchingRatioC = 1.0, Double_t branchingRatioBintoFinalDecay = 1.0)
 Main function to compute the corrected cross-section:
 variables : analysed delta_y, BR for the final correction,
             BR b --> D --> decay (relative to the input theoretical prediction)

   Sigma = ( 1. / (lumi * delta_y * BR_c * ParticleAntiPartFactor * eff_trig * eff_c ) ) * spectra (corrected for feed-down)

 Uncertainties: (stat) delta_sigma = sigma * sqrt ( (delta_spectra/spectra)^2 )
  (syst but feed-down) delta_sigma = sigma * sqrt ( (delta_spectra_syst/spectra)^2 + (delta_lumi/lumi)^2 + (delta_eff_trig/eff_trig)^2 + (delta_eff/eff)^2 )
      (feed-down syst) delta_sigma = sigma * sqrt ( (delta_spectra_fd/spectra_fd)^2 )

  In HIC the feed-down correction varies with an energy loss hypothesis:
      Raa(c-->D) / Raa(b-->D) for the "fc" method, Raa(b-->D) for the "Nb" method (see exact formulas in the functions)

TH1D * EstimateEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco, const char* name)
 Function that computes the acceptance and efficiency correction
  based on the simulated and reconstructed spectra
  and using the reconstructed spectra bin width

  eff = reco/sim ; err_eff = sqrt( eff*(1-eff) )/ sqrt( sim )

void EstimateAndSetDirectEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco)
 Function that computes the Direct  acceptance and efficiency correction
  based on the simulated and reconstructed spectra
  and using the reconstructed spectra bin width

  eff = reco/sim ; err_eff = sqrt( eff*(1-eff) )/ sqrt( sim )

void EstimateAndSetFeedDownEfficiencyRecoBin(TH1D* hSimu, TH1D* hReco)
 Function that computes the Feed-Down acceptance and efficiency correction
  based on the simulated and reconstructed spectra
  and using the reconstructed spectra bin width

  eff = reco/sim ; err_eff = sqrt( eff*(1-eff) )/ sqrt( sim )

Bool_t Initialize()
 Initialization of the variables (histograms)

Bool_t CheckHistosConsistency(TH1D* h1, TH1D* h2)
 Check the histograms consistency (bins, limits)

void CalculateCorrectedSpectrumNoFeedDown()
 Compute the corrected spectrum with no feed-down correction

void CalculateFeedDownCorrectionFc()
 Compute fc factor and its uncertainties bin by bin
   fc = 1 / ( 1 + (eff_b/eff_c)*(N_b/N_c) )

 uncertainties: (conservative) combine the upper/lower N_b & N_c predictions together
                (extreme) combine the upper N_b predictions with the lower N_c predictions & viceversa
                systematic uncertainty on the acceptance x efficiency b/c ratio are included

  In addition, in HIC the feed-down correction varies with an energy loss hypothesis: Raa(c-->D) / Raa(b-->D) = Rcb
	       fc (Rcb) = ( 1. / ( 1 + (eff_b/eff_c)*(N_b/N_c)* (1/Rcb) ) );

void CalculateFeedDownCorrectedSpectrumFc()
 Compute the feed-down corrected spectrum if feed-down correction is done via fc factor (bin by bin)
    physics = reco * fc / bin-width

    uncertainty:             (stat) delta_physics = physics * sqrt ( (delta_reco/reco)^2 )
               (syst but feed-down) delta_physics = physics * sqrt ( (delta_reco_syst/reco)^2 )
                   (feed-down syst) delta_physics = physics * sqrt ( (delta_fc/fc)^2 )

    ( Calculation done bin by bin )

  In addition, in HIC the feed-down correction varies with an energy loss hypothesis: Raa(c-->D) / Raa(b-->D) = Rcb
void CalculateFeedDownCorrectedSpectrumNb(Double_t deltaY, Double_t branchingRatioBintoFinalDecay)
 Compute the feed-down corrected spectrum if feed-down correction is done via Nb (bin by bin)
    physics =  [ reco  - (lumi * delta_y * BR_b * eff_trig * eff_b * Nb_th) ] / bin-width

    uncertainty:   (stat)  delta_physics = sqrt ( (delta_reco)^2 )  / bin-width
     (syst but feed-down)  delta_physics = sqrt ( (delta_reco_syst)^2 )  / bin-width
         (feed-down syst)  delta_physics = sqrt ( (k*delta_lumi/lumi)^2 + (k*delta_eff_trig/eff_trig)^2
                                                   + (k*delta_Nb/Nb)^2 + (k*delta_eff/eff)^2  + (k*global_eff_ratio)^2 ) / bin-width
                    where k = lumi * delta_y * BR_b * eff_trig * eff_b * Nb_th

  In addition, in HIC the feed-down correction varies with an energy loss hypothesis: Raa(b-->D) = Rb
    physics =  [ reco  - ( Tab * Nevt * delta_y * BR_b * eff_trig * eff_b * Nb_th * Rb ) ] / bin-width

void ComputeSystUncertainties(AliHFSystErr* systematics, Bool_t combineFeedDown)
 Function that re-calculates the global systematic uncertainties
   by calling the class AliHFSystErr and combining those
   (in quadrature) with the feed-down subtraction uncertainties

void DrawSpectrum(TGraphAsymmErrors* gPrediction)
 Example method to draw the corrected spectrum & the theoretical prediction

TH1D * ReweightHisto(TH1D* hToReweight, TH1D* hReference)
 Function to  reweight histograms for testing purposes:
 This function takes the histo hToReweight and reweights
  it (its pt shape) with respect to hReference

TH1D * ReweightRecHisto(TH1D* hRecToReweight, TH1D* hMCToReweight, TH1D* hMCReference)
 Function to  reweight histograms for testing purposes:
 This function takes the histo hToReweight and reweights
  it (its pt shape) with respect to hReference /hMCToReweight

Int_t FindTH2YBin(TH2D* histo, Float_t yvalue)
 Function to find the y-axis bin of a TH2 for a given y-value

void ResetStatUncEff()
void SetFeedDownCalculationOption(Int_t option)
 Set the calculation option flag for feed-down correction: 0=none, 1=fc , 2=Nb
{ fFeedDownOption = option; }
void SetComputeAsymmetricUncertainties(Bool_t flag)
 Set if the calculation has to consider asymmetric uncertaInt_ties or not
{ fAsymUncertainties = flag; }
void SetIsParticlePlusAntiParticleYield(Bool_t flag)
 Set if the yield is for particle plus anti-particle or not
void SetIsEventPlaneAnalysis(Bool_t flag)
{ fIsEventPlane = flag; }
void SetfIsStatUncEff(Bool_t flag)
 Set if the calculation has to consider Ratio(c/b eloss) hypothesis
{ fIsStatUncEff = flag; }
void SetComputeElossHypothesis(Bool_t flag)
 Set the luminosity and its uncertainty
void SetLuminosity(Double_t luminosity, Double_t unc)
void SetTriggerEfficiency(Double_t efficiency, Double_t unc)
 Set the trigger efficiency and its uncertainty
void SetAccEffPercentageUncertainty(Double_t globalEffUnc, Double_t globalBCEffRatioUnc)
 Set global acceptance x efficiency correction uncertainty (in percentages)
void SetNormalization(Double_t normalization)
 Set the normalization factors
void SetNormalization(Int_t nevents, Double_t sigma)
void SetNormalization(Int_t nevents, Double_t sigma, Double_t sigmaunc)
void SetTabParameter(Double_t tabvalue, Double_t uncertainty)
 Set the Tab parameter and its uncertainty
TH1D * GetDirectTheoreticalSpectrum() const
 Getters

 Return the theoretical predictions used for the calculation (rebinned if needed)
{ return (fhDirectMCpt ? (TH1D*)fhDirectMCpt : NULL); }
TH1D * GetDirectTheoreticalUpperLimitSpectrum() const
{ return (fhDirectMCptMax ? (TH1D*)fhDirectMCptMax : NULL); }
TH1D * GetDirectTheoreticalLowerLimitSpectrum() const
{ return (fhDirectMCptMin ? (TH1D*)fhDirectMCptMin : NULL); }
TH1D * GetFeedDownTheoreticalSpectrum() const
{ return (fhFeedDownMCpt ? (TH1D*)fhFeedDownMCpt : NULL); }
TH1D * GetFeedDownTheoreticalUpperLimitSpectrum() const
{ return (fhFeedDownMCptMax ? (TH1D*)fhFeedDownMCptMax : NULL); }
TH1D * GetFeedDownTheoreticalLowerLimitSpectrum() const
 Return the acceptance and efficiency corrections (rebinned if needed)
{ return (fhFeedDownMCptMin ? (TH1D*)fhFeedDownMCptMin : NULL); }
TH1D * GetDirectAccEffCorrection() const
{ return (fhDirectEffpt ? (TH1D*)fhDirectEffpt : NULL); }
TH1D * GetFeedDownAccEffCorrection() const
 Return whether the Ratio(c/b eloss) hypothesis has been considered
{ return (fhFeedDownEffpt ? (TH1D*)fhFeedDownEffpt : NULL); }
Bool_t IsElossHypothesisCalculated()
 Return the TGraphAsymmErrors of the feed-down correction (extreme systematics)
TGraphAsymmErrors * GetFeedDownCorrectionFcExtreme() const
 Return the TGraphAsymmErrors of the feed-down correction (conservative systematics)
{ return (fgFcExtreme ? fgFcExtreme : NULL); }
TGraphAsymmErrors * GetFeedDownCorrectionFcConservative() const
 Return the histogram of the feed-down correction
{ return (fgFcConservative ? fgFcConservative : NULL); }
TH1D * GetHistoFeedDownCorrectionFc() const
 Return the histograms of the feed-down correction bounds
{ return (fhFc ? (TH1D*)fhFc : NULL); }
TH1D * GetHistoUpperLimitFeedDownCorrectionFc() const
{ return (fhFcMax ? (TH1D*)fhFcMax : NULL); }
TH1D * GetHistoLowerLimitFeedDownCorrectionFc() const
 Return the histogram of the feed-down correction times the Ratio(c/b eloss)
{ return (fhFcMin ? (TH1D*)fhFcMin : NULL); }
TH2D * GetHistoFeedDownCorrectionFcVsEloss() const
 Return the TGraphAsymmErrors of the yield after feed-down correction (systematics but feed-down)
{ return (fhFcRcb ? (TH2D*)fhFcRcb : NULL); }
TGraphAsymmErrors * GetFeedDownCorrectedSpectrum() const
 Return the TGraphAsymmErrors of the yield after feed-down correction (feed-down extreme systematics)
{ return (fgYieldCorr ? fgYieldCorr : NULL); }
TGraphAsymmErrors * GetFeedDownCorrectedSpectrumExtreme() const
 Return the TGraphAsymmErrors of the yield after feed-down correction (feed-down conservative systematics)
{ return (fgYieldCorrExtreme ? fgYieldCorrExtreme : NULL); }
TGraphAsymmErrors * GetFeedDownCorrectedSpectrumConservative() const
 Return the histogram of the yield after feed-down correction
TH1D * GetHistoFeedDownCorrectedSpectrum() const
 Return the histogram of the yield after feed-down correction bounds
{ return (fhYieldCorr ? (TH1D*)fhYieldCorr : NULL); }
TH1D * GetHistoUpperLimitFeedDownCorrectedSpectrum() const
{ return (fhYieldCorrMax ? (TH1D*)fhYieldCorrMax : NULL); }
TH1D * GetHistoLowerLimitFeedDownCorrectedSpectrum() const
 Return the histogram of the yield after feed-down correction vs the Ratio(c/b eloss)
{ return (fhYieldCorrMin ? (TH1D*)fhYieldCorrMin : NULL); }
TH2D * GetHistoFeedDownCorrectedSpectrumVsEloss() const
 Return the equivalent invariant cross-section TGraphAsymmErrors (systematics but feed-down)
{ return (fhYieldCorrRcb ? (TH2D*)fhYieldCorrRcb : NULL); }
TGraphAsymmErrors * GetCrossSectionFromYieldSpectrum() const
 Return the equivalent invariant cross-section TGraphAsymmErrors (feed-down extreme systematics)
{ return (fgSigmaCorr ? fgSigmaCorr : NULL); }
TGraphAsymmErrors * GetCrossSectionFromYieldSpectrumExtreme() const
 Return the equivalent invariant cross-section TGraphAsymmErrors (feed-down conservative systematics)
{ return (fgSigmaCorrExtreme ? fgSigmaCorrExtreme : NULL); }
TGraphAsymmErrors * GetCrossSectionFromYieldSpectrumConservative() const
 Return the equivalent invariant cross-section histogram
TH1D * GetHistoCrossSectionFromYieldSpectrum() const
 Return the equivalent invariant cross-section histogram bounds
{ return (fhSigmaCorr ? (TH1D*)fhSigmaCorr : NULL); }
TH1D * GetHistoUpperLimitCrossSectionFromYieldSpectrum() const
{ return (fhSigmaCorrMax ? (TH1D*)fhSigmaCorrMax : NULL); }
TH1D * GetHistoLowerLimitCrossSectionFromYieldSpectrum() const
 Return the cross section systematics from data systematics
{ return (fhSigmaCorrMin ? (TH1D*)fhSigmaCorrMin : NULL); }
TH1D * GetHistoCrossSectionDataSystematics() const
 PbPb special calculations
 Return the equivalent invariant cross-section histogram vs the Ratio(c/b eloss)
{ return (fhSigmaCorrDataSyst ? (TH1D*)fhSigmaCorrDataSyst : NULL); }
TH2D * GetHistoCrossSectionFromYieldSpectrumVsEloss() const
 Return the ntuple of the calculation vs the Ratio(c/b eloss)
{ return (fhSigmaCorrRcb ? (TH2D*)fhSigmaCorrRcb : NULL); }
TNtuple * GetNtupleCrossSectionVsEloss()

 Histograms to keep track of the influence of the efficiencies statistical uncertainty on the cross-section
{ return (fnSigma ? (TNtuple*)fnSigma : NULL); }
TH1D * GetDirectStatEffUncOnSigma() const
{ return (TH1D*)fhStatUncEffcSigma; }
TH1D * GetFeedDownStatEffUncOnSigma() const
 Histograms to keep track of the influence of the efficiencies statistical uncertainty on the feed-down correction factor
{ return (TH1D*)fhStatUncEffbSigma; }
TH1D * GetDirectStatEffUncOnFc() const
{ return (TH1D*)fhStatUncEffcFD; }
TH1D * GetFeedDownStatEffUncOnFc() const
{ return (TH1D*)fhStatUncEffbFD; }