ROOT logo
AliRoot » PWGUD » BASE » AliMultiplicityCorrection

class AliMultiplicityCorrection: public TNamed

Function Members (Methods)

public:
AliMultiplicityCorrection()
AliMultiplicityCorrection(const Char_t* name, const Char_t* title)
virtual~AliMultiplicityCorrection()
voidTObject::AbstractMethod(const char* method) const
virtual voidTObject::AppendPad(Option_t* option = "")
voidApplyBayesianMethod(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Float_t regPar = 1, Int_t nIterations = 100, TH1* initialConditions = 0, Int_t determineError = 1)
voidApplyGaussianMethod(Int_t inputRange, Bool_t fullPhaseSpace)
voidApplyLaszloMethod(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)
Int_tApplyMinuitFit(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents, Bool_t check = kFALSE, TH1* initialConditions = 0, Bool_t errorAsBias = kFALSE)
Int_tApplyNBDFit(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)
virtual voidTObject::Browse(TBrowser* b)
voidCalculate0Bin(Int_t inputRange, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents)
TH2F*CalculateMultiplicityESD(TH1* inputMC, Int_t correlationMap)
static TH1*CalculateStdDev(TH1** results, Int_t max)
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
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
voidDrawComparison(const char* name, Int_t inputRange, Bool_t fullPhaseSpace, Bool_t normalizeESD, TH1* mcHist, Bool_t simple = kFALSE, AliMultiplicityCorrection::EventType eventType = kTrVtx)
voidDrawHistograms()
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
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
voidFFT(Int_t dir, Int_t m, Double_t* x, Double_t* y) const
virtual voidTNamed::FillBuffer(char*& buffer)
voidFillCorrection(Float_t vtx, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll, Int_t measured05, Int_t measured10, Int_t measured14)
voidFillGenerated(Float_t vtx, Bool_t triggered, Bool_t vertex, AliPWG0Helper::MCProcessType processType, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll)
voidFillMeasured(Float_t vtx, Int_t measured05, Int_t measured10, Int_t measured14)
voidFillNoVertexEvent(Float_t vtx, Bool_t vertexReconstructed, Int_t generated05, Int_t generated10, Int_t generated14, Int_t measured05, Int_t measured10, Int_t measured14)
voidFillTriggeredEvent(Int_t measured05, Int_t measured10, Int_t measured14)
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
voidFixTriggerEfficiencies(Int_t start)
voidGetComparisonResults(Float_t *const mc = 0, Int_t *const mcLimit = 0, Float_t *const residuals = 0, Float_t *const ratioAverage = 0) const
TH1*GetConvoluted(Int_t i, AliMultiplicityCorrection::EventType eventType)
TH3F*GetCorrelation(Int_t i) const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
TH1*GetEfficiency(Int_t inputRange, AliMultiplicityCorrection::EventType eventType)
Float_tGetFraction0Generated(Int_t inputRange)
virtual const char*TObject::GetIconName() const
TH2F*GetMultiplicityESD(Int_t i) const
TH1F*GetMultiplicityESDCorrected(Int_t i) const
TH2F*GetMultiplicityINEL(Int_t i) const
TH2F*GetMultiplicityMB(Int_t i) const
TH2F*GetMultiplicityMC(Int_t i, AliMultiplicityCorrection::EventType eventType) const
TH2F*GetMultiplicityNSD(Int_t i) const
TH2F*GetMultiplicityVtx(Int_t i) const
virtual const char*TNamed::GetName() const
TH1F*GetNoVertexEvents(Int_t i) const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
Float_tGetQuality(Int_t region) const
TH1*GetResiduals(Int_t i, AliMultiplicityCorrection::EventType eventType, Float_t& residualSum)
virtual const char*TNamed::GetTitle() const
TH1F*GetTriggeredEvents(Int_t i) const
TH1*GetTriggerEfficiency(Int_t inputRange, AliMultiplicityCorrection::EventType eventType)
virtual UInt_tTObject::GetUniqueID() const
Float_tGetVertexBegin(Int_t i)
Float_tGetVertexEnd(Int_t i)
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
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
Bool_tLoadHistograms(const Char_t* dir = 0)
virtual voidTNamed::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Long64_tMerge(const TCollection* list)
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static AliMultiplicityCorrection*Open(const char* fileName, const char* folderName = "Multiplicity")
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)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTNamed::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
voidRebin2DY(TH2F*& hist, Int_t nBins, Double_t* newBins) const
voidRebin3DY(TH3F*& hist, Int_t nBins, Double_t* newBins) const
voidRebinGenerated(Int_t nBins05, Double_t* newBins05, Int_t nBins10, Double_t* newBins10, Int_t nBins13, Double_t* newBins13)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
voidSaveHistograms(const char* dir = 0)
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidSetCorrelation(Int_t i, TH3F *const hist)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidSetGenMeasFromFunc(const TF1* inputMC, Int_t id)
voidSetMultiplicityESD(Int_t i, TH2F *const hist)
voidSetMultiplicityESDCorrected(Int_t i, TH1F *const hist)
voidSetMultiplicityINEL(Int_t i, TH2F *const hist)
voidSetMultiplicityMB(Int_t i, TH2F *const hist)
voidSetMultiplicityMC(Int_t i, AliMultiplicityCorrection::EventType eventType, TH2F *const hist)
voidSetMultiplicityNSD(Int_t i, TH2F *const hist)
voidSetMultiplicityVtx(Int_t i, TH2F *const hist)
virtual voidTNamed::SetName(const char* name)MENU
virtual voidTNamed::SetNameTitle(const char* name, const char* title)
voidSetNoVertexEvents(Int_t i, TH1F* hist)
static voidTObject::SetObjectStat(Bool_t stat)
static voidSetQualityRegions(Bool_t SPDStudy)
virtual voidTNamed::SetTitle(const char* title = "")MENU
voidSetTriggeredEvents(Int_t i, TH1F* hist)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidSetVertexRange(Int_t begin, Int_t end)
virtual voidShowMembers(TMemberInspector&)
virtual Int_tTNamed::Sizeof() const
TH1*StatisticalUncertainty(AliUnfolding::MethodType methodType, Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents, Bool_t randomizeMeasured, Bool_t randomizeResponse, const TH1* compareTo = 0)
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:
Float_tBayesCovarianceDerivate(Float_t matrixM[][251], const TH2* hResponse, Int_t k, Int_t i, Int_t r, Int_t u)
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTObject::MakeZombie()
voidSetupCurrentHists(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)

