ROOT » HIST » HIST » TUnfoldSys

class TUnfoldSys: public TUnfold


  TUnfoldSys : public TUnfold

  TUnfold is used to decompose a measurement y into several sources x
  given the measurement uncertainties and a matrix of migrations A

  TUnfoldSys adds error propagation of systematic errors to TUnfold
  Also, background sources (with errors) can be subtracted.


  * For most applications, it is better to use TUnfoldDensity *
  * instead of using TUnfoldSys or TUnfold                    *


  If you use this software, please consider the following citation
       S.Schmitt, JINST 7 (2012) T10003 [arXiv:1205.6201]

  More documentation and updates are available on
      http://www.desy.de/~sschmitt


  The following sources of systematic error are considered in TUnfoldSys

  (a) uncorrelated errors on the input matrix histA, taken as the
      errors provided with the histogram.
      These are typically statistical errors from finite Monte Carlo samples

  (b) correlated shifts of the input matrix histA. These shifts are taken
      as one-sigma effects when switchig on a given error soure.
      several such error sources may be defined

  (c) a systematic error on the regularisation parameter tau

  (d) uncorrelated errors on background sources, taken as the errors
      provided with the background histograms

  (e) scale errors on background sources

 In addition there is the (statistical) uncertainty of the input vector (i)

 Source (a) is providede with the original histogram histA
     TUnfoldSys(histA,...)

 Sources (b) are added by calls to
     AddSysError()

 The systematic uncertainty on tau (c) is set by
     SetTauError()

 Backgound sources causing errors of type (d) and (e) are added by
     SubtractBackground()


 NOTE:

    Systematic errors (a), (b), (c) are propagated to the result
       AFTER unfolding

    Background errors (d) and (e) are added to the data errors
       BEFORE unfolding

 For this reason:
  errors of type (d) and (e) are INCLUDED in the standard error matrix
  and other methods provided by the base class TUnfold:
      GetOutput()
      GetEmatrix()

  whereas errors of type (a), (b), (c) are NOT INCLUDED in the methods
  provided by the base class TUnfold.

 Accessing error matrices:

  The error sources (b),(c) and (e) propagate to shifts of the result.
  These shifts may be accessed as histograms using the methods
     GetDeltaSysSource()            corresponds to (b)
     GetDeltaSysTau()               corresponds to (c)
     GetDeltaSysBackgroundScale()   corresponds to (e)
  The error sources (a) and (d) originate from many uncorrelated errors,
  which in general are NOT uncorrelated on the result vector.
  Thus, there is no corresponding shift of the output vector, only error
  matrices are available

  Method to get error matrix       corresponds to error sources

   GetEmatrixSysUncorr()             (a)
   GetEmatrixSysSource()             (b)
   GetEmatrixSysTau()                (c)
   GetEmatrixSysBackgroundUncorr()   (d)
   GetEmatrixSysBackgroundScale()    (e)
   GetEmatrixInput()                 (i)
   GetEmatrix()                      (i)+(d)+(e)
   GetEmatrixTotal()                 (i)+(a)+(b)+(c)+(d)+(e)

  Error matrices can be added to existing histograms.
  This is useful to retreive the sum of several error matrices.
  If the last argument of the GetEmatrixXXX() methods is set to kFALSE,
  the histogram is not cleared, but the error matrix is simply added to the
  existing histogram


Function Members (Methods)

