/usr/include/root/TUnfoldDensity.h is in libroot-hist-dev 5.34.19+dfsg-1.2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | // Author: Stefan Schmitt
// DESY, 11/08/11
// Version 17.1, add scan type RhoSquare
//
// History:
// Version 17.0, support for density regularisation and complex binning schemes
#ifndef ROOT_TUnfoldDensity
#define ROOT_TUnfoldDensity
//////////////////////////////////////////////////////////////////////////
// //
// //
// TUnfoldDensity, an extension of the class TUnfoldSys to correct for //
// migration effects. TUnfoldDensity provides methods to deal with //
// multidimensional complex binning schemes and variable bin widths //
// //
// Citation: S.Schmitt, JINST 7 (2012) T10003 [arXiv:1205.6201] //
// //
//////////////////////////////////////////////////////////////////////////
/*
This file is part of TUnfold.
TUnfold is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
TUnfold is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with TUnfold. If not, see <http://www.gnu.org/licenses/>.
*/
#include "TUnfoldSys.h"
#include "TUnfoldBinning.h"
class TUnfoldDensity : public TUnfoldSys {
protected:
const TUnfoldBinning * fConstOutputBins; // binning scheme for the output
const TUnfoldBinning * fConstInputBins; // binning scheme for the input
TUnfoldBinning *fOwnedOutputBins; // output binning scheme if owner
TUnfoldBinning *fOwnedInputBins; // input binning scheme if owner
TUnfoldBinning *fRegularisationConditions; // binning scheme for the regularisation conditions
public:
enum EDensityMode {
kDensityModeeNone=0,
kDensityModeBinWidth=1,
kDensityModeUser=2,
kDensityModeBinWidthAndUser=3
};
protected:
virtual TString GetOutputBinName(Int_t iBinX) const; // name a bin
TUnfoldDensity(void); // constructor for derived classes, do nothing
Double_t GetDensityFactor(EDensityMode densityMode,Int_t iBin) const; // density correction factor for this bin
void RegularizeDistributionRecursive
(const TUnfoldBinning *binning,ERegMode regmode,
EDensityMode densityMode,const char *distribution,
const char *axisSteering); // regularize the given binning recursively
void RegularizeOneDistribution
(const TUnfoldBinning *binning,ERegMode regmode,
EDensityMode densityMode,const char *axisSteering); // regularize the distribution of one binning node
public:
TUnfoldDensity(const TH2 *hist_A, EHistMap histmap,
ERegMode regmode = kRegModeCurvature,
EConstraint constraint=kEConstraintArea,
EDensityMode densityMode=kDensityModeBinWidthAndUser,
const TUnfoldBinning *outputBins=0,
const TUnfoldBinning *inputBins=0,
const char *regularisationDistribution=0,
const char *regularisationAxisSteering="*[UOB]"); // constructor for using the histogram classes. Default regularisation is on the curvature of the bin-width normalized density, excluding underflow and overflow bins
virtual ~ TUnfoldDensity(void); // delete data members
void RegularizeDistribution(ERegMode regmode,EDensityMode densityMode,
const char *distribution,
const char *axisSteering); // regularize distribution(s) of the output binning scheme
enum EScanTauMode { // scan mode of correlation scan
kEScanTauRhoAvg =0, // average global correlation coefficient (from TUnfold::GetRhoI())
kEScanTauRhoMax =1, // maximum global correlation coefficient (from TUnfold::GetRhoI())
kEScanTauRhoAvgSys =2, // average global correlation coefficient (from TUnfoldSys::GetRhoItotal())
kEScanTauRhoMaxSys =3, // maximum global correlation coefficient (from TUnfoldSys::GetRhoItotal())
kEScanTauRhoSquareAvg =4, // average global correlation coefficient squared (from TUnfold::GetRhoI())
kEScanTauRhoSquareAvgSys =5 // average global correlation coefficient squared (from TUnfoldSys::GetRhoItotal())
};
virtual 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); // scan some variable (e.g. global correlation) and find a minimum using successive calls to DoUnfold(Double_t) at various tau
virtual Double_t GetScanVariable(Int_t mode,const char *distribution,const char *projectionMode); // calculate variable for ScanTau()
TH1 *GetOutput(const char *histogramName,
const char *histogramTitle=0,const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE) const; // get unfolding result
TH1 *GetBias(const char *histogramName,
const char *histogramTitle=0,const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE) const; // get bias
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; // get unfolding result folded back
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; // get background source
TH1 *GetInput(const char *histogramName,const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE) const; // get unfolding input
TH1 *GetDeltaSysSource(const char *source,
const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get systematic shifts from one systematic source
TH1 *GetDeltaSysBackgroundScale(const char *bgrSource,
const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get correlated uncertainty induced by the scale uncertainty of a background source
TH1 *GetDeltaSysTau(const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get correlated uncertainty from varying tau
TH2 *GetEmatrixSysUncorr(const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get error matrix contribution from uncorrelated errors on the matrix A
TH2 *GetEmatrixSysBackgroundUncorr(const char *bgrSource,
const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get error matrix from uncorrelated error of one background source
TH2 *GetEmatrixInput(const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get error contribution from input vector
TH2 *GetEmatrixTotal(const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get total error including systematic,statistical,background,tau errors
TH1 *GetRhoIstatbgr(const char *histogramName,const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE,
TH2 **ematInv=0); // get global correlation coefficients, stat+bgr errors only (from TUnfold)
TH1 *GetRhoItotal(const char *histogramName,const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE,
TH2 **ematInv=0); // get global correlation coefficients, including systematic errors (from TUnfoldSys)
TH2 *GetRhoIJtotal(const char *histogramName,
const char *histogramTitle=0,
const char *distributionName=0,
const char *projectionMode=0,Bool_t useAxisBinning=kTRUE); // get correlation coefficients
TH2 *GetL(const char *histogramName,
const char *histogramTitle=0,
Bool_t useAxisBinning=kTRUE); // get regularisation matrix
TH1 *GetLxMinusBias(const char *histogramName,const char *histogramTitle=0); // get vector L(x-bias) of regularisation conditions
TH2 *GetProbabilityMatrix(const char *histogramName,
const char *histogramTitle=0,Bool_t useAxisBinning=kTRUE) const; // get matrix of probabilities
const TUnfoldBinning *GetInputBinning(const char *distributionName=0) const; // find binning scheme for input bins
const TUnfoldBinning *GetOutputBinning(const char *distributionName=0) const; // find binning scheme for output bins
TUnfoldBinning *GetLBinning(void) const { return fRegularisationConditions; } // binning scheme for regularisation conditions (matrix L)
ClassDef(TUnfoldDensity, TUnfold_CLASS_VERSION) //Unfolding with densisty regularisation
};
#endif
|