Data Members

public:
enum EventType { kTrVtx
kMB
kINEL
kNSD
};
enum { kESDHists
kMCHists
kCorrHists
kQualityRegions
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TH3F*fCorrelation[6]vtx vs. (gene multiplicity (trig+vtx)) vs. (meas multiplicity); array: |eta| < 0.5, 1, 1.4, (0..2 and 3..5), the first corrects to the eta range itself, the second to full phase space
TH2*fCurrentCorrelation! current correlation
TH1*fCurrentESD! current input esd
TH1*fCurrentEfficiency! current efficiency
Int_tfLastBinLimit! last bin limit, determined in SetupCurrentHists()
Float_tfLastChi2MC! last Chi2 between MC and unfolded ESD (calculated in DrawComparison)
Int_tfLastChi2MCLimit! bin where the last chi2 breached a certain threshold, used to evaluate the multiplicity reach (calc. in DrawComparison)
Float_tfLastChi2Residuals! last Chi2 of the ESD and the folded unfolded ESD (calculated in DrawComparison)
TH2F*fMultiplicityESD[3]multiplicity histogram: vtx vs multiplicity; array: |eta| < 0.5, 1.0, 1.4 (0..2)
TH1F*fMultiplicityESDCorrected[6]corrected histograms
TH2F*fMultiplicityINEL[4]multiplicity histogram of all (inelastic) events : vtx vs multiplicity; array: |eta| < 0.5, 1.0, 1.4, inf (0..3)
TH2F*fMultiplicityMB[4]multiplicity histogram of triggered events : vtx vs multiplicity; array: |eta| < 0.5, 1.0, 1.4, inf (0..3)
TH2F*fMultiplicityNSD[4]multiplicity histogram of NSD events : vtx vs multiplicity; array: |eta| < 0.5, 1.0, 1.4, inf (0..3)
TH2F*fMultiplicityVtx[4]multiplicity histogram of events that have a reconstructed vertex : vtx vs multiplicity; array: |eta| < 0.5, 1.0, 1.4, inf (0..3)
TStringTNamed::fNameobject identifier
TH1F*fNoVertexEvents[3]distribution of true multiplicity just of triggered events without vertex or with 0 tracklets; array: |eta| < 0.5, 1.0, 1.4 (0..2)
Float_tfQuality[3]! stores the quality of the last comparison (calculated in DrawComparison). Contains 3 values that are averages of (MC - unfolded) / e(MC) in 3 regions, these are defined in fQualityRegionB,E
Float_tfRatioAverage! last average of |ratio-1| where ratio = unfolded / mc (bin 2..150)
TStringTNamed::fTitleobject title
TH1F*fTriggeredEvents[3](raw) multiplicity distribution of triggered events; array: |eta| < 0.5, 1.0, 1.4 (0..2)
Int_tfVtxBegin! vertex range for analysis
Int_tfVtxEnd! vertex range for analysis
static Int_tfgQualityRegionsB[3]! begin, given in multiplicity units
static Int_tfgQualityRegionsE[3]! end
static Double_tfgVtxRangeBegin[3]! begin of allowed vertex range for this eta bin
static Double_tfgVtxRangeEnd[3]! end of allowed vertex range for this eta bin

Class Charts

Inheritance Chart:
TNamed
AliMultiplicityCorrection

Function documentation

void SetQualityRegions(Bool_t SPDStudy)
 sets the quality region definition to TPC or SPD

AliMultiplicityCorrection()
 default constructor

AliMultiplicityCorrection* Open(const char* fileName, const char* folderName = "Multiplicity")
 opens the given file, reads the multiplicity from the given folder and returns the object
AliMultiplicityCorrection(const Char_t* name, const Char_t* title)
 named constructor

void Rebin2DY(TH2F*& hist, Int_t nBins, Double_t* newBins) const
 rebins the y axis of a two-dimensional histogram giving variable size binning (missing in ROOT v5/25/02)

void Rebin3DY(TH3F*& hist, Int_t nBins, Double_t* newBins) const
 rebins the y axis of a three-dimensional histogram giving variable size binning (missing in ROOT v5/25/02)
 this function is a mess - and it should have been Fons who should have gone through the pain of writing it! (JF)

void RebinGenerated(Int_t nBins05, Double_t* newBins05, Int_t nBins10, Double_t* newBins10, Int_t nBins13, Double_t* newBins13)
 Rebins the (and only the) generated multiplicity axis

~AliMultiplicityCorrection()
 Destructor

Long64_t Merge(const TCollection* list)
 Merge a list of AliMultiplicityCorrection objects with this (needed for
 PROOF).
 Returns the number of merged objects (including this).
Bool_t LoadHistograms(const Char_t* dir = 0)
 loads the histograms from a file
 if dir is empty a directory with the name of this object is taken (like in SaveHistogram)

void SaveHistograms(const char* dir = 0)
 saves the histograms

void FillGenerated(Float_t vtx, Bool_t triggered, Bool_t vertex, AliPWG0Helper::MCProcessType processType, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll)
 Fills an event from MC

void FillMeasured(Float_t vtx, Int_t measured05, Int_t measured10, Int_t measured14)
 Fills an event from ESD

void FillTriggeredEvent(Int_t measured05, Int_t measured10, Int_t measured14)
 fills raw distribution of triggered events

void FillNoVertexEvent(Float_t vtx, Bool_t vertexReconstructed, Int_t generated05, Int_t generated10, Int_t generated14, Int_t measured05, Int_t measured10, Int_t measured14)
 fills raw distribution of triggered events

void FillCorrection(Float_t vtx, Int_t generated05, Int_t generated10, Int_t generated14, Int_t generatedAll, Int_t measured05, Int_t measured10, Int_t measured14)
 Fills an event into the correlation map with the information from MC and ESD

void SetupCurrentHists(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)
TH1* GetEfficiency(Int_t inputRange, AliMultiplicityCorrection::EventType eventType)
 calculates efficiency for given event type

TH1* GetTriggerEfficiency(Int_t inputRange, AliMultiplicityCorrection::EventType eventType)
 calculates efficiency for given event type

Int_t ApplyMinuitFit(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents, Bool_t check = kFALSE, TH1* initialConditions = 0, Bool_t errorAsBias = kFALSE)
 correct spectrum using minuit chi2 method

