/**********************************************************************************

* Project : TMVA - a Root-integrated toolkit for multivariate data analysis *

* Package : TMVA *

* Exectuable: TMVAClassificationApplication *

* *

* This macro provides a simple example on how to use the trained classifiers *

* within an analysis module *

**********************************************************************************/

#include <cstdlib>

#include <vector>

#include <iostream>

#include <map>

#include <string>

#include "TFile.h"

#include "TTree.h"

#include "TString.h"

#include "TSystem.h"

#include "TROOT.h"

#include "TPluginManager.h"

#include "TStopwatch.h"

#include "TMVAGui.C"

#if not defined(__CINT__) || defined(__MAKECINT__)

#include "TMVA/Tools.h"

#include "TMVA/Reader.h"

#endif

using namespace TMVA;

void TMVAClassificationApplication( TString myMethodList = "", TString filename="" )

{

//---------------------------------------------------------------

// default MVA methods to be trained + tested

// this loads the library

TMVA::Tools::Instance();

std::map<std::string,int> Use;

Use["CutsGA"] = 1; // other "Cuts" methods work identically

// ---

Use["Likelihood"] = 1;

Use["LikelihoodD"] = 1; // the "D" extension indicates decorrelated input variables (see option strings)

Use["LikelihoodPCA"] = 0; // the "PCA" extension indicates PCA-transformed input variables (see option strings)

Use["LikelihoodKDE"] = 0;

Use["LikelihoodMIX"] = 0;

// ---

Use["PDERS"] = 1;

Use["PDERSD"] = 0;

Use["PDERSPCA"] = 0;

Use["PDERSkNN"] = 0; // depreciated until further notice

Use["PDEFoam"] = 1;

// --

Use["KNN"] = 1;

// ---

Use["HMatrix"] = 0;

Use["Fisher"] = 1;

Use["FisherG"] = 0;

Use["BoostedFisher"] = 0;

Use["LD"] = 1;

// ---

Use["FDA_GA"] = 0;

Use["FDA_SA"] = 0;

Use["FDA_MC"] = 0;

Use["FDA_MT"] = 1;

Use["FDA_GAMT"] = 0;

Use["FDA_MCMT"] = 0;

// ---

Use["MLP"] = 1; // this is the recommended ANN

Use["MLPBFGS"] = 0; // recommended ANN with optional training method

Use["CFMlpANN"] = 0; // *** missing

Use["TMlpANN"] = 0;

// ---

Use["SVM"] = 1;

// ---

Use["BDT"] = 1;

Use["BDTD"] = 0;

Use["BDTG"] = 1;

Use["BDTB"] = 0;

// ---

Use["RuleFit"] = 0;

// ---

Use["Plugin"] = 0;

// ---------------------------------------------------------------

std::cout << std::endl;

std::cout << "==> Start TMVAClassificationApplication" << std::endl;

if (myMethodList != "") {

for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) it->second = 0;

std::vector<TString> mlist = gTools().SplitString( myMethodList, ',' );

for (UInt_t i=0; i<mlist.size(); i++) {

std::string regMethod(mlist[i]);

if (Use.find(regMethod) == Use.end()) {

std::cout << "Method \"" << regMethod << "\" not known in TMVA under this name. Choose among the following:" << std::endl;

for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) std::cout << it->first << " ";

std::cout << std::endl;

return;

}

Use[regMethod] = 1;

}

}

//

// create the Reader object

//

TMVA::Reader *reader = new TMVA::Reader( "!Color:!Silent" );

// create a set of variables and declare them to the reader

// - the variable names must corresponds in name and type to

// those given in the weight file(s) that you use

///Our variables here:

/************************************************************************************************************

* Row * nEvt * sumEt * Et1 * lepeta * MET * dphiMETle * detajet2j * detajet3j *

************************************************************************************************************

mindijetmass

maxdijetmass

*/

Float_t sumEt;

Float_t Et1;

Float_t lepeta;

Float_t MET;

Float_t dphiMETlepton;

Float_t detajet2jet3;

Float_t detajet3jet4;

Float_t mindijetmass;

Float_t maxdijetmass;

reader->AddVariable( "sumEt", &sumEt );

reader->AddVariable( "Et1", &Et1 );

reader->AddVariable( "lepeta", &lepeta );

reader->AddVariable( "MET", &MET );

reader->AddVariable( "dphiMETlepton", &dphiMETlepton );

reader->AddVariable( "detajet2jet3", &detajet2jet3 );

reader->AddVariable( "detajet3jet4", &detajet3jet4 );

reader->AddVariable( "mindijetmass", &mindijetmass );

