Logo ROOT   6.18/05
Reference Guide
MethodTMlpANN.cxx
Go to the documentation of this file.
1// @(#)root/tmva $Id$
2// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard von Toerne
3/**********************************************************************************
4 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
5 * Package: TMVA *
6 * Class : MethodTMlpANN *
7 * Web : http://tmva.sourceforge.net *
8 * *
9 * Description: *
10 * Implementation (see header for description) *
11 * *
12 * Authors (alphabetical): *
13 * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
14 * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany *
15 * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
16 * *
17 * Copyright (c) 2005: *
18 * CERN, Switzerland *
19 * U. of Victoria, Canada *
20 * MPI-K Heidelberg, Germany *
21 * *
22 * Redistribution and use in source and binary forms, with or without *
23 * modification, are permitted according to the terms listed in LICENSE *
24 * (http://tmva.sourceforge.net/LICENSE) *
25 **********************************************************************************/
26
27/*! \class TMVA::MethodTMlpANN
28\ingroup TMVA
29
30This is the TMVA TMultiLayerPerceptron interface class. It provides the
31training and testing the ROOT internal MLP class in the TMVA framework.
32
33Available learning methods:<br>
34
35 - Stochastic
36 - Batch
37 - SteepestDescent
38 - RibierePolak
39 - FletcherReeves
40 - BFGS
41
42See the TMultiLayerPerceptron class description
43for details on this ANN.
44*/
45
46#include "TMVA/MethodTMlpANN.h"
47
48#include "TMVA/Config.h"
49#include "TMVA/Configurable.h"
50#include "TMVA/DataSet.h"
51#include "TMVA/DataSetInfo.h"
52#include "TMVA/IMethod.h"
53#include "TMVA/MethodBase.h"
54#include "TMVA/MsgLogger.h"
55#include "TMVA/Types.h"
56#include "TMVA/VariableInfo.h"
57
59#include "TMVA/Tools.h"
60
61#include "Riostream.h"
62#include "TLeaf.h"
63#include "TEventList.h"
64#include "TObjString.h"
65#include "TROOT.h"
67
68#include <cstdlib>
69#include <iostream>
70#include <fstream>
71
72
73using std::atoi;
74
75// some additional TMlpANN options
77#if ROOT_VERSION_CODE > ROOT_VERSION(5,13,06)
78//const TMultiLayerPerceptron::ELearningMethod LearningMethod__= TMultiLayerPerceptron::kStochastic;
79// const TMultiLayerPerceptron::ELearningMethod LearningMethod__= TMultiLayerPerceptron::kBatch;
80#else
81//const TMultiLayerPerceptron::LearningMethod LearningMethod__= TMultiLayerPerceptron::kStochastic;
82#endif
83
84REGISTER_METHOD(TMlpANN)
85
87
88////////////////////////////////////////////////////////////////////////////////
89/// standard constructor
90
92 const TString& methodTitle,
93 DataSetInfo& theData,
94 const TString& theOption) :
95 TMVA::MethodBase( jobName, Types::kTMlpANN, methodTitle, theData, theOption),
96 fMLP(0),
97 fLocalTrainingTree(0),
98 fNcycles(100),
99 fValidationFraction(0.5),
100 fLearningMethod( "" )
101{
102}
103
104////////////////////////////////////////////////////////////////////////////////
105/// constructor from weight file
106
108 const TString& theWeightFile) :
109 TMVA::MethodBase( Types::kTMlpANN, theData, theWeightFile),
110 fMLP(0),
111 fLocalTrainingTree(0),
112 fNcycles(100),
113 fValidationFraction(0.5),
114 fLearningMethod( "" )
115{
116}
117
118////////////////////////////////////////////////////////////////////////////////
119/// TMlpANN can handle classification with 2 classes
120
122 UInt_t /*numberTargets*/ )
123{
124 if (type == Types::kClassification && numberClasses == 2) return kTRUE;
125 return kFALSE;
126}
127
128
129////////////////////////////////////////////////////////////////////////////////
130/// default initialisations
131
133{
134}
135
136////////////////////////////////////////////////////////////////////////////////
137/// destructor
138
140{
141 if (fMLP) delete fMLP;
142}
143
144////////////////////////////////////////////////////////////////////////////////
145/// translates options from option string into TMlpANN language
146
148{
149 fHiddenLayer = ":";
150
151 while (layerSpec.Length()>0) {
152 TString sToAdd="";
153 if (layerSpec.First(',')<0) {
154 sToAdd = layerSpec;
155 layerSpec = "";
156 }
157 else {
158 sToAdd = layerSpec(0,layerSpec.First(','));
159 layerSpec = layerSpec(layerSpec.First(',')+1,layerSpec.Length());
160 }
161 int nNodes = 0;
162 if (sToAdd.BeginsWith("N")) { sToAdd.Remove(0,1); nNodes = GetNvar(); }
163 nNodes += atoi(sToAdd);
164 fHiddenLayer = Form( "%s%i:", (const char*)fHiddenLayer, nNodes );
165 }
166
167 // set input vars
168 std::vector<TString>::iterator itrVar = (*fInputVars).begin();
169 std::vector<TString>::iterator itrVarEnd = (*fInputVars).end();
170 fMLPBuildOptions = "";
171 for (; itrVar != itrVarEnd; ++itrVar) {
172 if (EnforceNormalization__) fMLPBuildOptions += "@";
173 TString myVar = *itrVar; ;
174 fMLPBuildOptions += myVar;
175 fMLPBuildOptions += ",";
176 }
177 fMLPBuildOptions.Chop(); // remove last ","
178
179 // prepare final options for MLP kernel
180 fMLPBuildOptions += fHiddenLayer;
181 fMLPBuildOptions += "type";
182
183 Log() << kINFO << "Use " << fNcycles << " training cycles" << Endl;
184 Log() << kINFO << "Use configuration (nodes per hidden layer): " << fHiddenLayer << Endl;
185}
186
187////////////////////////////////////////////////////////////////////////////////
188/// define the options (their key words) that can be set in the option string
189///
190/// know options:
191///
192/// - NCycles <integer> Number of training cycles (too many cycles could overtrain the network)
193/// - HiddenLayers <string> Layout of the hidden layers (nodes per layer)
194/// * specifications for each hidden layer are separated by comma
195/// * for each layer the number of nodes can be either absolut (simply a number)
196/// or relative to the number of input nodes to the neural net (N)
197/// * there is always a single node in the output layer
198///
199/// example: a net with 6 input nodes and "Hiddenlayers=N-1,N-2" has 6,5,4,1 nodes in the
200/// layers 1,2,3,4, respectively
201
203{
204 DeclareOptionRef( fNcycles = 200, "NCycles", "Number of training cycles" );
205 DeclareOptionRef( fLayerSpec = "N,N-1", "HiddenLayers", "Specification of hidden layer architecture (N stands for number of variables; any integers may also be used)" );
206
207 DeclareOptionRef( fValidationFraction = 0.5, "ValidationFraction",
208 "Fraction of events in training tree used for cross validation" );
209
210 DeclareOptionRef( fLearningMethod = "Stochastic", "LearningMethod", "Learning method" );
211 AddPreDefVal( TString("Stochastic") );
212 AddPreDefVal( TString("Batch") );
213 AddPreDefVal( TString("SteepestDescent") );
214 AddPreDefVal( TString("RibierePolak") );
215 AddPreDefVal( TString("FletcherReeves") );
216 AddPreDefVal( TString("BFGS") );
217}
218
219////////////////////////////////////////////////////////////////////////////////
220/// builds the neural network as specified by the user
221
223{
224 CreateMLPOptions(fLayerSpec);
225
226 if (IgnoreEventsWithNegWeightsInTraining()) {
227 Log() << kFATAL << "Mechanism to ignore events with negative weights in training not available for method"
228 << GetMethodTypeName()
229 << " --> please remove \"IgnoreNegWeightsInTraining\" option from booking string."
230 << Endl;
231 }
232}
233
234////////////////////////////////////////////////////////////////////////////////
235/// calculate the value of the neural net for the current event
236
238{
239 const Event* ev = GetEvent();
240 TTHREAD_TLS_DECL_ARG(Double_t*, d, new Double_t[Data()->GetNVariables()]);
241
242 for (UInt_t ivar = 0; ivar<Data()->GetNVariables(); ivar++) {
243 d[ivar] = (Double_t)ev->GetValue(ivar);
244 }
245 Double_t mvaVal = fMLP->Evaluate(0,d);
246
247 // cannot determine error
248 NoErrorCalc(err, errUpper);
249
250 return mvaVal;
251}
252
253////////////////////////////////////////////////////////////////////////////////
254/// performs TMlpANN training
255/// available learning methods:
256///
257/// - TMultiLayerPerceptron::kStochastic
258/// - TMultiLayerPerceptron::kBatch
259/// - TMultiLayerPerceptron::kSteepestDescent
260/// - TMultiLayerPerceptron::kRibierePolak
261/// - TMultiLayerPerceptron::kFletcherReeves
262/// - TMultiLayerPerceptron::kBFGS
263///
264/// TMultiLayerPerceptron wants test and training tree at once
265/// so merge the training and testing trees from the MVA factory first:
266
268{
269 Int_t type;
270 Float_t weight;
271 const Long_t basketsize = 128000;
272 Float_t* vArr = new Float_t[GetNvar()];
273
274 TTree *localTrainingTree = new TTree( "TMLPtrain", "Local training tree for TMlpANN" );
275 localTrainingTree->Branch( "type", &type, "type/I", basketsize );
276 localTrainingTree->Branch( "weight", &weight, "weight/F", basketsize );
277
278 for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
279 const char* myVar = GetInternalVarName(ivar).Data();
280 localTrainingTree->Branch( myVar, &vArr[ivar], Form("Var%02i/F", ivar), basketsize );
281 }
282
283 for (UInt_t ievt=0; ievt<Data()->GetNEvents(); ievt++) {
284 const Event *ev = GetEvent(ievt);
285 for (UInt_t i=0; i<GetNvar(); i++) {
286 vArr[i] = ev->GetValue( i );
287 }
288 type = DataInfo().IsSignal( ev ) ? 1 : 0;
289 weight = ev->GetWeight();
290 localTrainingTree->Fill();
291 }
292
293 // These are the event lists for the mlp train method
294 // first events in the tree are for training
295 // the rest for internal testing (cross validation)...
296 // NOTE: the training events are ordered: first part is signal, second part background
297 TString trainList = "Entry$<";
298 trainList += 1.0-fValidationFraction;
299 trainList += "*";
300 trainList += (Int_t)Data()->GetNEvtSigTrain();
301 trainList += " || (Entry$>";
302 trainList += (Int_t)Data()->GetNEvtSigTrain();
303 trainList += " && Entry$<";
304 trainList += (Int_t)(Data()->GetNEvtSigTrain() + (1.0 - fValidationFraction)*Data()->GetNEvtBkgdTrain());
305 trainList += ")";
306 TString testList = TString("!(") + trainList + ")";
307
308 // print the requirements
309 Log() << kHEADER << "Requirement for training events: \"" << trainList << "\"" << Endl;
310 Log() << kINFO << "Requirement for validation events: \"" << testList << "\"" << Endl;
311
312 // localTrainingTree->Print();
313
314 // create NN
315 if (fMLP != 0) { delete fMLP; fMLP = 0; }
316 fMLP = new TMultiLayerPerceptron( fMLPBuildOptions.Data(),
317 localTrainingTree,
318 trainList,
319 testList );
320 fMLP->SetEventWeight( "weight" );
321
322 // set learning method
323#if ROOT_VERSION_CODE > ROOT_VERSION(5,13,06)
325#else
326 TMultiLayerPerceptron::LearningMethod learningMethod = TMultiLayerPerceptron::kStochastic;
327#endif
328
329 fLearningMethod.ToLower();
330 if (fLearningMethod == "stochastic" ) learningMethod = TMultiLayerPerceptron::kStochastic;
331 else if (fLearningMethod == "batch" ) learningMethod = TMultiLayerPerceptron::kBatch;
332 else if (fLearningMethod == "steepestdescent" ) learningMethod = TMultiLayerPerceptron::kSteepestDescent;
333 else if (fLearningMethod == "ribierepolak" ) learningMethod = TMultiLayerPerceptron::kRibierePolak;
334 else if (fLearningMethod == "fletcherreeves" ) learningMethod = TMultiLayerPerceptron::kFletcherReeves;
335 else if (fLearningMethod == "bfgs" ) learningMethod = TMultiLayerPerceptron::kBFGS;
336 else {
337 Log() << kFATAL << "Unknown Learning Method: \"" << fLearningMethod << "\"" << Endl;
338 }
339 fMLP->SetLearningMethod( learningMethod );
340
341 // train NN
342 fMLP->Train(fNcycles, "" ); //"text,update=50" );
343
344 // write weights to File;
345 // this is not nice, but fMLP gets deleted at the end of Train()
346 delete localTrainingTree;
347 delete [] vArr;
348}
349
350////////////////////////////////////////////////////////////////////////////////
351/// write weights to xml file
352
353void TMVA::MethodTMlpANN::AddWeightsXMLTo( void* parent ) const
354{
355 // first the architecture
356 void *wght = gTools().AddChild(parent, "Weights");
357 void* arch = gTools().AddChild( wght, "Architecture" );
358 gTools().AddAttr( arch, "BuildOptions", fMLPBuildOptions.Data() );
359
360 // dump weights first in temporary txt file, read from there into xml
361 const TString tmpfile=GetWeightFileDir()+"/TMlp.nn.weights.temp";
362 fMLP->DumpWeights( tmpfile.Data() );
363 std::ifstream inf( tmpfile.Data() );
364 char temp[256];
365 TString data("");
366 void *ch=NULL;
367 while (inf.getline(temp,256)) {
368 TString dummy(temp);
369 //std::cout << dummy << std::endl; // remove annoying debug printout with std::cout
370 if (dummy.BeginsWith('#')) {
371 if (ch!=0) gTools().AddRawLine( ch, data.Data() );
372 dummy = dummy.Strip(TString::kLeading, '#');
373 dummy = dummy(0,dummy.First(' '));
374 ch = gTools().AddChild(wght, dummy);
375 data.Resize(0);
376 continue;
377 }
378 data += (dummy + " ");
379 }
380 if (ch != 0) gTools().AddRawLine( ch, data.Data() );
381
382 inf.close();
383}
384
385////////////////////////////////////////////////////////////////////////////////
386/// rebuild temporary textfile from xml weightfile and load this
387/// file into MLP
388
390{
391 void* ch = gTools().GetChild(wghtnode);
392 gTools().ReadAttr( ch, "BuildOptions", fMLPBuildOptions );
393
394 ch = gTools().GetNextChild(ch);
395 const TString fname = GetWeightFileDir()+"/TMlp.nn.weights.temp";
396 std::ofstream fout( fname.Data() );
397 double temp1=0,temp2=0;
398 while (ch) {
399 const char* nodecontent = gTools().GetContent(ch);
400 std::stringstream content(nodecontent);
401 if (strcmp(gTools().GetName(ch),"input")==0) {
402 fout << "#input normalization" << std::endl;
403 while ((content >> temp1) &&(content >> temp2)) {
404 fout << temp1 << " " << temp2 << std::endl;
405 }
406 }
407 if (strcmp(gTools().GetName(ch),"output")==0) {
408 fout << "#output normalization" << std::endl;
409 while ((content >> temp1) &&(content >> temp2)) {
410 fout << temp1 << " " << temp2 << std::endl;
411 }
412 }
413 if (strcmp(gTools().GetName(ch),"neurons")==0) {
414 fout << "#neurons weights" << std::endl;
415 while (content >> temp1) {
416 fout << temp1 << std::endl;
417 }
418 }
419 if (strcmp(gTools().GetName(ch),"synapses")==0) {
420 fout << "#synapses weights" ;
421 while (content >> temp1) {
422 fout << std::endl << temp1 ;
423 }
424 }
425 ch = gTools().GetNextChild(ch);
426 }
427 fout.close();;
428
429 // Here we create a dummy tree necessary to create a minimal NN
430 // to be used for testing, evaluation and application
431 TTHREAD_TLS_DECL_ARG(Double_t*, d, new Double_t[Data()->GetNVariables()]);
432 TTHREAD_TLS(Int_t) type;
433
434 gROOT->cd();
435 TTree * dummyTree = new TTree("dummy","Empty dummy tree", 1);
436 for (UInt_t ivar = 0; ivar<Data()->GetNVariables(); ivar++) {
437 TString vn = DataInfo().GetVariableInfo(ivar).GetInternalName();
438 dummyTree->Branch(Form("%s",vn.Data()), d+ivar, Form("%s/D",vn.Data()));
439 }
440 dummyTree->Branch("type", &type, "type/I");
441
442 if (fMLP != 0) { delete fMLP; fMLP = 0; }
443 fMLP = new TMultiLayerPerceptron( fMLPBuildOptions.Data(), dummyTree );
444 fMLP->LoadWeights( fname );
445}
446
447////////////////////////////////////////////////////////////////////////////////
448/// read weights from stream
449/// since the MLP can not read from the stream, we
450/// 1st: write the weights to temporary file
451
453{
454 std::ofstream fout( "./TMlp.nn.weights.temp" );
455 fout << istr.rdbuf();
456 fout.close();
457 // 2nd: load the weights from the temporary file into the MLP
458 // the MLP is already build
459 Log() << kINFO << "Load TMLP weights into " << fMLP << Endl;
460
461 Double_t* d = new Double_t[Data()->GetNVariables()] ;
462 Int_t type;
463 gROOT->cd();
464 TTree * dummyTree = new TTree("dummy","Empty dummy tree", 1);
465 for (UInt_t ivar = 0; ivar<Data()->GetNVariables(); ivar++) {
466 TString vn = DataInfo().GetVariableInfo(ivar).GetLabel();
467 dummyTree->Branch(Form("%s",vn.Data()), d+ivar, Form("%s/D",vn.Data()));
468 }
469 dummyTree->Branch("type", &type, "type/I");
470
471 if (fMLP != 0) { delete fMLP; fMLP = 0; }
472 fMLP = new TMultiLayerPerceptron( fMLPBuildOptions.Data(), dummyTree );
473
474 fMLP->LoadWeights( "./TMlp.nn.weights.temp" );
475 // here we can delete the temporary file
476 // how?
477 delete [] d;
478}
479
480////////////////////////////////////////////////////////////////////////////////
481/// create reader class for classifier -> overwrites base class function
482/// create specific class for TMultiLayerPerceptron
483
484void TMVA::MethodTMlpANN::MakeClass( const TString& theClassFileName ) const
485{
486 // the default consists of
487 TString classFileName = "";
488 if (theClassFileName == "")
489 classFileName = GetWeightFileDir() + "/" + GetJobName() + "_" + GetMethodName() + ".class";
490 else
491 classFileName = theClassFileName;
492
493 classFileName.ReplaceAll(".class","");
494 Log() << kINFO << "Creating specific (TMultiLayerPerceptron) standalone response class: " << classFileName << Endl;
495 fMLP->Export( classFileName.Data() );
496}
497
498////////////////////////////////////////////////////////////////////////////////
499/// write specific classifier response
500/// nothing to do here - all taken care of by TMultiLayerPerceptron
501
502void TMVA::MethodTMlpANN::MakeClassSpecific( std::ostream& /*fout*/, const TString& /*className*/ ) const
503{
504}
505
506////////////////////////////////////////////////////////////////////////////////
507/// get help message text
508///
509/// typical length of text line:
510/// "|--------------------------------------------------------------|"
511
513{
514 Log() << Endl;
515 Log() << gTools().Color("bold") << "--- Short description:" << gTools().Color("reset") << Endl;
516 Log() << Endl;
517 Log() << "This feed-forward multilayer perceptron neural network is the " << Endl;
518 Log() << "standard implementation distributed with ROOT (class TMultiLayerPerceptron)." << Endl;
519 Log() << Endl;
520 Log() << "Detailed information is available here:" << Endl;
521 if (gConfig().WriteOptionsReference()) {
522 Log() << "<a href=\"http://root.cern.ch/root/html/TMultiLayerPerceptron.html\">";
523 Log() << "http://root.cern.ch/root/html/TMultiLayerPerceptron.html</a>" << Endl;
524 }
525 else Log() << "http://root.cern.ch/root/html/TMultiLayerPerceptron.html" << Endl;
526 Log() << Endl;
527}
#define REGISTER_METHOD(CLASS)
for example
const Bool_t EnforceNormalization__
#define d(i)
Definition: RSha256.hxx:102
static RooMathCoreReg dummy
int Int_t
Definition: RtypesCore.h:41
unsigned int UInt_t
Definition: RtypesCore.h:42
const Bool_t kFALSE
Definition: RtypesCore.h:88
long Long_t
Definition: RtypesCore.h:50
bool Bool_t
Definition: RtypesCore.h:59
double Double_t
Definition: RtypesCore.h:55
float Float_t
Definition: RtypesCore.h:53
const Bool_t kTRUE
Definition: RtypesCore.h:87
#define ClassImp(name)
Definition: Rtypes.h:365
int type
Definition: TGX11.cxx:120
#define gROOT
Definition: TROOT.h:414
char * Form(const char *fmt,...)
Class that contains all the data information.
Definition: DataSetInfo.h:60
Float_t GetValue(UInt_t ivar) const
return value of i'th variable
Definition: Event.cxx:237
Double_t GetWeight() const
return the event weight - depending on whether the flag IgnoreNegWeightsInTraining is or not.
Definition: Event.cxx:382
Virtual base Class for all MVA method.
Definition: MethodBase.h:109
This is the TMVA TMultiLayerPerceptron interface class.
Definition: MethodTMlpANN.h:49
void ReadWeightsFromStream(std::istream &istr)
read weights from stream since the MLP can not read from the stream, we 1st: write the weights to tem...
void Init(void)
default initialisations
virtual Bool_t HasAnalysisType(Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets)
TMlpANN can handle classification with 2 classes.
void Train(void)
performs TMlpANN training available learning methods:
Double_t GetMvaValue(Double_t *err=0, Double_t *errUpper=0)
calculate the value of the neural net for the current event
void DeclareOptions()
define the options (their key words) that can be set in the option string
void CreateMLPOptions(TString)
translates options from option string into TMlpANN language
void ReadWeightsFromXML(void *wghtnode)
rebuild temporary textfile from xml weightfile and load this file into MLP
MethodTMlpANN(const TString &jobName, const TString &methodTitle, DataSetInfo &theData, const TString &theOption="3000:N-1:N-2")
standard constructor
void ProcessOptions()
builds the neural network as specified by the user
void MakeClassSpecific(std::ostream &, const TString &) const
write specific classifier response nothing to do here - all taken care of by TMultiLayerPerceptron
void AddWeightsXMLTo(void *parent) const
write weights to xml file
void MakeClass(const TString &classFileName=TString("")) const
create reader class for classifier -> overwrites base class function create specific class for TMulti...
virtual ~MethodTMlpANN(void)
destructor
void GetHelpMessage() const
get help message text
void * GetNextChild(void *prevchild, const char *childname=0)
XML helpers.
Definition: Tools.cxx:1174
void * AddChild(void *parent, const char *childname, const char *content=0, bool isRootNode=false)
add child node
Definition: Tools.cxx:1136
Bool_t AddRawLine(void *node, const char *raw)
XML helpers.
Definition: Tools.cxx:1202
const TString & Color(const TString &)
human readable color strings
Definition: Tools.cxx:840
const char * GetContent(void *node)
XML helpers.
Definition: Tools.cxx:1186
void * GetChild(void *parent, const char *childname=0)
get child node
Definition: Tools.cxx:1162
void ReadAttr(void *node, const char *, T &value)
read attribute from xml
Definition: Tools.h:337
void AddAttr(void *node, const char *, const T &value, Int_t precision=16)
add attribute to xml
Definition: Tools.h:355
Singleton class for Global types used by TMVA.
Definition: Types.h:73
EAnalysisType
Definition: Types.h:127
@ kClassification
Definition: Types.h:128
Basic string class.
Definition: TString.h:131
Ssiz_t Length() const
Definition: TString.h:405
Ssiz_t First(char c) const
Find first occurrence of a character c.
Definition: TString.cxx:499
const char * Data() const
Definition: TString.h:364
TString & Chop()
Definition: TString.h:674
TString & ReplaceAll(const TString &s1, const TString &s2)
Definition: TString.h:687
void Resize(Ssiz_t n)
Resize the string. Truncate or add blanks as necessary.
Definition: TString.cxx:1095
@ kLeading
Definition: TString.h:262
Bool_t BeginsWith(const char *s, ECaseCompare cmp=kExact) const
Definition: TString.h:610
TString & Remove(Ssiz_t pos)
Definition: TString.h:668
A TTree represents a columnar dataset.
Definition: TTree.h:71
virtual Int_t Fill()
Fill all branches.
Definition: TTree.cxx:4419
virtual Int_t Branch(TCollection *list, Int_t bufsize=32000, Int_t splitlevel=99, const char *name="")
Create one branch for each element in the collection.
Definition: TTree.cxx:1741
std::string GetMethodName(TCppMethod_t)
Definition: Cppyy.cxx:753
std::string GetName(const std::string &scope_name)
Definition: Cppyy.cxx:146
create variable transformations
Config & gConfig()
Tools & gTools()
MsgLogger & Endl(MsgLogger &ml)
Definition: MsgLogger.h:158
Double_t Log(Double_t x)
Definition: TMath.h:748