benhoob/HWW/ClassApplication.C

/**********************************************************************************
 * Project   : TMVA - a Root-integrated toolkit for multivariate data analysis    *
 * Package   : TMVA                                                               *
 * Exectuable: ClassApplication                                                   *
 *                                                                                *
 * Test suit for comparison of Reader and standalone class outputs                *
 **********************************************************************************/

#include <vector>

void ClassApplication( TString myMethodList = "Fisher" ) 
{
   cout << endl;
   cout << "==> start ClassApplication" << endl;
   const int Nmvas = 16;

   const char* bulkname[Nmvas] = { "MLP","MLPBFGS","Fisher","FisherG","Likelihood","LikelihoodD","LikelihoodPCA","LD","HMatrix","FDA_MT","FDA_MC","FDA_GA","BDT","BDTD","BDTG","BDTB"};

   bool iuse[Nmvas] = { Nmvas*kFALSE };

   // interpret input list
   if (myMethodList != "") {
      TList* mlist = TMVA::gTools().ParseFormatLine( myMethodList, " :," );
      for (int imva=0; imva<Nmvas; imva++) if (mlist->FindObject( bulkname[imva] )) iuse[imva] = kTRUE;
      delete mlist;
   }

   // 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
   std::vector<std::string> inputVars;
   inputVars.push_back( "var1+var2" );
   inputVars.push_back( "var1-var2" );
   inputVars.push_back( "var3" );
   inputVars.push_back( "var4" );
      
   // preload standalone class(es)
   string dir    = "weights/";
   string prefix = "TMVAClassification";

   for (int imva=0; imva<Nmvas; imva++) {
      if (iuse[imva]) {
         TString cfile = dir + prefix + "_" + bulkname[imva] + ".class.C++";

         cout << "=== Macro        : Loading class  file: " << cfile << endl;         

         // load the classifier's standalone class
         gROOT->LoadMacro( cfile );
      }
   }
   cout << "=== Macro        : Classifier class loading successfully terminated" << endl;

   // define classes
   IClassifierReader* classReader[Nmvas] = { Nmvas*0 };

   // ... and create them (and some histograms for the output)
   int nbin = 100;
   TH1* hist[Nmvas];

   for (int imva=0; imva<Nmvas; imva++) {
      if (iuse[imva]) {
         cout << "=== Macro        : Testing " << bulkname[imva] << endl;
         if (bulkname[imva] == "Likelihood"   ) {
            classReader[imva] = new ReadLikelihood   ( inputVars );            
            hist[imva] = new TH1F( "MVA_Likelihood",    "MVA_Likelihood",    nbin,  0, 1 );
         }
         if (bulkname[imva] == "LikelihoodD"  ) {
            classReader[imva] = new ReadLikelihoodD  ( inputVars );
            hist[imva] = new TH1F( "MVA_LikelihoodD",   "MVA_LikelihoodD",   nbin,  0, 1 );
         }
         if (bulkname[imva] == "LikelihoodPCA") {
            classReader[imva] = new ReadLikelihoodPCA( inputVars );
            hist[imva] = new TH1F( "MVA_LikelihoodPCA", "MVA_LikelihoodPCA", nbin,  0, 1 );
         }
         if (bulkname[imva] == "LikelihoodMIX") {
            classReader[imva] = new ReadLikelihoodMIX( inputVars );
            hist[imva] = new TH1F( "MVA_LikelihoodMIX", "MVA_LikelihoodMIX", nbin,  0, 1 );
         }
         if (bulkname[imva] == "HMatrix"      ) {
            classReader[imva] = new ReadHMatrix      ( inputVars );
            hist[imva] = new TH1F( "MVA_HMatrix",       "MVA_HMatrix",       nbin, -0.95, 1.55 );
         }
         if (bulkname[imva] == "Fisher"       ) {
            classReader[imva] = new ReadFisher       ( inputVars );
            hist[imva] = new TH1F( "MVA_Fisher",        "MVA_Fisher",        nbin, -4, 4 );
         }
         if (bulkname[imva] == "FisherG"       ) {
            classReader[imva] = new ReadFisherG       ( inputVars );
            hist[imva] = new TH1F( "MVA_FisherG",        "MVA_FisherG",        nbin, -4, 4 );
         }
         if (bulkname[imva] == "LD"   ) {
            classReader[imva] = new ReadLD   ( inputVars );            
            hist[imva] = new TH1F( "MVA_LD",    "MVA_LD",    nbin,  -1., 1 );
         }       
         if (bulkname[imva] == "FDA_MT"       ) {
            classReader[imva] = new ReadFDA_MT       ( inputVars );
            hist[imva] = new TH1F( "MVA_FDA_MT",        "MVA_FDA_MT",        nbin, -2.0, 3.0 );
         }
         if (bulkname[imva] == "FDA_MC"       ) {
            classReader[imva] = new ReadFDA_MC       ( inputVars );
            hist[imva] = new TH1F( "MVA_FDA_MC",        "MVA_FDA_MC",        nbin, -2.0, 3.0 );
         }
         if (bulkname[imva] == "FDA_GA"       ) {
            classReader[imva] = new ReadFDA_GA       ( inputVars );
            hist[imva] = new TH1F( "MVA_FDA_GA",        "MVA_FDA_GA",        nbin, -2.0, 3.0 );
         }
         if (bulkname[imva] == "MLP"          ) {
            classReader[imva] = new ReadMLP          ( inputVars );
            hist[imva] = new TH1F( "MVA_MLP",           "MVA_MLP",           nbin, -1.2, 1.2 );
         }
         if (bulkname[imva] == "MLPBFGS"          ) {
            classReader[imva] = new ReadMLPBFGS          ( inputVars );
            hist[imva] = new TH1F( "MVA_MLPBFGS",           "MVA_MLPBFGS",           nbin, -1.5, 1.5 );
         }
         if (bulkname[imva] == "BDT"          ) {
            classReader[imva] = new ReadBDT          ( inputVars );
            hist[imva] = new TH1F( "MVA_BDT",           "MVA_BDT",           nbin, -1, 1 );
         }
         if (bulkname[imva] == "BDTD"          ) {
            classReader[imva] = new ReadBDTD          ( inputVars );
            hist[imva] = new TH1F( "MVA_BDTD",           "MVA_BDTD",         nbin, -1, 1 );
         }
         if (bulkname[imva] == "BDTG"          ) {
            classReader[imva] = new ReadBDTG          ( inputVars );
            hist[imva] = new TH1F( "MVA_BDTG",           "MVA_BDTG",         nbin, -1, 1 );
         }
         if (bulkname[imva] == "BDTB"          ) {
            classReader[imva] = new ReadBDTB          ( inputVars );
            hist[imva] = new TH1F( "MVA_BDTB",           "MVA_BDTB",         nbin, -1, 1 );
         }
      }
   }
   cout << "=== Macro        : Class creation was successful" << endl;

   // 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);
   if (!gSystem->AccessPathName("./tmva_example.root")) {
      // first we try to find tmva_example.root in the local directory
      cout << "=== Macro        : Accessing ./tmva_example.root" << endl;
      input = TFile::Open("tmva_example.root");
   } 
   
   if (!input) {
      cout << "ERROR: could not open data file" << endl;
      exit(1);
   }

   //
   // 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
   //
   TTree* theTree = (TTree*)input->Get("TreeS");
   cout << "=== Macro        : Loop over signal sample" << endl;

   // the references to the variables
   float var1, var2, var3, var4;
   float userVar1, userVar2;
   theTree->SetBranchAddress( "var1", &userVar1 );
   theTree->SetBranchAddress( "var2", &userVar2 );
   theTree->SetBranchAddress( "var3", &var3 );
   theTree->SetBranchAddress( "var4", &var4 );

   cout << "=== Macro        : Processing total of " << theTree->GetEntries() << " events ... " << endl;

   std::vector<double>* inputVec = new std::vector<double>( 4 );
   for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {

      if (ievt%1000 == 0) cout << "=== Macro        : ... processing event: " << ievt << endl;

      theTree->GetEntry(ievt);

      var1 = userVar1 + userVar2;
      var2 = userVar1 - userVar2;

      (*inputVec)[0] = var1;
      (*inputVec)[1] = var2;
      (*inputVec)[2] = var3;
      (*inputVec)[3] = var4;
      
      // loop over all booked classifiers
      for (int imva=0; imva<Nmvas; imva++) {

         if (iuse[imva]) {
            
            // retrive the classifier responses            
            double retval = classReader[imva]->GetMvaValue( *inputVec );
            hist[imva]->Fill( retval, 1.0 );
         }
      }
   }
   
   cout << "=== Macro        : Event loop done! " << endl;

   TFile *target  = new TFile( "ClassApp.root","RECREATE" );
   for (int imva=0; imva<Nmvas; imva++) {
      if (iuse[imva]) {
         hist[imva]->Write();
      }
   }
   cout << "=== Macro        : Created target file: " << target->GetName() << endl;
   target->Close();

   delete target;
   delete inputVec;
    
   cout << "==> ClassApplication is done!" << endl << endl;
} 
Revision:	1.1
Committed:	Mon Feb 14 12:39:14 2011 UTC (14 years, 3 months ago) by benhoob
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Initial commit
#	User	Rev	Content
1	benhoob	1.1	/**********************************************************************************
2			* Project : TMVA - a Root-integrated toolkit for multivariate data analysis *
3			* Package : TMVA *
4			* Exectuable: ClassApplication *
5			* *
6			* Test suit for comparison of Reader and standalone class outputs *
7			**********************************************************************************/
8
9			#include <vector>
10
11			void ClassApplication( TString myMethodList = "Fisher" )
12			{
13			cout << endl;
14			cout << "==> start ClassApplication" << endl;
15			const int Nmvas = 16;
16
17			const char* bulkname[Nmvas] = { "MLP","MLPBFGS","Fisher","FisherG","Likelihood","LikelihoodD","LikelihoodPCA","LD","HMatrix","FDA_MT","FDA_MC","FDA_GA","BDT","BDTD","BDTG","BDTB"};
18
19			bool iuse[Nmvas] = { Nmvas*kFALSE };
20
21			// interpret input list
22			if (myMethodList != "") {
23			TList* mlist = TMVA::gTools().ParseFormatLine( myMethodList, " :," );
24			for (int imva=0; imva<Nmvas; imva++) if (mlist->FindObject( bulkname[imva] )) iuse[imva] = kTRUE;
25			delete mlist;
26			}
27
28			// create a set of variables and declare them to the reader
29			// - the variable names must corresponds in name and type to
30			// those given in the weight file(s) that you use
31			std::vector<std::string> inputVars;
32			inputVars.push_back( "var1+var2" );
33			inputVars.push_back( "var1-var2" );
34			inputVars.push_back( "var3" );
35			inputVars.push_back( "var4" );
36
37			// preload standalone class(es)
38			string dir = "weights/";
39			string prefix = "TMVAClassification";
40
41			for (int imva=0; imva<Nmvas; imva++) {
42			if (iuse[imva]) {
43			TString cfile = dir + prefix + "_" + bulkname[imva] + ".class.C++";
44
45			cout << "=== Macro : Loading class file: " << cfile << endl;
46
47			// load the classifier's standalone class
48			gROOT->LoadMacro( cfile );
49			}
50			}
51			cout << "=== Macro : Classifier class loading successfully terminated" << endl;
52
53			// define classes
54			IClassifierReader* classReader[Nmvas] = { Nmvas*0 };
55
56			// ... and create them (and some histograms for the output)
57			int nbin = 100;
58			TH1* hist[Nmvas];
59
60			for (int imva=0; imva<Nmvas; imva++) {
61			if (iuse[imva]) {
62			cout << "=== Macro : Testing " << bulkname[imva] << endl;
63			if (bulkname[imva] == "Likelihood" ) {
64			classReader[imva] = new ReadLikelihood ( inputVars );
65			hist[imva] = new TH1F( "MVA_Likelihood", "MVA_Likelihood", nbin, 0, 1 );
66			}
67			if (bulkname[imva] == "LikelihoodD" ) {
68			classReader[imva] = new ReadLikelihoodD ( inputVars );
69			hist[imva] = new TH1F( "MVA_LikelihoodD", "MVA_LikelihoodD", nbin, 0, 1 );
70			}
71			if (bulkname[imva] == "LikelihoodPCA") {
72			classReader[imva] = new ReadLikelihoodPCA( inputVars );
73			hist[imva] = new TH1F( "MVA_LikelihoodPCA", "MVA_LikelihoodPCA", nbin, 0, 1 );
74			}
75			if (bulkname[imva] == "LikelihoodMIX") {
76			classReader[imva] = new ReadLikelihoodMIX( inputVars );
77			hist[imva] = new TH1F( "MVA_LikelihoodMIX", "MVA_LikelihoodMIX", nbin, 0, 1 );
78			}
79			if (bulkname[imva] == "HMatrix" ) {
80			classReader[imva] = new ReadHMatrix ( inputVars );
81			hist[imva] = new TH1F( "MVA_HMatrix", "MVA_HMatrix", nbin, -0.95, 1.55 );
82			}
83			if (bulkname[imva] == "Fisher" ) {
84			classReader[imva] = new ReadFisher ( inputVars );
85			hist[imva] = new TH1F( "MVA_Fisher", "MVA_Fisher", nbin, -4, 4 );
86			}
87			if (bulkname[imva] == "FisherG" ) {
88			classReader[imva] = new ReadFisherG ( inputVars );
89			hist[imva] = new TH1F( "MVA_FisherG", "MVA_FisherG", nbin, -4, 4 );
90			}
91			if (bulkname[imva] == "LD" ) {
92			classReader[imva] = new ReadLD ( inputVars );
93			hist[imva] = new TH1F( "MVA_LD", "MVA_LD", nbin, -1., 1 );
94			}
95			if (bulkname[imva] == "FDA_MT" ) {
96			classReader[imva] = new ReadFDA_MT ( inputVars );
97			hist[imva] = new TH1F( "MVA_FDA_MT", "MVA_FDA_MT", nbin, -2.0, 3.0 );
98			}
99			if (bulkname[imva] == "FDA_MC" ) {
100			classReader[imva] = new ReadFDA_MC ( inputVars );
101			hist[imva] = new TH1F( "MVA_FDA_MC", "MVA_FDA_MC", nbin, -2.0, 3.0 );
102			}
103			if (bulkname[imva] == "FDA_GA" ) {
104			classReader[imva] = new ReadFDA_GA ( inputVars );
105			hist[imva] = new TH1F( "MVA_FDA_GA", "MVA_FDA_GA", nbin, -2.0, 3.0 );
106			}
107			if (bulkname[imva] == "MLP" ) {
108			classReader[imva] = new ReadMLP ( inputVars );
109			hist[imva] = new TH1F( "MVA_MLP", "MVA_MLP", nbin, -1.2, 1.2 );
110			}
111			if (bulkname[imva] == "MLPBFGS" ) {
112			classReader[imva] = new ReadMLPBFGS ( inputVars );
113			hist[imva] = new TH1F( "MVA_MLPBFGS", "MVA_MLPBFGS", nbin, -1.5, 1.5 );
114			}
115			if (bulkname[imva] == "BDT" ) {
116			classReader[imva] = new ReadBDT ( inputVars );
117			hist[imva] = new TH1F( "MVA_BDT", "MVA_BDT", nbin, -1, 1 );
118			}
119			if (bulkname[imva] == "BDTD" ) {
120			classReader[imva] = new ReadBDTD ( inputVars );
121			hist[imva] = new TH1F( "MVA_BDTD", "MVA_BDTD", nbin, -1, 1 );
122			}
123			if (bulkname[imva] == "BDTG" ) {
124			classReader[imva] = new ReadBDTG ( inputVars );
125			hist[imva] = new TH1F( "MVA_BDTG", "MVA_BDTG", nbin, -1, 1 );
126			}
127			if (bulkname[imva] == "BDTB" ) {
128			classReader[imva] = new ReadBDTB ( inputVars );
129			hist[imva] = new TH1F( "MVA_BDTB", "MVA_BDTB", nbin, -1, 1 );
130			}
131			}
132			}
133			cout << "=== Macro : Class creation was successful" << endl;
134
135			// Prepare input tree (this must be replaced by your data source)
136			// in this example, there is a toy tree with signal and one with background events
137			// we'll later on use only the "signal" events for the test in this example.
138			//
139			TFile *input(0);
140			if (!gSystem->AccessPathName("./tmva_example.root")) {
141			// first we try to find tmva_example.root in the local directory
142			cout << "=== Macro : Accessing ./tmva_example.root" << endl;
143			input = TFile::Open("tmva_example.root");
144			}
145
146			if (!input) {
147			cout << "ERROR: could not open data file" << endl;
148			exit(1);
149			}
150
151			//
152			// prepare the tree
153			// - here the variable names have to corresponds to your tree
154			// - you can use the same variables as above which is slightly faster,
155			// but of course you can use different ones and copy the values inside the event loop
156			//
157			TTree* theTree = (TTree*)input->Get("TreeS");
158			cout << "=== Macro : Loop over signal sample" << endl;
159
160			// the references to the variables
161			float var1, var2, var3, var4;
162			float userVar1, userVar2;
163			theTree->SetBranchAddress( "var1", &userVar1 );
164			theTree->SetBranchAddress( "var2", &userVar2 );
165			theTree->SetBranchAddress( "var3", &var3 );
166			theTree->SetBranchAddress( "var4", &var4 );
167
168			cout << "=== Macro : Processing total of " << theTree->GetEntries() << " events ... " << endl;
169
170			std::vector<double>* inputVec = new std::vector<double>( 4 );
171			for (Long64_t ievt=0; ievt<theTree->GetEntries();ievt++) {
172
173			if (ievt%1000 == 0) cout << "=== Macro : ... processing event: " << ievt << endl;
174
175			theTree->GetEntry(ievt);
176
177			var1 = userVar1 + userVar2;
178			var2 = userVar1 - userVar2;
179
180			(*inputVec)[0] = var1;
181			(*inputVec)[1] = var2;
182			(*inputVec)[2] = var3;
183			(*inputVec)[3] = var4;
184
185			// loop over all booked classifiers
186			for (int imva=0; imva<Nmvas; imva++) {
187
188			if (iuse[imva]) {
189
190			// retrive the classifier responses
191			double retval = classReader[imva]->GetMvaValue( *inputVec );
192			hist[imva]->Fill( retval, 1.0 );
193			}
194			}
195			}
196
197			cout << "=== Macro : Event loop done! " << endl;
198
199			TFile *target = new TFile( "ClassApp.root","RECREATE" );
200			for (int imva=0; imva<Nmvas; imva++) {
201			if (iuse[imva]) {
202			hist[imva]->Write();
203			}
204			}
205			cout << "=== Macro : Created target file: " << target->GetName() << endl;
206			target->Close();
207
208			delete target;
209			delete inputVec;
210
211			cout << "==> ClassApplication is done!" << endl << endl;
212			}