reader->AddVariable( "maxdijetmass", &maxdijetmass );

TString TreeName = "KinVars";

TFile * input = TFile::Open(filename+".root");

TTree* theTree = (TTree*)input->Get(TreeName);

Float_t userVar1, userVar2;

theTree->SetBranchAddress( "MassOfJets", &MassOfJets );

theTree->SetBranchAddress( "DeltaPhiOfJets", &DeltaPhiOfJets );

theTree->SetBranchAddress( "DeltaPhiLeadingJet", &DeltaPhiLeadingJet );

theTree->SetBranchAddress( "Pbalance", &Pbalance );

theTree->SetBranchAddress( "Sphericity", &Sphericity );

Double_t _Weight=1.0;

if (filename.Contains("hbb_120GeV")) _Weight = 5.09999999999999967e-02;

if (filename.Contains("qcd_15to30Gev")) _Weight = 3.54815799999999990e+03;

if (filename.Contains("qcd_30to50Gev")) _Weight = 3.36987000000000023e+02;

if (filename.Contains("qcd_50to150Gev")) _Weight = 1.08418000000000006e+02;

if (filename.Contains("qcd_150toInfGev")) _Weight = 4.70999999999999996e+00;

if (filename.Contains("data")) _Weight = -1e0;

//

// book the MVA methods

//

TString dir = "weights/";

TString prefix = "TMVAClassification";

// book method(s)

for (std::map<std::string,int>::iterator it = Use.begin(); it != Use.end(); it++) {

if (it->second) {

TString methodName = it->first + " method";

TString weightfile = dir + prefix + "_" + TString(it->first) + ".weights.xml";

reader->BookMVA( methodName, weightfile );

}

}

// example how to use your own method as plugin

if (Use["Plugin"]) {

// the weight file contains a line

// Method : MethodName::InstanceName

// if MethodName is not a known TMVA method, it is assumed to be

// a user implemented method which has to be loaded via the

// plugin mechanism

// for user implemented methods the line in the weight file can be

// Method : PluginName::InstanceName

// where PluginName can be anything

// before usage the plugin has to be defined, which can happen

// either through the following line in .rootrc:

// # plugin handler plugin class library constructor format

// Plugin.TMVA@@MethodBase: PluginName MethodClassName UserPackage "MethodName(DataSet&,TString)"

//

// or by telling the global plugin manager directly

gPluginMgr->AddHandler("TMVA@@MethodBase", "PluginName", "MethodClassName", "UserPackage", "MethodName(DataSet&,TString)");

// the class is then looked for in libUserPackage.so

// now the method can be booked like any other

reader->BookMVA( "User method", dir + prefix + "_User.weights.txt" );

}

// book output histograms

UInt_t nbin = 100;

TH1F *histLk(0), *histLkD(0), *histLkPCA(0), *histLkKDE(0), *histLkMIX(0), *histPD(0), *histPDD(0);

TH1F *histPDPCA(0), *histPDEFoam(0), *histPDEFoamErr(0), *histPDEFoamSig(0), *histKNN(0), *histHm(0);

TH1F *histFi(0), *histFiG(0), *histFiB(0), *histLD(0), *histNn(0), *histNnC(0), *histNnT(0), *histBdt(0), *histBdtG(0), *histBdtD(0);

TH1F *histRf(0), *histSVMG(0), *histSVMP(0), *histSVML(0), *histFDAMT(0), *histFDAGA(0), *histPBdt(0);

if (Use["Likelihood"]) histLk = new TH1F( "MVA_Likelihood", "MVA_Likelihood", nbin, -1, 1 );

if (Use["LikelihoodD"]) histLkD = new TH1F( "MVA_LikelihoodD", "MVA_LikelihoodD", nbin, -1, 0.9999 );

if (Use["LikelihoodPCA"]) histLkPCA = new TH1F( "MVA_LikelihoodPCA", "MVA_LikelihoodPCA", nbin, -1, 1 );

if (Use["LikelihoodKDE"]) histLkKDE = new TH1F( "MVA_LikelihoodKDE", "MVA_LikelihoodKDE", nbin, -0.00001, 0.99999 );

if (Use["LikelihoodMIX"]) histLkMIX = new TH1F( "MVA_LikelihoodMIX", "MVA_LikelihoodMIX", nbin, 0, 1 );

if (Use["PDERS"]) histPD = new TH1F( "MVA_PDERS", "MVA_PDERS", nbin, 0, 1 );

if (Use["PDERSD"]) histPDD = new TH1F( "MVA_PDERSD", "MVA_PDERSD", nbin, 0, 1 );

