Logo ROOT   6.08/07
Reference Guide
PDEFoam.h
Go to the documentation of this file.
1 // @(#)root/tmva $Id$
2 // Author: S. Jadach, Tancredi Carli, Dominik Dannheim, Alexander Voigt
3 
4 /**********************************************************************************
5  * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
6  * Package: TMVA *
7  * Classes: PDEFoam *
8  * Web : http://tmva.sourceforge.net *
9  * *
10  * Description: *
11  * Class for PDEFoam object *
12  * *
13  * Authors (alphabetical): *
14  * S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
15  * Tancredi Carli - CERN, Switzerland *
16  * Dominik Dannheim - CERN, Switzerland *
17  * Alexander Voigt - TU Dresden, Germany *
18  * *
19  * Copyright (c) 2008, 2010: *
20  * CERN, Switzerland *
21  * MPI-K Heidelberg, Germany *
22  * *
23  * Redistribution and use in source and binary forms, with or without *
24  * modification, are permitted according to the terms listed in LICENSE *
25  * (http://tmva.sourceforge.net/LICENSE) *
26  **********************************************************************************/
27 
28 #ifndef ROOT_TMVA_PDEFoam
29 #define ROOT_TMVA_PDEFoam
30 
31 #include <iosfwd>
32 #include <cassert>
33 
34 #ifndef ROOT_TH2D
35 #include "TH2D.h"
36 #endif
37 #ifndef ROOT_TObjArray
38 #include "TObjArray.h"
39 #endif
40 #ifndef ROOT_TObjString
41 #include "TObjString.h"
42 #endif
43 #ifndef ROOT_TVectorT
44 #include "TVectorT.h"
45 #endif
46 #ifndef ROOT_TString
47 #include "TString.h"
48 #endif
49 #ifndef ROOT_TMVA_VariableInfo
50 #include "TMVA/VariableInfo.h"
51 #endif
52 #ifndef ROOT_TMVA_Timer
53 #include "TMVA/Timer.h"
54 #endif
55 #ifndef ROOT_TObject
56 #include "TObject.h"
57 #endif
58 #ifndef ROOT_TRandom3
59 #include "TRandom3.h"
60 #endif
61 
62 namespace TMVA {
63  class PDEFoamCell;
64  class PDEFoamVect;
65  class PDEFoamDensityBase;
66  class PDEFoamKernelBase;
67  class PDEFoam;
68 
69  // separation types
72 
73  // foam types
75 
76  // enum type for possible foam cell values
77  // kValue : cell value who's rms is minimized
78  // kValueError : error on kValue
79  // kValueDensity : kValue / cell volume
80  // kMeanValue : mean sampling value (saved in fIntegral)
81  // kRms : rms of sampling distribution (saved in fDriver)
82  // kRmsOvMean : rms/mean of sampling distribution (saved in
83  // fDriver and fIntegral)
84  // kCellVolume : volume of cell
87 }
88 
89 #ifndef ROOT_TMVA_PDEFoamDensityBase
91 #endif
92 #ifndef ROOT_TMVA_PDEFoamVect
93 #include "TMVA/PDEFoamVect.h"
94 #endif
95 #ifndef ROOT_TMVA_PDEFoamCell
96 #include "TMVA/PDEFoamCell.h"
97 #endif
98 
99 namespace TMVA {
100 
101  class PDEFoam : public TObject {
102  protected:
103  // COMPONENTS //
104  //-------------- Input parameters
105  TString fName; // Name of a given instance of the FOAM class
106  Int_t fDim; // Dimension of the integration/simulation space
107  Int_t fNCells; // Maximum number of cells
108  //-------------------
109  Int_t fNBin; // No. of bins in the edge histogram for cell MC exploration
110  Int_t fNSampl; // No. of MC events, when dividing (exploring) cell
111  Int_t fEvPerBin; // Maximum number of effective (wt=1) events per bin
112  //------------------- MULTI-BRANCHING ---------------------
113  Int_t *fMaskDiv; //! [fDim] Dynamic Mask for cell division
114  Int_t *fInhiDiv; //! [fDim] Flags for inhibiting cell division
115  //------------------- GEOMETRY ----------------------------
116  Int_t fNoAct; // Number of active cells
117  Int_t fLastCe; // Index of the last cell
118  PDEFoamCell **fCells; // [fNCells] Array of ALL cells
119  //------------------ M.C. generation----------------------------
120  TObjArray *fHistEdg; // Histograms of wt, one for each cell edge
121  Double_t *fRvec; // [fDim] random number vector from r.n. generator fDim+1 maximum elements
122  //----------- Procedures
123  TRandom3 *fPseRan; // Pointer to user-defined generator of pseudorandom numbers
124  //---------- working space for CELL exploration -------------
125  Double_t *fAlpha; // [fDim] Internal parameters of the hyperrectangle
126  // --------- PDE-Foam specific variables
127  EFoamType fFoamType; // BACKWARDS COMPATIBILITY: type of foam
128  Double_t *fXmin; // [fDim] minimum for variable transform
129  Double_t *fXmax; // [fDim] maximum for variable transform
130  UInt_t fNElements; // BACKWARDS COMPATIBILITY: number of variables in every cell
131  UInt_t fNmin; // minimal number of events in cell to split cell
132  UInt_t fMaxDepth; // maximum depth of cell tree
133  Float_t fVolFrac; // BACKWARDS COMPATIBILITY: volume fraction (with respect to total phase space
134  Bool_t fFillFoamWithOrigWeights; // BACKWARDS COMPATIBILITY: fill the foam with boost or orig. weights
135  EDTSeparation fDTSeparation; // BACKWARDS COMPATIBILITY: split cells according to decision tree logic
136  Bool_t fPeekMax; // BACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split
137  PDEFoamDensityBase *fDistr; //! distribution of training events
138  Timer *fTimer; //! timer for graphical output
139  TObjArray *fVariableNames;// collection of all variable names
140  mutable MsgLogger* fLogger; //! message logger
141 
142  /////////////////////////////////////////////////////////////////
143  // METHODS //
144  /////////////////////////////////////////////////////////////////
145 
146  protected:
147  // ---------- TMVA console output
148 
149  void OutputGrow(Bool_t finished = false ); // nice TMVA console output
150 
151  // ---------- Foam build-up functions
152 
153  // Internal foam initialization functions
154  void InitCells(); // Initialisation of all foam cells
155  Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and return its index
156  virtual void Explore(PDEFoamCell *Cell); // Exploration of the new cell, determine <wt>, wtMax etc.
157  void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction
158  void MakeAlpha(); // Provides random point inside hyperrectangle
159  void Grow(); // build up foam
160  Long_t PeekMax(); // peek cell with max. driver integral
161  Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCell retained, taged as inactive
162  Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate distribution on point 'xRand'
163 
164  // ---------- Cell value access functions
165 
166  // low level functions to access a certain cell value
167  Double_t GetCellElement(const PDEFoamCell *cell, UInt_t i) const; // get Element 'i' in cell 'cell'
168  void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); // set Element 'i' in cell 'cell' to value 'value'
169 
170  // specific function used during evaluation; determines, whether a cell value is undefined
172 
173  // finds cell according to given event variables
174  PDEFoamCell* FindCell(const std::vector<Float_t>&) const ;
175  std::vector<TMVA::PDEFoamCell*> FindCells(const std::vector<Float_t>&) const;
176  std::vector<TMVA::PDEFoamCell*> FindCells(const std::map<Int_t,Float_t>&) const;
177  void FindCells(const std::map<Int_t, Float_t>&, PDEFoamCell*, std::vector<PDEFoamCell*> &) const;
178 
179  // get internal density
180  PDEFoamDensityBase* GetDistr() const { assert(fDistr); return fDistr; }
181 
182  // Square function (fastest implementation)
183  template<typename T> T Sqr(T x) const { return x*x; }
184 
185  PDEFoam(const PDEFoam&); // Copy Constructor NOT USED
186 
187  // ---------- Public functions ----------------------------------
188  public:
189  PDEFoam(); // Default constructor (used only by ROOT streamer)
190  PDEFoam(const TString&); // Principal user-defined constructor
191  virtual ~PDEFoam(); // Default destructor
192 
193  // ---------- Foam creation functions
194 
195  void Initialize() {} // initialize the PDEFoam
196  void FillBinarySearchTree( const Event* ev ); // fill event into BST
197  void Create(); // build-up foam
198 
199  // function to fill created cell with given value
200  virtual void FillFoamCells(const Event* ev, Float_t wt);
201 
202  // remove all cell elements
203  void ResetCellElements();
204 
205  // function to call after foam is grown
206  virtual void Finalize() {}
207 
208  // ---------- Getters and Setters
209 
210  void SetDim(Int_t kDim); // Sets dimension of cubical space
211  void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum number of cells
212  void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC events in cell exploration
213  void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins in histogs in cell exploration
214  void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. no. of effective events per bin
215  void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division along certain edge
216  void SetDensity(PDEFoamDensityBase *dens) { fDistr = dens; }
217 
218  // coverity[ -tainted_data_return ]
219  Int_t GetTotDim() const {return fDim; } // Get total dimension
220  TString GetFoamName() const {return fName; } // Get name of foam
221  UInt_t GetNActiveCells() const {return fNoAct;} // returns number of active cells
222  UInt_t GetNInActiveCells() const {return GetNCells()-GetNActiveCells();} // returns number of not active cells
223  UInt_t GetNCells() const {return fNCells;} // returns number of cells
224  PDEFoamCell* GetRootCell() const {return fCells[0];} // get pointer to root cell
225 
226  // Getters and Setters for user cut options
227  void SetNmin(UInt_t val) { fNmin=val; }
228  UInt_t GetNmin() { return fNmin; }
229  void SetMaxDepth(UInt_t maxdepth) { fMaxDepth = maxdepth; }
230  UInt_t GetMaxDepth() const { return fMaxDepth; }
231 
232  // Getters and Setters for foam boundaries
233  void SetXmin(Int_t idim, Double_t wmin);
234  void SetXmax(Int_t idim, Double_t wmax);
235  Double_t GetXmin(Int_t idim) const {return fXmin[idim];}
236  Double_t GetXmax(Int_t idim) const {return fXmax[idim];}
237 
238  // Getters and Setters for variable names
239  void AddVariableName(const char *s) { AddVariableName(new TObjString(s)); }
240  void AddVariableName(TObjString *s) { fVariableNames->Add(s); }
241  TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjString*>(fVariableNames->At(idx));}
242 
243  // Delete the fDistr object, which contains the binary search
244  // tree
245  void DeleteBinarySearchTree();
246 
247  // ---------- Transformation functions for event variables into foam boundaries
248  // reason: foam allways has boundaries [0, 1]
249 
250  Float_t VarTransform(Int_t idim, Float_t x) const; // transform [xmin, xmax] --> [0, 1]
251  std::vector<Float_t> VarTransform(const std::vector<Float_t> &invec) const;
252  Float_t VarTransformInvers(Int_t idim, Float_t x) const; // transform [0, 1] --> [xmin, xmax]
253  std::vector<Float_t> VarTransformInvers(const std::vector<Float_t> &invec) const;
254 
255  // ---------- Debug functions
256 
257  void CheckAll(Int_t); // Checks correctness of the entire data structure in the FOAM object
258  void PrintCell(Long_t iCell=0); // Print content of cell
259  void PrintCells(); // Prints content of all cells
260 
261  // Message logger
262  MsgLogger& Log() const { return *fLogger; }
263 
264  // ---------- Foam projection methods
265 
266  // project foam to two-dimensional histogram
267  virtual TH2D* Project2(Int_t idim1, Int_t idim2, ECellValue cell_value=kValue,
268  PDEFoamKernelBase *kernel=NULL, UInt_t nbin=50);
269 
270  // Project one-dimensional foam to a 1-dim histogram
271  TH1D* Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase *kernel=NULL);
272 
273  // Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)
274  void RootPlot2dim( const TString& filename, TString opt,
275  Bool_t createCanvas = kTRUE, Bool_t colors = kTRUE );
276 
277  // ---------- Foam evaluation functions
278 
279  // get cell value for a given event
280  virtual Float_t GetCellValue( const std::vector<Float_t>& xvec, ECellValue cv, PDEFoamKernelBase* );
281 
282  // get cell values for a given (incomplete) event vector
283  virtual std::vector<Float_t> GetCellValue( const std::map<Int_t,Float_t>& xvec, ECellValue cv );
284 
285  // get cell value stored in a foam cell
286  virtual Float_t GetCellValue( const PDEFoamCell* cell, ECellValue cv );
287 
288  // ---------- friend classes
289  friend class PDEFoamKernelBase;
290  friend class PDEFoamKernelTrivial;
291  friend class PDEFoamKernelLinN;
292  friend class PDEFoamKernelGauss;
293 
294  // ---------- ROOT class definition
295  ClassDef(PDEFoam,7) // Tree of PDEFoamCells
296  }; // end of PDEFoam
297 
298 } // namespace TMVA
299 
300 // ---------- Inline functions
301 
302 //_____________________________________________________________________
304 {
305  // transform variable x from [xmin, xmax] --> [0, 1]
306  return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
307 }
308 
309 //_____________________________________________________________________
310 inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(const std::vector<Float_t> &invec) const
311 {
312  // transform vector invec from [xmin, xmax] --> [0, 1]
313  std::vector<Float_t> outvec;
314  for(UInt_t i=0; i<invec.size(); i++)
315  outvec.push_back(VarTransform(i, invec.at(i)));
316  return outvec;
317 }
318 
319 //_____________________________________________________________________
321 {
322  // transform variable x from [0, 1] --> [xmin, xmax]
323  return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];
324 }
325 
326 //_____________________________________________________________________
327 inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(const std::vector<Float_t> &invec) const
328 {
329  // transform vector invec from [0, 1] --> [xmin, xmax]
330  std::vector<Float_t> outvec;
331  for(UInt_t i=0; i<invec.size(); i++)
332  outvec.push_back(VarTransformInvers(i, invec.at(i)));
333  return outvec;
334 }
335 
336 #endif
Double_t * fRvec
Definition: PDEFoam.h:121
Bool_t fFillFoamWithOrigWeights
Definition: PDEFoam.h:134
void Varedu(Double_t [], Int_t &, Double_t &, Double_t &)
Internal subrogram used by Create.
Definition: PDEFoam.cxx:570
virtual void FillFoamCells(const Event *ev, Float_t wt)
This function fills a weight &#39;wt&#39; into the PDEFoam cell, which corresponds to the given event &#39;ev&#39;...
Definition: PDEFoam.cxx:955
An array of TObjects.
Definition: TObjArray.h:39
MsgLogger * fLogger
Definition: PDEFoam.h:140
UInt_t fNmin
Definition: PDEFoam.h:131
Random number generator class based on M.
Definition: TRandom3.h:29
Long_t PeekMax()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:651
EDTSeparation
Definition: PDEFoam.h:70
TObjArray * fVariableNames
timer for graphical output
Definition: PDEFoam.h:139
Int_t * fInhiDiv
[fDim] Dynamic Mask for cell division
Definition: PDEFoam.h:114
Float_t fVolFrac
Definition: PDEFoam.h:133
Int_t fDim
Definition: PDEFoam.h:106
Collectable string class.
Definition: TObjString.h:32
float Float_t
Definition: RtypesCore.h:53
EFoamType fFoamType
Definition: PDEFoam.h:127
void OutputGrow(Bool_t finished=false)
message logger
Definition: PDEFoam.cxx:1460
double T(double x)
Definition: ChebyshevPol.h:34
Float_t VarTransform(Int_t idim, Float_t x) const
Definition: PDEFoam.h:303
PDEFoamCell * GetRootCell() const
Definition: PDEFoam.h:224
std::vector< TMVA::PDEFoamCell * > FindCells(const std::vector< Float_t > &) const
Find all cells, that contain txvec.
Definition: PDEFoam.cxx:1165
void Grow()
Internal subrogram used by Create.
Definition: PDEFoam.cxx:767
Double_t * fXmax
Definition: PDEFoam.h:129
Basic string class.
Definition: TString.h:137
void SetXmin(Int_t idim, Double_t wmin)
set lower foam bound in dimension idim
Definition: PDEFoam.cxx:265
Double_t GetXmax(Int_t idim) const
Definition: PDEFoam.h:236
int Int_t
Definition: RtypesCore.h:41
bool Bool_t
Definition: RtypesCore.h:59
Double_t GetCellElement(const PDEFoamCell *cell, UInt_t i) const
Returns cell element i of cell &#39;cell&#39;.
Definition: PDEFoam.cxx:1416
void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value)
Set cell element i of cell to value.
Definition: PDEFoam.cxx:1432
Int_t Divide(PDEFoamCell *)
Internal subrogram used by Create.
Definition: PDEFoam.cxx:714
TObject * At(Int_t idx) const
Definition: TObjArray.h:167
TH1D * Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase *kernel=NULL)
Draws 1-dimensional foam (= histogram)
Definition: PDEFoam.cxx:1218
void CheckAll(Int_t)
User utility, miscellaneous and debug.
Definition: PDEFoam.cxx:822
Int_t GetTotDim() const
Definition: PDEFoam.h:219
Int_t CellFill(Int_t, PDEFoamCell *)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:389
void MakeAlpha()
Internal subrogram used by Create.
Definition: PDEFoam.cxx:637
Timer * fTimer
distribution of training events
Definition: PDEFoam.h:138
virtual Bool_t CellValueIsUndefined(PDEFoamCell *)
Returns true, if the value of the given cell is undefined.
Definition: PDEFoam.cxx:990
Double_t x[n]
Definition: legend1.C:17
#define ClassDef(name, id)
Definition: Rtypes.h:254
void RootPlot2dim(const TString &filename, TString opt, Bool_t createCanvas=kTRUE, Bool_t colors=kTRUE)
Debugging tool which plots the cells of a 2-dimensional PDEFoam as rectangles in C++ format readable ...
Definition: PDEFoam.cxx:1511
UInt_t GetNmin()
Definition: PDEFoam.h:228
PDEFoamCell * FindCell(const std::vector< Float_t > &) const
Find cell that contains &#39;xvec&#39; (in foam coordinates [0,1]).
Definition: PDEFoam.cxx:1080
PDEFoamDensityBase * fDistr
Definition: PDEFoam.h:137
Double_t GetXmin(Int_t idim) const
Definition: PDEFoam.h:235
EFoamType
Definition: PDEFoam.h:74
TRandom3 * fPseRan
Definition: PDEFoam.h:123
void ResetCellElements()
Remove the cell elements from all cells.
Definition: PDEFoam.cxx:971
virtual void Explore(PDEFoamCell *Cell)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:434
void SetMaxDepth(UInt_t maxdepth)
Definition: PDEFoam.h:229
Int_t fNBin
Definition: PDEFoam.h:109
void SetnSampl(Long_t nSampl)
Definition: PDEFoam.h:212
void InitCells()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:356
void SetNmin(UInt_t val)
Definition: PDEFoam.h:227
void PrintCells()
Prints geometry of ALL cells of the FOAM.
Definition: PDEFoam.cxx:942
Float_t VarTransformInvers(Int_t idim, Float_t x) const
Definition: PDEFoam.h:320
void AddVariableName(const char *s)
Definition: PDEFoam.h:239
void SetXmax(Int_t idim, Double_t wmax)
set upper foam bound in dimension idim
Definition: PDEFoam.cxx:276
UInt_t fNElements
Definition: PDEFoam.h:130
Int_t fEvPerBin
Definition: PDEFoam.h:111
PDEFoamDensityBase * GetDistr() const
Definition: PDEFoam.h:180
TObjString * GetVariableName(Int_t idx)
Definition: PDEFoam.h:241
unsigned int UInt_t
Definition: RtypesCore.h:42
Bool_t fPeekMax
Definition: PDEFoam.h:136
void SetDensity(PDEFoamDensityBase *dens)
Definition: PDEFoam.h:216
void SetDim(Int_t kDim)
Sets dimension of cubical space.
Definition: PDEFoam.cxx:250
tomato 1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:618
TObjArray * fHistEdg
Definition: PDEFoam.h:120
void PrintCell(Long_t iCell=0)
Prints geometry of and elements of &#39;iCell&#39;, as well as relations to parent and daughter cells...
Definition: PDEFoam.cxx:895
MsgLogger & Log() const
Definition: PDEFoam.h:262
UInt_t GetNCells() const
Definition: PDEFoam.h:223
EDTSeparation fDTSeparation
Definition: PDEFoam.h:135
Double_t * fXmin
Definition: PDEFoam.h:128
Int_t fNSampl
Definition: PDEFoam.h:110
long Long_t
Definition: RtypesCore.h:50
Color * colors
Definition: X3DBuffer.c:19
Double_t Eval(Double_t *xRand, Double_t &event_density)
Internal subprogram.
Definition: PDEFoam.cxx:747
TString GetFoamName() const
Definition: PDEFoam.h:220
double Double_t
Definition: RtypesCore.h:55
ECellValue
Definition: PDEFoam.h:85
Int_t fNoAct
[fDim] Flags for inhibiting cell division
Definition: PDEFoam.h:116
void SetnCells(Long_t nCells)
Definition: PDEFoam.h:211
void Create()
Basic initialization of FOAM invoked by the user.
Definition: PDEFoam.cxx:292
Double_t * fAlpha
Definition: PDEFoam.h:125
PDEFoamCell ** fCells
Definition: PDEFoam.h:118
virtual TH2D * Project2(Int_t idim1, Int_t idim2, ECellValue cell_value=kValue, PDEFoamKernelBase *kernel=NULL, UInt_t nbin=50)
Project foam variable idim1 and variable idim2 to histogram.
Definition: PDEFoam.cxx:1270
Int_t * fMaskDiv
Definition: PDEFoam.h:113
virtual Float_t GetCellValue(const std::vector< Float_t > &xvec, ECellValue cv, PDEFoamKernelBase *)
This function finds the cell, which corresponds to the given untransformed event vector &#39;xvec&#39; and re...
Definition: PDEFoam.cxx:1016
void AddVariableName(TObjString *s)
Definition: PDEFoam.h:240
UInt_t fMaxDepth
Definition: PDEFoam.h:132
void Initialize()
Definition: PDEFoam.h:195
Mother of all ROOT objects.
Definition: TObject.h:37
Abstract ClassifierFactory template that handles arbitrary types.
void DeleteBinarySearchTree()
Delete the foam&#39;s density estimator, which contains the binary search tree.
Definition: PDEFoam.cxx:1666
void FillBinarySearchTree(const Event *ev)
Insert event to internal foam&#39;s density estimator PDEFoamDensityBase.
Definition: PDEFoam.cxx:1657
T Sqr(T x) const
Definition: PDEFoam.h:183
virtual ~PDEFoam()
Default destructor.
Definition: PDEFoam.cxx:184
void SetnBin(Int_t nBin)
Definition: PDEFoam.h:213
void SetEvPerBin(Int_t EvPerBin)
Definition: PDEFoam.h:214
#define NULL
Definition: Rtypes.h:82
Int_t fLastCe
Definition: PDEFoam.h:117
Int_t fNCells
Definition: PDEFoam.h:107
void Add(TObject *obj)
Definition: TObjArray.h:75
virtual void Finalize()
Definition: PDEFoam.h:206
const Bool_t kTRUE
Definition: Rtypes.h:91
TString fName
Definition: PDEFoam.h:105
UInt_t GetNInActiveCells() const
Definition: PDEFoam.h:222
UInt_t GetNActiveCells() const
Definition: PDEFoam.h:221
void SetInhiDiv(Int_t, Int_t)
This can be called before Create, after setting kDim It defines which variables are excluded in the p...
Definition: PDEFoam.cxx:802
PDEFoam()
Default constructor for streamer, user should not use it.
Definition: PDEFoam.cxx:103
tomato 2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:296
UInt_t GetMaxDepth() const
Definition: PDEFoam.h:230