 for description of parameters, see AliUnfolding::Unfold

void Calculate0Bin(Int_t inputRange, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents)
 fills the 0 bin
void FixTriggerEfficiencies(Int_t start)
 sets trigger and vertex efficiencies to 1 for large multiplicities where no event was simulated

Float_t GetFraction0Generated(Int_t inputRange)
 returns the fraction of events that have 0 generated particles in the given range among all events without vertex OR 0 tracklets

Int_t ApplyNBDFit(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)
 correct spectrum using minuit chi2 method with a NBD function

 for description of parameters, see AliUnfolding::Unfold

void DrawHistograms()
 draws the histograms of this class

void DrawComparison(const char* name, Int_t inputRange, Bool_t fullPhaseSpace, Bool_t normalizeESD, TH1* mcHist, Bool_t simple = kFALSE, AliMultiplicityCorrection::EventType eventType = kTrVtx)
 draw comparison plots
void FFT(Int_t dir, Int_t m, Double_t* x, Double_t* y) const
   This computes an in-place complex-to-complex FFT
   x and y are the real and imaginary arrays of 2^m points.
   dir =  1 gives forward transform
   dir = -1 gives reverse transform

     Formula: forward
                  N-1
                  ---
              1   \          - j k 2 pi n / N
      X(n) = ---   >   x(k) e                    = forward transform
              N   /                                n=0..N-1
                  ---
                  k=0

