Execution Time29.14s

Test: tutorial-tmva-TMVAClassification (Passed)
Build: master-x86_64-mac1014-clang100-opt-exp-rtcxxmod (macphsft17.dyndns.cern.ch) on 2020-01-29 04:15:01

Test Timing: Passed
Processors1

Show Command Line
Display graphs:

Test output
Processing /build/jenkins/night/LABEL/mac1014/SPEC/rtcxxmod/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 % [17.5 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
create data set info dataset
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
                         : 
                         : Building event vectors for type 2 Signal
                         : Dataset[dataset] :  create input formulas for tree TreeS
                         : Building event vectors for type 2 Background
                         : Dataset[dataset] :  create input formulas for tree TreeB
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):
                         : ----------------------------------------
                         :           myvar1  myvar2    var3    var4
                         :  myvar1:  +1.000  -0.034  +0.771  +0.930
                         :  myvar2:  -0.034  +1.000  -0.100  +0.046
                         :    var3:  +0.771  -0.100  +1.000  +0.856
                         :    var4:  +0.930  +0.046  +0.856  +1.000
                         : ----------------------------------------
DataSetInfo              : Correlation matrix (Background):
                         : ----------------------------------------
                         :           myvar1  myvar2    var3    var4
                         :  myvar1:  +1.000  -0.009  +0.789  +0.934
                         :  myvar2:  -0.009  +1.000  -0.132  +0.071
                         :    var3:  +0.789  -0.132  +1.000  +0.845
                         :    var4:  +0.934  +0.071  +0.845  +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 now use 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.015080     1.7324   [    -9.3187     7.5304 ]
                         :   myvar2:  -0.034779     1.1155   [    -3.7067     4.0291 ]
                         :     var3: -0.0079573     1.0713   [    -5.0508     4.3301 ]
                         :     var4:    0.14942     1.2570   [    -5.8296     5.0307 ]
                         : -----------------------------------------------------------
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
                         : Preparing the Principle Component (PCA) transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1: -0.0053192     2.2925   [    -11.971     9.3295 ]
                         :   myvar2:   0.026354     1.1267   [    -4.0519     3.7451 ]
                         :     var3:  -0.011734    0.57939   [    -1.9673     2.1984 ]
                         :     var4: -0.0074322    0.33559   [    -1.0773     1.0734 ]
                         : -----------------------------------------------------------
                         : Preparing the Gaussian transformation...
                         : Preparing the Decorrelation transformation...
TFHandler_Factory        : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:  -0.036773     1.0000   [    -3.0875     8.2962 ]
                         :   myvar2: -0.0064547     1.0000   [    -3.2228     5.7588 ]
                         :     var3: -0.0048158     1.0000   [    -3.1042     7.1073 ]
                         :     var4:   0.069766     1.0000   [    -3.5018     6.0169 ]
                         : -----------------------------------------------------------
                         : Ranking input variables (method unspecific)...
IdTransformation         : Ranking result (top variable is best ranked)
                         : -------------------------------------
                         : Rank : Variable     : Separation
                         : -------------------------------------
                         :    1 : Variable 4   : 2.725e-01
                         :    2 : Variable 3   : 1.478e-01
                         :    3 : myvar1       : 9.376e-02
                         :    4 : Expression 2 : 3.146e-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.43 sec                           
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.1
                         : Corresponding background efficiency       : 0.00526008
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.66754 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=   0.396795
                         : Cut[ 2]:   -4.09811 <   var3 <=      1e+30
                         : Cut[ 3]:    1.92503 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.0190872
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.45493 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.19089
                         : Cut[ 2]:   -4.77664 <   var3 <=      1e+30
                         : Cut[ 3]:    1.70772 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.0386523
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:    -4.7772 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=   0.977644
                         : Cut[ 2]:   -1.79692 <   var3 <=      1e+30
                         : Cut[ 3]:    1.14937 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.0623442
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.79225 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    1.93205
                         : Cut[ 2]:  -0.909042 <   var3 <=      1e+30
                         : Cut[ 3]:    1.06298 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.109266
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -8.59467 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    1.54856
                         : Cut[ 2]:  -0.902111 <   var3 <=      1e+30
                         : Cut[ 3]:   0.689079 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.144641
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -3.38024 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.36249
                         : Cut[ 2]:   -5.12445 <   var3 <=      1e+30
                         : Cut[ 3]:     0.5184 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.241452
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -7.91418 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    3.08155
                         : Cut[ 2]:   -3.35271 <   var3 <=      1e+30
                         : Cut[ 3]:   0.214767 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.361263
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:   -1.95767 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.98091
                         : Cut[ 2]:   -3.70204 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.118037 <   var4 <=      1e+30
                         : ------------------------------------------
                         : ------------------------------------------
