ROOT logo
ROOT » HIST » HIST » TUnfoldDensity

class TUnfoldDensity: public TUnfoldSys


  TUnfoldDensity : public 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

  More details are described with the documentation of TUnfold.

  For most applications, it is best 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


  As compared to TUnfold, TUndolfDensity adds the following functionality
    * background subtraction (see documentation of TUnfoldSys)
    * error propagation (see documentation of TUnfoldSys)
    * regularisation schemes respecting the bin widths
    * support for complex, multidimensional input distributions

  Complex binning schemes are imposed on the measurements y and
  on the result vector x with the help of the class TUnfoldBinning
  The components of x or y are part of multi-dimensional distributions.
  The bin widths along the relevant directions in these distributions
  are used to calculate bin densities (number of events divided by bin width)
  or to calculate derivatives taking into account the proper distance of
  adjacent bin centers

  Complex binning schemes

  in literature on unfolding, the "standard" test case is a
  one-dimensional distribution without underflow or overflow bins.
  The migration matrix is almost diagonal.

  This "standard" case is rarely realized for real problems.

  Often one has to deal with multi-dimensional input distributions.
  In addition, there are underflow and overflow bins
  or other background bins, possibly determined with the help of auxillary
  measurements

  In TUnfoldDensity, such complex binning schemes are handled with the help
  of the class TUnfoldBinning. For each vector there is a tree
  structure. The tree nodes hold multi-dimensiopnal distributions

  For example, the "measurement" tree could have two leaves, one for
  the primary distribution and one for auxillary measurements

  Similarly, the "truth" tree could have two leaves, one for the
  signal and one for the background.

  each of the leaves may then have a multi-dimensional distribution.

  The class TUnfoldBinning takes care to map all bins of the
  "measurement" to the one-dimensional vector y.
  Similarly, the "truth" bins are mapped to the vector x.

  Choice of the regularisation

  In TUnfoldDensity, two methods are implemented to determine tau**2
    (1)  ScanLcurve()  locate the tau where the L-curve plot has a "kink"
      this function is implemented in the TUnfold class
    (2)  ScanTau() finds the solution such that some variable
           (e.g. global correlation coefficient) is minimized
      this function is implemented in the TUnfoldDensity class,
      such that the variable could be made depend on the binning scheme

  Each of the algorithms has its own advantages and disadvantages

  The algorithm (1) does not work if the input data are too similar to the
  MC prediction, that is unfolding with tau=0 gives a least-square sum
  of zero. Typical no-go cases of the L-curve scan are:
    (a) the number of measurements is too small (e.g. ny=nx)
    (b) the input data have no statistical fluctuations
         [identical MC events are used to fill the matrix of migrations
          and the vector y]

  The algorithm (2) only works if the variable does have a real minimum
  as a function of tau.
  If global correlations are minimized, the situation is as follows:
  The matrix of migration typically introduces negative correlations.
   The area constraint introduces some positive correlation.
   Regularisation on the "size" introduces no correlation.
   Regularisation on 1st or 2nd derivatives adds positive correlations.
   For this reason, "size" regularisation does not work well with
   the tau-scan: the higher tau, the smaller rho, but there is no minimum.
   In contrast, the tau-scan is expected to work well with 1st or 2nd
   derivative regularisation, because at some point the negative
   correlations from migrations are approximately cancelled by the
   positive correlations from the regularisation conditions.

  whichever algorithm is used, the output has to be checked:
  (1) The L-curve should have approximate L-shape
       and the final choice of tau should not be at the very edge of the
       scanned region
  (2) The scan result should have a well-defined minimum and the
       final choice of tau should sit right in the minimum


Function Members (Methods)