      Formula: reverse
                  N-1
                  ---
                  \          j k 2 pi n / N
      X(n) =       >   x(k) e                    = forward transform
                  /                                n=0..N-1
                  ---
                  k=0

void GetComparisonResults(Float_t *const mc = 0, Int_t *const mcLimit = 0, Float_t *const residuals = 0, Float_t *const ratioAverage = 0) const
 Returns the chi2 between the MC and the unfolded ESD as well as between the ESD and the folded unfolded ESD
 These values are computed during DrawComparison, thus this function picks up the
 last calculation
TH2F* GetMultiplicityMC(Int_t i, AliMultiplicityCorrection::EventType eventType) const
 returns the corresponding MC spectrum

void SetMultiplicityMC(Int_t i, AliMultiplicityCorrection::EventType eventType, TH2F *const hist)
 returns the corresponding MC spectrum

TH1* CalculateStdDev(TH1** results, Int_t max)
 calculate standard deviation of (results[0] - results[k]) k=1...max-1
 per bin one gets: sigma(r[0] - r[n]) / r[0]
TH1* StatisticalUncertainty(AliUnfolding::MethodType methodType, Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Int_t zeroBinEvents, Bool_t randomizeMeasured, Bool_t randomizeResponse, const TH1* compareTo = 0)
 evaluates the uncertainty that arises from the non-infinite statistics in the response matrix
 the function unfolds the spectrum using the default response matrix and several modified ones
 the modified ones are created by randomizing each cell using poisson statistics with the mean = bin value
 these unfolded results are compared to the first result gained with the default response OR to the histogram given
 in <compareTo> (optional)

 returns the error assigned to the measurement

void ApplyBayesianMethod(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType, Float_t regPar = 1, Int_t nIterations = 100, TH1* initialConditions = 0, Int_t determineError = 1)
 correct spectrum using bayesian method

