ROOT logo
ROOT » TMVA » TMVA::MethodPDEFoam

class TMVA::MethodPDEFoam: public TMVA::MethodBase


 MethodPDEFoam

 The PDEFoam method is an extension of the PDERS method, which
 divides the multi-dimensional phase space in a finite number of
 hyper-rectangles (cells) of constant event density.  This "foam" of
 cells is filled with averaged probability-density information
 sampled from a training event sample.

 For a given number of cells, the binning algorithm adjusts the size
 and position of the cells inside the multidimensional phase space
 based on a binary-split algorithm, minimizing the variance of the
 event density in the cell.
 The binned event density information of the final foam is stored in
 binary trees, allowing for a fast and memory-efficient
 classification of events.

 The implementation of PDEFoam is based on the Monte-Carlo
 integration package TFoam included in the analysis package ROOT.

Function Members (Methods)

public:
virtual~MethodPDEFoam()
voidTObject::AbstractMethod(const char* method) const
voidTMVA::Configurable::AddOptionsXMLTo(void* parent) const
voidTMVA::MethodBase::AddOutput(TMVA::Types::ETreeType type, TMVA::Types::EAnalysisType analysisType)
virtual voidAddWeightsXMLTo(void* parent) const
virtual voidTObject::AppendPad(Option_t* option = "")
TDirectory*TMVA::MethodBase::BaseDir() const
virtual voidTObject::Browse(TBrowser* b)
voidTMVA::Configurable::CheckForUnusedOptions() const
virtual voidTMVA::MethodBase::CheckSetup()
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
TMVA::ConfigurableTMVA::Configurable::Configurable(const TString& theOption = "")
virtual voidTObject::Copy(TObject& object) const
virtual const TMVA::Ranking*CreateRanking()
TMVA::DataSet*TMVA::MethodBase::Data() const
TMVA::DataSetInfo&TMVA::MethodBase::DataInfo() const
virtual voidTObject::Delete(Option_t* option = "")MENU
voidTMVA::MethodBase::DisableWriting(Bool_t setter)
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
Bool_tTMVA::MethodBase::DoMulticlass() const
Bool_tTMVA::MethodBase::DoRegression() const
virtual voidTObject::Draw(Option_t* option = "")
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
virtual voidTObject::Dump() constMENU
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
TMVA::Types::EAnalysisTypeTMVA::MethodBase::GetAnalysisType() const
const char*TMVA::Configurable::GetConfigDescription() const
const char*TMVA::Configurable::GetConfigName() const
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual Double_tTMVA::MethodBase::GetEfficiency(const TString&, TMVA::Types::ETreeType, Double_t& err)
const TMVA::Event*TMVA::MethodBase::GetEvent() const
const TMVA::Event*TMVA::MethodBase::GetEvent(const TMVA::Event* ev) const
const TMVA::Event*TMVA::MethodBase::GetEvent(Long64_t ievt) const
const TMVA::Event*TMVA::MethodBase::GetEvent(Long64_t ievt, TMVA::Types::ETreeType type) const
const vector<TMVA::Event*>&TMVA::MethodBase::GetEventCollection(TMVA::Types::ETreeType type)
virtual const char*TObject::GetIconName() const
const TString&TMVA::MethodBase::GetInputLabel(Int_t i) const
const TString&TMVA::MethodBase::GetInputTitle(Int_t i) const
const TString&TMVA::MethodBase::GetInputVar(Int_t i) const
const TString&TMVA::MethodBase::GetJobName() const
TMVA::MethodPDEFoam::EKernelGetKernel()
virtual Double_tTMVA::MethodBase::GetKSTrainingVsTest(Char_t SorB, TString opt = "X")
virtual Double_tTMVA::MethodBase::GetMaximumSignificance(Double_t SignalEvents, Double_t BackgroundEvents, Double_t& optimal_significance_value) const
Double_tTMVA::MethodBase::GetMean(Int_t ivar) const
const TString&TMVA::MethodBase::GetMethodName() const
TMVA::Types::EMVATMVA::MethodBase::GetMethodType() const
TStringTMVA::MethodBase::GetMethodTypeName() const
virtual vector<Float_t>TMVA::MethodBase::GetMulticlassEfficiency(vector<std::vector<Float_t> >& purity)
virtual vector<Float_t>TMVA::MethodBase::GetMulticlassTrainingEfficiency(vector<std::vector<Float_t> >& purity)
virtual const vector<Float_t>&GetMulticlassValues()
virtual Double_tGetMvaValue(Double_t* err = 0, Double_t* errUpper = 0)
virtual const char*TMVA::MethodBase::GetName() const
voidGetNCuts(TMVA::PDEFoamCell* cell, vector<UInt_t>& nCuts)
UInt_tTMVA::MethodBase::GetNEvents() const
UInt_tTMVA::MethodBase::GetNTargets() const
UInt_tTMVA::MethodBase::GetNvar() const
UInt_tTMVA::MethodBase::GetNVariables() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
const TString&TMVA::Configurable::GetOptions() const
virtual Double_tTMVA::MethodBase::GetProba(const TMVA::Event* ev)
virtual Double_tTMVA::MethodBase::GetProba(Double_t mvaVal, Double_t ap_sig)
const TStringTMVA::MethodBase::GetProbaName() const
virtual Double_tTMVA::MethodBase::GetRarity(Double_t mvaVal, TMVA::Types::ESBType reftype = Types::kBackground) const
virtual voidTMVA::MethodBase::GetRegressionDeviation(UInt_t tgtNum, TMVA::Types::ETreeType type, Double_t& stddev, Double_t& stddev90Percent) const
virtual const vector<Float_t>&GetRegressionValues()
Double_tTMVA::MethodBase::GetRMS(Int_t ivar) const
virtual Double_tTMVA::MethodBase::GetROCIntegral(TH1D* histS, TH1D* histB) const
virtual Double_tTMVA::MethodBase::GetROCIntegral(TMVA::PDF* pdfS = 0, TMVA::PDF* pdfB = 0) const
virtual Double_tTMVA::MethodBase::GetSeparation(TH1*, TH1*) const
virtual Double_tTMVA::MethodBase::GetSeparation(TMVA::PDF* pdfS = 0, TMVA::PDF* pdfB = 0) const
Double_tTMVA::MethodBase::GetSignalReferenceCut() const
Double_tTMVA::MethodBase::GetSignalReferenceCutOrientation() const
virtual Double_tTMVA::MethodBase::GetSignificance() const
const TMVA::Event*TMVA::MethodBase::GetTestingEvent(Long64_t ievt) const
Double_tTMVA::MethodBase::GetTestTime() const
const TString&TMVA::MethodBase::GetTestvarName() const
virtual const char*TObject::GetTitle() const
virtual Double_tTMVA::MethodBase::GetTrainingEfficiency(const TString&)
const TMVA::Event*TMVA::MethodBase::GetTrainingEvent(Long64_t ievt) const
UInt_tTMVA::MethodBase::GetTrainingROOTVersionCode() const
TStringTMVA::MethodBase::GetTrainingROOTVersionString() const
UInt_tTMVA::MethodBase::GetTrainingTMVAVersionCode() const
TStringTMVA::MethodBase::GetTrainingTMVAVersionString() const
Double_tTMVA::MethodBase::GetTrainTime() const
TMVA::TransformationHandler&TMVA::MethodBase::GetTransformationHandler(Bool_t takeReroutedIfAvailable = true)
const TMVA::TransformationHandler&TMVA::MethodBase::GetTransformationHandler(Bool_t takeReroutedIfAvailable = true) const
virtual UInt_tTObject::GetUniqueID() const
TStringTMVA::MethodBase::GetWeightFileName() const
Double_tTMVA::MethodBase::GetXmax(Int_t ivar) const
Double_tTMVA::MethodBase::GetXmin(Int_t ivar) const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual Bool_tHasAnalysisType(TMVA::Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
virtual ULong_tTObject::Hash() const
Bool_tTMVA::MethodBase::HasMVAPdfs() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTMVA::MethodBase::IsSignalLike()
virtual Bool_tTMVA::MethodBase::IsSignalLike(Double_t mvaVal)
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
UInt_tKernelToUInt(TMVA::MethodPDEFoam::EKernel ker) const
virtual voidTObject::ls(Option_t* option = "") const
virtual voidTMVA::MethodBase::MakeClass(const TString& classFileName = TString("")) const
voidTObject::MayNotUse(const char* method) const
TDirectory*TMVA::MethodBase::MethodBaseDir() const
TMVA::MethodPDEFoamMethodPDEFoam(TMVA::DataSetInfo& dsi, const TString& theWeightFile, TDirectory* theTargetDir = NULL)
TMVA::MethodPDEFoamMethodPDEFoam(const TString& jobName, const TString& methodTitle, TMVA::DataSetInfo& dsi, const TString& theOption = "PDEFoam", TDirectory* theTargetDir = 0)
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
TMVA::IMethod&TMVA::IMethod::operator=(const TMVA::IMethod&)
virtual map<TString,Double_t>TMVA::MethodBase::OptimizeTuningParameters(TString fomType = "ROCIntegral", TString fitType = "FitGA")
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTMVA::Configurable::ParseOptions()
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual voidTMVA::MethodBase::PrintHelpMessage() const
voidTMVA::Configurable::PrintOptions() const
voidTMVA::MethodBase::ProcessSetup()
virtual Int_tTObject::Read(const char* name)
TMVA::PDEFoam*ReadClonedFoamFromFile(TFile*, const TString&)
voidReadFoamsFromFile()
voidTMVA::Configurable::ReadOptionsFromStream(istream& istr)
voidTMVA::Configurable::ReadOptionsFromXML(void* node)
voidTMVA::MethodBase::ReadStateFromFile()
voidTMVA::MethodBase::ReadStateFromStream(istream& tf)
voidTMVA::MethodBase::ReadStateFromStream(TFile& rf)
voidTMVA::MethodBase::ReadStateFromXMLString(const char* xmlstr)
virtual voidReadWeightsFromStream(istream& i)
virtual voidReadWeightsFromXML(void* wghtnode)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTMVA::MethodBase::RerouteTransformationHandler(TMVA::TransformationHandler* fTargetTransformation)
virtual voidReset()
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(ostream& out, Option_t* option = "")
virtual voidTMVA::MethodBase::SetAnalysisType(TMVA::Types::EAnalysisType type)
voidTMVA::MethodBase::SetBaseDir(TDirectory* methodDir)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
voidTMVA::Configurable::SetConfigDescription(const char* d)
voidTMVA::Configurable::SetConfigName(const char* n)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
voidTMVA::MethodBase::SetMethodBaseDir(TDirectory* methodDir)
voidTMVA::MethodBase::SetMethodDir(TDirectory* methodDir)
voidTMVA::Configurable::SetMsgType(TMVA::EMsgType t)
static voidTObject::SetObjectStat(Bool_t stat)
voidTMVA::Configurable::SetOptions(const TString& s)
voidTMVA::MethodBase::SetSignalReferenceCut(Double_t cut)
voidTMVA::MethodBase::SetSignalReferenceCutOrientation(Double_t cutOrientation)
voidTMVA::MethodBase::SetTestTime(Double_t testTime)
voidTMVA::MethodBase::SetTestvarName(const TString& v = "")
voidTMVA::MethodBase::SetTrainTime(Double_t trainTime)
virtual voidTMVA::MethodBase::SetTuneParameters(map<TString,Double_t> tuneParameters)
virtual voidTObject::SetUniqueID(UInt_t uid)
voidTMVA::MethodBase::SetupMethod()
virtual voidShowMembers(TMemberInspector&)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
UInt_tTargetSelectionToUInt(TMVA::ETargetSelection ts) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTMVA::MethodBase::TestClassification()
virtual voidTMVA::MethodBase::TestMulticlass()
virtual voidTMVA::MethodBase::TestRegression(Double_t& bias, Double_t& biasT, Double_t& dev, Double_t& devT, Double_t& rms, Double_t& rmsT, Double_t& mInf, Double_t& mInfT, Double_t& corr, TMVA::Types::ETreeType type)
virtual voidTrain()
voidTMVA::MethodBase::TrainMethod()
voidTrainMonoTargetRegression()
voidTrainMultiClassification()
voidTrainMultiTargetRegression()
voidTrainSeparatedClassification()
voidTrainUnifiedClassification()
TMVA::MethodPDEFoam::EKernelUIntToKernel(UInt_t iker)
TMVA::ETargetSelectionUIntToTargetSelection(UInt_t its)
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
virtual voidTMVA::MethodBase::WriteEvaluationHistosToFile(TMVA::Types::ETreeType treetype)
voidWriteFoamsToFile() const
virtual voidTMVA::MethodBase::WriteMonitoringHistosToFile() const
voidTMVA::Configurable::WriteOptionsToStream(ostream& o, const TString& prefix) const
voidTMVA::MethodBase::WriteStateToFile() const
protected:
Double_tCalculateMVAError()
voidCalcXminXmax()
TMVA::PDEFoamKernelBase*CreatePDEFoamKernel()
voidDeleteFoams()
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidTMVA::Configurable::EnableLooseOptions(Bool_t b = kTRUE)
voidFillVariableNamesToFoam() const
virtual voidGetHelpMessage() const
const TString&TMVA::MethodBase::GetInternalVarName(Int_t ivar) const
const TString&TMVA::MethodBase::GetOriginalVarName(Int_t ivar) const
const TString&TMVA::Configurable::GetReferenceFile() const
static TMVA::MethodBase*TMVA::MethodBase::GetThisBase()
const TString&TMVA::MethodBase::GetWeightFileDir() const
Bool_tTMVA::MethodBase::HasTrainingTree() const
Bool_tTMVA::MethodBase::Help() const
Bool_tTMVA::MethodBase::IgnoreEventsWithNegWeightsInTraining() const
TMVA::PDEFoam*InitFoam(TString, TMVA::EFoamType, UInt_t cls = 0)
Bool_tTMVA::MethodBase::IsConstructedFromWeightFile() const
Bool_tTMVA::MethodBase::IsNormalised() const
TMVA::MsgLogger&TMVA::Configurable::Log() const
Bool_tTMVA::Configurable::LooseOptionCheckingEnabled() const
virtual voidMakeClassSpecific(ostream&, const TString&) const
virtual voidTMVA::MethodBase::MakeClassSpecificHeader(ostream&, const TString& = "") const
voidTObject::MakeZombie()
voidTMVA::MethodBase::NoErrorCalc(Double_t *const err, Double_t *const errUpper)
voidTMVA::Configurable::ResetSetFlag()
voidTMVA::MethodBase::SetNormalised(Bool_t norm)
voidTMVA::MethodBase::SetWeightFileDir(TString fileDir)
voidTMVA::MethodBase::SetWeightFileName(TString)
voidSetXminXmax(TMVA::PDEFoam*)
voidTMVA::MethodBase::Statistics(TMVA::Types::ETreeType treeType, const TString& theVarName, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&)
Bool_tTMVA::MethodBase::TxtWeightsOnly() const
Bool_tTMVA::MethodBase::Verbose() const
voidTMVA::Configurable::WriteOptionsReferenceToFile()
private:
virtual voidDeclareCompatibilityOptions()
virtual voidDeclareOptions()
virtual voidInit()
voidPrintCoefficients()
virtual voidProcessOptions()

Data Members

public:
enum EKernel { kNone
kGaus
kLinN
};
enum TMVA::MethodBase::EWeightFileType { kROOT
kTEXT
};
enum TObject::EStatusBits { kCanDelete
kMustCleanup
kObjInCanvas
kIsReferenced
kHasUUID
kCannotPick
kNoContextMenu
kInvalidObject
};
enum TObject::[unnamed] { kIsOnHeap
kNotDeleted
kZombie
kBitMask
kSingleKey
kOverwrite
kWriteDelete
};
public:
Bool_tTMVA::MethodBase::fSetupCompletedis method setup
const TMVA::Event*TMVA::MethodBase::fTmpEvent! temporary event when testing on a different DataSet than the own one
protected:
TMVA::Types::EAnalysisTypeTMVA::MethodBase::fAnalysisTypemethod-mode : true --> regression, false --> classification
UInt_tTMVA::MethodBase::fBackgroundClassindex of the Background-class
vector<TString>*TMVA::MethodBase::fInputVarsvector of input variables used in MVA
vector<Float_t>*TMVA::MethodBase::fMulticlassReturnValholds the return-values for the multiclass classification
Int_tTMVA::MethodBase::fNbinsnumber of bins in input variable histograms
Int_tTMVA::MethodBase::fNbinsHnumber of bins in evaluation histograms
Int_tTMVA::MethodBase::fNbinsMVAoutputnumber of bins in MVA output histograms
TMVA::Ranking*TMVA::MethodBase::fRankingpointer to ranking object (created by derived classifiers)
vector<Float_t>*TMVA::MethodBase::fRegressionReturnValholds the return-values for the regression
UInt_tTMVA::MethodBase::fSignalClassindex of the Signal-class
private:
Bool_tfCompresscompress foam output file
Bool_tfCutNminKeep for bw compatibility: Grabbing cell with maximal RMS to split next (TFoam default)
TStringfDTLogicuse DT algorithm to split cells
TMVA::EDTSeparationfDTSeparationenum which specifies the separation to use for the DT logic
Float_tfDiscrErrCutcut on discrimant error
Int_tfEvPerBinMaximum events (equiv.) per bin in buid-up (1000)
Bool_tfFillFoamWithOrigWeightsfill the foam with boost weights
vector<PDEFoam*>fFoamgrown PDEFoams
Float_tfFracFraction used for calc of Xmin, Xmax
TMVA::MethodPDEFoam::EKernelfKernelKernel for GetMvaValue()
TMVA::PDEFoamKernelBase*fKernelEstimatorKernel estimator
TStringfKernelStrKernel for GetMvaValue() (option string)
UInt_tfMaxDepthmaximum depth of cell tree
Bool_tfMultiTargetRegressiondo regression on multible targets
UInt_tfNminminimal number of events in cell necessary to split cell"
Bool_tfPeekMaxBACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split
Bool_tfSigBgSeparatedSeparate Sig and Bg, or not
TMVA::ETargetSelectionfTargetSelectionmethod of selecting the target (only mulit target regr.)
TStringfTargetSelectionStrmethod of selecting the target (only mulit target regr.)
Bool_tfUseYesNoCellreturn -1 or 1 for bg or signal like event
Float_tfVolFracvolume fraction (used for density calculation during buildup)
vector<Float_t>fXmaxrange for histograms and foams
vector<Float_t>fXmin
Int_tfnActiveCellsNumber of active cells
Int_tfnBinNumber of bins in build-up (100)
Int_tfnCellsNumber of Cells (1000)
Int_tfnSamplNumber of MC events per cell in build-up (1000)

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

MethodPDEFoam(const TString& jobName, const TString& methodTitle, TMVA::DataSetInfo& dsi, const TString& theOption = "PDEFoam", TDirectory* theTargetDir = 0)
 init PDEFoam objects
MethodPDEFoam(TMVA::DataSetInfo& dsi, const TString& theWeightFile, TDirectory* theTargetDir = NULL)
 constructor from weight file
Bool_t HasAnalysisType(TMVA::Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
 PDEFoam can handle classification with multiple classes and regression
 with one or more regression-targets
void Init( void )
 default initialization called by all constructors
void DeclareOptions()
 Declare MethodPDEFoam options

void DeclareCompatibilityOptions()
 options that are used ONLY for the READER to ensure backward compatibility
void ProcessOptions()
 process user options
~MethodPDEFoam( void )
 destructor
void CalcXminXmax()
 Determine foam range [fXmin, fXmax] for all dimensions, such
 that a fraction of 'fFrac' events lie outside the foam.
void Train( void )
 Train PDE-Foam depending on the set options
void TrainSeparatedClassification()
 Creation of 2 separated foams: one for signal events, one for
 backgound events.  At the end the foam cells of fFoam[0] will
 contain the average number of signal events and fFoam[1] will
 contain the average number of background events.
void TrainUnifiedClassification()
 Create only one unified foam (fFoam[0]) whose cells contain the
 average discriminator (N_sig)/(N_sig + N_bg)
void TrainMultiClassification()
 Create one unified foam (see TrainUnifiedClassification()) for
 each class, where the cells of foam i (fFoam[i]) contain the
 average fraction of events of class i, i.e.

   D = number events of class i / total number of events
void TrainMonoTargetRegression()
 Training one (mono target regression) foam, whose cells contain
 the average 0th target.  The dimension of the foam = number of
 non-targets (= number of variables).
void TrainMultiTargetRegression()
 Training one (multi target regression) foam, whose cells contain
 the average event density.  The dimension of the foam = number
 of non-targets + number of targets.
Double_t GetMvaValue(Double_t* err = 0, Double_t* errUpper = 0)
 Return Mva-Value.

 In case of 'fSigBgSeparated==false' (one unifiend PDEFoam was
 trained) the function returns the content of the cell, which
 corresponds to the current TMVA::Event, i.e.  D =
 N_sig/(N_bg+N_sig).

 In case of 'fSigBgSeparated==true' (two separate PDEFoams were
 trained) the function returns

    D = Density_sig/(Density_sig+Density_bg)

 where 'Density_sig' is the content of the cell in the signal
 PDEFoam (fFoam[0]) and 'Density_bg' is the content of the cell
 in the background PDEFoam (fFoam[1]).

 In both cases the error on the discriminant is stored in 'err'
 and 'errUpper'.  (Of course err and errUpper must be non-zero
 and point to valid address to make this work.)
Double_t CalculateMVAError()
 Calculate the error on the Mva value

 If fSigBgSeparated == true the error is calculated from the
 number of events in the signal and background PDEFoam cells.

 If fSigBgSeparated == false, the error is taken directly from
 the PDEFoam cell.
const std::vector<Float_t>& GetMulticlassValues()
 Get the multiclass MVA response for the PDEFoam classifier.  The
 returned MVA values are normalized, i.e. their sum equals 1.
const TMVA::Ranking* CreateRanking()
 Compute ranking of input variables from the number of cuts made
 in each PDEFoam dimension.  The PDEFoam dimension (the variable)
 for which the most cuts were done is ranked highest.
void GetNCuts(TMVA::PDEFoamCell* cell, vector<UInt_t>& nCuts)
 Fill in 'nCuts' the number of cuts made in every foam dimension,
 starting at the root cell 'cell'.

 Parameters:

 - cell - root cell to start the counting from

 - nCuts - the number of cuts are saved in this vector
void SetXminXmax(TMVA::PDEFoam* )
 Set Xmin, Xmax for every dimension in the given pdefoam object
TMVA::PDEFoam* InitFoam(TString , TMVA::EFoamType , UInt_t cls = 0)
 Create a new PDEFoam, set the PDEFoam options (nCells, nBin,
 Xmin, Xmax, etc.) and initialize the PDEFoam by calling
 pdefoam->Initialize().

 Parameters:

 - foamcaption - name of PDEFoam object

 - ft - type of PDEFoam
   Candidates are:
     - kSeparate    - creates TMVA::PDEFoamEvent
     - kDiscr       - creates TMVA::PDEFoamDiscriminant
     - kMonoTarget  - creates TMVA::PDEFoamTarget
     - kMultiTarget - creates TMVA::MultiTarget
     - kMultiClass  - creates TMVA::PDEFoamDiscriminant

   If 'fDTSeparation != kFoam' then a TMVA::PDEFoamDecisionTree
   is created (the separation type depends on fDTSeparation).

 - cls - marked event class (optional, default value = 0)
const std::vector<Float_t>& GetRegressionValues()
 Return regression values for both multi- and mono-target regression
TMVA::PDEFoamKernelBase* CreatePDEFoamKernel()
 create a pdefoam kernel estimator, depending on the current
 value of fKernel
void DeleteFoams()
 Deletes all trained foams
void Reset()
 reset MethodPDEFoam:
 - delete all PDEFoams
 - delete the kernel estimator
void PrintCoefficients( void )
{}
void AddWeightsXMLTo(void* parent) const
 create XML output of PDEFoam method variables
void WriteFoamsToFile() const
 Write PDEFoams to file
void ReadWeightsFromStream(istream& i)
 read options and internal parameters
void ReadWeightsFromXML(void* wghtnode)
 read PDEFoam variables from xml weight file
TMVA::PDEFoam* ReadClonedFoamFromFile(TFile* , const TString& )
 Reads a foam with name 'foamname' from file, and returns a clone
 of the foam.  The given ROOT file must be open.  (The ROOT file
 will not be closed in this function.)

 Parameters:

 - file - an open ROOT file

 - foamname - name of foam to load from the file

 Returns:

 If a foam with name 'foamname' exists in the file, then it is
 read from the file, cloned and returned.  If a foam with name
 'foamname' does not exist in the file or the clone operation
 does not succeed, then NULL is returned.
void ReadFoamsFromFile()
 read foams from file
TMVA::ETargetSelection UIntToTargetSelection(UInt_t its)
 convert UInt_t to ETargetSelection (used for reading weight files)
void FillVariableNamesToFoam() const
 store the variable names in all foams
void MakeClassSpecific(ostream& , const TString& ) const
 write PDEFoam-specific classifier response
 NOT IMPLEMENTED YET!
void GetHelpMessage() const
 provide help message
EKernel GetKernel( void )
 helper functions to convert enum types to UInt_t and back
{ return fKernel; }
UInt_t KernelToUInt(TMVA::MethodPDEFoam::EKernel ker) const
{ return UInt_t(ker); }
EKernel UIntToKernel(UInt_t iker)
UInt_t TargetSelectionToUInt(TMVA::ETargetSelection ts) const
{ return UInt_t(ts); }