if (Use["PDERSPCA"]) histPDPCA = new TH1F( "MVA_PDERSPCA", "MVA_PDERSPCA", nbin, 0, 1 );

if (Use["KNN"]) histKNN = new TH1F( "MVA_KNN", "MVA_KNN", nbin, 0, 1 );

if (Use["HMatrix"]) histHm = new TH1F( "MVA_HMatrix", "MVA_HMatrix", nbin, -0.95, 1.55 );

if (Use["Fisher"]) histFi = new TH1F( "MVA_Fisher", "MVA_Fisher", nbin, -4, 4 );

if (Use["FisherG"]) histFiG = new TH1F( "MVA_FisherG", "MVA_FisherG", nbin, -1, 1 );

if (Use["BoostedFisher"]) histFiB = new TH1F( "MVA_BoostedFisher", "MVA_BoostedFisher", nbin, -2, 2 );

if (Use["LD"]) histLD = new TH1F( "MVA_LD", "MVA_LD", nbin, -2, 2 );

if (Use["MLP"]) histNn = new TH1F( "MVA_MLP", "MVA_MLP", nbin, -1.25, 1.5 );

if (Use["CFMlpANN"]) histNnC = new TH1F( "MVA_CFMlpANN", "MVA_CFMlpANN", nbin, 0, 1 );

if (Use["TMlpANN"]) histNnT = new TH1F( "MVA_TMlpANN", "MVA_TMlpANN", nbin, -1.3, 1.3 );

if (Use["BDT"]) histBdt = new TH1F( "MVA_BDT", "MVA_BDT", nbin, -0.8, 0.8 );

if (Use["BDTD"]) histBdtD = new TH1F( "MVA_BDTD", "MVA_BDTD", nbin, -0.8, 0.8 );

if (Use["BDTG"]) histBdtG = new TH1F( "MVA_BDTG", "MVA_BDTG", nbin, -1.0, 1.0 );

if (Use["RuleFit"]) histRf = new TH1F( "MVA_RuleFit", "MVA_RuleFit", nbin, -2.0, 2.0 );

if (Use["SVM_Gauss"]) histSVMG = new TH1F( "MVA_SVM_Gauss", "MVA_SVM_Gauss", nbin, 0.0, 1.0 );

if (Use["SVM_Poly"]) histSVMP = new TH1F( "MVA_SVM_Poly", "MVA_SVM_Poly", nbin, 0.0, 1.0 );

if (Use["SVM_Lin"]) histSVML = new TH1F( "MVA_SVM_Lin", "MVA_SVM_Lin", nbin, 0.0, 1.0 );

if (Use["FDA_MT"]) histFDAMT = new TH1F( "MVA_FDA_MT", "MVA_FDA_MT", nbin, -2.0, 3.0 );

if (Use["FDA_GA"]) histFDAGA = new TH1F( "MVA_FDA_GA", "MVA_FDA_GA", nbin, -2.0, 3.0 );

if (Use["Plugin"]) histPBdt = new TH1F( "MVA_PBDT", "MVA_BDT", nbin, -0.8, 0.8 );

// PDEFoam also returns per-event error, fill in histogram, and also fill significance

if (Use["PDEFoam"]) {

histPDEFoam = new TH1F( "MVA_PDEFoam", "MVA_PDEFoam", nbin, 0, 1 );

histPDEFoamErr = new TH1F( "MVA_PDEFoamErr", "MVA_PDEFoam error", nbin, 0, 1 );

histPDEFoamSig = new TH1F( "MVA_PDEFoamSig", "MVA_PDEFoam significance", nbin, 0, 10 );

}

// book example histogram for probability (the other methods are done similarly)

TH1F *probHistFi(0), *rarityHistFi(0);

if (Use["Fisher"]) {

probHistFi = new TH1F( "MVA_Fisher_Proba", "MVA_Fisher_Proba", nbin, 0, 1 );

rarityHistFi = new TH1F( "MVA_Fisher_Rarity", "MVA_Fisher_Rarity", nbin, 0, 1 );

}

// Prepare input tree (this must be replaced by your data source)

// in this example, there is a toy tree with signal and one with background events

// we'll later on use only the "signal" events for the test in this example.

//

/*TFile *input(0);

TString fname = "./tmva_example.root";

if (!gSystem->AccessPathName( fname )) {

input = TFile::Open( fname ); // check if file in local directory exists

}

else {

input = TFile::Open( "http://root.cern.ch/files/tmva_class_example.root" ); // if not: download from ROOT server

}

if (!input) {

std::cout << "ERROR: could not open data file" << std::endl;

exit(1);

}

std::cout << "--- TMVAClassificationApp : Using input file: " << input->GetName() << std::endl;

*/

