Logo ROOT  
Reference Guide
PDEFoam.cxx
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  * Implementations *
12  * *
13  * Authors (alphabetical): *
14  * Tancredi Carli - CERN, Switzerland *
15  * Dominik Dannheim - CERN, Switzerland *
16  * S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
17  * Alexander Voigt - TU Dresden, Germany *
18  * Peter Speckmayer - CERN, Switzerland *
19  * *
20  * Copyright (c) 2008, 2010: *
21  * CERN, Switzerland *
22  * MPI-K Heidelberg, Germany *
23  * *
24  * Redistribution and use in source and binary forms, with or without *
25  * modification, are permitted according to the terms listed in LICENSE *
26  * (http://tmva.sourceforge.net/LICENSE) *
27  **********************************************************************************/
28 
29 /*! \class TMVA::PDEFoam
30 \ingroup TMVA
31 
32 Implementation of PDEFoam
33 
34 The PDEFoam method is an extension of the PDERS method, which uses
35 self-adapting binning to divide the multi-dimensional phase space
36 in a finite number of hyper-rectangles (boxes).
37 
38 For a given number of boxes, the binning algorithm adjusts the size
39 and position of the boxes inside the multidimensional phase space,
40 minimizing the variance of the signal and background densities inside
41 the boxes. The binned density information is stored in binary trees,
42 allowing for a very fast and memory-efficient classification of
43 events.
44 
45 The implementation of the PDEFoam is based on the monte-carlo
46 integration package TFoam included in the analysis package ROOT.
47 
48 The class TMVA::PDEFoam defines the default interface for the
49 PDEFoam variants:
50 
51  - PDEFoamEvent
52  - PDEFoamDiscriminant
53  - PDEFoamTarget
54  - PDEFoamMultiTarget
55  - PDEFoamDecisionTree
56 
57 Per default PDEFoam stores in the cells the number of events (event
58 weights) and therefore acts as an event density estimator.
59 However, the above listed derived classes override this behaviour
60 to implement certain PDEFoam variations.
61 
62 In order to use PDEFoam the user has to set the density estimator
63 of the type TMVA::PDEFoamDensityBase, which is used to during the foam
64 build-up. The default PDEFoam should be used with
65 PDEFoamEventDensity.
66 */
67 
68 #include "TMVA/PDEFoam.h"
69 
70 #include "TMVA/Event.h"
71 #include "TMVA/MsgLogger.h"
72 #include "TMVA/PDEFoamKernelBase.h"
73 #include "TMVA/Timer.h"
74 #include "TMVA/Tools.h"
75 #include "TMVA/Types.h"
76 
77 #include "TStyle.h"
78 #include "TObject.h"
79 #include "TH1D.h"
80 #include "TMath.h"
81 #include "TVectorT.h"
82 #include "TRandom3.h"
83 #include "TColor.h"
84 #include "TDirectory.h"
85 #include "TObjArray.h"
86 
87 #include <cassert>
88 #include <fstream>
89 #include <iostream>
90 #include <limits>
91 #include <sstream>
92 
94 
95 static const Float_t kHigh= FLT_MAX;
96 static const Float_t kVlow=-FLT_MAX;
97 
98 using namespace std;
99 
100 ////////////////////////////////////////////////////////////////////////////////
101 /// Default constructor for streamer, user should not use it.
102 
104  fName("PDEFoam"),
105  fDim(0),
106  fNCells(0),
107  fNBin(5),
108  fNSampl(2000),
109  fEvPerBin(0),
110  fMaskDiv(0),
111  fInhiDiv(0),
112  fNoAct(1),
113  fLastCe(-1),
114  fCells(0),
115  fHistEdg(0),
116  fRvec(0),
117  fPseRan(new TRandom3(4356)),
118  fAlpha(0),
119  fFoamType(kSeparate),
120  fXmin(0),
121  fXmax(0),
122  fNElements(0),
123  fNmin(100),
124  fMaxDepth(0),
125  fVolFrac(1.0/15.0),
126  fFillFoamWithOrigWeights(kFALSE),
127  fDTSeparation(kFoam),
128  fPeekMax(kTRUE),
129  fDistr(NULL),
130  fTimer(new Timer(0, "PDEFoam", kTRUE)),
131  fVariableNames(new TObjArray()),
132  fLogger(new MsgLogger("PDEFoam"))
133 {
134  // fVariableNames may delete it's heap-based content
135  if (fVariableNames)
137 }
138 
139 ////////////////////////////////////////////////////////////////////////////////
140 /// User constructor, to be employed by the user
141 
143  fName(name),
144  fDim(0),
145  fNCells(1000),
146  fNBin(5),
147  fNSampl(2000),
148  fEvPerBin(0),
149  fMaskDiv(0),
150  fInhiDiv(0),
151  fNoAct(1),
152  fLastCe(-1),
153  fCells(0),
154  fHistEdg(0),
155  fRvec(0),
156  fPseRan(new TRandom3(4356)),
157  fAlpha(0),
158  fFoamType(kSeparate),
159  fXmin(0),
160  fXmax(0),
161  fNElements(0),
162  fNmin(100),
163  fMaxDepth(0),
164  fVolFrac(1.0/15.0),
165  fFillFoamWithOrigWeights(kFALSE),
166  fDTSeparation(kFoam),
167  fPeekMax(kTRUE),
168  fDistr(NULL),
169  fTimer(new Timer(1, "PDEFoam", kTRUE)),
170  fVariableNames(new TObjArray()),
171  fLogger(new MsgLogger("PDEFoam"))
172 {
173  if(strlen(name) > 128)
174  Log() << kFATAL << "Name too long " << name.Data() << Endl;
175 
176  // fVariableNames may delete it's heap-based content
177  if (fVariableNames)
179 }
180 
181 ////////////////////////////////////////////////////////////////////////////////
182 /// Default destructor
183 
185 {
186  delete fVariableNames;
187  delete fTimer;
188  if (fDistr) delete fDistr;
189  if (fPseRan) delete fPseRan;
190  if (fXmin) { delete [] fXmin; fXmin=0; }
191  if (fXmax) { delete [] fXmax; fXmax=0; }
192 
193  ResetCellElements();
194  if(fCells!= 0) {
195  for(Int_t i=0; i<fNCells; i++) delete fCells[i]; // PDEFoamCell*[]
196  delete [] fCells;
197  }
198  delete [] fRvec; //double[]
199  delete [] fAlpha; //double[]
200  delete [] fMaskDiv; //int[]
201  delete [] fInhiDiv; //int[]
202 
203  delete fLogger;
204 }
205 
206 ////////////////////////////////////////////////////////////////////////////////
207 /// Copy Constructor NOT IMPLEMENTED (NEVER USED)
208 
210  TObject(from)
211  , fDim(0)
212  , fNCells(0)
213  , fNBin(0)
214  , fNSampl(0)
215  , fEvPerBin(0)
216  , fMaskDiv(0)
217  , fInhiDiv(0)
218  , fNoAct(0)
219  , fLastCe(0)
220  , fCells(0)
221  , fHistEdg(0)
222  , fRvec(0)
223  , fPseRan(0)
224  , fAlpha(0)
225  , fFoamType(kSeparate)
226  , fXmin(0)
227  , fXmax(0)
228  , fNElements(0)
229  , fNmin(0)
230  , fMaxDepth(0)
231  , fVolFrac(1.0/15.0)
232  , fFillFoamWithOrigWeights(kFALSE)
233  , fDTSeparation(kFoam)
234  , fPeekMax(kTRUE)
235  , fDistr(0)
236  , fTimer(0)
237  , fVariableNames(0)
238  , fLogger(new MsgLogger(*from.fLogger))
239 {
240  Log() << kFATAL << "COPY CONSTRUCTOR NOT IMPLEMENTED" << Endl;
241 
242  // fVariableNames may delete it's heap-based content
243  if (fVariableNames)
245 }
246 
247 ////////////////////////////////////////////////////////////////////////////////
248 /// Sets dimension of cubical space
249 
251 {
252  if (kDim < 1)
253  Log() << kFATAL << "<SetDim>: Dimension is zero or negative!" << Endl;
254 
255  fDim = kDim;
256  if (fXmin) delete [] fXmin;
257  if (fXmax) delete [] fXmax;
258  fXmin = new Double_t[GetTotDim()];
259  fXmax = new Double_t[GetTotDim()];
260 }
261 
262 ////////////////////////////////////////////////////////////////////////////////
263 /// set lower foam bound in dimension idim
264 
266 {
267  if (idim<0 || idim>=GetTotDim())
268  Log() << kFATAL << "<SetXmin>: Dimension out of bounds!" << Endl;
269 
270  fXmin[idim]=wmin;
271 }
272 
273 ////////////////////////////////////////////////////////////////////////////////
274 /// set upper foam bound in dimension idim
275 
277 {
278  if (idim<0 || idim>=GetTotDim())
279  Log() << kFATAL << "<SetXmax>: Dimension out of bounds!" << Endl;
280 
281  fXmax[idim]=wmax;
282 }
283 
284 ////////////////////////////////////////////////////////////////////////////////
285 /// Basic initialization of FOAM invoked by the user.
286 /// IMPORTANT: Random number generator and the distribution object has to be
287 /// provided using SetPseRan and SetRho prior to invoking this initializator!
288 ///
289 /// After the foam is grown, space for 2 variables is reserved in
290 /// every cell. They are used for filling the foam cells.
291 
293 {
294  Bool_t addStatus = TH1::AddDirectoryStatus();
296 
297  if(fPseRan==0) Log() << kFATAL << "Random number generator not set" << Endl;
298  if(fDistr==0) Log() << kFATAL << "Distribution function not set" << Endl;
299  if(fDim==0) Log() << kFATAL << "Zero dimension not allowed" << Endl;
300 
301  /////////////////////////////////////////////////////////////////////////
302  // ALLOCATE SMALL LISTS //
303  // it is done globally, not for each cell, to save on allocation time //
304  /////////////////////////////////////////////////////////////////////////
305  fRvec = new Double_t[fDim]; // Vector of random numbers
306  if(fRvec==0) Log() << kFATAL << "Cannot initialize buffer fRvec" << Endl;
307 
308  if(fDim>0){
309  fAlpha = new Double_t[fDim]; // sum<1 for internal parametrization of the simplex
310  if(fAlpha==0) Log() << kFATAL << "Cannot initialize buffer fAlpha" << Endl;
311  }
312 
313  //====== List of directions inhibited for division
314  if(fInhiDiv == 0){
315  fInhiDiv = new Int_t[fDim];
316  for(Int_t i=0; i<fDim; i++) fInhiDiv[i]=0;
317  }
318  //====== Dynamic mask used in Explore for edge determination
319  if(fMaskDiv == 0){
320  fMaskDiv = new Int_t[fDim];
321  for(Int_t i=0; i<fDim; i++) fMaskDiv[i]=1;
322  }
323  //====== Initialize list of histograms
324  fHistEdg = new TObjArray(fDim); // Initialize list of histograms
325  for(Int_t i=0; i<fDim; i++){
326  TString hname, htitle;
327  hname = fName+TString("_HistEdge_");
328  hname += i;
329  htitle = TString("Edge Histogram No. ");
330  htitle += i;
331  (*fHistEdg)[i] = new TH1D(hname.Data(),htitle.Data(),fNBin,0.0, 1.0); // Initialize histogram for each edge
332  ((TH1D*)(*fHistEdg)[i])->Sumw2();
333  }
334 
335  // ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| //
336  // BUILD-UP of the FOAM //
337  // ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| //
338 
339  // prepare PDEFoam for growing
340  ResetCellElements(); // reset all cell elements
341 
342  // Define and explore root cell(s)
343  InitCells();
344  Grow();
345 
346  TH1::AddDirectory(addStatus);
347 
348  // prepare PDEFoam for the filling with events
349  ResetCellElements(); // reset all cell elements
350 } // Create
351 
352 ////////////////////////////////////////////////////////////////////////////////
353 /// Internal subprogram used by Create.
354 /// It initializes "root part" of the FOAM of the tree of cells.
355 
357 {
358  fLastCe =-1; // Index of the last cell
359  if(fCells!= 0) {
360  for(Int_t i=0; i<fNCells; i++) delete fCells[i];
361  delete [] fCells;
362  }
363 
364  fCells = new(nothrow) PDEFoamCell*[fNCells];
365  if (!fCells) {
366  Log() << kFATAL << "not enough memory to create " << fNCells
367  << " cells" << Endl;
368  }
369  for(Int_t i=0; i<fNCells; i++){
370  fCells[i]= new PDEFoamCell(fDim); // Allocate BIG list of cells
371  fCells[i]->SetSerial(i);
372  }
373 
374  /////////////////////////////////////////////////////////////////////////////
375  // Single Root Hypercube //
376  /////////////////////////////////////////////////////////////////////////////
377  CellFill(1, 0); // 0-th cell ACTIVE
378 
379  // Exploration of the root cell(s)
380  for(Long_t iCell=0; iCell<=fLastCe; iCell++){
381  Explore( fCells[iCell] ); // Exploration of root cell(s)
382  }
383 }//InitCells
384 
385 ////////////////////////////////////////////////////////////////////////////////
386 /// Internal subprogram used by Create.
387 /// It initializes content of the newly allocated active cell.
388 
390 {
391  PDEFoamCell *cell;
392  if (fLastCe==fNCells){
393  Log() << kFATAL << "Too many cells" << Endl;
394  }
395  fLastCe++; // 0-th cell is the first
396 
397  cell = fCells[fLastCe];
398 
399  cell->Fill(status, parent, 0, 0);
400 
401  cell->SetBest( -1); // pointer for planning division of the cell
402  cell->SetXdiv(0.5); // factor for division
403  Double_t xInt2,xDri2;
404  if(parent!=0){
405  xInt2 = 0.5*parent->GetIntg();
406  xDri2 = 0.5*parent->GetDriv();
407  cell->SetIntg(xInt2);
408  cell->SetDriv(xDri2);
409  }else{
410  cell->SetIntg(0.0);
411  cell->SetDriv(0.0);
412  }
413  return fLastCe;
414 }
415 
416 ////////////////////////////////////////////////////////////////////////////////
417 /// Internal subprogram used by Create.
418 /// It explores newly defined cell with help of special short MC sampling.
419 /// As a result, estimates of kTRUE and drive volume is defined/determined
420 /// Average and dispersion of the weight distribution will is found along
421 /// each edge and the best edge (minimum dispersion, best maximum weight)
422 /// is memorized for future use.
423 /// The optimal division point for eventual future cell division is
424 /// determined/recorded. Recorded are also minimum and maximum weight etc.
425 /// The volume estimate in all (inactive) parent cells is updated.
426 /// Note that links to parents and initial volume = 1/2 parent has to be
427 /// already defined prior to calling this routine.
428 ///
429 /// If fNmin > 0 then the total number of (training) events found in
430 /// the cell during the exploration is stored in the cell. This
431 /// information is used within PeekMax() to avoid splitting cells
432 /// which contain less than fNmin events.
433 
435 {
436  Double_t wt, dx, xBest=0, yBest;
437  Double_t intOld, driOld;
438 
439  Long_t iev;
440  Double_t nevMC;
441  Int_t i, j, k;
442  Int_t nProj, kBest;
443  Double_t ceSum[5], xproj;
444 
445  Double_t event_density = 0;
446  Double_t totevents = 0;
447  Double_t toteventsOld = 0;
448 
449  PDEFoamVect cellSize(fDim);
450  PDEFoamVect cellPosi(fDim);
451 
452  cell->GetHcub(cellPosi,cellSize);
453 
454  PDEFoamCell *parent;
455 
456  Double_t *xRand = new Double_t[fDim];
457 
458  Double_t *volPart=0;
459 
460  // calculate volume scale
461  Double_t vol_scale = 1.0;
462  for (Int_t idim = 0; idim < fDim; ++idim)
463  vol_scale *= fXmax[idim] - fXmin[idim];
464 
465  cell->CalcVolume();
466  dx = cell->GetVolume() * vol_scale;
467  intOld = cell->GetIntg(); //memorize old values,
468  driOld = cell->GetDriv(); //will be needed for correcting parent cells
469  toteventsOld = GetCellElement(cell, 0);
470 
471  /////////////////////////////////////////////////////
472  // Special Short MC sampling to probe cell //
473  /////////////////////////////////////////////////////
474  ceSum[0]=0;
475  ceSum[1]=0;
476  ceSum[2]=0;
477  ceSum[3]=kHigh; //wtmin
478  ceSum[4]=kVlow; //wtmax
479 
480  for (i=0;i<fDim;i++) ((TH1D *)(*fHistEdg)[i])->Reset(); // Reset histograms
481 
482  Double_t nevEff=0.;
483  // ||||||||||||||||||||||||||BEGIN MC LOOP|||||||||||||||||||||||||||||
484  for (iev=0;iev<fNSampl;iev++){
485  MakeAlpha(); // generate uniformly vector inside hypercube
486 
487  if (fDim>0) for (j=0; j<fDim; j++) xRand[j]= cellPosi[j] +fAlpha[j]*(cellSize[j]);
488 
489  wt = dx*Eval(xRand, event_density);
490  totevents += event_density;
491 
492  nProj = 0;
493  if (fDim>0) {
494  for (k=0; k<fDim; k++) {
495  xproj =fAlpha[k];
496  ((TH1D *)(*fHistEdg)[nProj])->Fill(xproj,wt);
497  nProj++;
498  }
499  }
500 
501  ceSum[0] += wt; // sum of weights
502  ceSum[1] += wt*wt; // sum of weights squared
503  ceSum[2]++; // sum of 1
504  if (ceSum[3]>wt) ceSum[3]=wt; // minimum weight;
505  if (ceSum[4]<wt) ceSum[4]=wt; // maximum weight
506  // test MC loop exit condition
507  if (ceSum[1]>0) nevEff = ceSum[0]*ceSum[0]/ceSum[1];
508  else nevEff = 0;
509  if ( nevEff >= fNBin*fEvPerBin) break;
510  } // ||||||||||||||||||||||||||END MC LOOP|||||||||||||||||||||||||||||
511  totevents *= dx;
512 
513  if (fNSampl>0) totevents /= fNSampl;
514 
515  // make sure that, if root cell is explored, more than zero
516  // events were found.
517  if (cell==fCells[0] && ceSum[0]<=0.0){
518  if (ceSum[0]==0.0)
519  Log() << kFATAL << "No events were found during exploration of "
520  << "root cell. Please check PDEFoam parameters nSampl "
521  << "and VolFrac." << Endl;
522  else
523  Log() << kWARNING << "Negative number of events found during "
524  << "exploration of root cell" << Endl;
525  }
526 
527  //------------------------------------------------------------------
528  //--- predefine logics of searching for the best division edge ---
529  for (k=0; k<fDim;k++){
530  fMaskDiv[k] =1; // default is all
531  if ( fInhiDiv[k]==1) fMaskDiv[k] =0; // inhibit some...
532  }
533  kBest=-1;
534 
535  /////////////////////////////////////////////////////////////////////////////
536 
537  nevMC = ceSum[2];
538  Double_t intTrue = ceSum[0]/(nevMC+0.000001);
539  Double_t intDriv=0.;
540 
541  if (kBest == -1) Varedu(ceSum,kBest,xBest,yBest); // determine the best edge,
542  intDriv =sqrt(ceSum[1]/nevMC) -intTrue; // Foam build-up, sqrt(<w**2>) -<w>
543 
544  //=================================================================================
545  cell->SetBest(kBest);
546  cell->SetXdiv(xBest);
547  cell->SetIntg(intTrue);
548  cell->SetDriv(intDriv);
549  SetCellElement(cell, 0, totevents);
550 
551  // correct/update integrals in all parent cells to the top of the tree
552  Double_t parIntg, parDriv;
553  for (parent = cell->GetPare(); parent!=0; parent = parent->GetPare()){
554  parIntg = parent->GetIntg();
555  parDriv = parent->GetDriv();
556  parent->SetIntg( parIntg +intTrue -intOld );
557  parent->SetDriv( parDriv +intDriv -driOld );
558  SetCellElement( parent, 0, GetCellElement(parent, 0) + totevents - toteventsOld);
559  }
560  delete [] volPart;
561  delete [] xRand;
562 }
563 
564 ////////////////////////////////////////////////////////////////////////////////
565 /// Internal subprogram used by Create.
566 /// In determines the best edge candidate and the position of the cell division plane
567 /// in case of the variance reduction for future cell division,
568 /// using results of the MC exploration run stored in fHistEdg
569 
570 void TMVA::PDEFoam::Varedu(Double_t ceSum[5], Int_t &kBest, Double_t &xBest, Double_t &yBest)
571 {
572  Double_t nent = ceSum[2];
573  // Double_t swAll = ceSum[0];
574  Double_t sswAll = ceSum[1];
575  Double_t ssw = sqrt(sswAll)/sqrt(nent);
576  //
577  Double_t sswIn,sswOut,xLo,xUp;
578  kBest =-1;
579  xBest =0.5;
580  yBest =1.0;
581  Double_t maxGain=0.0;
582  // Now go over all projections kProj
583  for(Int_t kProj=0; kProj<fDim; kProj++) {
584  if( fMaskDiv[kProj]) {
585  // initialize search over bins
586  // Double_t sigmIn =0.0; Double_t sigmOut =0.0;
587  Double_t sswtBest = kHigh;
588  Double_t gain =0.0;
589  Double_t xMin=0.0; Double_t xMax=0.0;
590  // Double loop over all pairs jLo<jUp
591  for(Int_t jLo=1; jLo<=fNBin; jLo++) {
592  Double_t aswIn=0; Double_t asswIn=0;
593  for(Int_t jUp=jLo; jUp<=fNBin;jUp++) {
594  aswIn += ((TH1D *)(*fHistEdg)[kProj])->GetBinContent(jUp);
595  asswIn += Sqr(((TH1D *)(*fHistEdg)[kProj])->GetBinError( jUp));
596  xLo=(jLo-1.0)/fNBin;
597  xUp=(jUp*1.0)/fNBin;
598  // swIn = aswIn/nent;
599  // swOut = (swAll-aswIn)/nent;
600  if ( (xUp-xLo) < std::numeric_limits<double>::epsilon()) sswIn=0.;
601  else sswIn = sqrt(asswIn) /sqrt(nent*(xUp-xLo)) *(xUp-xLo);
602  if ( (1.0-xUp+xLo) < std::numeric_limits<double>::epsilon()) sswOut=0.;
603  else if ( sswAll-asswIn < std::numeric_limits<double>::epsilon()) sswOut=0.;
604  else sswOut= sqrt(sswAll-asswIn)/sqrt(nent*(1.0-xUp+xLo)) *(1.0-xUp+xLo);
605  if( (sswIn+sswOut) < sswtBest) {
606  sswtBest = sswIn+sswOut;
607  gain = ssw-sswtBest;
608  // sigmIn = sswIn -swIn; // Debug
609  // sigmOut = sswOut-swOut; // Debug
610  xMin = xLo;
611  xMax = xUp;
612  }
613  }//jUp
614  }//jLo
615  Int_t iLo = (Int_t) (fNBin*xMin);
616  Int_t iUp = (Int_t) (fNBin*xMax);
617 
618  if(gain>=maxGain) {
619  maxGain=gain;
620  kBest=kProj; // <--- !!!!! The best edge
621  xBest=xMin;
622  yBest=xMax;
623  if(iLo == 0) xBest=yBest; // The best division point
624  if(iUp == fNBin) yBest=xBest; // this is not really used
625  }
626  }
627  } //kProj
628 
629  if( (kBest >= fDim) || (kBest<0) )
630  Log() << kFATAL << "Something wrong with kBest" << Endl;
631 } //PDEFoam::Varedu
632 
633 ////////////////////////////////////////////////////////////////////////////////
634 /// Internal subprogram used by Create.
635 /// Provides random vector Alpha 0< Alpha(i) < 1
636 
638 {
639  // simply generate and load kDim uniform random numbers
640  fPseRan->RndmArray(fDim,fRvec); // kDim random numbers needed
641  for(Int_t k=0; k<fDim; k++) fAlpha[k] = fRvec[k];
642 } //MakeAlpha
643 
644 ////////////////////////////////////////////////////////////////////////////////
645 /// Internal subprogram used by Create. It finds cell with maximal
646 /// driver integral for the purpose of the division. This function
647 /// is overridden by the PDEFoam Class to apply cuts on the number
648 /// of events in the cell (fNmin) and the cell tree depth
649 /// (GetMaxDepth() > 0) during cell buildup.
650 
652 {
653  Long_t iCell = -1;
654 
655  Long_t i;
656  Double_t drivMax, driv, xDiv;
657  Bool_t bCutNmin = kTRUE;
658  Bool_t bCutMaxDepth = kTRUE;
659  // drivMax = kVlow;
660  drivMax = 0; // only split cells if gain>0 (this also avoids splitting at cell boundary)
661  for(i=0; i<=fLastCe; i++) {//without root
662  if( fCells[i]->GetStat() == 1 ) {
663  // if driver integral < numeric limit, skip cell
664  driv = fCells[i]->GetDriv();
666  continue;
667 
668  // do not split cell at the edges
669  xDiv = TMath::Abs(fCells[i]->GetXdiv());
672  continue;
673 
674  // apply cut on depth
675  if (GetMaxDepth() > 0)
676  bCutMaxDepth = fCells[i]->GetDepth() < GetMaxDepth();
677 
678  // apply Nmin-cut
679  if (GetNmin() > 0)
680  bCutNmin = GetCellElement(fCells[i], 0) > GetNmin();
681 
682  // choose cell
683  if(driv > drivMax && bCutNmin && bCutMaxDepth) {
684  drivMax = driv;
685  iCell = i;
686  }
687  }
688  }
689 
690  if (iCell == -1){
691  if (!bCutNmin)
692  Log() << kVERBOSE << "Warning: No cell with more than "
693  << GetNmin() << " events found!" << Endl;
694  else if (!bCutMaxDepth)
695  Log() << kVERBOSE << "Warning: Maximum depth reached: "
696  << GetMaxDepth() << Endl;
697  else
698  Log() << kWARNING << "<PDEFoam::PeekMax>: no more candidate cells (drivMax>0) found for further splitting." << Endl;
699  }
700 
701  return(iCell);
702 }
703 
704 ////////////////////////////////////////////////////////////////////////////////
705 /// Internal subprogram used by Create.
706 /// It divides cell iCell into two daughter cells.
707 /// The iCell is retained and tagged as inactive, daughter cells are appended
708 /// at the end of the buffer.
709 /// New vertex is added to list of vertices.
710 /// List of active cells is updated, iCell removed, two daughters added
711 /// and their properties set with help of MC sampling (PDEFoam_Explore)
712 /// Returns Code RC=-1 of buffer limit is reached, fLastCe=fnBuf.
713 
715 {
716  // Double_t xdiv;
717  Int_t kBest;
718 
719  if(fLastCe+1 >= fNCells) Log() << kFATAL << "Buffer limit is reached, fLastCe=fnBuf" << Endl;
720 
721  cell->SetStat(0); // reset cell as inactive
722  fNoAct++;
723 
724  // xdiv = cell->GetXdiv();
725  kBest = cell->GetBest();
726  if( kBest<0 || kBest>=fDim ) Log() << kFATAL << "Wrong kBest" << Endl;
727 
728  //////////////////////////////////////////////////////////////////
729  // define two daughter cells (active) //
730  //////////////////////////////////////////////////////////////////
731 
732  Int_t d1 = CellFill(1, cell);
733  Int_t d2 = CellFill(1, cell);
734  cell->SetDau0((fCells[d1]));
735  cell->SetDau1((fCells[d2]));
736 
737  Explore( (fCells[d1]) );
738  Explore( (fCells[d2]) );
739 
740  return 1;
741 } // PDEFoam_Divide
742 
743 ////////////////////////////////////////////////////////////////////////////////
744 /// Internal subprogram.
745 /// Evaluates (training) distribution.
746 
748 {
749  // Transform variable xRand, since Foam boundaries are [0,1] and
750  // fDistr is filled with events which range in [fXmin,fXmax]
751  //
752  // Transformation: [0, 1] --> [xmin, xmax]
753  std::vector<Double_t> xvec;
754  xvec.reserve(GetTotDim());
755  for (Int_t idim = 0; idim < GetTotDim(); ++idim)
756  xvec.push_back( VarTransformInvers(idim, xRand[idim]) );
757 
758  return GetDistr()->Density(xvec, event_density);
759 }
760 
761 ////////////////////////////////////////////////////////////////////////////////
762 /// Internal subprogram used by Create.
763 /// It grow new cells by the binary division process.
764 /// This function is overridden by the PDEFoam class to stop the foam buildup process
765 /// if one of the cut conditions stop the cell split.
766 
768 {
769  fTimer->Init(fNCells);
770 
771  Long_t iCell;
772  PDEFoamCell* newCell;
773 
774  while ( (fLastCe+2) < fNCells ) { // this condition also checked inside Divide
775  iCell = PeekMax(); // peek up cell with maximum driver integral
776 
777  if ( (iCell<0) || (iCell>fLastCe) ) {
778  Log() << kVERBOSE << "Break: "<< fLastCe+1 << " cells created" << Endl;
779  // remove remaining empty cells
780  for (Long_t jCell=fLastCe+1; jCell<fNCells; jCell++)
781  delete fCells[jCell];
782  fNCells = fLastCe+1;
783  break;
784  }
785  newCell = fCells[iCell];
786 
787  OutputGrow();
788 
789  if ( Divide( newCell )==0) break; // and divide it into two
790  }
791  OutputGrow( kTRUE );
792  CheckAll(1); // set arg=1 for more info
793 
794  Log() << kVERBOSE << GetNActiveCells() << " active cells created" << Endl;
795 }// Grow
796 
797 ////////////////////////////////////////////////////////////////////////////////
798 /// This can be called before Create, after setting kDim
799 /// It defines which variables are excluded in the process of the cell division.
800 /// For example 'FoamX->SetInhiDiv(1, 1);' inhibits division of y-variable.
801 
803 {
804  if(fDim==0) Log() << kFATAL << "SetInhiDiv: fDim=0" << Endl;
805  if(fInhiDiv == 0) {
806  fInhiDiv = new Int_t[ fDim ];
807  for(Int_t i=0; i<fDim; i++) fInhiDiv[i]=0;
808  }
809  //
810  if( ( 0<=iDim) && (iDim<fDim)) {
811  fInhiDiv[iDim] = inhiDiv;
812  } else
813  Log() << kFATAL << "Wrong iDim" << Endl;
814 }//SetInhiDiv
815 
816 ////////////////////////////////////////////////////////////////////////////////
817 /// User utility, miscellaneous and debug.
818 /// Checks all pointers in the tree of cells. This is useful auto-diagnostic.
819 /// level=0, no printout, failures causes STOP
820 /// level=1, printout, failures lead to WARNINGS only
821 
823 {
824  Int_t errors, warnings;
825  PDEFoamCell *cell;
826  Long_t iCell;
827 
828  errors = 0; warnings = 0;
829  if (level==1) Log() << kVERBOSE << "Performing consistency checks for created foam" << Endl;
830  for(iCell=1; iCell<=fLastCe; iCell++) {
831  cell = fCells[iCell];
832  // checking general rules
833  if( ((cell->GetDau0()==0) && (cell->GetDau1()!=0) ) ||
834  ((cell->GetDau1()==0) && (cell->GetDau0()!=0) ) ) {
835  errors++;
836  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d has only one daughter " << iCell << Endl;
837  }
838  if( (cell->GetDau0()==0) && (cell->GetDau1()==0) && (cell->GetStat()==0) ) {
839  errors++;
840  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d has no daughter and is inactive " << iCell << Endl;
841  }
842  if( (cell->GetDau0()!=0) && (cell->GetDau1()!=0) && (cell->GetStat()==1) ) {
843  errors++;
844  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d has two daughters and is active " << iCell << Endl;
845  }
846 
847  // checking parents
848  if( (cell->GetPare())!=fCells[0] ) { // not child of the root
849  if ( (cell != cell->GetPare()->GetDau0()) && (cell != cell->GetPare()->GetDau1()) ) {
850  errors++;
851  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d parent not pointing to this cell " << iCell << Endl;
852  }
853  }
854 
855  // checking daughters
856  if(cell->GetDau0()!=0) {
857  if(cell != (cell->GetDau0())->GetPare()) {
858  errors++;
859  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d daughter 0 not pointing to this cell " << iCell << Endl;
860  }
861  }
862  if(cell->GetDau1()!=0) {
863  if(cell != (cell->GetDau1())->GetPare()) {
864  errors++;
865  if (level==1) Log() << kFATAL << "ERROR: Cell's no %d daughter 1 not pointing to this cell " << iCell << Endl;
866  }
867  }
868  if(cell->GetVolume()<1E-50) {
869  errors++;
870  if(level==1) Log() << kFATAL << "ERROR: Cell no. " << iCell << " has Volume of <1E-50" << Endl;
871  }
872  }// loop after cells;
873 
874  // Check for cells with Volume=0
875  for(iCell=0; iCell<=fLastCe; iCell++) {
876  cell = fCells[iCell];
877  if( (cell->GetStat()==1) && (cell->GetVolume()<1E-11) ) {
878  errors++;
879  if(level==1) Log() << kFATAL << "ERROR: Cell no. " << iCell << " is active but Volume is 0 " << Endl;
880  }
881  }
882  // summary
883  if(level==1){
884  Log() << kVERBOSE << "Check has found " << errors << " errors and " << warnings << " warnings." << Endl;
885  }
886  if(errors>0){
887  Info("CheckAll","Check - found total %d errors \n",errors);
888  }
889 } // Check
890 
891 ////////////////////////////////////////////////////////////////////////////////
892 /// Prints geometry of and elements of 'iCell', as well as relations
893 /// to parent and daughter cells.
894 
896 {
897  if (iCell < 0 || iCell > fLastCe) {
898  Log() << kWARNING << "<PrintCell(iCell=" << iCell
899  << ")>: cell number " << iCell << " out of bounds!"
900  << Endl;
901  return;
902  }
903 
904  PDEFoamVect cellPosi(fDim), cellSize(fDim);
905  fCells[iCell]->GetHcub(cellPosi,cellSize);
906  Int_t kBest = fCells[iCell]->GetBest();
907  Double_t xBest = fCells[iCell]->GetXdiv();
908 
909  Log() << "Cell[" << iCell << "]={ ";
910  Log() << " " << fCells[iCell] << " " << Endl; // extra DEBUG
911  Log() << " Xdiv[abs. coord.]="
912  << VarTransformInvers(kBest,cellPosi[kBest] + xBest*cellSize[kBest])
913  << Endl;
914  Log() << " Abs. coord. = (";
915  for (Int_t idim=0; idim<fDim; idim++) {
916  Log() << "dim[" << idim << "]={"
917  << VarTransformInvers(idim,cellPosi[idim]) << ","
918  << VarTransformInvers(idim,cellPosi[idim] + cellSize[idim])
919  << "}";
920  if (idim < fDim-1)
921  Log() << ", ";
922  }
923  Log() << ")" << Endl;
924  fCells[iCell]->Print("1");
925  // print the cell elements
926  Log() << "Elements: [";
927  TVectorD *vec = (TVectorD*)fCells[iCell]->GetElement();
928  if (vec != NULL){
929  for (Int_t i=0; i<vec->GetNrows(); i++){
930  if (i>0) Log() << ", ";
931  Log() << GetCellElement(fCells[iCell], i);
932  }
933  } else
934  Log() << "not set";
935  Log() << "]" << Endl;
936  Log()<<"}"<<Endl;
937 }
938 
939 ////////////////////////////////////////////////////////////////////////////////
940 /// Prints geometry of ALL cells of the FOAM
941 
943 {
944  for(Long_t iCell=0; iCell<=fLastCe; iCell++)
945  PrintCell(iCell);
946 }
947 
948 ////////////////////////////////////////////////////////////////////////////////
949 /// This function fills a weight 'wt' into the PDEFoam cell, which
950 /// corresponds to the given event 'ev'. Per default cell element 0
951 /// is filled with the weight 'wt', and cell element 1 is filled
952 /// with the squared weight. This function can be overridden by a
953 /// subclass in order to change the values stored in the foam cells.
954 
956 {
957  // find corresponding foam cell
958  std::vector<Float_t> values = ev->GetValues();
959  std::vector<Float_t> tvalues = VarTransform(values);
960  PDEFoamCell *cell = FindCell(tvalues);
961 
962  // 0. Element: Sum of weights 'wt'
963  // 1. Element: Sum of weights 'wt' squared
964  SetCellElement(cell, 0, GetCellElement(cell, 0) + wt);
965  SetCellElement(cell, 1, GetCellElement(cell, 1) + wt*wt);
966 }
967 
968 ////////////////////////////////////////////////////////////////////////////////
969 /// Remove the cell elements from all cells.
970 
972 {
973  if (!fCells) return;
974 
975  Log() << kVERBOSE << "Delete cell elements" << Endl;
976  for (Long_t iCell = 0; iCell < fNCells; ++iCell) {
977  TObject* elements = fCells[iCell]->GetElement();
978  if (elements) {
979  delete elements;
980  fCells[iCell]->SetElement(NULL);
981  }
982  }
983 }
984 
985 ////////////////////////////////////////////////////////////////////////////////
986 /// Returns true, if the value of the given cell is undefined.
987 /// Default value: kFALSE. This function can be overridden by
988 /// sub-classes.
989 
991 {
992  return kFALSE;
993 }
994 
995 ////////////////////////////////////////////////////////////////////////////////
996 /// This function finds the cell, which corresponds to the given
997 /// untransformed event vector 'xvec' and return its value, which is
998 /// given by the parameter 'cv'. If kernel != NULL, then
999 /// PDEFoamKernelBase::Estimate() is called on the transformed event
1000 /// variables.
1001 ///
1002 /// Parameters:
1003 ///
1004 /// - xvec - event vector (untransformed, [fXmin,fXmax])
1005 ///
1006 /// - cv - the cell value to return
1007 ///
1008 /// - kernel - PDEFoam kernel estimator. If NULL is given, than the
1009 /// pure cell value is returned
1010 ///
1011 /// Return:
1012 ///
1013 /// The cell value, corresponding to 'xvec', estimated by the given
1014 /// kernel.
1015 
1016 Float_t TMVA::PDEFoam::GetCellValue(const std::vector<Float_t> &xvec, ECellValue cv, PDEFoamKernelBase *kernel)
1017 {
1018  std::vector<Float_t> txvec(VarTransform(xvec));
1019  if (kernel == NULL)
1020  return GetCellValue(FindCell(txvec), cv);
1021  else
1022  return kernel->Estimate(this, txvec, cv);
1023 }
1024 
1025 ////////////////////////////////////////////////////////////////////////////////
1026 /// This function finds all cells, which corresponds to the given
1027 /// (incomplete) untransformed event vector 'xvec' and returns the
1028 /// cell values, according to the parameter 'cv'.
1029 ///
1030 /// Parameters:
1031 ///
1032 /// - xvec - map for the untransformed vector. The key (Int_t) is
1033 /// the dimension, and the value (Float_t) is the event
1034 /// coordinate. Note that not all coordinates have to be
1035 /// specified.
1036 ///
1037 /// - cv - cell values to return
1038 ///
1039 /// Return:
1040 ///
1041 /// cell values from all cells that were found
1042 
1043 std::vector<Float_t> TMVA::PDEFoam::GetCellValue( const std::map<Int_t,Float_t>& xvec, ECellValue cv )
1044 {
1045  // transformed event
1046  std::map<Int_t,Float_t> txvec;
1047  for (std::map<Int_t,Float_t>::const_iterator it=xvec.begin(); it!=xvec.end(); ++it)
1048  txvec.insert(std::pair<Int_t, Float_t>(it->first, VarTransform(it->first, it->second)));
1049 
1050  // find all cells, which correspond to the transformed event
1051  std::vector<PDEFoamCell*> cells = FindCells(txvec);
1052 
1053  // get the cell values
1054  std::vector<Float_t> cell_values;
1055  cell_values.reserve(cells.size());
1056  for (std::vector<PDEFoamCell*>::const_iterator cell_it=cells.begin();
1057  cell_it != cells.end(); ++cell_it)
1058  cell_values.push_back(GetCellValue(*cell_it, cv));
1059 
1060  return cell_values;
1061 }
1062 
1063 ////////////////////////////////////////////////////////////////////////////////
1064 /// Find cell that contains 'xvec' (in foam coordinates [0,1]).
1065 ///
1066 /// Loop to find cell that contains 'xvec' starting at root cell,
1067 /// and traversing binary tree to find the cell quickly. Note, that
1068 /// if 'xvec' lies outside the foam, the cell which is nearest to
1069 /// 'xvec' is returned. (The returned pointer should never be
1070 /// NULL.)
1071 ///
1072 /// Parameters:
1073 ///
1074 /// - xvec - event vector (in foam coordinates [0,1])
1075 ///
1076 /// Return:
1077 ///
1078 /// PDEFoam cell corresponding to 'xvec'
1079 
1080 TMVA::PDEFoamCell* TMVA::PDEFoam::FindCell( const std::vector<Float_t> &xvec ) const
1081 {
1082  PDEFoamVect cellPosi0(GetTotDim()), cellSize0(GetTotDim());
1083  PDEFoamCell *cell, *cell0;
1084 
1085  cell=fCells[0]; // start with root cell
1086  Int_t idim=0;
1087  while (cell->GetStat()!=1) { //go down binary tree until cell is found
1088  idim=cell->GetBest(); // dimension that changed
1089  cell0=cell->GetDau0();
1090  cell0->GetHcub(cellPosi0,cellSize0);
1091 
1092  if (xvec.at(idim)<=cellPosi0[idim]+cellSize0[idim])
1093  cell=cell0;
1094  else
1095  cell=(cell->GetDau1());
1096  }
1097  return cell;
1098 }
1099 
1100 ////////////////////////////////////////////////////////////////////////////////
1101 /// This is a helper function for std::vector<PDEFoamCell*>
1102 /// FindCells(...) and a generalisation of PDEFoamCell* FindCell().
1103 /// It saves in 'cells' all cells, which contain the coordinates
1104 /// specifies in 'txvec'. Note, that not all coordinates have to be
1105 /// specified in 'txvec'.
1106 ///
1107 /// Parameters:
1108 ///
1109 /// - txvec - event vector in foam coordinates [0,1]. The key is
1110 /// the dimension and the value is the event coordinate. Note,
1111 /// that not all coordinates have to be specified.
1112 ///
1113 /// - cell - cell to start searching with (usually root cell
1114 /// fCells[0])
1115 ///
1116 /// - cells - list of cells that were found
1117 
1118 void TMVA::PDEFoam::FindCells(const std::map<Int_t, Float_t> &txvec, PDEFoamCell* cell, std::vector<PDEFoamCell*> &cells) const
1119 {
1120  PDEFoamVect cellPosi0(GetTotDim()), cellSize0(GetTotDim());
1121  PDEFoamCell *cell0;
1122  Int_t idim=0;
1123 
1124  while (cell->GetStat()!=1) { //go down binary tree until cell is found
1125  idim=cell->GetBest(); // dimension that changed
1126 
1127  // check if dimension 'idim' is specified in 'txvec'
1128  map<Int_t, Float_t>::const_iterator it = txvec.find(idim);
1129 
1130  if (it != txvec.end()){
1131  // case 1: cell is splitten in a dimension which is specified
1132  // in txvec
1133  cell0=cell->GetDau0();
1134  cell0->GetHcub(cellPosi0,cellSize0);
1135  // check, whether left daughter cell contains txvec
1136  if (it->second <= cellPosi0[idim] + cellSize0[idim])
1137  cell=cell0;
1138  else
1139  cell=cell->GetDau1();
1140  } else {
1141  // case 2: cell is splitten in target dimension
1142  FindCells(txvec, cell->GetDau0(), cells);
1143  FindCells(txvec, cell->GetDau1(), cells);
1144  return;
1145  }
1146  }
1147  cells.push_back(cell);
1148 }
1149 
1150 ////////////////////////////////////////////////////////////////////////////////
1151 /// Find all cells, that contain txvec. This function can be used,
1152 /// when the dimension of the foam is greater than the dimension of
1153 /// txvec. E.g. this is the case for multi-target regression.
1154 ///
1155 /// Parameters:
1156 ///
1157 /// - txvec - event vector of variables, transformed into foam
1158 /// coordinates [0,1]. The size of txvec can be smaller than the
1159 /// dimension of the foam.
1160 ///
1161 /// Return value:
1162 ///
1163 /// - vector of cells, that fit txvec
1164 
1165 std::vector<TMVA::PDEFoamCell*> TMVA::PDEFoam::FindCells(const std::vector<Float_t> &txvec) const
1166 {
1167  // copy the coordinates from 'txvec' into a map
1168  std::map<Int_t, Float_t> txvec_map;
1169  for (UInt_t i=0; i<txvec.size(); ++i)
1170  txvec_map.insert(std::pair<Int_t, Float_t>(i, txvec.at(i)));
1171 
1172  // the cells found
1173  std::vector<PDEFoamCell*> cells(0);
1174 
1175  // loop over all target dimensions
1176  FindCells(txvec_map, fCells[0], cells);
1177 
1178  return cells;
1179 }
1180 
1181 ////////////////////////////////////////////////////////////////////////////////
1182 /// Find all cells, that contain the coordinates specified in txvec.
1183 /// The key in 'txvec' is the dimension, and the corresponding value
1184 /// is the coordinate. Note, that not all coordinates have to be
1185 /// specified in txvec.
1186 ///
1187 /// Parameters:
1188 ///
1189 /// - txvec - map of coordinates (transformed into foam coordinates
1190 /// [0,1])
1191 ///
1192 /// Return value:
1193 ///
1194 /// - vector of cells, that fit txvec
1195 
1196 std::vector<TMVA::PDEFoamCell*> TMVA::PDEFoam::FindCells(const std::map<Int_t, Float_t> &txvec) const
1197 {
1198  // the cells found
1199  std::vector<PDEFoamCell*> cells(0);
1200 
1201  // loop over all target dimensions
1202  FindCells(txvec, fCells[0], cells);
1203 
1204  return cells;
1205 }
1206 
1207 ////////////////////////////////////////////////////////////////////////////////
1208 /// Draws 1-dimensional foam (= histogram)
1209 ///
1210 /// Parameters:
1211 ///
1212 /// - cell_value - the cell value to draw
1213 ///
1214 /// - nbin - number of bins of result histogram
1215 ///
1216 /// - kernel - a PDEFoam kernel.
1217 
1218 TH1D* TMVA::PDEFoam::Draw1Dim( ECellValue cell_value, Int_t nbin, PDEFoamKernelBase *kernel )
1219 {
1220  // avoid plotting of wrong dimensions
1221  if ( GetTotDim()!=1 )
1222  Log() << kFATAL << "<Draw1Dim>: function can only be used for 1-dimensional foams!"
1223  << Endl;
1224 
1225  TString hname("h_1dim");
1226  TH1D* h1=(TH1D*)gDirectory->Get(hname);
1227  if (h1) delete h1;
1228  h1= new TH1D(hname, "1-dimensional Foam", nbin, fXmin[0], fXmax[0]);
1229 
1230  if (!h1) Log() << kFATAL << "ERROR: Can not create histo" << hname << Endl;
1231 
1232  // loop over all bins
1233  for (Int_t ibinx=1; ibinx<=h1->GetNbinsX(); ++ibinx) {
1234  // get event vector corresponding to bin
1235  std::vector<Float_t> txvec;
1236  txvec.push_back( VarTransform(0, h1->GetBinCenter(ibinx)) );
1237  Float_t val = 0;
1238  if (kernel != NULL) {
1239  // get cell value using the kernel
1240  val = kernel->Estimate(this, txvec, cell_value);
1241  } else {
1242  val = GetCellValue(FindCell(txvec), cell_value);
1243  }
1244  // fill value to histogram
1245  h1->SetBinContent(ibinx, val + h1->GetBinContent(ibinx));
1246  }
1247 
1248  return h1;
1249 }
1250 
1251 ////////////////////////////////////////////////////////////////////////////////
1252 /// Project foam variable idim1 and variable idim2 to histogram.
1253 ///
1254 /// Parameters:
1255 ///
1256 /// - idim1, idim2 - dimensions to project to
1257 ///
1258 /// - cell_value - the cell value to draw
1259 ///
1260 /// - kernel - a PDEFoam kernel (optional). If NULL is given, the
1261 /// kernel is ignored and the pure cell values are
1262 /// plotted.
1263 ///
1264 /// - nbin - number of bins in x and y direction of result histogram
1265 /// (optional, default is 50).
1266 ///
1267 /// Returns:
1268 /// a 2-dimensional histogram
1269 
1270 TH2D* TMVA::PDEFoam::Project2( Int_t idim1, Int_t idim2, ECellValue cell_value, PDEFoamKernelBase *kernel, UInt_t nbin )
1271 {
1272  // avoid plotting of wrong dimensions
1273  if ((idim1>=GetTotDim()) || (idim1<0) ||
1274  (idim2>=GetTotDim()) || (idim2<0) ||
1275  (idim1==idim2) )
1276  Log() << kFATAL << "<Project2>: wrong dimensions given: "
1277  << idim1 << ", " << idim2 << Endl;
1278 
1279  // root can not handle too many bins in one histogram --> catch this
1280  // Furthermore, to have more than 1000 bins in the histogram doesn't make
1281  // sense.
1282  if (nbin>1000){
1283  Log() << kWARNING << "Warning: number of bins too big: " << nbin
1284  << " Using 1000 bins for each dimension instead." << Endl;
1285  nbin = 1000;
1286  } else if (nbin<1) {
1287  Log() << kWARNING << "Wrong bin number: " << nbin
1288  << "; set nbin=50" << Endl;
1289  nbin = 50;
1290  }
1291 
1292  // create result histogram
1293  TString hname(Form("h_%d_vs_%d",idim1,idim2));
1294 
1295  // if histogram with this name already exists, delete it
1296  TH2D* h1=(TH2D*)gDirectory->Get(hname.Data());
1297  if (h1) delete h1;
1298  h1= new TH2D(hname.Data(), Form("var%d vs var%d",idim1,idim2), nbin, fXmin[idim1], fXmax[idim1], nbin, fXmin[idim2], fXmax[idim2]);
1299 
1300  if (!h1) Log() << kFATAL << "ERROR: Can not create histo" << hname << Endl;
1301 
1302  // ============== start projection algorithm ================
1303  // loop over all histogram bins (2-dim)
1304  for (Int_t xbin = 1; xbin <= h1->GetNbinsX(); ++xbin) {
1305  for (Int_t ybin = 1; ybin <= h1->GetNbinsY(); ++ybin) {
1306  // calculate the phase space point, which corresponds to this
1307  // bin combination
1308  std::map<Int_t, Float_t> txvec;
1309  txvec[idim1] = VarTransform(idim1, h1->GetXaxis()->GetBinCenter(xbin));
1310  txvec[idim2] = VarTransform(idim2, h1->GetYaxis()->GetBinCenter(ybin));
1311 
1312  // find the cells, which corresponds to this phase space
1313  // point
1314  std::vector<TMVA::PDEFoamCell*> cells = FindCells(txvec);
1315 
1316  // loop over cells and fill the histogram with the cell
1317  // values
1318  Float_t sum_cv = 0; // sum of the cell values
1319  for (std::vector<TMVA::PDEFoamCell*>::const_iterator it = cells.begin();
1320  it != cells.end(); ++it) {
1321  // get cell position and size
1322  PDEFoamVect cellPosi(GetTotDim()), cellSize(GetTotDim());
1323  (*it)->GetHcub(cellPosi,cellSize);
1324  // Create complete event vector from txvec. The missing
1325  // coordinates of txvec are set to the cell center.
1326  std::vector<Float_t> tvec;
1327  for (Int_t i=0; i<GetTotDim(); ++i) {
1328  if ( i != idim1 && i != idim2 )
1329  tvec.push_back(cellPosi[i] + 0.5*cellSize[i]);
1330  else
1331  tvec.push_back(txvec[i]);
1332  }
1333  if (kernel != NULL) {
1334  // get the cell value using the kernel
1335  sum_cv += kernel->Estimate(this, tvec, cell_value);
1336  } else {
1337  sum_cv += GetCellValue(FindCell(tvec), cell_value);
1338  }
1339  }
1340 
1341  // fill the bin content
1342  h1->SetBinContent(xbin, ybin, sum_cv + h1->GetBinContent(xbin, ybin));
1343  }
1344  }
1345 
1346  return h1;
1347 }
1348 
1349 ////////////////////////////////////////////////////////////////////////////////
1350 /// Returns the cell value of 'cell' corresponding to the given
1351 /// option 'cv'. This function should be overridden by the subclass
1352 /// in order to specify which cell elements to return for a given
1353 /// cell value 'cv'. By default kValue returns cell element 0, and
1354 /// kValueError returns cell element 1.
1355 
1357 {
1358  // calculate cell value (depending on the given option 'cv')
1359  switch (cv) {
1360 
1361  case kValue:
1362  return GetCellElement(cell, 0);
1363 
1364  case kValueError:
1365  return GetCellElement(cell, 1);
1366 
1367  case kValueDensity: {
1368 
1369  Double_t volume = cell->GetVolume();
1370  if (volume > numeric_limits<double>::epsilon()) {
1371  return GetCellValue(cell, kValue)/volume;
1372  } else {
1373  if (volume<=0){
1374  cell->Print("1"); // debug output
1375  Log() << kWARNING << "<GetCellDensity(cell)>: ERROR: cell volume"
1376  << " negative or zero!"
1377  << " ==> return cell density 0!"
1378  << " cell volume=" << volume
1379  << " cell entries=" << GetCellValue(cell, kValue) << Endl;
1380  } else {
1381  Log() << kWARNING << "<GetCellDensity(cell)>: WARNING: cell volume"
1382  << " close to zero!"
1383  << " cell volume: " << volume << Endl;
1384  }
1385  }
1386  }
1387  return 0;
1388 
1389  case kMeanValue:
1390  return cell->GetIntg();
1391 
1392  case kRms:
1393  return cell->GetDriv();
1394 
1395  case kRmsOvMean:
1396  if (cell->GetIntg() != 0)
1397  return cell->GetDriv()/cell->GetIntg();
1398  else
1399  return 0;
1400 
1401  case kCellVolume:
1402  return cell->GetVolume();
1403 
1404  default:
1405  Log() << kFATAL << "<GetCellValue>: unknown cell value" << Endl;
1406  return 0;
1407  }
1408 
1409  return 0;
1410 }
1411 
1412 ////////////////////////////////////////////////////////////////////////////////
1413 /// Returns cell element i of cell 'cell'. If the cell has no
1414 /// elements or the index 'i' is out of range, than 0 is returned.
1415 
1417 {
1418  // dynamic_cast doesn't seem to work here ?!
1419  TVectorD *vec = (TVectorD*)cell->GetElement();
1420 
1421  // if vec is not set or index out of range, return 0
1422  if (!vec || i >= (UInt_t) vec->GetNrows())
1423  return 0;
1424 
1425  return (*vec)(i);
1426 }
1427 
1428 ////////////////////////////////////////////////////////////////////////////////
1429 /// Set cell element i of cell to value. If the cell element i does
1430 /// not exist, it is created.
1431 
1433 {
1434  TVectorD *vec = NULL;
1435 
1436  // if no cell elements are set, create TVectorD with i+1 entries,
1437  // ranging from [0,i]
1438  if (cell->GetElement() == NULL) {
1439  vec = new TVectorD(i+1);
1440  vec->Zero(); // set all values to zero
1441  (*vec)(i) = value; // set element i to value
1442  cell->SetElement(vec);
1443  } else {
1444  // dynamic_cast doesn't seem to work here ?!
1445  vec = (TVectorD*)cell->GetElement();
1446  if (!vec)
1447  Log() << kFATAL << "<SetCellElement> ERROR: cell element is not a TVectorD*" << Endl;
1448  // check vector size and resize if necessary
1449  if (i >= (UInt_t) vec->GetNrows())
1450  vec->ResizeTo(0,i);
1451  // set element i to value
1452  (*vec)(i) = value;
1453  }
1454 }
1455 
1456 ////////////////////////////////////////////////////////////////////////////////
1457 /// Overridden function of PDEFoam to avoid native foam output.
1458 /// Draw TMVA-process bar instead.
1459 
1461 {
1462  if (finished) {
1463  Log() << kINFO << "Elapsed time: " + fTimer->GetElapsedTime()
1464  << " " << Endl;
1465  return;
1466  }
1467 
1468  Int_t modulo = 1;
1469 
1470  if (fNCells >= 100) modulo = Int_t(fNCells/100);
1471  if (fLastCe%modulo == 0) fTimer->DrawProgressBar( fLastCe );
1472 }
1473 
1474 ////////////////////////////////////////////////////////////////////////////////
1475 /// Debugging tool which plots the cells of a 2-dimensional PDEFoam
1476 /// as rectangles in C++ format readable for ROOT.
1477 ///
1478 /// Parameters:
1479 /// - filename - filename of output root macro
1480 ///
1481 /// - opt - cell_value, rms, rms_ov_mean
1482 /// If cell_value is set, the following values will be filled into
1483 /// the result histogram:
1484 /// - number of events - in case of classification with 2 separate
1485 /// foams or multi-target regression
1486 /// - discriminator - in case of classification with one
1487 /// unified foam
1488 /// - target - in case of mono-target regression
1489 /// If none of {cell_value, rms, rms_ov_mean} is given, the cells
1490 /// will not be filled.
1491 /// If 'opt' contains the string 'cellnumber', the index of
1492 /// each cell is draw in addition.
1493 ///
1494 /// - createCanvas - whether to create a new canvas or not
1495 ///
1496 /// - colors - whether to fill cells with colors or shades of grey
1497 ///
1498 /// Example:
1499 ///
1500 /// The following commands load a mono-target regression foam from
1501 /// file 'foam.root' and create a ROOT macro 'output.C', which
1502 /// draws all PDEFoam cells with little boxes. The latter are
1503 /// filled with colors according to the target value stored in the
1504 /// cell. Also the cell number is drawn.
1505 ///
1506 /// TFile file("foam.root");
1507 /// TMVA::PDEFoam *foam = (TMVA::PDEFoam*) gDirectory->Get("MonoTargetRegressionFoam");
1508 /// foam->RootPlot2dim("output.C","cell_value,cellnumber");
1509 /// gROOT->Macro("output.C");
1510 
1511 void TMVA::PDEFoam::RootPlot2dim( const TString& filename, TString opt,
1512  Bool_t createCanvas, Bool_t colors )
1513 {
1514  if (GetTotDim() != 2)
1515  Log() << kFATAL << "RootPlot2dim() can only be used with "
1516  << "two-dimensional foams!" << Endl;
1517 
1518  // select value to plot
1519  ECellValue cell_value = kValue;
1520  Bool_t plotcellnumber = kFALSE;
1521  Bool_t fillcells = kTRUE;
1522  if (opt.Contains("cell_value")){
1523  cell_value = kValue;
1524  } else if (opt.Contains("rms_ov_mean")){
1525  cell_value = kRmsOvMean;
1526  } else if (opt.Contains("rms")){
1527  cell_value = kRms;
1528  } else {
1529  fillcells = kFALSE;
1530  }
1531  if (opt.Contains("cellnumber"))
1532  plotcellnumber = kTRUE;
1533 
1534  // open file (root macro)
1535  std::ofstream outfile(filename, std::ios::out);
1536 
1537  outfile<<"{" << std::endl;
1538 
1539  // declare boxes and set the fill styles
1540  if (!colors) { // define grayscale colors from light to dark,
1541  // starting from color index 1000
1542  outfile << "TColor *graycolors[100];" << std::endl;
1543  outfile << "for (Int_t i=0.; i<100; i++)" << std::endl;
1544  outfile << " graycolors[i]=new TColor(1000+i, 1-(Float_t)i/100.,1-(Float_t)i/100.,1-(Float_t)i/100.);"<< std::endl;
1545  }
1546  if (createCanvas)
1547  outfile << "cMap = new TCanvas(\"" << fName << "\",\"Cell Map for "
1548  << fName << "\",600,600);" << std::endl;
1549 
1550  outfile<<"TBox*a=new TBox();"<<std::endl;
1551  outfile<<"a->SetFillStyle(0);"<<std::endl; // big frame
1552  outfile<<"a->SetLineWidth(4);"<<std::endl;
1553  outfile<<"TBox *b1=new TBox();"<<std::endl; // single cell
1554  outfile<<"TText*t=new TText();"<<std::endl; // text for numbering
1555  if (fillcells) {
1556  outfile << (colors ? "gStyle->SetPalette(1, 0);" : "gStyle->SetPalette(0);")
1557  << std::endl;
1558  outfile <<"b1->SetFillStyle(1001);"<<std::endl;
1559  outfile<<"TBox *b2=new TBox();"<<std::endl; // single cell
1560  outfile <<"b2->SetFillStyle(0);"<<std::endl;
1561  }
1562  else {
1563  outfile <<"b1->SetFillStyle(0);"<<std::endl;
1564  }
1565 
1566  if (fillcells)
1567  (colors ? gStyle->SetPalette(1, 0) : gStyle->SetPalette(0) );
1568 
1569  Float_t zmin = 1E8; // minimal value (for color calculation)
1570  Float_t zmax = -1E8; // maximal value (for color calculation)
1571 
1572  // if cells shall be filled, calculate minimal and maximal plot
1573  // value --> store in zmin and zmax
1574  if (fillcells) {
1575  for (Long_t iCell=1; iCell<=fLastCe; iCell++) {
1576  if ( fCells[iCell]->GetStat() == 1) {
1577  Float_t value = GetCellValue(fCells[iCell], cell_value);
1578  if (value<zmin)
1579  zmin=value;
1580  if (value>zmax)
1581  zmax=value;
1582  }
1583  }
1584  outfile << "// observed minimum and maximum of distribution: " << std::endl;
1585  outfile << "// Float_t zmin = "<< zmin << ";" << std::endl;
1586  outfile << "// Float_t zmax = "<< zmax << ";" << std::endl;
1587  }
1588 
1589  outfile << "// used minimum and maximum of distribution (taking into account log scale if applicable): " << std::endl;
1590  outfile << "Float_t zmin = "<< zmin << ";" << std::endl;
1591  outfile << "Float_t zmax = "<< zmax << ";" << std::endl;
1592 
1593  Float_t x1,y1,x2,y2,x,y; // box and text coordinates
1594  Float_t offs = 0.01;
1595  Float_t lpag = 1-2*offs;
1596  Int_t ncolors = colors ? gStyle->GetNumberOfColors() : 100;
1597  Float_t scale = (ncolors-1)/(zmax - zmin);
1598  PDEFoamVect cellPosi(GetTotDim()), cellSize(GetTotDim());
1599 
1600  // loop over cells and draw a box for every cell (and maybe the
1601  // cell number as well)
1602  outfile << "// =========== Rectangular cells ==========="<< std::endl;
1603  for (Long_t iCell=1; iCell<=fLastCe; iCell++) {
1604  if ( fCells[iCell]->GetStat() == 1) {
1605  fCells[iCell]->GetHcub(cellPosi,cellSize);
1606  x1 = offs+lpag*(cellPosi[0]);
1607  y1 = offs+lpag*(cellPosi[1]);
1608  x2 = offs+lpag*(cellPosi[0]+cellSize[0]);
1609  y2 = offs+lpag*(cellPosi[1]+cellSize[1]);
1610 
1611  if (fillcells) {
1612  // get cell value
1613  Float_t value = GetCellValue(fCells[iCell], cell_value);
1614 
1615  // calculate fill color
1616  Int_t color;
1617  if (colors)
1618  color = gStyle->GetColorPalette(Int_t((value-zmin)*scale));
1619  else
1620  color = 1000+(Int_t((value-zmin)*scale));
1621 
1622  // set fill color of box b1
1623  outfile << "b1->SetFillColor(" << color << ");" << std::endl;
1624  }
1625 
1626  // cell rectangle
1627  outfile<<"b1->DrawBox("<<x1<<","<<y1<<","<<x2<<","<<y2<<");"<<std::endl;
1628  if (fillcells)
1629  outfile<<"b2->DrawBox("<<x1<<","<<y1<<","<<x2<<","<<y2<<");"<<std::endl;
1630 
1631  // cell number
1632  if (plotcellnumber) {
1633  outfile<<"t->SetTextColor(4);"<<std::endl;
1634  if(fLastCe<51)
1635  outfile<<"t->SetTextSize(0.025);"<<std::endl; // text for numbering
1636  else if(fLastCe<251)
1637  outfile<<"t->SetTextSize(0.015);"<<std::endl;
1638  else
1639  outfile<<"t->SetTextSize(0.008);"<<std::endl;
1640  x = offs+lpag*(cellPosi[0]+0.5*cellSize[0]);
1641  y = offs+lpag*(cellPosi[1]+0.5*cellSize[1]);
1642  outfile<<"t->DrawText("<<x<<","<<y<<","<<"\""<<iCell<<"\""<<");"<<std::endl;
1643  }
1644  }
1645  }
1646  outfile<<"// ============== End Rectangles ==========="<< std::endl;
1647 
1648  outfile << "}" << std::endl;
1649  outfile.flush();
1650  outfile.close();
1651 }
1652 
1653 ////////////////////////////////////////////////////////////////////////////////
1654 /// Insert event to internal foam's density estimator
1655 /// PDEFoamDensityBase.
1656 
1658 {
1659  GetDistr()->FillBinarySearchTree(ev);
1660 }
1661 
1662 ////////////////////////////////////////////////////////////////////////////////
1663 /// Delete the foam's density estimator, which contains the binary
1664 /// search tree.
1665 
1667 {
1668  if(fDistr) delete fDistr;
1669  fDistr = NULL;
1670 }
TMVA::PDEFoamCell::SetBest
void SetBest(Int_t Best)
Definition: PDEFoamCell.h:79
TMVA::PDEFoam::SetInhiDiv
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
TMVA::PDEFoam::PDEFoam
PDEFoam()
Default constructor for streamer, user should not use it.
Definition: PDEFoam.cxx:103
kTRUE
const Bool_t kTRUE
Definition: RtypesCore.h:91
TMVA::PDEFoam::FillFoamCells
virtual void FillFoamCells(const Event *ev, Float_t wt)
This function fills a weight 'wt' into the PDEFoam cell, which corresponds to the given event 'ev'.
Definition: PDEFoam.cxx:955
TObjArray
An array of TObjects.
Definition: TObjArray.h:37
TDirectory.h
TMVA::PDEFoam::PeekMax
Long_t PeekMax()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:651
TMVA::PDEFoam::PrintCells
void PrintCells()
Prints geometry of ALL cells of the FOAM.
Definition: PDEFoam.cxx:942
TObject::Print
virtual void Print(Option_t *option="") const
This method must be overridden when a class wants to print itself.
Definition: TObject.cxx:552
PDEFoamKernelBase.h
TMVA::PDEFoamCell::GetStat
Int_t GetStat() const
Definition: PDEFoamCell.h:91
TMVA::PDEFoam::Varedu
void Varedu(Double_t[], Int_t &, Double_t &, Double_t &)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:570
TVectorT::ResizeTo
TVectorT< Element > & ResizeTo(Int_t lwb, Int_t upb)
Resize the vector to [lwb:upb] .
Definition: TVectorT.cxx:294
TMVA::PDEFoam::Grow
void Grow()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:767
TString::Data
const char * Data() const
Definition: TString.h:369
TMVA::PDEFoam::PrintCell
void PrintCell(Long_t iCell=0)
Prints geometry of and elements of 'iCell', as well as relations to parent and daughter cells.
Definition: PDEFoam.cxx:895
ClassImp
#define ClassImp(name)
Definition: Rtypes.h:364
Form
char * Form(const char *fmt,...)
TMVA::PDEFoamKernelBase
This class is the abstract kernel interface for PDEFoam.
Definition: PDEFoamKernelBase.h:41
TMVA::PDEFoam::GetCellElement
Double_t GetCellElement(const PDEFoamCell *cell, UInt_t i) const
Returns cell element i of cell 'cell'.
Definition: PDEFoam.cxx:1416
TMath::Log
Double_t Log(Double_t x)
Definition: TMath.h:760
TMVA::PDEFoam::Divide
Int_t Divide(PDEFoamCell *)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:714
colors
Color * colors
Definition: X3DBuffer.c:21
TCollection::SetOwner
virtual void SetOwner(Bool_t enable=kTRUE)
Set whether this collection is the owner (enable==true) of its content.
Definition: TCollection.cxx:746
TH1D
1-D histogram with a double per channel (see TH1 documentation)}
Definition: TH1.h:618
TStyle::GetNumberOfColors
Int_t GetNumberOfColors() const
Return number of colors in the color palette.
Definition: TStyle.cxx:1122
Float_t
float Float_t
Definition: RtypesCore.h:57
TStyle.h
TMVA::PDEFoam::SetDim
void SetDim(Int_t kDim)
Sets dimension of cubical space.
Definition: PDEFoam.cxx:250
TMVA::PDEFoamCell::Print
void Print(Option_t *option) const
Printout of the cell geometry parameters for the debug purpose.
Definition: PDEFoamCell.cxx:244
TMVA::PDEFoamCell::SetXdiv
void SetXdiv(Double_t Xdiv)
Definition: PDEFoamCell.h:80
Int_t
int Int_t
Definition: RtypesCore.h:45
TMVA::PDEFoam::Project2
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
TAxis::GetBinCenter
virtual Double_t GetBinCenter(Int_t bin) const
Return center of bin.
Definition: TAxis.cxx:478
TMVA::PDEFoam::GetCellValue
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 'xvec' and re...
Definition: PDEFoam.cxx:1016
TString::Contains
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
Definition: TString.h:624
TH1::SetBinContent
virtual void SetBinContent(Int_t bin, Double_t content)
Set bin content see convention for numbering bins in TH1::GetBin In case the bin number is greater th...
Definition: TH1.cxx:8988
TMVA::PDEFoam::SetXmin
void SetXmin(Int_t idim, Double_t wmin)
set lower foam bound in dimension idim
Definition: PDEFoam.cxx:265
x
Double_t x[n]
Definition: legend1.C:17
TColor.h
TMVA::PDEFoam::Eval
Double_t Eval(Double_t *xRand, Double_t &event_density)
Internal subprogram.
Definition: PDEFoam.cxx:747
TMath::Abs
Short_t Abs(Short_t d)
Definition: TMathBase.h:120
TMVA::PDEFoam::Draw1Dim
TH1D * Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase *kernel=NULL)
Draws 1-dimensional foam (= histogram)
Definition: PDEFoam.cxx:1218
kVlow
static const Float_t kVlow
Definition: PDEFoam.cxx:96
TMVA::PDEFoamCell::SetDriv
void SetDriv(Double_t Driv)
Definition: PDEFoamCell.h:89
TString
Basic string class.
Definition: TString.h:136
TMVA::PDEFoam::CellFill
Int_t CellFill(Int_t, PDEFoamCell *)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:389
h1
TH1F * h1
Definition: legend1.C:5
bool
TMVA::PDEFoamCell::GetVolume
Double_t GetVolume() const
Definition: PDEFoamCell.h:85
TMVA::PDEFoam::ResetCellElements
void ResetCellElements()
Remove the cell elements from all cells.
Definition: PDEFoam.cxx:971
TVectorT::GetNrows
Int_t GetNrows() const
Definition: TVectorT.h:75
x1
static const double x1[5]
Definition: RooGaussKronrodIntegrator1D.cxx:346
TMVA::PDEFoam::CellValueIsUndefined
virtual Bool_t CellValueIsUndefined(PDEFoamCell *)
Returns true, if the value of the given cell is undefined.
Definition: PDEFoam.cxx:990
TMVA::PDEFoam
Implementation of PDEFoam.
Definition: PDEFoam.h:79
TMVA::PDEFoamCell::GetHcub
void GetHcub(PDEFoamVect &, PDEFoamVect &) const
Provides size and position of the cell These parameter are calculated by analyzing information in all...
Definition: PDEFoamCell.cxx:140
TMVA::PDEFoam::~PDEFoam
virtual ~PDEFoam()
Default destructor.
Definition: PDEFoam.cxx:184
TH1::GetBinContent
virtual Double_t GetBinContent(Int_t bin) const
Return content of bin number bin.
Definition: TH1.cxx:4970
MsgLogger.h
TVectorT.h
Timer.h
gStyle
R__EXTERN TStyle * gStyle
Definition: TStyle.h:412
TH1::GetYaxis
TAxis * GetYaxis()
Definition: TH1.h:321
TMVA::Event::GetValues
std::vector< Float_t > & GetValues()
Definition: Event.h:94
TRandom3
Random number generator class based on M.
Definition: TRandom3.h:27
epsilon
REAL epsilon
Definition: triangle.c:617
TMVA::PDEFoam::InitCells
void InitCells()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:356
kFALSE
const Bool_t kFALSE
Definition: RtypesCore.h:92
TH1::AddDirectory
static void AddDirectory(Bool_t add=kTRUE)
Sets the flag controlling the automatic add of histograms in memory.
Definition: TH1.cxx:1258
TH1::GetBinCenter
virtual Double_t GetBinCenter(Int_t bin) const
Return bin center for 1D histogram.
Definition: TH1.cxx:8907
Long_t
long Long_t
Definition: RtypesCore.h:54
TH2D
2-D histogram with a double per channel (see TH1 documentation)}
Definition: TH2.h:292
TMVA::PDEFoam::fVariableNames
TObjArray * fVariableNames
timer for graphical output
Definition: PDEFoam.h:117
TMVA::PDEFoamCell::SetElement
void SetElement(TObject *fobj)
Definition: PDEFoamCell.h:106
TMVA::PDEFoamCell::GetIntg
Double_t GetIntg() const
Definition: PDEFoamCell.h:86
gDirectory
#define gDirectory
Definition: TDirectory.h:236
TMVA::PDEFoam::SetXmax
void SetXmax(Int_t idim, Double_t wmax)
set upper foam bound in dimension idim
Definition: PDEFoam.cxx:276
Event.h
kHigh
static const Float_t kHigh
Definition: PDEFoam.cxx:95
TRandom3.h
TStyle::GetColorPalette
Int_t GetColorPalette(Int_t i) const
Return color number i in current palette.
Definition: TStyle.cxx:1056
TMVA::PDEFoamVect
Definition: PDEFoamVect.h:36
PDEFoam.h
y
Double_t y[n]
Definition: legend1.C:17
sqrt
double sqrt(double)
TMVA::PDEFoam::OutputGrow
void OutputGrow(Bool_t finished=false)
message logger
Definition: PDEFoam.cxx:1460
TMVA::PDEFoam::SetCellElement
void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value)
Set cell element i of cell to value.
Definition: PDEFoam.cxx:1432
Types.h
TMVA::Endl
MsgLogger & Endl(MsgLogger &ml)
Definition: MsgLogger.h:158
unsigned int
TMVA::Timer
Timing information for training and evaluation of MVA methods.
Definition: Timer.h:58
TMVA::PDEFoamCell::SetIntg
void SetIntg(Double_t Intg)
Definition: PDEFoamCell.h:88
TMVA::PDEFoamKernelBase::Estimate
virtual Float_t Estimate(PDEFoam *, std::vector< Float_t > &, ECellValue)=0
TMVA::PDEFoamCell::GetElement
TObject * GetElement() const
Definition: PDEFoamCell.h:107
TMVA::PDEFoam::Log
MsgLogger & Log() const
Definition: PDEFoam.h:240
TMVA::PDEFoamCell::CalcVolume
void CalcVolume()
Calculates volume of the cell using size params which are calculated.
Definition: PDEFoamCell.cxx:194
TMVA::PDEFoamCell::Fill
void Fill(Int_t, PDEFoamCell *, PDEFoamCell *, PDEFoamCell *)
Fills in certain data into newly allocated cell.
Definition: PDEFoamCell.cxx:123
TVectorT< Double_t >
TMVA::PDEFoamCell::SetDau0
void SetDau0(PDEFoamCell *Daug)
Definition: PDEFoamCell.h:96
Double_t
double Double_t
Definition: RtypesCore.h:59
TMVA::MsgLogger
ostringstream derivative to redirect and format output
Definition: MsgLogger.h:59
TMVA::PDEFoamCell::GetDau0
PDEFoamCell * GetDau0() const
Definition: PDEFoamCell.h:94
TStyle::SetPalette
void SetPalette(Int_t ncolors=kBird, Int_t *colors=0, Float_t alpha=1.)
See TColor::SetPalette.
Definition: TStyle.cxx:1782
TObject.h
TObjArray.h
TVectorD
TVectorT< Double_t > TVectorD
Definition: TVectorDfwd.h:22
TMVA::PDEFoam::FindCells
std::vector< TMVA::PDEFoamCell * > FindCells(const std::vector< Float_t > &) const
Find all cells, that contain txvec.
Definition: PDEFoam.cxx:1165
TMVA::PDEFoam::RootPlot2dim
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
TMVA::PDEFoam::CheckAll
void CheckAll(Int_t)
User utility, miscellaneous and debug.
Definition: PDEFoam.cxx:822
TMVA::PDEFoam::Create
void Create()
Basic initialization of FOAM invoked by the user.
Definition: PDEFoam.cxx:292
Info
void Info(const char *location, const char *msgfmt,...)
Use this function for informational messages.
Definition: TError.cxx:220
TMVA::PDEFoam::DeleteBinarySearchTree
void DeleteBinarySearchTree()
Delete the foam's density estimator, which contains the binary search tree.
Definition: PDEFoam.cxx:1666
TObject
Mother of all ROOT objects.
Definition: TObject.h:37
TMVA::Event
Definition: Event.h:51
TVectorT::Zero
TVectorT< Element > & Zero()
Set vector elements to zero.
Definition: TVectorT.cxx:453
name
char name[80]
Definition: TGX11.cxx:110
TMVA::PDEFoam::MakeAlpha
void MakeAlpha()
Internal subprogram used by Create.
Definition: PDEFoam.cxx:637
TMVA::PDEFoamCell::GetDriv
Double_t GetDriv() const
Definition: PDEFoamCell.h:87
x2
static const double x2[5]
Definition: RooGaussKronrodIntegrator1D.cxx:364
TMVA::PDEFoamCell::SetStat
void SetStat(Int_t Stat)
Definition: PDEFoamCell.h:92
TMVA::PDEFoamCell::SetDau1
void SetDau1(PDEFoamCell *Daug)
Definition: PDEFoamCell.h:97
TH1::GetNbinsY
virtual Int_t GetNbinsY() const
Definition: TH1.h:297
Tools.h
TMVA::PDEFoam::FillBinarySearchTree
void FillBinarySearchTree(const Event *ev)
Insert event to internal foam's density estimator PDEFoamDensityBase.
Definition: PDEFoam.cxx:1657
TMVA::PDEFoam::FindCell
PDEFoamCell * FindCell(const std::vector< Float_t > &) const
Find cell that contains 'xvec' (in foam coordinates [0,1]).
Definition: PDEFoam.cxx:1080
TMVA::PDEFoamCell::GetDau1
PDEFoamCell * GetDau1() const
Definition: PDEFoamCell.h:95
TH1::AddDirectoryStatus
static Bool_t AddDirectoryStatus()
Static function: cannot be inlined on Windows/NT.
Definition: TH1.cxx:738
Float_t
CPyCppyy::Utility::kValue
@ kValue
Definition: Utility.h:36
TH1D.h
TH1::GetXaxis
TAxis * GetXaxis()
Get the behaviour adopted by the object about the statoverflows. See EStatOverflows for more informat...
Definition: TH1.h:320
RooFit::Eval
@ Eval
Definition: RooGlobalFunc.h:68
TMath::E
constexpr Double_t E()
Base of natural log:
Definition: TMath.h:96
TMVA::PDEFoam::Explore
virtual void Explore(PDEFoamCell *Cell)
Internal subprogram used by Create.
Definition: PDEFoam.cxx:434
TMVA::PDEFoamCell::GetBest
Int_t GetBest() const
Definition: PDEFoamCell.h:78
TMVA::PDEFoamCell
Definition: PDEFoamCell.h:41
TMath.h
TH1::GetNbinsX
virtual Int_t GetNbinsX() const
Definition: TH1.h:296
int
TMVA::PDEFoamCell::GetPare
PDEFoamCell * GetPare() const
Definition: PDEFoamCell.h:93