public:
TUnfoldDensity(const TUnfoldDensity&)
TUnfoldDensity(const TH2* hist_A, TUnfold::EHistMap histmap, TUnfold::ERegMode regmode = kRegModeCurvature, TUnfold::EConstraint constraint = kEConstraintArea, TUnfoldDensity::EDensityMode densityMode = kDensityModeBinWidthAndUser, const TUnfoldBinning* outputBins = 0, const TUnfoldBinning* inputBins = 0, const char* regularisationDistribution = 0, const char* regularisationAxisSteering = "*[UOB]")
virtual~TUnfoldDensity()
voidTObject::AbstractMethod(const char* method) const
voidTUnfoldSys::AddSysError(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.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
TH1*GetBackground(const char* histogramName, const char* bgrSource = 0, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, Int_t includeError = 3, Bool_t clearHist = kTRUE) const
TH1*GetBias(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE) const
Double_tTUnfold::GetChi2A() const
Double_tTUnfold::GetChi2L() const
Double_tTUnfoldSys::GetChi2Sys()
TH1*GetDeltaSysBackgroundScale(const char* bgrSource, const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH1*GetDeltaSysSource(const char* source, const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH1*GetDeltaSysTau(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
voidTUnfold::GetEmatrix(TH2* ematrix, const Int_t* binMap = 0) const
TH2*GetEmatrixInput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
voidTUnfoldSys::GetEmatrixSysBackgroundScale(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
TH2*GetEmatrixSysBackgroundUncorr(const char* bgrSource, const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
voidTUnfoldSys::GetEmatrixSysSource(TH2* ematrix, const char* source, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
voidTUnfoldSys::GetEmatrixSysTau(TH2* ematrix, const Int_t* binMap = 0, Bool_t clearEmat = kTRUE)
TH2*GetEmatrixSysUncorr(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH2*GetEmatrixTotal(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
Double_tTUnfold::GetEpsMatrix() const
TH1*GetFoldedOutput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, Bool_t addBgr = kFALSE) const
virtual const char*TObject::GetIconName() const
TH1*GetInput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE) const
const TUnfoldBinning*GetInputBinning(const char* distributionName = 0) const
voidTUnfold::GetInputInverseEmatrix(TH2* ematrix)
TH2*GetL(const char* histogramName, const char* histogramTitle = 0, Bool_t useAxisBinning = kTRUE)
TUnfoldBinning*GetLBinning() const
virtual Double_tTUnfold::GetLcurveX() const
virtual Double_tTUnfold::GetLcurveY() const
voidTUnfold::GetLsquared(TH2* lsquared) const
TH1*GetLxMinusBias(const char* histogramName, const char* histogramTitle = 0)
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
TH1*GetOutput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE) const
const TUnfoldBinning*GetOutputBinning(const char* distributionName = 0) const
TH2*GetProbabilityMatrix(const char* histogramName, const char* histogramTitle = 0, Bool_t useAxisBinning = kTRUE) 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
TH2*GetRhoIJtotal(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH1*GetRhoIstatbgr(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, TH2** ematInv = 0)
TH1*GetRhoItotal(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, TH2** ematInv = 0)
Double_tTUnfold::GetRhoMax() const
virtual Double_tGetScanVariable(Int_t mode, const char* distribution, const char* projectionMode)
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
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)
TUnfoldSys&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.0, Double_t scale_right = 1.0)
Int_tTUnfold::RegularizeDerivative(int left_bin, int right_bin, Double_t scale = 1.0)
voidRegularizeDistribution(TUnfold::ERegMode regmode, TUnfoldDensity::EDensityMode densityMode, const char* distribution, const char* axisSteering)
Int_tTUnfold::RegularizeSize(int bin, Double_t scale = 1.0)
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)
virtual Int_tScanTau(Int_t nPoint, Double_t tauMin, Double_t tauMax, TSpline** scanResult, Int_t mode = kEScanTauRhoAvg, const char* distribution = 0, const char* projectionMode = 0, TGraph** lCurvePlot = 0, TSpline** logTauXPlot = 0, TSpline** logTauYPlot = 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_tTUnfoldSys::SetInput(const TH1* hist_y, Double_t scaleBias = 0.0, Double_t oneOverZeroError = 0.0, const TH2* hist_vyy = 0, const TH2* hist_vyy_inv = 0)
static voidTObject::SetObjectStat(Bool_t stat)
voidTUnfoldSys::SetTauError(Double_t delta_tau)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
voidTUnfoldSys::SubtractBackground(const TH1* hist_bgr, const char* name, Double_t scale = 1.0, Double_t scale_error = 0.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
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:
TUnfoldDensity()
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 voidTUnfoldSys::ClearResults()
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)
voidTUnfoldSys::DoBackgroundSubtraction()
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
Double_tGetDensityFactor(TUnfoldDensity::EDensityMode densityMode, Int_t iBin) 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
voidTUnfoldSys::GetEmatrixFromVyy(const TMatrixDSparse* vyy, TH2* ematrix, const Int_t* binMap, Bool_t clearEmat)
Int_tTUnfold::GetNx() const
Int_tTUnfold::GetNy() const
virtual TStringGetOutputBinName(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*TUnfoldSys::GetSummedErrorMatrixXX()
TMatrixDSparse*TUnfoldSys::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*TUnfoldSys::PrepareCorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2, const TMatrixDSparse* dsys)
virtual voidTUnfoldSys::PrepareSysError()
virtual TMatrixDSparse*TUnfoldSys::PrepareUncorrEmat(const TMatrixDSparse* m1, const TMatrixDSparse* m2)
voidRegularizeDistributionRecursive(const TUnfoldBinning* binning, TUnfold::ERegMode regmode, TUnfoldDensity::EDensityMode densityMode, const char* distribution, const char* axisSteering)
voidRegularizeOneDistribution(const TUnfoldBinning* binning, TUnfold::ERegMode regmode, TUnfoldDensity::EDensityMode densityMode, const char* axisSteering)
voidTUnfoldSys::ScaleColumnsByVector(TMatrixDSparse* m, const TMatrixTBase<Double_t>* v) const
voidTUnfoldSys::VectorMapToHist(TH1* hist_delta, const TMatrixDSparse* delta, const Int_t* binMap)

Data Members

public:
enum EDensityMode { kDensityModeeNone
kDensityModeBinWidth
kDensityModeUser
kDensityModeBinWidthAndUser
};
enum EScanTauMode { kEScanTauRhoAvg
kEScanTauRhoMax
kEScanTauRhoAvgSys
kEScanTauRhoMaxSys
kEScanTauRhoSquareAvg
kEScanTauRhoSquareAvgSys
};
enum TUnfoldSys::ESysErrMode { kSysErrModeMatrix
kSysErrModeShift
kSysErrModeRelative
};
enum TUnfold::EConstraint { kEConstraintNone
kEConstraintArea
};
enum TUnfold::ERegMode { kRegModeNone
kRegModeSize
kRegModeDerivative
kRegModeCurvature
kRegModeMixed
};
enum TUnfold::EHistMap { kHistMapOutputHoriz
kHistMapOutputVert
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
protected:
TMatrixDSparse*TUnfold::fAInput: matrix
TMatrixD*TUnfoldSys::fAoutsideInput: underflow/overflow bins
TMap*TUnfoldSys::fBgrErrScaleInInput: background sources correlated error
TMap*TUnfoldSys::fBgrErrUncorrInSqInput: uncorr error squared from bgr sources
TMap*TUnfoldSys::fBgrInInput: size of background sources
Double_tTUnfold::fBiasScaleInput: scale factor for the bias
const TUnfoldBinning*fConstInputBinsbinning scheme for the input
const TUnfoldBinning*fConstOutputBinsbinning scheme for the output
TUnfold::EConstraintTUnfold::fConstraintInput: type of constraint to use
TMatrixD*TUnfoldSys::fDAinColRelSqInput: normalized column err.sq. (inp.matr.)
TMatrixDSparse*TUnfoldSys::fDAinRelSqInput: normalized errors from input matrix
TMap*TUnfoldSys::fDeltaCorrAxResult: syst.shift from fSysIn on fAx
TMap*TUnfoldSys::fDeltaCorrXResult: syst.shift from fSysIn on fX
TMatrixDSparse*TUnfoldSys::fDeltaSysTauResult: systematic shift from tau
Double_tTUnfoldSys::fDtauInput: error on tau
TMatrixDSparse*TUnfoldSys::fEmatUncorrAxResult: syst.error from fDA2 on fAx
TMatrixDSparse*TUnfoldSys::fEmatUncorrXResult: syst.error from fDA2 on fX
TArrayITUnfold::fHistToXInput: histogram bins -> matrix indices
TMatrixDSparse*TUnfold::fLInput: regularisation conditions
TUnfoldBinning*fOwnedInputBinsinput binning scheme if owner
TUnfoldBinning*fOwnedOutputBinsoutput binning scheme if owner
TUnfold::ERegModeTUnfold::fRegModeInput: type of regularisation
TUnfoldBinning*fRegularisationConditionsbinning scheme for the regularisation conditions
TArrayDTUnfold::fSumOverYInput: sum of all columns
TMap*TUnfoldSys::fSysInInput: correlated errors
Double_tTUnfold::fTauSquaredInput: regularisation parameter
TMatrixDSparse*TUnfold::fVyyInput: covariance matrix for y
TMatrixDSparse*TUnfoldSys::fVyyDataInput: error on fY prior to bgr subtraction
TMatrixD*TUnfold::fX0Input: x0
TArrayITUnfold::fXToHistInput: matrix indices -> histogram bins
TMatrixD*TUnfold::fYInput: y
TMatrixD*TUnfoldSys::fYDataInput: fY prior to bgr subtraction

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

TUnfoldDensity(const TUnfoldDensity& )
 empty constructor, for derived classes
~TUnfoldDensity(void)
 clean up
TString GetOutputBinName(Int_t iBinX) const
TUnfoldDensity(const TUnfoldDensity& )
Double_t GetDensityFactor(TUnfoldDensity::EDensityMode densityMode, Int_t iBin) const
TUnfoldDensity(const TH2* hist_A, TUnfold::EHistMap histmap, TUnfold::ERegMode regmode = kRegModeCurvature, TUnfold::EConstraint constraint = kEConstraintArea, TUnfoldDensity::EDensityMode densityMode = kDensityModeBinWidthAndUser, const TUnfoldBinning* outputBins = 0, const TUnfoldBinning* inputBins = 0, const char* regularisationDistribution = 0, const char* regularisationAxisSteering = "*[UOB]")
void RegularizeDistribution(TUnfold::ERegMode regmode, TUnfoldDensity::EDensityMode densityMode, const char* distribution, const char* axisSteering)
Int_t ScanTau(Int_t nPoint, Double_t tauMin, Double_t tauMax, TSpline** scanResult, Int_t mode = kEScanTauRhoAvg, const char* distribution = 0, const char* projectionMode = 0, TGraph** lCurvePlot = 0, TSpline** logTauXPlot = 0, TSpline** logTauYPlot = 0)
TH1 * GetOutput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE) const
TH1 * GetFoldedOutput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, Bool_t addBgr = kFALSE) const
TH1 * GetInput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE) const
TH1 * GetDeltaSysBackgroundScale(const char* bgrSource, const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH2 * GetEmatrixSysUncorr(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH2 * GetEmatrixInput(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH1 * GetRhoIstatbgr(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE, TH2** ematInv = 0)
TH2 * GetRhoIJtotal(const char* histogramName, const char* histogramTitle = 0, const char* distributionName = 0, const char* projectionMode = 0, Bool_t useAxisBinning = kTRUE)
TH1 * GetLxMinusBias(const char* histogramName, const char* histogramTitle = 0)
TH2 * GetProbabilityMatrix(const char* histogramName, const char* histogramTitle = 0, Bool_t useAxisBinning = kTRUE) const
const TUnfoldBinning * GetOutputBinning(const char* distributionName = 0) const
TUnfoldBinning * GetLBinning(void)