//

// prepare the tree

// - here the variable names have to corresponds to your tree

// - you can use the same variables as above which is slightly faster,

// but of course you can use different ones and copy the values inside the event loop

//

// efficiency calculator for cut method

Int_t nSelCutsGA = 0;

Double_t effS = 0.7;

std::cout << "--- Processing: " << theTree->GetEntries() << " events" << std::endl;

TStopwatch sw;

sw.Start();

for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {

cout<<"Entry # "<<ievt<<endl;

if (ievt%1000 == 0){

std::cout << "--- ... Processing event: " << ievt << std::endl;

}

theTree->GetEntry(ievt);

//

// return the MVAs and fill to histograms

//

/* if (Use["CutsGA"]) {

// Cuts is a special case: give the desired signal efficienciy

Bool_t passed = reader->EvaluateMVA( "CutsGA method", effS );

if (passed) nSelCutsGA++;

}

*/

if (Use["Likelihood" ]) histLk ->Fill( reader->EvaluateMVA( "Likelihood method" ) );

if (Use["Likelihood" ]) cout<<"MVA value: "<<reader->EvaluateMVA( "Likelihood method" )<<endl;

continue;

/*

if (Use["LikelihoodD" ]) histLkD ->Fill( reader->EvaluateMVA( "LikelihoodD method" ) );

if (Use["LikelihoodPCA"]) histLkPCA ->Fill( reader->EvaluateMVA( "LikelihoodPCA method" ) );

if (Use["LikelihoodKDE"]) histLkKDE ->Fill( reader->EvaluateMVA( "LikelihoodKDE method" ) );

if (Use["LikelihoodMIX"]) histLkMIX ->Fill( reader->EvaluateMVA( "LikelihoodMIX method" ) );

if (Use["PDERS" ]) histPD ->Fill( reader->EvaluateMVA( "PDERS method" ) );

if (Use["PDERSD" ]) histPDD ->Fill( reader->EvaluateMVA( "PDERSD method" ) );

if (Use["PDERSPCA" ]) histPDPCA ->Fill( reader->EvaluateMVA( "PDERSPCA method" ) );

if (Use["KNN" ]) histKNN ->Fill( reader->EvaluateMVA( "KNN method" ) );

if (Use["HMatrix" ]) histHm ->Fill( reader->EvaluateMVA( "HMatrix method" ) );

if (Use["Fisher" ]) histFi ->Fill( reader->EvaluateMVA( "Fisher method" ) );

if (Use["FisherG" ]) histFiG ->Fill( reader->EvaluateMVA( "FisherG method" ) );

if (Use["BoostedFisher"]) histFiB ->Fill( reader->EvaluateMVA( "BoostedFisher method" ) );

if (Use["LD" ]) histLD ->Fill( reader->EvaluateMVA( "LD method" ) );

if (Use["MLP" ]) histNn ->Fill( reader->EvaluateMVA( "MLP method" ) );

if (Use["CFMlpANN" ]) histNnC ->Fill( reader->EvaluateMVA( "CFMlpANN method" ) );

if (Use["TMlpANN" ]) histNnT ->Fill( reader->EvaluateMVA( "TMlpANN method" ) );

if (Use["BDT" ]) histBdt ->Fill( reader->EvaluateMVA( "BDT method" ) );

if (Use["BDTD" ]) histBdtD ->Fill( reader->EvaluateMVA( "BDTD method" ) );

if (Use["BDTG" ]) histBdtG ->Fill( reader->EvaluateMVA( "BDTG method" ) );

if (Use["RuleFit" ]) histRf ->Fill( reader->EvaluateMVA( "RuleFit method" ) );

if (Use["SVM_Gauss" ]) histSVMG ->Fill( reader->EvaluateMVA( "SVM_Gauss method" ) );

if (Use["SVM_Poly" ]) histSVMP ->Fill( reader->EvaluateMVA( "SVM_Poly method" ) );

if (Use["SVM_Lin" ]) histSVML ->Fill( reader->EvaluateMVA( "SVM_Lin method" ) );

if (Use["FDA_MT" ]) histFDAMT ->Fill( reader->EvaluateMVA( "FDA_MT method" ) );

if (Use["FDA_GA" ]) histFDAGA ->Fill( reader->EvaluateMVA( "FDA_GA method" ) );

if (Use["Plugin" ]) histPBdt ->Fill( reader->EvaluateMVA( "P_BDT method" ) );

// retrieve also per-event error

if (Use["PDEFoam"]) {

Double_t val = reader->EvaluateMVA( "PDEFoam method" );

Double_t err = reader->GetMVAError();

histPDEFoam ->Fill( val );

histPDEFoamErr->Fill( err );

histPDEFoamSig->Fill( val/err );

}

// retrieve probability instead of MVA output

if (Use["Fisher"]) {

probHistFi ->Fill( reader->GetProba ( "Fisher method" ) );

rarityHistFi->Fill( reader->GetRarity( "Fisher method" ) );

}

*/

cout<<"End of processing"<<endl;

}