public:
virtual~TUnfoldSys()
voidTObject::AbstractMethod(const char* method) const
voidAddSysError(const TH2* sysError, const char* name, TUnfold::EHistMap histmap, TUnfoldSys::ESysErrMode mode)
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidTObject::Delete(Option_t* option = "")MENU
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual Double_tTUnfold::DoUnfold(Double_t tau)
Double_tTUnfold::DoUnfold(Double_t tau, const TH1* hist_y, Double_t scaleBias = 0.)
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
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
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
voidGetBackground(TH1* bgr, const char* bgrSource = 0, const Int_t* binMap = 0, Int_t includeError = 3, Bool_t clearHist = kTRUE) const
voidTUnfold::GetBias(TH1* bias, const Int_t* binMap = 0) const
Double_tTUnfold::GetChi2A() const
Double_tTUnfold::GetChi2L() const
Double_tGetChi2Sys()
Bool_tGetDeltaSysBackgroundScale(TH1* delta, const char* source, const Int_t* binMap = 0)
Bool_tGetDeltaSysSource(TH1* hist_delta, const char* source, const Int_t* binMap = 0)
Bool_tGetDeltaSysTau(TH1* delta, const Int_t* binMap = 0)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
voidTUnfold::GetEmatrix(TH2* ematrix, const Int_t* binMap = 0) const
voidGetEmatrixInput(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixSysBackgroundScale(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixSysBackgroundUncorr(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixSysSource(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixSysTau(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixSysUncorr(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidGetEmatrixTotal(TH2* ematrix, const Int_t* binMap = 0)
Double_tTUnfold::GetEpsMatrix() const
voidTUnfold::GetFoldedOutput(TH1* folded, const Int_t* binMap = 0) const
virtual const char*TObject::GetIconName() const
voidTUnfold::GetInput(TH1* inputData, const Int_t* binMap = 0) const
voidTUnfold::GetInputInverseEmatrix(TH2* ematrix)
voidTUnfold::GetL(TH2* l) const
virtual Double_tTUnfold::GetLcurveX() const
virtual Double_tTUnfold::GetLcurveY() const
voidTUnfold::GetLsquared(TH2* lsquared) const
virtual const char*TObject::GetName() const
Int_tTUnfold::GetNdf() const
voidTUnfold::GetNormalisationVector(TH1* s, const Int_t* binMap = 0) const
Int_tTUnfold::GetNpar() const
Int_tTUnfold::GetNr() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
voidTUnfold::GetOutput(TH1* output, const Int_t* binMap = 0) const
voidTUnfold::GetProbabilityMatrix(TH2* A, TUnfold::EHistMap histmap) const
Double_tTUnfold::GetRhoAvg() const
Double_tTUnfold::GetRhoI(TH1* rhoi, const Int_t* binMap = 0, TH2* invEmat = 0) const
voidTUnfold::GetRhoIJ(TH2* rhoij, const Int_t* binMap = 0) const
voidGetRhoItotal(TH1* rhoi, const Int_t* binMap = 0, TH2* invEmat = 0)
Double_tTUnfold::GetRhoMax() const
Double_tTUnfold::GetTau() const
virtual const char*TObject::GetTitle() const
static const char*TUnfold::GetTUnfoldVersion()
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::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_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::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
voidTObject::operator delete(void* ptr)
voidTObject::operator delete(void* ptr, void* vp)
voidTObject::operator delete[](void* ptr)
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)
TUnfoldSys&operator=(const TUnfoldSys&)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
Int_tTUnfold::RegularizeBins(int start, int step, int nbin, TUnfold::ERegMode regmode)
Int_tTUnfold::RegularizeBins2D(int start_bin, int step1, int nbin1, int step2, int nbin2, TUnfold::ERegMode regmode)
Int_tTUnfold::RegularizeCurvature(int left_bin, int center_bin, int right_bin, Double_t scale_left = 1., Double_t scale_right = 1.)
Int_tTUnfold::RegularizeDerivative(int left_bin, int right_bin, Double_t scale = 1.)
Int_tTUnfold::RegularizeSize(int bin, Double_t scale = 1.)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual Int_tTUnfold::ScanLcurve(Int_t nPoint, Double_t tauMin, Double_t tauMax, TGraph** lCurve, TSpline** logTauX = 0, TSpline** logTauY = 0)
voidTUnfold::SetBias(const TH1* bias)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTUnfold::SetConstraint(TUnfold::EConstraint constraint)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidTUnfold::SetEpsMatrix(Double_t eps)
virtual Int_tSetInput(const TH1* hist_y, Double_t scaleBias = 0., Double_t oneOverZeroError = 0., const TH2* hist_vyy = 0, const TH2* hist_vyy_inv = 0)
static voidTObject::SetObjectStat(Bool_t stat)
voidSetTauError(Double_t delta_tau)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector& insp) const
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
voidSubtractBackground(const TH1* hist_bgr, const char* name, Double_t scale = 1., Double_t scale_error = 0.)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
TUnfoldSys(const TUnfoldSys&)
TUnfoldSys(const TH2* hist_A, TUnfold::EHistMap histmap, TUnfold::ERegMode regmode = kRegModeSize, TUnfold::EConstraint constraint = kEConstraintArea)
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:
voidTUnfold::AddMSparse(TMatrixDSparse* dest, Double_t f, const TMatrixDSparse* src) const
Bool_tTUnfold::AddRegularisationCondition(Int_t nEle, const Int_t* indices, const Double_t* rowData)
Bool_tTUnfold::AddRegularisationCondition(Int_t i0, Double_t f0, Int_t i1 = -1, Double_t f1 = 0., Int_t i2 = -1, Double_t f2 = 0.)
voidTUnfold::ClearHistogram(TH1* h, Double_t x = 0.) const
virtual voidClearResults()
TMatrixDSparse*TUnfold::CreateSparseMatrix(Int_t nrow, Int_t ncol, Int_t nele, Int_t* row, Int_t* col, Double_t* data) const
static voidTUnfold::DeleteMatrix(TMatrixD** m)
static voidTUnfold::DeleteMatrix(TMatrixDSparse** m)
voidDoBackgroundSubtraction()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
virtual Double_tTUnfold::DoUnfold()
voidTUnfold::ErrorMatrixToHist(TH2* ematrix, const TMatrixDSparse* emat, const Int_t* binMap, Bool_t doClear) const
const TMatrixDSparse*TUnfold::GetAx() const
Int_tTUnfold::GetBinFromRow(int ix) const
const TMatrixDSparse*TUnfold::GetDXDAM(int i) const
const TMatrixDSparse*TUnfold::GetDXDAZ(int i) const
const TMatrixDSparse*TUnfold::GetDXDtauSquared() const
const TMatrixDSparse*TUnfold::GetDXDY() const
const TMatrixDSparse*TUnfold::GetE() const
const TMatrixDSparse*TUnfold::GetEinv() const
voidGetEmatrixFromVyy(const TMatrixDSparse* vyy, TH2* ematrix, const Int_t* binMap, Bool_t clearEmat)
Int_tTUnfold::GetNx() const
Int_tTUnfold::GetNy() const
virtual TStringTUnfold::GetOutputBinName(Int_t iBinX) const
Double_tTUnfold::GetRhoIFromMatrix(TH1* rhoi, const TMatrixDSparse* eOrig, const Int_t* binMap, TH2* invEmat) const
Int_tTUnfold::GetRowFromBin(int ix) const
TMatrixDSparse*GetSummedErrorMatrixXX()
TMatrixDSparse*GetSummedErrorMatrixYY()
const TMatrixDSparse*TUnfold::GetVxx() const
const TMatrixDSparse*TUnfold::GetVxxInv() const
const TMatrixDSparse*TUnfold::GetVyyInv() const
const TMatrixD*TUnfold::GetX() const
TMatrixDSparse*TUnfold::InvertMSparseSymmPos(const TMatrixDSparse* A, Int_t* rank) const
voidTObject::MakeZombie()
TMatrixDSparse*TUnfold::MultiplyMSparseM(const TMatrixDSparse* a, const TMatrixD* b) const
TMatrixDSparse*TUnfold::MultiplyMSparseMSparse(const TMatrixDSparse* a, const TMatrixDSparse* b) const
TMatrixDSparse*TUnfold::MultiplyMSparseMSparseTranspVector(const TMatrixDSparse* m1, const TMatrixDSparse* m2, const TMatrixTBase<Double_t>* v) const
TMatrixDSparse*TUnfold::MultiplyMSparseTranspMSparse(const TMatrixDSparse* a, const TMatrixDSparse* b) const
virtual TMatrixDSparse*PrepareCorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2, const TMatrixDSparse* dsys)
virtual voidPrepareSysError()
virtual TMatrixDSparse*PrepareUncorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2)
voidScaleColumnsByVector(TMatrixDSparse* m, const TMatrixTBase<Double_t>* v) const
TUnfoldSys()
voidVectorMapToHist(TH1* hist_delta, const TMatrixDSparse* delta, const Int_t* binMap)
private:
voidInitTUnfoldSys()

Data Members

public:
static TObject::<anonymous>TObject::kBitMask
static TObject::EStatusBitsTObject::kCanDelete
static TObject::EStatusBitsTObject::kCannotPick
static TUnfold::EConstraintTUnfold::kEConstraintArea
static TUnfold::EConstraintTUnfold::kEConstraintNone
static TObject::EStatusBitsTObject::kHasUUID
static TUnfold::EHistMapTUnfold::kHistMapOutputHoriz
static TUnfold::EHistMapTUnfold::kHistMapOutputVert
static TObject::EStatusBitsTObject::kInvalidObject
static TObject::<anonymous>TObject::kIsOnHeap
static TObject::EStatusBitsTObject::kIsReferenced
static TObject::EStatusBitsTObject::kMustCleanup
static TObject::EStatusBitsTObject::kNoContextMenu
static TObject::<anonymous>TObject::kNotDeleted
static TObject::EStatusBitsTObject::kObjInCanvas
static TObject::<anonymous>TObject::kOverwrite
static TUnfold::ERegModeTUnfold::kRegModeCurvature
static TUnfold::ERegModeTUnfold::kRegModeDerivative
static TUnfold::ERegModeTUnfold::kRegModeMixed
static TUnfold::ERegModeTUnfold::kRegModeNone
static TUnfold::ERegModeTUnfold::kRegModeSize
static TObject::<anonymous>TObject::kSingleKey
static TUnfoldSys::ESysErrModekSysErrModeMatrix
static TUnfoldSys::ESysErrModekSysErrModeRelative
static TUnfoldSys::ESysErrModekSysErrModeShift
static TObject::<anonymous>TObject::kWriteDelete
static TObject::<anonymous>TObject::kZombie
protected:
TMatrixDSparse*TUnfold::fAInput: matrix
TMatrixD*fAoutsideInput: underflow/overflow bins
TMap*fBgrErrScaleInInput: background sources correlated error
TMap*fBgrErrUncorrInSqInput: uncorr error squared from bgr sources
TMap*fBgrInInput: size of background sources
Double_tTUnfold::fBiasScaleInput: scale factor for the bias
TUnfold::EConstraintTUnfold::fConstraintInput: type of constraint to use
TMatrixD*fDAinColRelSqInput: normalized column err.sq. (inp.matr.)
TMatrixDSparse*fDAinRelSqInput: normalized errors from input matrix
TMap*fDeltaCorrAxResult: syst.shift from fSysIn on fAx
TMap*fDeltaCorrXResult: syst.shift from fSysIn on fX
TMatrixDSparse*fDeltaSysTauResult: systematic shift from tau
Double_tfDtauInput: error on tau
TMatrixDSparse*fEmatUncorrAxResult: syst.error from fDA2 on fAx
TMatrixDSparse*fEmatUncorrXResult: syst.error from fDA2 on fX
TArrayITUnfold::fHistToXInput: histogram bins -> matrix indices
TMatrixDSparse*TUnfold::fLInput: regularisation conditions
TUnfold::ERegModeTUnfold::fRegModeInput: type of regularisation
TArrayDTUnfold::fSumOverYInput: sum of all columns
TMap*fSysInInput: correlated errors
Double_tTUnfold::fTauSquaredInput: regularisation parameter
TMatrixDSparse*TUnfold::fVyyInput: covariance matrix for y
TMatrixDSparse*fVyyDataInput: error on fY prior to bgr subtraction
TMatrixD*TUnfold::fX0Input: x0
TArrayITUnfold::fXToHistInput: matrix indices -> histogram bins
TMatrixD*TUnfold::fYInput: y
TMatrixD*fYDataInput: fY prior to bgr subtraction

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TUnfoldSys(const TUnfoldSys& )
 set all pointers to zero
void DoBackgroundSubtraction(void)
 performs background subtraction
 fY = fYData - fBgrIn
 fVyy = fVyyData + fBgrErrUncorr^2 + fBgrErrCorr * fBgrErrCorr#
 fVyyinv = fVyy^(-1)
Int_t SetInput(const TH1* hist_y, Double_t scaleBias = 0., Double_t oneOverZeroError = 0., const TH2* hist_vyy = 0, const TH2* hist_vyy_inv = 0)
 Define the input data for subsequent calls to DoUnfold(Double_t)
  input:   input distribution with errors
  scaleBias:  scale factor applied to the bias
  oneOverZeroError: for bins with zero error, this number defines 1/error.
 Return value: number of bins with bad error
                 +10000*number of unconstrained output bins
         Note: return values>=10000 are fatal errors,
               for the given input, the unfolding can not be done!
 Calls the SetInput method of the base class, then renames the input
 vectors fY and fVyy, then performs the background subtraction
 Data members modified:
   fYData,fY,fVyyData,fVyy,fVyyinvData,fVyyinv
 and those modified by TUnfold::SetInput()
 and those modified by DoBackgroundSubtraction()
void InitTUnfoldSys(void)
 initialize pointers and TMaps
~TUnfoldSys(void)
 delete all data members
void ClearResults(void)
 clear all data members which depend on the unfolding results
void PrepareSysError(void)
 calculations required for syst.error
 data members modified
    fEmatUncorrX, fEmatUncorrAx, fDeltaCorrX, fDeltaCorrAx
void SetTauError(Double_t delta_tau)
 set uncertainty on tau
Bool_t GetDeltaSysSource(TH1* hist_delta, const char* source, const Int_t* binMap = 0)
 calculate systematic shift from a given source
    ematrix: output
    source: name of the error source
    binMap: see method GetEmatrix()
Bool_t GetDeltaSysTau(TH1* delta, const Int_t* binMap = 0)
 calculate systematic shift from tau variation
    ematrix: output
    binMap: see method GetEmatrix()
void GetEmatrixTotal(TH2* ematrix, const Int_t* binMap = 0)
 get total error including statistical error
    ematrix: output
    binMap: see method GetEmatrix()
TMatrixDSparse * GetSummedErrorMatrixYY(void)
TMatrixDSparse * GetSummedErrorMatrixXX(void)
Double_t GetChi2Sys(void)
 calculate total chi**2 including systematic errors
void GetRhoItotal(TH1* rhoi, const Int_t* binMap = 0, TH2* invEmat = 0)
 get global correlation coefficients including systematic,statistical,background,tau errors
    rhoi: output histogram
    binMap: for each global bin, indicate in which histogram bin
            to store its content
    invEmat: output histogram for inverse of error matrix
              (pointer may zero if inverse is not requested)
TUnfoldSys(const TUnfoldSys& )
TMatrixDSparse * PrepareUncorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2)
TMatrixDSparse * PrepareCorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2, const TMatrixDSparse* dsys)
void ScaleColumnsByVector(TMatrixDSparse* m, const TMatrixTBase<Double_t>* v) const
void VectorMapToHist(TH1* hist_delta, const TMatrixDSparse* delta, const Int_t* binMap)
void GetEmatrixFromVyy(const TMatrixDSparse* vyy, TH2* ematrix, const Int_t* binMap, Bool_t clearEmat)
TUnfoldSys(const TH2* hist_A, TUnfold::EHistMap histmap, TUnfold::ERegMode regmode = kRegModeSize, TUnfold::EConstraint constraint = kEConstraintArea)
void AddSysError(const TH2* sysError, const char* name, TUnfold::EHistMap histmap, TUnfoldSys::ESysErrMode mode)
void SubtractBackground(const TH1* hist_bgr, const char* name, Double_t scale = 1., Double_t scale_error = 0.)
Bool_t GetDeltaSysBackgroundScale(TH1* delta, const char* source, const Int_t* binMap = 0)
void GetEmatrixSysUncorr(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
void GetEmatrixSysSource(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
void GetEmatrixSysBackgroundScale(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
void GetEmatrixInput(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)