 determineError:
   0 = no errors
   1 = from randomizing
   2 = with UnfoldGetBias
Float_t BayesCovarianceDerivate(Float_t matrixM[][251], const TH2* hResponse, Int_t k, Int_t i, Int_t r, Int_t u)
 helper function for the covariance matrix of the bayesian method

void ApplyLaszloMethod(Int_t inputRange, Bool_t fullPhaseSpace, AliMultiplicityCorrection::EventType eventType)
 correct spectrum using bayesian method

void ApplyGaussianMethod(Int_t inputRange, Bool_t fullPhaseSpace)
 correct spectrum using a simple Gaussian approach, that is model-dependent

TH1* GetConvoluted(Int_t i, AliMultiplicityCorrection::EventType eventType)
 convolutes the corrected histogram i with the response matrix
TH1* GetResiduals(Int_t i, AliMultiplicityCorrection::EventType eventType, Float_t& residualSum)
 creates the residual histogram from the corrected histogram i corresponding to an eventType event sample using the corresponding correlation matrix
 residual is : M - UT / eM
 residualSum contains the squared sum of the residuals
TH2F* CalculateMultiplicityESD(TH1* inputMC, Int_t correlationMap)
 runs the distribution given in inputMC through the response matrix identified by
 correlationMap and produces a measured distribution
 although it is a TH2F the vertex axis is not used at the moment and all entries are filled in mid-vertex
void SetGenMeasFromFunc(const TF1* inputMC, Int_t id)
 uses the given function to fill the input MC histogram and generates from that
 the measured histogram by applying the response matrix
 this can be used to evaluate if the methods work indepedently of the input
 distribution
 WARNING does not respect the vertex distribution, just fills central vertex bin
AliMultiplicityCorrection()
TH2F* GetMultiplicityESD(Int_t i) const
{ return fMultiplicityESD[i]; }
TH1F* GetTriggeredEvents(Int_t i) const
{ return fTriggeredEvents[i]; }
TH2F* GetMultiplicityVtx(Int_t i) const
{ return fMultiplicityVtx[i]; }
TH2F* GetMultiplicityMB(Int_t i) const
{ return fMultiplicityMB[i]; }
TH2F* GetMultiplicityINEL(Int_t i) const
{ return fMultiplicityINEL[i]; }
TH2F* GetMultiplicityNSD(Int_t i) const
{ return fMultiplicityNSD[i]; }
TH3F* GetCorrelation(Int_t i) const
{ return fCorrelation[i]; }
TH1F* GetNoVertexEvents(Int_t i) const
{ return fNoVertexEvents[i]; }
TH1F* GetMultiplicityESDCorrected(Int_t i) const
void SetMultiplicityESD(Int_t i, TH2F *const hist)
{ fMultiplicityESD[i] = hist; }
void SetTriggeredEvents(Int_t i, TH1F* hist)
{ fTriggeredEvents[i] = hist; }
void SetMultiplicityVtx(Int_t i, TH2F *const hist)
{ fMultiplicityVtx[i] = hist; }
void SetMultiplicityMB(Int_t i, TH2F *const hist)
{ fMultiplicityMB[i] = hist; }
void SetMultiplicityINEL(Int_t i, TH2F *const hist)
{ fMultiplicityINEL[i] = hist; }
void SetMultiplicityNSD(Int_t i, TH2F *const hist)
{ fMultiplicityNSD[i] = hist; }
void SetCorrelation(Int_t i, TH3F *const hist)
{ fCorrelation[i] = hist; }
void SetNoVertexEvents(Int_t i, TH1F* hist)
{ fNoVertexEvents[i] = hist; }
void SetMultiplicityESDCorrected(Int_t i, TH1F *const hist)
Float_t GetQuality(Int_t region) const
{ return fQuality[region]; }
Float_t GetVertexBegin(Int_t i)
{ return fgVtxRangeBegin[i]; }
Float_t GetVertexEnd(Int_t i)
{ return fgVtxRangeEnd[i]; }
void SetVertexRange(Int_t begin, Int_t end)
{ fVtxBegin = begin; fVtxEnd = end; }
AliMultiplicityCorrection& operator=(const AliMultiplicityCorrection& )