// get elapsed time

sw.Stop();

std::cout << "--- End of event loop: "; sw.Print();

// get efficiency for cuts classifier

if (Use["CutsGA"]) std::cout << "--- Efficiency for CutsGA method: " << double(nSelCutsGA)/theTree->GetEntries()

<< " (for a required signal efficiency of " << effS << ")" << std::endl;

if (Use["CutsGA"]) {

// test: retrieve cuts for particular signal efficiency

// CINT ignores dynamic_casts so we have to use a cuts-secific Reader function to acces the pointer

TMVA::MethodCuts* mcuts = reader->FindCutsMVA( "CutsGA method" ) ;

if (mcuts) {

std::vector<Double_t> cutsMin;

std::vector<Double_t> cutsMax;

mcuts->GetCuts( 0.7, cutsMin, cutsMax );

std::cout << "--- -------------------------------------------------------------" << std::endl;

std::cout << "--- Retrieve cut values for signal efficiency of 0.7 from Reader" << std::endl;

for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {

std::cout << "... Cut: "

<< cutsMin[ivar]

<< " < \""

<< mcuts->GetInputVar(ivar)

<< "\" <= "

<< cutsMax[ivar] << std::endl;

}

std::cout << "--- -------------------------------------------------------------" << std::endl;

}

}

//

// write histograms

//

TFile *target = new TFile( filename+"_out"+".root","RECREATE" );

if (Use["Likelihood" ]) {if (_Weight>0)histLk->Scale(_Weight);histLk ->Write();}

if (Use["LikelihoodD" ]) {if (_Weight>0)histLkD->Scale(_Weight);histLkD ->Write();}

if (Use["LikelihoodPCA"]) {if (_Weight>0)histLkPCA->Scale(_Weight);histLkPCA ->Write();}

if (Use["LikelihoodKDE"]) {if (_Weight>0)histLkKDE->Scale(_Weight);histLkKDE ->Write();}

if (Use["LikelihoodMIX"]) {if (_Weight>0)histLkMIX->Scale(_Weight);histLkMIX ->Write();}

if (Use["PDERS" ]) histPD ->Write();

if (Use["PDERSD" ]) histPDD ->Write();

if (Use["PDERSPCA" ]) histPDPCA ->Write();

if (Use["KNN" ]) histKNN ->Write();

if (Use["HMatrix" ]) histHm ->Write();

if (Use["Fisher" ]) histFi ->Write();

if (Use["FisherG" ]) histFiG ->Write();

if (Use["BoostedFisher"]) histFiB ->Write();

if (Use["LD" ]) histLD ->Write();

if (Use["MLP" ]) histNn ->Write();

if (Use["CFMlpANN" ]) histNnC ->Write();

if (Use["TMlpANN" ]) histNnT ->Write();

if (Use["BDT" ]) histBdt ->Write();

if (Use["BDTD" ]) histBdtD ->Write();

if (Use["BDTG" ]) histBdtG ->Write();

if (Use["RuleFit" ]) histRf ->Write();

if (Use["SVM_Gauss" ]) histSVMG ->Write();

if (Use["SVM_Poly" ]) histSVMP ->Write();

if (Use["SVM_Lin" ]) histSVML ->Write();

if (Use["FDA_MT" ]) histFDAMT ->Write();

if (Use["FDA_GA" ]) histFDAGA ->Write();

if (Use["Plugin" ]) histPBdt ->Write();

// write also error and significance histos

if (Use["PDEFoam"]) { histPDEFoam->Write(); histPDEFoamErr->Write(); histPDEFoamSig->Write(); }

// write also probability hists

if (Use["Fisher"]) { if (probHistFi != 0) probHistFi->Write(); if (rarityHistFi != 0) rarityHistFi->Write(); }

target->Close();

std::cout << "--- Created root file: \"TMVApp.root\" containing the MVA output histograms" << std::endl;

delete reader;

std::cout << "==> TMVAClassificationApplication is done!" << endl << std::endl;

}