Cuts                     : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.599748
                         : Transformation applied to input variables : None
                         : ------------------------------------------
                         : Cut[ 0]:    -7.0228 < myvar1 <=      1e+30
                         : Cut[ 1]:     -1e+30 < myvar2 <=    2.97185
                         : Cut[ 2]:   -1.38278 <   var3 <=      1e+30
                         : Cut[ 3]:  -0.728796 <   var4 <=      1e+30
                         : ------------------------------------------
                         : Elapsed time for training with 2000 events: 3.44 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.000489 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.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
TFHandler_CutsD          : Variable        Mean        RMS   [        Min        Max ]
                         : -----------------------------------------------------------
                         :   myvar1:   -0.13942     1.0000   [    -4.8534     4.6721 ]
                         :   myvar2:  -0.057698     1.0000   [    -3.3267     3.6525 ]
                         :     var3:   -0.13281     1.0000   [    -3.8074     4.2782 ]
                         :     var4:    0.34988     1.0000   [    -3.6552     3.4484 ]
                         : -----------------------------------------------------------
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: 2 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: 1 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: 3.02 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.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=  -0.293952
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.82497
                         : Cut[ 2]:  -0.412575 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.23915 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.2
                         : Corresponding background efficiency       : 0.000958133
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=   0.301143
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.55858
                         : Cut[ 2]:  -0.783016 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.22918 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.3
                         : Corresponding background efficiency       : 0.0048755
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    4.19975
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=   -0.15415
                         : Cut[ 2]:   -3.60378 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.820318 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.4
                         : Corresponding background efficiency       : 0.0119257
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=     4.6873
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    1.70715
                         : Cut[ 2]:   -1.69799 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    1.15831 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.5
                         : Corresponding background efficiency       : 0.0205391
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    4.07561
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    1.10156
                         : Cut[ 2]:   -2.34168 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.941765 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.6
                         : Corresponding background efficiency       : 0.0312968
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=     4.0724
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.47532
                         : Cut[ 2]:   -2.52894 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:    0.88763 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.7
                         : Corresponding background efficiency       : 0.0728951
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    3.01933
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    2.63051
                         : Cut[ 2]:   -2.53907 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.670062 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.8
                         : Corresponding background efficiency       : 0.132385
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    2.83282
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.63856
                         : Cut[ 2]:   -2.32922 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:   0.450885 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : ------------------------------------------------------------------------------------------------------------------------
CutsD                    : Cut values for requested signal efficiency: 0.9
                         : Corresponding background efficiency       : 0.283046
                         : Transformation applied to input variables : "Deco"
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Cut[ 0]:     -1e+30 <  +     1.1413*[myvar1] +   0.040052*[myvar2] -    0.20511*[var3] -    0.81946*[var4] <=    3.83336
                         : Cut[ 1]:     -1e+30 <  +   0.040052*[myvar1] +    0.91911*[myvar2] +    0.16163*[var3] -    0.15956*[var4] <=    3.24452
                         : Cut[ 2]:   -3.17726 <  -    0.20511*[myvar1] +    0.16163*[myvar2] +     1.7957*[var3] -     0.7763*[var4] <=      1e+30
                         : Cut[ 3]:  0.0796929 <  -    0.81946*[myvar1] -    0.15956*[myvar2] -     0.7763*[var3] +     2.1804*[var4] <=      1e+30
                         : ------------------------------------------------------------------------------------------------------------------------
                         : Elapsed time for training with 2000 events: 3.03 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.00258 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.0249 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.00234 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.0053192     2.2925   [    -11.971     9.3295 ]
                         :   myvar2:   0.026354     1.1267   [    -4.0519     3.7451 ]
                         :     var3:  -0.011734    0.57939   [    -1.9673     2.1984 ]
                         :     var4: -0.0074322    0.33559   [    -1.0773     1.0734 ]
                         : -----------------------------------------------------------
                         : Filling reference histograms
                         : Building PDF out of reference histograms
                         : Elapsed time for training with 2000 events: 0.0241 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.00687 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.00599 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.298 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: 3 sec
                         : Elapsed time: 0.538 sec                                 
                         : Elapsed time for training with 2000 events: 0.581 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.0237 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.00509 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.0623 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.333
                         :   myvar2:       -0.085
                         :     var3:       -0.171
                         :     var4:       +0.746
                         : (offset):       -0.060
                         : -----------------------
                         : Elapsed time for training with 2000 events: 0.00136 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.000933 sec       
                         : <CreateMVAPdfs> Separation from histogram (PDF): 0.560 (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: 1 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: 1.29 sec                            
FDA_GA                   : Results for parameter fit using "GA" fitter:
                         : -----------------------
                         : Parameter:  Fit result:
                         : -----------------------
                         :    Par(0):    0.311649
                         :    Par(1):   -0.147682
                         :    Par(2):           0
                         :    Par...
The rest of the test output was removed since it exceeds the threshold of 64000 bytes.