/usr/include/root/TMVA/PDEFoam.h is in libroot-tmva-dev 5.34.30-0ubuntu8.
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 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 | // @(#)root/tmva $Id$
// Author: S. Jadach, Tancredi Carli, Dominik Dannheim, Alexander Voigt
/**********************************************************************************
* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
* Package: TMVA *
* Classes: PDEFoam *
* Web : http://tmva.sourceforge.net *
* *
* Description: *
* Class for PDEFoam object *
* *
* Authors (alphabetical): *
* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
* Tancredi Carli - CERN, Switzerland *
* Dominik Dannheim - CERN, Switzerland *
* Alexander Voigt - TU Dresden, Germany *
* *
* Copyright (c) 2008, 2010: *
* CERN, Switzerland *
* MPI-K Heidelberg, Germany *
* *
* Redistribution and use in source and binary forms, with or without *
* modification, are permitted according to the terms listed in LICENSE *
* (http://tmva.sourceforge.net/LICENSE) *
**********************************************************************************/
#ifndef ROOT_TMVA_PDEFoam
#define ROOT_TMVA_PDEFoam
#include <iosfwd>
#include <cassert>
#ifndef ROOT_TH2D
#include "TH2D.h"
#endif
#ifndef ROOT_TObjArray
#include "TObjArray.h"
#endif
#ifndef ROOT_TObjString
#include "TObjString.h"
#endif
#ifndef ROOT_TVectorT
#include "TVectorT.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_TMVA_VariableInfo
#include "TMVA/VariableInfo.h"
#endif
#ifndef ROOT_TMVA_Timer
#include "TMVA/Timer.h"
#endif
#ifndef ROOT_TObject
#include "TObject.h"
#endif
#ifndef ROOT_TRandom3
#include "TRandom3.h"
#endif
namespace TMVA {
class PDEFoamCell;
class PDEFoamVect;
class PDEFoamDensityBase;
class PDEFoamKernelBase;
class PDEFoam;
// separation types
enum EDTSeparation { kFoam, kGiniIndex, kMisClassificationError,
kCrossEntropy, kGiniIndexWithLaplace, kSdivSqrtSplusB };
// foam types
enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget, kMultiClass };
// enum type for possible foam cell values
// kValue : cell value who's rms is minimized
// kValueError : error on kValue
// kValueDensity : kValue / cell volume
// kMeanValue : mean sampling value (saved in fIntegral)
// kRms : rms of sampling distribution (saved in fDriver)
// kRmsOvMean : rms/mean of sampling distribution (saved in
// fDriver and fIntegral)
// kCellVolume : volume of cell
enum ECellValue { kValue, kValueError, kValueDensity, kMeanValue,
kRms, kRmsOvMean, kCellVolume };
}
#ifndef ROOT_TMVA_PDEFoamDensityBase
#include "TMVA/PDEFoamDensityBase.h"
#endif
#ifndef ROOT_TMVA_PDEFoamVect
#include "TMVA/PDEFoamVect.h"
#endif
#ifndef ROOT_TMVA_PDEFoamCell
#include "TMVA/PDEFoamCell.h"
#endif
#ifndef ROOT_TMVA_PDEFoamKernelBase
#include "TMVA/PDEFoamKernelBase.h"
#endif
namespace TMVA {
class PDEFoam : public TObject {
protected:
// COMPONENTS //
//-------------- Input parameters
TString fName; // Name of a given instance of the FOAM class
Int_t fDim; // Dimension of the integration/simulation space
Int_t fNCells; // Maximum number of cells
//-------------------
Int_t fNBin; // No. of bins in the edge histogram for cell MC exploration
Int_t fNSampl; // No. of MC events, when dividing (exploring) cell
Int_t fEvPerBin; // Maximum number of effective (wt=1) events per bin
//------------------- MULTI-BRANCHING ---------------------
Int_t *fMaskDiv; //! [fDim] Dynamic Mask for cell division
Int_t *fInhiDiv; //! [fDim] Flags for inhibiting cell division
//------------------- GEOMETRY ----------------------------
Int_t fNoAct; // Number of active cells
Int_t fLastCe; // Index of the last cell
PDEFoamCell **fCells; // [fNCells] Array of ALL cells
//------------------ M.C. generation----------------------------
TObjArray *fHistEdg; // Histograms of wt, one for each cell edge
Double_t *fRvec; // [fDim] random number vector from r.n. generator fDim+1 maximum elements
//----------- Procedures
TRandom3 *fPseRan; // Pointer to user-defined generator of pseudorandom numbers
//---------- working space for CELL exploration -------------
Double_t *fAlpha; // [fDim] Internal parameters of the hyperrectangle
// --------- PDE-Foam specific variables
EFoamType fFoamType; // BACKWARDS COMPATIBILITY: type of foam
Double_t *fXmin; // [fDim] minimum for variable transform
Double_t *fXmax; // [fDim] maximum for variable transform
UInt_t fNElements; // BACKWARDS COMPATIBILITY: number of variables in every cell
UInt_t fNmin; // minimal number of events in cell to split cell
UInt_t fMaxDepth; // maximum depth of cell tree
Float_t fVolFrac; // BACKWARDS COMPATIBILITY: volume fraction (with respect to total phase space
Bool_t fFillFoamWithOrigWeights; // BACKWARDS COMPATIBILITY: fill the foam with boost or orig. weights
EDTSeparation fDTSeparation; // BACKWARDS COMPATIBILITY: split cells according to decision tree logic
Bool_t fPeekMax; // BACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split
PDEFoamDensityBase *fDistr; //! distribution of training events
Timer *fTimer; //! timer for graphical output
TObjArray *fVariableNames;// collection of all variable names
mutable MsgLogger* fLogger; //! message logger
/////////////////////////////////////////////////////////////////
// METHODS //
/////////////////////////////////////////////////////////////////
protected:
// ---------- TMVA console output
void OutputGrow(Bool_t finished = false ); // nice TMVA console output
// ---------- Foam build-up functions
// Internal foam initialization functions
void InitCells(); // Initialisation of all foam cells
Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and return its index
virtual void Explore(PDEFoamCell *Cell); // Exploration of the new cell, determine <wt>, wtMax etc.
void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction
void MakeAlpha(); // Provides random point inside hyperrectangle
void Grow(); // build up foam
Long_t PeekMax(); // peek cell with max. driver integral
Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCell retained, taged as inactive
Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate distribution on point 'xRand'
// ---------- Cell value access functions
// low level functions to access a certain cell value
Double_t GetCellElement(const PDEFoamCell *cell, UInt_t i) const; // get Element 'i' in cell 'cell'
void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); // set Element 'i' in cell 'cell' to value 'value'
// specific function used during evaluation; determines, whether a cell value is undefined
virtual Bool_t CellValueIsUndefined( PDEFoamCell* );
// finds cell according to given event variables
PDEFoamCell* FindCell(const std::vector<Float_t>&) const ;
std::vector<TMVA::PDEFoamCell*> FindCells(const std::vector<Float_t>&) const;
std::vector<TMVA::PDEFoamCell*> FindCells(const std::map<Int_t,Float_t>&) const;
void FindCells(const std::map<Int_t, Float_t>&, PDEFoamCell*, std::vector<PDEFoamCell*> &) const;
// get internal density
PDEFoamDensityBase* GetDistr() const { assert(fDistr); return fDistr; }
// Square function (fastest implementation)
template<typename T> T Sqr(T x) const { return x*x; }
PDEFoam(const PDEFoam&); // Copy Constructor NOT USED
// ---------- Public functions ----------------------------------
public:
PDEFoam(); // Default constructor (used only by ROOT streamer)
PDEFoam(const TString&); // Principal user-defined constructor
virtual ~PDEFoam(); // Default destructor
// ---------- Foam creation functions
void Initialize() {} // initialize the PDEFoam
void FillBinarySearchTree( const Event* ev ); // fill event into BST
void Create(); // build-up foam
// function to fill created cell with given value
virtual void FillFoamCells(const Event* ev, Float_t wt);
// remove all cell elements
void ResetCellElements();
// function to call after foam is grown
virtual void Finalize() {}
// ---------- Getters and Setters
void SetDim(Int_t kDim); // Sets dimension of cubical space
void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum number of cells
void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC events in cell exploration
void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins in histogs in cell exploration
void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. no. of effective events per bin
void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division along certain edge
void SetDensity(PDEFoamDensityBase *dens) { fDistr = dens; }
// coverity[ -tainted_data_return ]
Int_t GetTotDim() const {return fDim; } // Get total dimension
TString GetFoamName() const {return fName; } // Get name of foam
UInt_t GetNActiveCells() const {return fNoAct;} // returns number of active cells
UInt_t GetNInActiveCells() const {return GetNCells()-GetNActiveCells();} // returns number of not active cells
UInt_t GetNCells() const {return fNCells;} // returns number of cells
PDEFoamCell* GetRootCell() const {return fCells[0];} // get pointer to root cell
// Getters and Setters for user cut options
void SetNmin(UInt_t val) { fNmin=val; }
UInt_t GetNmin() { return fNmin; }
void SetMaxDepth(UInt_t maxdepth) { fMaxDepth = maxdepth; }
UInt_t GetMaxDepth() const { return fMaxDepth; }
// Getters and Setters for foam boundaries
void SetXmin(Int_t idim, Double_t wmin);
void SetXmax(Int_t idim, Double_t wmax);
Double_t GetXmin(Int_t idim) const {return fXmin[idim];}
Double_t GetXmax(Int_t idim) const {return fXmax[idim];}
// Getters and Setters for variable names
void AddVariableName(const char *s) { AddVariableName(new TObjString(s)); }
void AddVariableName(TObjString *s) { fVariableNames->Add(s); }
TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjString*>(fVariableNames->At(idx));}
// Delete the fDistr object, which contains the binary search
// tree
void DeleteBinarySearchTree();
// ---------- Transformation functions for event variables into foam boundaries
// reason: foam allways has boundaries [0, 1]
Float_t VarTransform(Int_t idim, Float_t x) const; // transform [xmin, xmax] --> [0, 1]
std::vector<Float_t> VarTransform(const std::vector<Float_t> &invec) const;
Float_t VarTransformInvers(Int_t idim, Float_t x) const; // transform [0, 1] --> [xmin, xmax]
std::vector<Float_t> VarTransformInvers(const std::vector<Float_t> &invec) const;
// ---------- Debug functions
void CheckAll(Int_t); // Checks correctness of the entire data structure in the FOAM object
void PrintCell(Long_t iCell=0); // Print content of cell
void PrintCells(); // Prints content of all cells
// Message logger
MsgLogger& Log() const { return *fLogger; }
// ---------- Foam projection methods
// project foam to two-dimensional histogram
virtual TH2D* Project2(Int_t idim1, Int_t idim2, ECellValue cell_value=kValue,
PDEFoamKernelBase *kernel=NULL, UInt_t nbin=50);
// Project one-dimensional foam to a 1-dim histogram
TH1D* Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase *kernel=NULL);
// Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)
void RootPlot2dim( const TString& filename, TString opt,
Bool_t createCanvas = kTRUE, Bool_t colors = kTRUE );
// ---------- Foam evaluation functions
// get cell value for a given event
virtual Float_t GetCellValue( const std::vector<Float_t>& xvec, ECellValue cv, PDEFoamKernelBase* );
// get cell values for a given (incomplete) event vector
virtual std::vector<Float_t> GetCellValue( const std::map<Int_t,Float_t>& xvec, ECellValue cv );
// get cell value stored in a foam cell
virtual Float_t GetCellValue( const PDEFoamCell* cell, ECellValue cv );
// ---------- friend classes
friend class PDEFoamKernelBase;
friend class PDEFoamKernelTrivial;
friend class PDEFoamKernelLinN;
friend class PDEFoamKernelGauss;
// ---------- ROOT class definition
ClassDef(PDEFoam,7) // Tree of PDEFoamCells
}; // end of PDEFoam
} // namespace TMVA
// ---------- Inline functions
//_____________________________________________________________________
inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x) const
{
// transform variable x from [xmin, xmax] --> [0, 1]
return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
}
//_____________________________________________________________________
inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(const std::vector<Float_t> &invec) const
{
// transform vector invec from [xmin, xmax] --> [0, 1]
std::vector<Float_t> outvec;
for(UInt_t i=0; i<invec.size(); i++)
outvec.push_back(VarTransform(i, invec.at(i)));
return outvec;
}
//_____________________________________________________________________
inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x) const
{
// transform variable x from [0, 1] --> [xmin, xmax]
return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];
}
//_____________________________________________________________________
inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(const std::vector<Float_t> &invec) const
{
// transform vector invec from [0, 1] --> [xmin, xmax]
std::vector<Float_t> outvec;
for(UInt_t i=0; i<invec.size(); i++)
outvec.push_back(VarTransformInvers(i, invec.at(i)));
return outvec;
}
#endif
|