Execution Time39.50s

Test: tutorial-tmva-TMVAClassification (Passed)
Build: v6-18-00-patches-x86_64-ubuntu18-gcc7-opt (sft-ubuntu-1804-3) on 2020-01-24 02:15:47
Repository revision: 0a774756bda016f71683da97dbc82f76bc082689

Test Timing: Passed
Processors1

Show Command Line
Display graphs:

Test output
Processing /mnt/build/night/LABEL/ROOT-ubuntu18.04/SPEC/rtcxxmod/V/6-18/root/tutorials/tmva/TMVAClassification.C...

==> Start TMVAClassification
[TFile::Cp] Total 0.20 MB	|>...................| 0.00 % [0.0 MB/s][TFile::Cp] Total 0.20 MB	|====================| 100.00 % [55.0 MB/s]
Info in <TFile::OpenFromCache>: using local cache copy of http://root.cern.ch/files/tmva_class_example.root [./files/tmva_class_example.root]
--- TMVAClassification       : Using input file: ./files/tmva_class_example.root
DataSetInfo              : [dataset] : Added class "Signal"
                         : Add Tree TreeS of type Signal with 6000 events
DataSetInfo              : [dataset] : Added class "Background"
                         : Add Tree TreeB of type Background with 6000 events
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mCuts[NON-XML-CHAR-0x1B][0m
                         : 
                         : Use optimization method: "Monte Carlo"
                         : Use efficiency computation method: "Event Selection"
                         : Use "FSmart" cuts for variable: 'myvar1'
                         : Use "FSmart" cuts for variable: 'myvar2'
                         : Use "FSmart" cuts for variable: 'var3'
                         : Use "FSmart" cuts for variable: 'var4'
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mCutsD[NON-XML-CHAR-0x1B][0m
                         : 
CutsD                    : [dataset] : Create Transformation "Decorrelate" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
                         : Use optimization method: "Monte Carlo"
                         : Use efficiency computation method: "Event Selection"
                         : Use "FSmart" cuts for variable: 'myvar1'
                         : Use "FSmart" cuts for variable: 'myvar2'
                         : Use "FSmart" cuts for variable: 'var3'
                         : Use "FSmart" cuts for variable: 'var4'
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mLikelihood[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mLikelihoodPCA[NON-XML-CHAR-0x1B][0m
                         : 
LikelihoodPCA            : [dataset] : Create Transformation "PCA" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mPDERS[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mPDEFoam[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mKNN[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mLD[NON-XML-CHAR-0x1B][0m
                         : 
DataSetFactory           : [dataset] : Number of events in input trees
                         : 
                         : 
                         : Number of training and testing events
                         : ---------------------------------------------------------------------------
                         : Signal     -- training events            : 1000
                         : Signal     -- testing events             : 5000
                         : Signal     -- training and testing events: 6000
                         : Background -- training events            : 1000
                         : Background -- testing events             : 5000
                         : Background -- training and testing events: 6000
                         : 
DataSetInfo              : Correlation matrix (Signal):
                         : ----------------------------------------------
                         :            var1+var2 var1-var2    var3    var4
                         : var1+var2:    +1.000    +0.038  +0.748  +0.922
                         : var1-var2:    +0.038    +1.000  -0.058  +0.128
                         :      var3:    +0.748    -0.058  +1.000  +0.831
                         :      var4:    +0.922    +0.128  +0.831  +1.000
                         : ----------------------------------------------
DataSetInfo              : Correlation matrix (Background):
                         : ----------------------------------------------
                         :            var1+var2 var1-var2    var3    var4
                         : var1+var2:    +1.000    -0.021  +0.783  +0.931
                         : var1-var2:    -0.021    +1.000  -0.162  +0.057
                         :      var3:    +0.783    -0.162  +1.000  +0.841
                         :      var4:    +0.931    +0.057  +0.841  +1.000
                         : ----------------------------------------------
DataSetFactory           : [dataset] :  
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mFDA_GA[NON-XML-CHAR-0x1B][0m
                         : 
                         : Create parameter interval for parameter 0 : [-1,1]
                         : Create parameter interval for parameter 1 : [-10,10]
                         : Create parameter interval for parameter 2 : [-10,10]
                         : Create parameter interval for parameter 3 : [-10,10]
                         : Create parameter interval for parameter 4 : [-10,10]
                         : User-defined formula string       : "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
                         : TFormula-compatible formula string: "[0]+[1]*[5]+[2]*[6]+[3]*[7]+[4]*[8]"
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mMLPBNN[NON-XML-CHAR-0x1B][0m
                         : 
MLPBNN                   : [dataset] : Create Transformation "N" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
MLPBNN                   : Building Network. 
                         : Initializing weights
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mDNN_CPU[NON-XML-CHAR-0x1B][0m
                         : 
                         : Parsing option string: 
                         : ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:Layout=TANH|128,TANH|128,TANH|128,LINEAR:TrainingStrategy=LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5, Multithreading=True|LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=20,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0, Multithreading=True|LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=20,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0, Multithreading=True:Architecture=CPU"
                         : The following options are set:
                         : - By User:
                         :     <none>
                         : - Default:
                         :     Boost_num: "0" [Number of times the classifier will be boosted]
                         : Parsing option string: 
                         : ... "!H:V:ErrorStrategy=CROSSENTROPY:VarTransform=N:WeightInitialization=XAVIERUNIFORM:Layout=TANH|128,TANH|128,TANH|128,LINEAR:TrainingStrategy=LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5, Multithreading=True|LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=20,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0, Multithreading=True|LearningRate=1e-3,Momentum=0.0,Repetitions=1,ConvergenceSteps=20,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=L2,DropConfig=0.0+0.0+0.0+0.0, Multithreading=True:Architecture=CPU"
                         : The following options are set:
                         : - By User:
                         :     V: "True" [Verbose output (short form of "VerbosityLevel" below - overrides the latter one)]
                         :     VarTransform: "N" [List of variable transformations performed before training, e.g., "D_Background,P_Signal,G,N_AllClasses" for: "Decorrelation, PCA-transformation, Gaussianisation, Normalisation, each for the given class of events ('AllClasses' denotes all events of all classes, if no class indication is given, 'All' is assumed)"]
                         :     H: "False" [Print method-specific help message]
                         :     Layout: "TANH|128,TANH|128,TANH|128,LINEAR" [Layout of the network.]
                         :     ErrorStrategy: "CROSSENTROPY" [Loss function: Mean squared error (regression) or cross entropy (binary classification).]
                         :     WeightInitialization: "XAVIERUNIFORM" [Weight initialization strategy]
                         :     Architecture: "CPU" [Which architecture to perform the training on.]
                         :     TrainingStrategy: "LearningRate=1e-2,Momentum=0.9,Repetitions=1,ConvergenceSteps=30,BatchSize=256,TestRepetitions=10,WeightDecay=1e-4,Regularization=None,DropConfig=0.0+0.5+0.5+0.5," [Defines the training strategies.]
                         : - Default:
                         :     VerbosityLevel: "Default" [Verbosity level]
                         :     CreateMVAPdfs: "False" [Create PDFs for classifier outputs (signal and background)]
                         :     IgnoreNegWeightsInTraining: "False" [Events with negative weights are ignored in the training (but are included for testing and performance evaluation)]
                         :     InputLayout: "0|0|0" [The Layout of the input]
                         :     BatchLayout: "0|0|0" [The Layout of the batch]
                         :     RandomSeed: "0" [Random seed used for weight initialization and batch shuffling]
                         :     ValidationSize: "20%" [Part of the training data to use for validation. Specify as 0.2 or 20% to use a fifth of the data set as validation set. Specify as 100 to use exactly 100 events. (Default: 20%)]
DNN_CPU                  : [dataset] : Create Transformation "N" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
                         : Will use now the CPU architecture !
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mSVM[NON-XML-CHAR-0x1B][0m
                         : 
SVM                      : [dataset] : Create Transformation "Norm" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mBDT[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : Booking method: [NON-XML-CHAR-0x1B][1mRuleFit[NON-XML-CHAR-0x1B][0m
                         : 
Factory                  : [NON-XML-CHAR-0x1B][1mTrain all methods[NON-XML-CHAR-0x1B][0m
Factory                  : [dataset] : Create Transformation "I" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : [dataset] : Create Transformation "D" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : [dataset] : Create Transformation "P" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : [dataset] : Create Transformation "G" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
Factory                  : [dataset] : Create Transformation "D" with events from all classes.
                         : 
                         : Transformation, Variable selection : 
                         : Input : variable 'myvar1' <---> Output : variable 'myvar1'
                         : Input : variable 'myvar2' <---> Output : variable 'myvar2'
                         : Input : variable 'var3' <---> Output : variable 'var3'
                         : Input : variable 'var4' <---> Output : variable 'var4'
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:  -0.062775     1.7187   [    -9.3380     7.6931 ]
                         :   myvar2:   0.056495     1.0784   [    -3.2551     4.0291 ]
                         :     var3:  -0.020366     1.0633   [    -5.2777     4.6430 ]
                         :     var4:    0.13214     1.2464   [    -5.6007     4.6744 ]
                         : -----------------------------------------------------------
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.17586     1.0000   [    -5.6401     4.8529 ]
                         :   myvar2:   0.026952     1.0000   [    -2.9292     3.7065 ]
                         :     var3:   -0.11549     1.0000   [    -4.1792     3.5180 ]
                         :     var4:    0.34819     1.0000   [    -3.3363     3.3963 ]
                         : -----------------------------------------------------------
                         : Preparing the Principle Component (PCA) transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.11433     2.2714   [    -11.272     9.0916 ]
                         :   myvar2: -0.0070834     1.0934   [    -3.9875     3.3836 ]
                         :     var3:   0.011107    0.57824   [    -2.0171     2.1958 ]
                         :     var4: -0.0094450    0.33437   [    -1.0176     1.0617 ]
                         : -----------------------------------------------------------
                         : Preparing the Gaussian transformation...
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:  -0.054412     1.0000   [    -3.0924     8.1350 ]
                         :   myvar2: -0.0021417     1.0000   [    -4.5913     5.6461 ]
                         :     var3: -0.0051998     1.0000   [    -3.1457     4.6043 ]
                         :     var4:   0.074624     1.0000   [    -3.4587     5.9397 ]
                         : -----------------------------------------------------------
                         : Ranking input variables (method unspecific)...
IdTransformation         : Ranking result (top variable is best ranked)
                         : -------------------------------------
                         : Rank : Variable     : Separation
                         : -------------------------------------
                         :    1 : Variable 4   : 2.843e-01
                         :    2 : Variable 3   : 1.756e-01
                         :    3 : myvar1       : 1.018e-01
                         :    4 : Expression 2 : 3.860e-02
                         : -------------------------------------
Factory                  : Train method: Cuts for Classification
                         : 
FitterBase               : <MCFitter> Sampling, please be patient ...
0%, time left: unknown
7%, time left: 3 sec
13%, time left: 2 sec
19%, time left: 2 sec
25%, time left: 2 sec
32%, time left: 2 sec
38%, time left: 2 sec
44%, time left: 1 sec
50%, time left: 1 sec
57%, time left: 1 sec
63%, time left: 1 sec
69%, time left: 1 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time: 3.29 sec                           
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.1
                         : Corresponding background efficiency       : 0.00621902
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.19223 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=      2.126
                         : Cut[ 2]:   -2.90978 <   var3 <=      1e+30
                         : Cut[ 3]:    2.16207 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.0171253
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -5.85714 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.21109
                         : Cut[ 2]:  -0.759439 <   var3 <=      1e+30
                         : Cut[ 3]:    1.66846 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.0401486
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -6.09813 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.81831
                         : Cut[ 2]:   -2.09336 <   var3 <=      1e+30
                         : Cut[ 3]:    1.34308 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.062887
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -4.55141 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.94573
                         : Cut[ 2]:   -4.68697 <   var3 <=      1e+30
                         : Cut[ 3]:    1.07157 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.104486
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -5.86032 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.89615
                         : Cut[ 2]:  -0.966191 <   var3 <=      1e+30
                         : Cut[ 3]:   0.773848 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.172806
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -5.52552 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    4.08498
                         : Cut[ 2]:   -2.61706 <   var3 <=      1e+30
                         : Cut[ 3]:   0.469684 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.258379
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -5.69875 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    1.73784
                         : Cut[ 2]:   -1.21467 <   var3 <=      1e+30
                         : Cut[ 3]:   0.109026 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.362964
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.99372 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.93767
                         : Cut[ 2]:   -1.56317 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.124013 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.503885
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.97304 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.31284
                         : Cut[ 2]:   -2.82879 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.577302 <   var4 <=      1e+30
                         : ------------------------------------------
                         : Elapsed time for training with 2000 events: 3.3 sec         
Cuts                     : [dataset] : Evaluation of Cuts on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.000678 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Cuts.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Cuts.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Cuts/Cuts
Factory                  : Training finished
                         : 
Factory                  : Train method: CutsD for Classification
                         : 
                         : Preparing the Decorrelation transformation...
TFHandler_CutsD          : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.17586     1.0000   [    -5.6401     4.8529 ]
                         :   myvar2:   0.026952     1.0000   [    -2.9292     3.7065 ]
                         :     var3:   -0.11549     1.0000   [    -4.1792     3.5180 ]
                         :     var4:    0.34819     1.0000   [    -3.3363     3.3963 ]
                         : -----------------------------------------------------------
TFHandler_CutsD          : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.17586     1.0000   [    -5.6401     4.8529 ]
                         :   myvar2:   0.026952     1.0000   [    -2.9292     3.7065 ]
                         :     var3:   -0.11549     1.0000   [    -4.1792     3.5180 ]
                         :     var4:    0.34819     1.0000   [    -3.3363     3.3963 ]
                         : -----------------------------------------------------------
FitterBase               : <MCFitter> Sampling, please be patient ...
0%, time left: unknown
7%, time left: 2 sec
13%, time left: 2 sec
19%, time left: 2 sec
25%, time left: 1 sec
32%, time left: 1 sec
38%, time left: 1 sec
44%, time left: 1 sec
50%, time left: 1 sec
57%, time left: 1 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time: 2.58 sec                           
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.1
                         : Corresponding background efficiency       : 0
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=   0.513038
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=  -0.733858
                         : Cut[ 2]:   -0.87113 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:   0.687739 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.000493656
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    1.60056
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    1.26936
                         : Cut[ 2]:   -1.50073 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:    1.54845 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.00334252
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    2.16898
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    3.25932
                         : Cut[ 2]:   -2.08503 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:    1.43959 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.00821453
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=     1.9086
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    1.94778
                         : Cut[ 2]:   -2.11471 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:     1.1885 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.0209024
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    3.97301
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    2.87835
                         : Cut[ 2]:   -1.68889 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:   0.969507 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.055037
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    2.57624
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    2.20263
                         : Cut[ 2]:   -3.86902 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:   0.802122 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.0975699
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    3.65719
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    3.19411
                         : Cut[ 2]:   -2.87372 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:   0.583961 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.170999
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    4.74857
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    2.75269
                         : Cut[ 2]:   -3.22043 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:   0.327788 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.326977
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1476*[myvar1] +   0.027923*[myvar2] -    0.19981*[var3] -    0.82843*[var4] <=    3.56614
                         : Cut[ 1]:     -1e+30 <  +   0.027923*[myvar1] +    0.95469*[myvar2] +    0.18581*[var3] -     0.1623*[var4] <=    3.09071
                         : Cut[ 2]:    -3.9944 <  -    0.19981*[myvar1] +    0.18581*[myvar2] +     1.7913*[var3] -    0.77231*[var4] <=      1e+30
                         : Cut[ 3]:  0.0311777 <  -    0.82843*[myvar1] -     0.1623*[myvar2] -    0.77231*[var3] +     2.1918*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Elapsed time for training with 2000 events: 2.58 sec         
CutsD                    : [dataset] : Evaluation of CutsD on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00127 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_CutsD.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_CutsD.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Cuts/CutsD
Factory                  : Training finished
                         : 
Factory                  : Train method: Likelihood for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ Likelihood ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : The maximum-likelihood classifier models the data with probability 
                         : density functions (PDF) reproducing the signal and background
                         : distributions of the input variables. Correlations among the 
                         : variables are ignored.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : Required for good performance are decorrelated input variables
                         : (PCA transformation via the option "VarTransform=Decorrelate"
                         : may be tried). Irreducible non-linear correlations may be reduced
                         : by precombining strongly correlated input variables, or by simply
                         : removing one of the variables.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : High fidelity PDF estimates are mandatory, i.e., sufficient training 
                         : statistics is required to populate the tails of the distributions
                         : It would be a surprise if the default Spline or KDE kernel parameters
                         : provide a satisfying fit to the data. The user is advised to properly
                         : tune the events per bin and smooth options in the spline cases
                         : individually per variable. If the KDE kernel is used, the adaptive
                         : Gaussian kernel may lead to artefacts, so please always also try
                         : the non-adaptive one.
                         : 
                         : All tuning parameters must be adjusted individually for each input
                         : variable!
                         : 
                         : <Suppress this message by specifying "!H" in the booking option>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
                         : Filling reference histograms
                         : Building PDF out of reference histograms
                         : Elapsed time for training with 2000 events: 0.0142 sec         
Likelihood               : [dataset] : Evaluation of Likelihood on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00221 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Likelihood.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_Likelihood.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Likelihood/Likelihood
Factory                  : Training finished
                         : 
Factory                  : Train method: LikelihoodPCA for Classification
                         : 
                         : Preparing the Principle Component (PCA) transformation...
TFHandler_LikelihoodPCA  : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.11433     2.2714   [    -11.272     9.0916 ]
                         :   myvar2: -0.0070834     1.0934   [    -3.9875     3.3836 ]
                         :     var3:   0.011107    0.57824   [    -2.0171     2.1958 ]
                         :     var4: -0.0094450    0.33437   [    -1.0176     1.0617 ]
                         : -----------------------------------------------------------
                         : Filling reference histograms
                         : Building PDF out of reference histograms
                         : Elapsed time for training with 2000 events: 0.0166 sec         
LikelihoodPCA            : [dataset] : Evaluation of LikelihoodPCA on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.00378 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LikelihoodPCA.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LikelihoodPCA.class.C[NON-XML-CHAR-0x1B][0m
                         : TMVA.root:/dataset/Method_Likelihood/LikelihoodPCA
Factory                  : Training finished
                         : 
Factory                  : Train method: PDERS for Classification
                         : 
                         : Elapsed time for training with 2000 events: 0.00335 sec         
PDERS                    : [dataset] : Evaluation of PDERS on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.252 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDERS.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDERS.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: PDEFoam for Classification
                         : 
PDEFoam                  : NormMode=NUMEVENTS chosen. Note that only NormMode=EqualNumEvents ensures that Discriminant values correspond to signal probabilities.
                         : Build up discriminator foam
0%, time left: unknown
7%, time left: 2 sec
                         : Elapsed time: 0.335 sec                                 
                         : Elapsed time for training with 2000 events: 0.364 sec         
PDEFoam                  : [dataset] : Evaluation of PDEFoam on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.0142 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.weights.xml[NON-XML-CHAR-0x1B][0m
                         : writing foam DiscrFoam to file
                         : Foams written to file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.weights_foams.root[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_PDEFoam.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: KNN for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ KNN ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : The k-nearest neighbor (k-NN) algorithm is a multi-dimensional classification
                         : and regression algorithm. Similarly to other TMVA algorithms, k-NN uses a set of
                         : training events for which a classification category/regression target is known. 
                         : The k-NN method compares a test event to all training events using a distance 
                         : function, which is an Euclidean distance in a space defined by the input variables. 
                         : The k-NN method, as implemented in TMVA, uses a kd-tree algorithm to perform a
                         : quick search for the k events with shortest distance to the test event. The method
                         : returns a fraction of signal events among the k neighbors. It is recommended
                         : that a histogram which stores the k-NN decision variable is binned with k+1 bins
                         : between 0 and 1.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options: [NON-XML-CHAR-0x1B][0m
                         : 
                         : The k-NN method estimates a density of signal and background events in a 
                         : neighborhood around the test event. The method assumes that the density of the 
                         : signal and background events is uniform and constant within the neighborhood. 
                         : k is an adjustable parameter and it determines an average size of the 
                         : neighborhood. Small k values (less than 10) are sensitive to statistical 
                         : fluctuations and large (greater than 100) values might not sufficiently capture  
                         : local differences between events in the training set. The speed of the k-NN
                         : method also increases with larger values of k. 
                         : 
                         : The k-NN method assigns equal weight to all input variables. Different scales 
                         : among the input variables is compensated using ScaleFrac parameter: the input 
                         : variables are scaled so that the widths for central ScaleFrac*100% events are 
                         : equal among all the input variables.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Additional configuration options: [NON-XML-CHAR-0x1B][0m
                         : 
                         : The method inclues an option to use a Gaussian kernel to smooth out the k-NN
                         : response. The kernel re-weights events using a distance to the test event.
                         : 
                         : <Suppress this message by specifying "!H" in the booking option>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
KNN                      : <Train> start...
                         : Reading 2000 events
                         : Number of signal events 1000
                         : Number of background events 1000
                         : Creating kd-tree with 2000 events
                         : Computing scale factor for 1d distributions: (ifrac, bottom, top) = (80%, 10%, 90%)
ModulekNN                : Optimizing tree for 4 variables with 2000 values
                         : <Fill> Class 1 has     1000 events
                         : <Fill> Class 2 has     1000 events
                         : Elapsed time for training with 2000 events: 0.00417 sec         
KNN                      : [dataset] : Evaluation of KNN on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.0383 sec       
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_KNN.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_KNN.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: LD for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ LD ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : Linear discriminants select events by distinguishing the mean 
                         : values of the signal and background distributions in a trans- 
                         : formed variable space where linear correlations are removed.
                         : The LD implementation here is equivalent to the "Fisher" discriminant
                         : for classification, but also provides linear regression.
                         : 
                         :    (More precisely: the "linear discriminator" determines
                         :     an axis in the (correlated) hyperspace of the input 
                         :     variables such that, when projecting the output classes 
                         :     (signal and background) upon this axis, they are pushed 
                         :     as far as possible away from each other, while events
                         :     of a same class are confined in a close vicinity. The  
                         :     linearity property of this classifier is reflected in the 
                         :     metric with which "far apart" and "close vicinity" are 
                         :     determined: the covariance matrix of the discriminating
                         :     variable space.)
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : Optimal performance for the linear discriminant is obtained for 
                         : linearly correlated Gaussian-distributed variables. Any deviation
                         : from this ideal reduces the achievable separation power. In 
                         : particular, no discrimination at all is achieved for a variable
                         : that has the same sample mean for signal and background, even if 
                         : the shapes of the distributions are very different. Thus, the linear 
                         : discriminant often benefits from a suitable transformation of the 
                         : input variables. For example, if a variable x in [-1,1] has a 
                         : a parabolic signal distributions, and a uniform background
                         : distributions, their mean value is zero in both cases, leading 
                         : to no separation. The simple transformation x -> |x| renders this 
                         : variable powerful for the use in a linear discriminant.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : <None>
                         : 
                         : <Suppress this message by specifying "!H" in the booking option>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
LD                       : Results for LD coefficients:
                         : -----------------------
                         : Variable:  Coefficient:
                         : -----------------------
                         :   myvar1:       -0.309
                         :   myvar2:       -0.102
                         :     var3:       -0.142
                         :     var4:       +0.705
                         : (offset):       -0.055
                         : -----------------------
                         : Elapsed time for training with 2000 events: 0.00105 sec         
LD                       : [dataset] : Evaluation of LD on training sample (2000 events)
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Elapsed time for evaluation of 2000 events: 0.000476 sec       
                         : <CreateMVAPdfs> Separation from histogram (PDF): 0.540 (0.000)
                         : Dataset[dataset] : Evaluation of LD on training sample
0%, time left: unknown
7%, time left: 0 sec
13%, time left: 0 sec
19%, time left: 0 sec
25%, time left: 0 sec
32%, time left: 0 sec
38%, time left: 0 sec
44%, time left: 0 sec
50%, time left: 0 sec
57%, time left: 0 sec
63%, time left: 0 sec
69%, time left: 0 sec
75%, time left: 0 sec
82%, time left: 0 sec
88%, time left: 0 sec
94%, time left: 0 sec
                         : Creating xml weight file: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LD.weights.xml[NON-XML-CHAR-0x1B][0m
                         : Creating standalone class: [NON-XML-CHAR-0x1B][0;36mdataset/weights/TMVAClassification_LD.class.C[NON-XML-CHAR-0x1B][0m
Factory                  : Training finished
                         : 
Factory                  : Train method: FDA_GA for Classification
                         : 
                         : 
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : [NON-XML-CHAR-0x1B][1mH e l p   f o r   M V A   m e t h o d   [ FDA_GA ] :[NON-XML-CHAR-0x1B][0m
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Short description:[NON-XML-CHAR-0x1B][0m
                         : 
                         : The function discriminant analysis (FDA) is a classifier suitable 
                         : to solve linear or simple nonlinear discrimination problems.
                         : 
                         : The user provides the desired function with adjustable parameters
                         : via the configuration option string, and FDA fits the parameters to
                         : it, requiring the signal (background) function value to be as close
                         : as possible to 1 (0). Its advantage over the more involved and
                         : automatic nonlinear discriminators is the simplicity and transparency 
                         : of the discrimination expression. A shortcoming is that FDA will
                         : underperform for involved problems with complicated, phase space
                         : dependent nonlinear correlations.
                         : 
                         : Please consult the Users Guide for the format of the formula string
                         : and the allowed parameter ranges:
                         : http://tmva.sourceforge.net/docu/TMVAUsersGuide.pdf
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance optimisation:[NON-XML-CHAR-0x1B][0m
                         : 
                         : The FDA performance depends on the complexity and fidelity of the
                         : user-defined discriminator function. As a general rule, it should
                         : be able to reproduce the discrimination power of any linear
                         : discriminant analysis. To reach into the nonlinear domain, it is
                         : useful to inspect the correlation profiles of the input variables,
                         : and add quadratic and higher polynomial terms between variables as
                         : necessary. Comparison with more involved nonlinear classifiers can
                         : be used as a guide.
                         : 
                         : [NON-XML-CHAR-0x1B][1m--- Performance tuning via configuration options:[NON-XML-CHAR-0x1B][0m
                         : 
                         : Depending on the function used, the choice of "FitMethod" is
                         : crucial for getting valuable solutions with FDA. As a guideline it
                         : is recommended to start with "FitMethod=MINUIT". When more complex
                         : functions are used where MINUIT does not converge to reasonable
                         : results, the user should switch to non-gradient FitMethods such
                         : as GeneticAlgorithm (GA) or Monte Carlo (MC). It might prove to be
                         : useful to combine GA (or MC) with MINUIT by setting the option
                         : "Converger=MINUIT". GA (MC) will then set the starting parameters
                         : for MINUIT such that the basic quality of GA (MC) of finding global
                         : minima is combined with the efficacy of MINUIT of finding local
                         : minima.
                         : 
                         : <Suppress this message by specifying "!H" in the booking option>
                         : [NON-XML-CHAR-0x1B][1m================================================================[NON-XML-CHAR-0x1B][0m
                         : 
FitterBase               : <GeneticFitter> Optimisation, please be patient ... (inaccurate progress timing for GA)
0%, time left: unknown
10%, time left: 0 sec
20%, time left: 0 sec
30%, time left: 0 sec
40%, time left: 0 sec
50%, time left: 0 sec
60%, time left: 0 sec
70%, time left: 0 sec
80%, time left: 0 sec
90%, time left: 0 sec
100%, time left: 0 sec
                         : Elapsed time: 0.422 sec                            
FDA_GA                   : Results for parameter fit using "GA" fitter:
                         : -----------------------
                         : Parameter:  Fit result:
                         : -----------------------
                         :    Par(0):    0.548897
                         :    Par(1):   -0.195107
                         :    Par(2):           0
                         :    Par(3):           0
                         :    Par(4):    0.390594
                         : -----------------------
                         : Discriminator expression: "(0)+(1)*x0+(2)*x1+(3)*x2+(4)*x3"
                         : Value of ...
The rest of the test output was removed since it exceeds the threshold of 64000 bytes.