// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Matt Jachowski, Peter Speckmayer, Eckhard von Toerne, Helge Voss, Kai Voss

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate Data analysis       *
 * Package: TMVA                                                                  *
 * Class  : TMVA::MethodCuts                                                      *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation (see header for description)                               *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Matt Jachowski  <jachowski@stanford.edu> - Stanford University, USA       *
 *      Peter Speckmayer <speckmay@mail.cern.ch> - CERN, Switzerland              *
 *      Eckhard von Toerne <evt@physik.uni-bonn.de> - U. of Bonn, Germany         *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *      Kai Voss        <Kai.Voss@cern.ch>       - U. of Victoria, Canada         *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      CERN, Switzerland                                                         *
 *      U. of Victoria, Canada                                                    *
 *      MPI-K Heidelberg, Germany                                                 *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://tmva.sourceforge.net/LICENSE)                                          *
 **********************************************************************************/

//_______________________________________________________________________
/* Begin_Html
  Multivariate optimisation of signal efficiency for given background
  efficiency, applying rectangular minimum and maximum requirements.

  <p>
  Also implemented is a "decorrelate/diagonlized cuts approach",
  which improves over the uncorrelated cuts ansatz by
  transforming linearly the input variables into a diagonal space,
  using the square-root of the covariance matrix.

  <p>
  <font size="-1">
  Other optimisation criteria, such as maximising the signal significance-
  squared, S^2/(S+B), with S and B being the signal and background yields,
  correspond to a particular point in the optimised background rejection
  versus signal efficiency curve. This working point requires the knowledge
  of the expected yields, which is not the case in general. Note also that
  for rare signals, Poissonian statistics should be used, which modifies
  the significance criterion.
  </font>

  <p>
  The rectangular cut of a volume in the variable space is performed using
  a binary tree to sort the training events. This provides a significant
  reduction in computing time (up to several orders of magnitudes, depending
  on the complexity of the problem at hand).

  <p>
  Technically, optimisation is achieved in TMVA by two methods:

  <ol>
  <li>Monte Carlo generation using uniform priors for the lower cut value,
  and the cut width, thrown within the variable ranges.

  <li>A Genetic Algorithm (GA) searches for the optimal ("fittest") cut sample.
  The GA is configurable by many external settings through the option
  string. For difficult cases (such as many variables), some tuning
  may be necessary to achieve satisfying results
  </ol>

  <p>
  <font size="-1">
  Attempts to use Minuit fits (Simplex ot Migrad) instead have not shown
  superior results, and often failed due to convergence at local minima.
  </font>

  <p>
  The tests we have performed so far showed that in generic applications,
  the GA is superior to MC sampling, and hence GA is the default method.
  It is worthwhile trying both anyway.

  <b>Decorrelated (or "diagonalized") Cuts</b>

  <p>
  See class description for Method Likelihood for a detailed explanation.
End_Html */
//

#include <iostream>
#include <cstdlib>

#include "Riostream.h"
#include "TH1F.h"
#include "TObjString.h"
#include "TDirectory.h"
#include "TMath.h"
#include "TGraph.h"
#include "TSpline.h"
#include "TRandom3.h"

#include "TMVA/ClassifierFactory.h"
#include "TMVA/MethodCuts.h"
#include "TMVA/GeneticFitter.h"
#include "TMVA/MinuitFitter.h"
#include "TMVA/MCFitter.h"
#include "TMVA/SimulatedAnnealingFitter.h"
#include "TMVA/PDF.h"
#include "TMVA/Tools.h"
#include "TMVA/Timer.h"
#include "TMVA/Interval.h"
#include "TMVA/TSpline1.h"
#include "TMVA/Config.h"
#include "TMVA/VariableTransformBase.h"
#include "TMVA/Results.h"

using std::atof;

REGISTER_METHOD(Cuts)

ClassImp(TMVA::MethodCuts)

const Double_t TMVA::MethodCuts::fgMaxAbsCutVal = 1.0e30;

//_______________________________________________________________________
TMVA::MethodCuts::MethodCuts( const TString& jobName,
                              const TString& methodTitle,
                              DataSetInfo& theData,
                              const TString& theOption,
                              TDirectory* theTargetDir ) :
   MethodBase( jobName, Types::kCuts, methodTitle, theData, theOption, theTargetDir ),
   fFitMethod  ( kUseGeneticAlgorithm ),
   fEffMethod  ( kUseEventSelection ),
   fFitParams (0),
   fTestSignalEff(0.7),
   fEffSMin    ( 0 ),
   fEffSMax    ( 0 ),
   fCutRangeMin( 0 ),
   fCutRangeMax( 0 ),
   fBinaryTreeS( 0 ),
   fBinaryTreeB( 0 ),
   fCutMin     ( 0 ),
   fCutMax     ( 0 ),
   fTmpCutMin  ( 0 ),
   fTmpCutMax  ( 0 ),
   fAllVarsI   ( 0 ),
   fNpar       ( 0 ),
   fEffRef     ( 0 ),
   fRangeSign  ( 0 ),
   fRandom     ( 0 ),
   fMeanS      ( 0 ),
   fMeanB      ( 0 ),
   fRmsS       ( 0 ),
   fRmsB       ( 0 ),
   fEffBvsSLocal( 0 ),
   fVarHistS   ( 0 ),
   fVarHistB   ( 0 ),
   fVarHistS_smooth( 0 ),
   fVarHistB_smooth( 0 ),
   fVarPdfS    ( 0 ),
   fVarPdfB    ( 0 ),
   fNegEffWarning( kFALSE )
{ 
   // standard constructor
}

//_______________________________________________________________________
TMVA::MethodCuts::MethodCuts( DataSetInfo& theData, 
                              const TString& theWeightFile,  
                              TDirectory* theTargetDir ) :
   MethodBase( Types::kCuts, theData, theWeightFile, theTargetDir ), 
   fFitMethod  ( kUseGeneticAlgorithm ),
   fEffMethod  ( kUseEventSelection ),
   fFitParams (0),
   fTestSignalEff(0.7),
   fEffSMin    ( 0 ),
   fEffSMax    ( 0 ),
   fCutRangeMin( 0 ),
   fCutRangeMax( 0 ),
   fBinaryTreeS( 0 ),
   fBinaryTreeB( 0 ),
   fCutMin     ( 0 ),
   fCutMax     ( 0 ),
   fTmpCutMin  ( 0 ),
   fTmpCutMax  ( 0 ),
   fAllVarsI   ( 0 ),
   fNpar       ( 0 ),
   fEffRef     ( 0 ),
   fRangeSign  ( 0 ),
   fRandom     ( 0 ),
   fMeanS      ( 0 ),
   fMeanB      ( 0 ),
   fRmsS       ( 0 ),
   fRmsB       ( 0 ),
   fEffBvsSLocal( 0 ),
   fVarHistS   ( 0 ),
   fVarHistB   ( 0 ),
   fVarHistS_smooth( 0 ),
   fVarHistB_smooth( 0 ),
   fVarPdfS    ( 0 ),
   fVarPdfB    ( 0 ),
   fNegEffWarning( kFALSE )
{
   // construction from weight file
}

//_______________________________________________________________________
Bool_t TMVA::MethodCuts::HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, 
                                          UInt_t /*numberTargets*/ )
{
   // Cuts can only handle classification with 2 classes
   return (type == Types::kClassification && numberClasses == 2);
}

//_______________________________________________________________________
void TMVA::MethodCuts::Init( void ) 
{
   // default initialisation called by all constructors
   fVarHistS          = fVarHistB = 0;                 
   fVarHistS_smooth   = fVarHistB_smooth = 0;
   fVarPdfS           = fVarPdfB = 0; 
   fFitParams         = 0;
   fBinaryTreeS       = fBinaryTreeB = 0;
   fEffSMin           = 0;
   fEffSMax           = 0; 

   // vector with fit results
   fNpar      = 2*GetNvar();
   fRangeSign = new std::vector<Int_t>   ( GetNvar() );
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) (*fRangeSign)[ivar] = +1;

   fMeanS     = new std::vector<Double_t>( GetNvar() ); 
   fMeanB     = new std::vector<Double_t>( GetNvar() ); 
   fRmsS      = new std::vector<Double_t>( GetNvar() );  
   fRmsB      = new std::vector<Double_t>( GetNvar() );  

   // get the variable specific options, first initialize default
   fFitParams = new std::vector<EFitParameters>( GetNvar() );
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) (*fFitParams)[ivar] = kNotEnforced;

   fFitMethod = kUseMonteCarlo;
   fTestSignalEff = -1;

   // create LUT for cuts
   fCutMin = new Double_t*[GetNvar()];
   fCutMax = new Double_t*[GetNvar()];
   for (UInt_t i=0; i<GetNvar(); i++) {
      fCutMin[i] = new Double_t[fNbins];
      fCutMax[i] = new Double_t[fNbins];
   }
  
   // init
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      for (Int_t ibin=0; ibin<fNbins; ibin++) {
         fCutMin[ivar][ibin] = 0;
         fCutMax[ivar][ibin] = 0;
      }
   }

   fTmpCutMin = new Double_t[GetNvar()];
   fTmpCutMax = new Double_t[GetNvar()];
}

//_______________________________________________________________________
TMVA::MethodCuts::~MethodCuts( void )
{
   // destructor
   delete fRangeSign;
   delete fMeanS;
   delete fMeanB;
   delete fRmsS;
   delete fRmsB;
   delete fFitParams;
   delete fEffBvsSLocal;

   if (NULL != fCutRangeMin) delete [] fCutRangeMin;
   if (NULL != fCutRangeMax) delete [] fCutRangeMax;
   if (NULL != fAllVarsI)    delete [] fAllVarsI;

   for (UInt_t i=0;i<GetNvar();i++) {
      if (NULL != fCutMin[i]  ) delete [] fCutMin[i];
      if (NULL != fCutMax[i]  ) delete [] fCutMax[i];
      if (NULL != fCutRange[i]) delete fCutRange[i];
   }

   if (NULL != fCutMin) delete [] fCutMin;
   if (NULL != fCutMax) delete [] fCutMax;

   if (NULL != fTmpCutMin) delete [] fTmpCutMin;
   if (NULL != fTmpCutMax) delete [] fTmpCutMax;

   if (NULL != fBinaryTreeS) delete fBinaryTreeS;
   if (NULL != fBinaryTreeB) delete fBinaryTreeB;
}

//_______________________________________________________________________
void TMVA::MethodCuts::DeclareOptions() 
{
   // define the options (their key words) that can be set in the option string 
   // know options:
   // Method             <string> Minimisation method
   //    available values are:        MC Monte Carlo <default>
   //                                 GA Genetic Algorithm
   //                                 SA Simulated annealing
   //
   // EffMethod          <string> Efficiency selection method
   //    available values are:        EffSel <default>
   //                                 EffPDF
   //
   // VarProp            <string> Property of variable 1 for the MC method (taking precedence over the
   //    globale setting. The same values as for the global option are available. Variables 1..10 can be
   //    set this way
   //
   // CutRangeMin/Max    <float>  user-defined ranges in which cuts are varied

   DeclareOptionRef(fFitMethodS = "GA", "FitMethod", "Minimisation Method (GA, SA, and MC are the primary methods to be used; the others have been introduced for testing purposes and are depreciated)");
   AddPreDefVal(TString("GA"));
   AddPreDefVal(TString("SA"));
   AddPreDefVal(TString("MC"));
   AddPreDefVal(TString("MCEvents"));
   AddPreDefVal(TString("MINUIT"));
   AddPreDefVal(TString("EventScan"));

   // selection type
   DeclareOptionRef(fEffMethodS = "EffSel", "EffMethod", "Selection Method");
   AddPreDefVal(TString("EffSel"));
   AddPreDefVal(TString("EffPDF"));

   // cut ranges 
   fCutRange.resize(GetNvar());
   fCutRangeMin = new Double_t[GetNvar()];
   fCutRangeMax = new Double_t[GetNvar()];
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fCutRange[ivar] = 0;
      fCutRangeMin[ivar] = fCutRangeMax[ivar] = -1;
   }

   DeclareOptionRef( fCutRangeMin, GetNvar(), "CutRangeMin", "Minimum of allowed cut range (set per variable)" );
   DeclareOptionRef( fCutRangeMax, GetNvar(), "CutRangeMax", "Maximum of allowed cut range (set per variable)" );   

   fAllVarsI = new TString[GetNvar()];

   for (UInt_t i=0; i<GetNvar(); i++) fAllVarsI[i] = "NotEnforced";  

   DeclareOptionRef(fAllVarsI, GetNvar(), "VarProp", "Categorisation of cuts");  
   AddPreDefVal(TString("NotEnforced"));
   AddPreDefVal(TString("FMax"));
   AddPreDefVal(TString("FMin"));
   AddPreDefVal(TString("FSmart"));
}

//_______________________________________________________________________
void TMVA::MethodCuts::ProcessOptions() 
{
   // process user options
   // sanity check, do not allow the input variables to be normalised, because this 
   // only creates problems when interpreting the cuts
   if (IsNormalised()) {
      Log() << kWARNING << "Normalisation of the input variables for cut optimisation is not" << Endl;
      Log() << kWARNING << "supported because this provides intransparent cut values, and no" << Endl;
      Log() << kWARNING << "improvement in the performance of the algorithm." << Endl;
      Log() << kWARNING << "Please remove \"Normalise\" option from booking option string" << Endl;
      Log() << kWARNING << "==> Will reset normalisation flag to \"False\"" << Endl;
      SetNormalised( kFALSE );
   }

   if (IgnoreEventsWithNegWeightsInTraining()) {
      Log() << kFATAL << "Mechanism to ignore events with negative weights in training not yet available for method: "
            << GetMethodTypeName() 
            << " --> Please remove \"IgnoreNegWeightsInTraining\" option from booking string."
            << Endl;
   }

   if      (fFitMethodS == "MC"      ) fFitMethod = kUseMonteCarlo;
   else if (fFitMethodS == "MCEvents") fFitMethod = kUseMonteCarloEvents;
   else if (fFitMethodS == "GA"      ) fFitMethod = kUseGeneticAlgorithm;
   else if (fFitMethodS == "SA"      ) fFitMethod = kUseSimulatedAnnealing;
   else if (fFitMethodS == "MINUIT"  ) {
      fFitMethod = kUseMinuit;
      Log() << kWARNING << "poor performance of MINUIT in MethodCuts; preferred fit method: GA" << Endl;
   }
   else if (fFitMethodS == "EventScan" ) fFitMethod = kUseEventScan;
   else Log() << kFATAL << "unknown minimisation method: " << fFitMethodS << Endl;

   if      (fEffMethodS == "EFFSEL" ) fEffMethod = kUseEventSelection; // highly recommended
   else if (fEffMethodS == "EFFPDF" ) fEffMethod = kUsePDFs;
   else                               fEffMethod = kUseEventSelection;

   // options output
   Log() << kINFO << Form("Use optimization method: \"%s\"", 
                            (fFitMethod == kUseMonteCarlo) ? "Monte Carlo" : 
                            (fFitMethod == kUseMonteCarlo) ? "Monte-Carlo-Event sampling" : 
                            (fFitMethod == kUseEventScan)  ? "Full Event Scan (slow)" :
                            (fFitMethod == kUseMinuit)     ? "MINUIT" : "Genetic Algorithm" ) << Endl;
   Log() << kINFO << Form("Use efficiency computation method: \"%s\"", 
                            (fEffMethod == kUseEventSelection) ? "Event Selection" : "PDF" ) << Endl;

   // cut ranges
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fCutRange[ivar] = new Interval( fCutRangeMin[ivar], fCutRangeMax[ivar] );
   }

   // individual options
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      EFitParameters theFitP = kNotEnforced;      
      if (fAllVarsI[ivar] == "" || fAllVarsI[ivar] == "NotEnforced") theFitP = kNotEnforced;
      else if (fAllVarsI[ivar] == "FMax" )                           theFitP = kForceMax;
      else if (fAllVarsI[ivar] == "FMin" )                           theFitP = kForceMin;
      else if (fAllVarsI[ivar] == "FSmart" )                         theFitP = kForceSmart;
      else {
         Log() << kFATAL << "unknown value \'" << fAllVarsI[ivar]
                 << "\' for fit parameter option " << Form("VarProp[%i]",ivar) << Endl;
      }
      (*fFitParams)[ivar] = theFitP;
      
      if (theFitP != kNotEnforced) 
         Log() << kINFO << "Use \"" << fAllVarsI[ivar] 
                 << "\" cuts for variable: " << "'" << (*fInputVars)[ivar] << "'" << Endl;
   }
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::GetMvaValue( Double_t* err, Double_t* errUpper )
{
   // cut evaluation: returns 1.0 if event passed, 0.0 otherwise

   // cannot determine error
   NoErrorCalc(err, errUpper);

   // sanity check
   if (fCutMin == NULL || fCutMax == NULL || fNbins == 0) {
      Log() << kFATAL << "<Eval_Cuts> fCutMin/Max have zero pointer. "
              << "Did you book Cuts ?" << Endl;
   }

   const Event* ev = GetEvent();

   // sanity check
   if (fTestSignalEff > 0) {
      // get efficiency bin
      Int_t ibin = fEffBvsSLocal->FindBin( fTestSignalEff );
      if (ibin < 0      ) ibin = 0;
      else if (ibin >= fNbins) ibin = fNbins - 1;

      Bool_t passed = kTRUE;
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++)
         passed &= ( (ev->GetValue(ivar) >  fCutMin[ivar][ibin]) &&
                     (ev->GetValue(ivar) <= fCutMax[ivar][ibin]) );

      return passed ? 1. : 0. ;
   }
   else return 0;
}

//_______________________________________________________________________
void TMVA::MethodCuts::PrintCuts( Double_t effS ) const
{
   // print cuts

   std::vector<Double_t> cutsMin;
   std::vector<Double_t> cutsMax;
   Int_t ibin = fEffBvsSLocal->FindBin( effS );

   Double_t trueEffS = GetCuts( effS, cutsMin, cutsMax );

   // retrieve variable expressions (could be transformations)
   std::vector<TString>* varVec = 0;
   if (GetTransformationHandler().GetNumOfTransformations() == 0) {
      // no transformation applied, replace by current variables
      varVec = new std::vector<TString>;
      for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
         varVec->push_back( DataInfo().GetVariableInfo(ivar).GetLabel() );
      }
   }
   else if (GetTransformationHandler().GetNumOfTransformations() == 1) {
      // get transformation string
      varVec = GetTransformationHandler().GetTransformationStringsOfLastTransform();
   }
   else {
      // replace transformation print by current variables and indicated incompleteness
      varVec = new std::vector<TString>;
      for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
         varVec->push_back( DataInfo().GetVariableInfo(ivar).GetLabel() + " [transformed]" );
      }
   }
   
   UInt_t maxL = 0;
   for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
      if ((UInt_t)(*varVec)[ivar].Length() > maxL) maxL = (*varVec)[ivar].Length();
   }
   UInt_t maxLine = 20+maxL+16;

   for (UInt_t i=0; i<maxLine; i++) Log() << "-";
   Log() << Endl;
   Log() << kINFO << "Cut values for requested signal efficiency: " << trueEffS << Endl;
   Log() << kINFO << "Corresponding background efficiency       : " << fEffBvsSLocal->GetBinContent( ibin ) << Endl;
   if (GetTransformationHandler().GetNumOfTransformations() == 1) {
      Log() << kINFO << "Transformation applied to input variables : \"" 
              << GetTransformationHandler().GetNameOfLastTransform() << "\"" << Endl;
   }
   else if (GetTransformationHandler().GetNumOfTransformations() > 1) {
      Log() << kINFO << "[ More than one (=" << GetTransformationHandler().GetNumOfTransformations() << ") "
              << " transformations applied in transformation chain; cuts applied on transformed quantities ] " << Endl;
   }
   else {
      Log() << kINFO << "Transformation applied to input variables : None"  << Endl;
   }
   for (UInt_t i=0; i<maxLine; i++) Log() << "-";
   Log() << Endl;
   for (UInt_t ivar=0; ivar<cutsMin.size(); ivar++) {
      Log() << kINFO 
              << "Cut[" << std::setw(2) << ivar << "]: " 
              << std::setw(10) << cutsMin[ivar] 
              << " < " 
              << std::setw(maxL) << (*varVec)[ivar]
              << " <= " 
              << std::setw(10) << cutsMax[ivar] << Endl;
   }
   for (UInt_t i=0; i<maxLine; i++) Log() << "-";
   Log() << Endl;

   delete varVec; // yes, ownership has been given to us 
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::GetCuts( Double_t effS, Double_t* cutMin, Double_t* cutMax ) const
{
   // retrieve cut values for given signal efficiency
   // assume vector of correct size !!

   std::vector<Double_t> cMin( GetNvar() );
   std::vector<Double_t> cMax( GetNvar() );
   Double_t trueEffS = GetCuts( effS, cMin, cMax );
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      cutMin[ivar] = cMin[ivar];
      cutMax[ivar] = cMax[ivar];
   }   
   return trueEffS;
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::GetCuts( Double_t effS, 
                                    std::vector<Double_t>& cutMin, 
                                    std::vector<Double_t>& cutMax ) const
{
   // retrieve cut values for given signal efficiency

   // find corresponding bin
   Int_t ibin = fEffBvsSLocal->FindBin( effS );

   // get the true efficiency which is the one on the "left hand" side of the bin
   Double_t trueEffS = fEffBvsSLocal->GetBinLowEdge( ibin );

   ibin--; // the 'cut' vector has 0...fNbins indices
   if      (ibin < 0      ) ibin = 0;
   else if (ibin >= fNbins) ibin = fNbins - 1;

   cutMin.clear();
   cutMax.clear();
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      cutMin.push_back( fCutMin[ivar][ibin]  );
      cutMax.push_back( fCutMax[ivar][ibin] );
   }   

   return trueEffS;
}

//_______________________________________________________________________
void  TMVA::MethodCuts::Train( void )
{
   // training method: here the cuts are optimised for the training sample
   
   if (fEffMethod == kUsePDFs) CreateVariablePDFs(); // create PDFs for variables

   // create binary trees (global member variables) for signal and background
   if (fBinaryTreeS != 0) { delete fBinaryTreeS; fBinaryTreeS = 0; }
   if (fBinaryTreeB != 0) { delete fBinaryTreeB; fBinaryTreeB = 0; }

   // the variables may be transformed by a transformation method: to coherently 
   // treat signal and background one must decide which transformation type shall 
   // be used: our default is signal-type
   
   fBinaryTreeS = new BinarySearchTree();
   fBinaryTreeS->Fill( GetEventCollection(Types::kTraining), fSignalClass );
   fBinaryTreeB = new BinarySearchTree();
   fBinaryTreeB->Fill( GetEventCollection(Types::kTraining), fBackgroundClass );

   for (UInt_t ivar =0; ivar < Data()->GetNVariables(); ivar++) {
      (*fMeanS)[ivar] = fBinaryTreeS->Mean(Types::kSignal, ivar);
      (*fRmsS)[ivar]  = fBinaryTreeS->RMS (Types::kSignal, ivar);
      (*fMeanB)[ivar] = fBinaryTreeB->Mean(Types::kBackground, ivar);
      (*fRmsB)[ivar]  = fBinaryTreeB->RMS (Types::kBackground, ivar);

      // update interval ?
      Double_t xmin = TMath::Min(fBinaryTreeS->Min(Types::kSignal,     ivar), 
                                 fBinaryTreeB->Min(Types::kBackground, ivar));
      Double_t xmax = TMath::Max(fBinaryTreeS->Max(Types::kSignal,     ivar), 
                                 fBinaryTreeB->Max(Types::kBackground, ivar));

      // redefine ranges to be slightly smaller and larger than xmin and xmax, respectively
      Double_t eps = 0.01*(xmax - xmin);
      xmin -= eps;
      xmax += eps;

      if (TMath::Abs(fCutRange[ivar]->GetMin() - fCutRange[ivar]->GetMax()) < 1.0e-300 ) {
         fCutRange[ivar]->SetMin( xmin );
         fCutRange[ivar]->SetMax( xmax );
      }         
      else if (xmin > fCutRange[ivar]->GetMin()) fCutRange[ivar]->SetMin( xmin );
      else if (xmax < fCutRange[ivar]->GetMax()) fCutRange[ivar]->SetMax( xmax );
   }   

   std::vector<TH1F*> signalDist, bkgDist;

   // this is important: reset the branch addresses of the training tree to the current event
   delete fEffBvsSLocal;
   fEffBvsSLocal = new TH1F( GetTestvarName() + "_effBvsSLocal", 
                             TString(GetName()) + " efficiency of B vs S", fNbins, 0.0, 1.0 );
   fEffBvsSLocal->SetDirectory(0); // it's local

   // init
   for (Int_t ibin=1; ibin<=fNbins; ibin++) fEffBvsSLocal->SetBinContent( ibin, -0.1 ); 

   // --------------------------------------------------------------------------
   if (fFitMethod == kUseGeneticAlgorithm || 
       fFitMethod == kUseMonteCarlo       || 
       fFitMethod == kUseMinuit           || 
       fFitMethod == kUseSimulatedAnnealing) {

      // ranges
      std::vector<Interval*> ranges;

      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {

         Int_t nbins = 0;
         if (DataInfo().GetVariableInfo(ivar).GetVarType() == 'I') {
            nbins = Int_t(fCutRange[ivar]->GetMax() - fCutRange[ivar]->GetMin()) + 1;
         }

         if ((*fFitParams)[ivar] == kForceSmart) {
            if ((*fMeanS)[ivar] > (*fMeanB)[ivar]) (*fFitParams)[ivar] = kForceMax;
            else                                   (*fFitParams)[ivar] = kForceMin;          
         }         

         if ((*fFitParams)[ivar] == kForceMin) {
            ranges.push_back( new Interval( fCutRange[ivar]->GetMin(), fCutRange[ivar]->GetMin(), nbins ) );
            ranges.push_back( new Interval( 0, fCutRange[ivar]->GetMax() - fCutRange[ivar]->GetMin(), nbins ) );
         }
         else if ((*fFitParams)[ivar] == kForceMax) {
            ranges.push_back( new Interval( fCutRange[ivar]->GetMin(), fCutRange[ivar]->GetMax(), nbins ) );
            ranges.push_back( new Interval( fCutRange[ivar]->GetMax() - fCutRange[ivar]->GetMin(), 
                                            fCutRange[ivar]->GetMax() - fCutRange[ivar]->GetMin(), nbins ) );
         }
         else {
            ranges.push_back( new Interval( fCutRange[ivar]->GetMin(), fCutRange[ivar]->GetMax(), nbins ) );
            ranges.push_back( new Interval( 0, fCutRange[ivar]->GetMax() - fCutRange[ivar]->GetMin(), nbins ) );
         }
      }

      // create the fitter
      FitterBase* fitter = NULL;
      
      switch (fFitMethod) {
      case kUseGeneticAlgorithm:
         fitter = new GeneticFitter( *this, Form("%sFitter_GA",     GetName()), ranges, GetOptions() );
         break;
      case kUseMonteCarlo:
         fitter = new MCFitter     ( *this, Form("%sFitter_MC",     GetName()), ranges, GetOptions() );
         break;
      case kUseMinuit:
         fitter = new MinuitFitter ( *this, Form("%sFitter_MINUIT", GetName()), ranges, GetOptions() );
         break;
      case kUseSimulatedAnnealing:
         fitter = new SimulatedAnnealingFitter( *this, Form("%sFitter_SA", GetName()), ranges, GetOptions() );
         break;
      default:
         Log() << kFATAL << "Wrong fit method: " << fFitMethod << Endl;
      }

      fitter->CheckForUnusedOptions();

      // perform the fit
      fitter->Run();      

      // clean up
      for (UInt_t ivar=0; ivar<ranges.size(); ivar++) delete ranges[ivar];
      delete fitter;
      
   }
   // --------------------------------------------------------------------------
   else if (fFitMethod == kUseEventScan) {

      Int_t nevents = Data()->GetNEvents();
      Int_t ic = 0;

      // timing of MC
      Int_t nsamples = Int_t(0.5*nevents*(nevents - 1));
      Timer timer( nsamples, GetName() ); 

      Log() << kINFO << "Running full event scan: " << Endl;
      for (Int_t ievt1=0; ievt1<nevents; ievt1++) {
         for (Int_t ievt2=ievt1+1; ievt2<nevents; ievt2++) {

            EstimatorFunction( ievt1, ievt2 );

            // what's the time please?
            ic++;
            if ((nsamples<10000) || ic%10000 == 0) timer.DrawProgressBar( ic );
         }
      }
   }
   // --------------------------------------------------------------------------
   else if (fFitMethod == kUseMonteCarloEvents) {

      Int_t  nsamples = 200000;
      UInt_t seed     = 100;
      DeclareOptionRef( nsamples, "SampleSize", "Number of Monte-Carlo-Event samples" );  
      DeclareOptionRef( seed,     "Seed",       "Seed for the random generator (0 takes random seeds)" );  
      ParseOptions();

      Int_t nevents = Data()->GetNEvents();
      Int_t ic = 0;

      // timing of MC
      Timer timer( nsamples, GetName() ); 

      // random generator
      TRandom3*rnd = new TRandom3( seed );

      Log() << kINFO << "Running Monte-Carlo-Event sampling over " << nsamples << " events" << Endl;
      std::vector<Double_t> pars( 2*GetNvar() );
      
      for (Int_t itoy=0; itoy<nsamples; itoy++) {

         for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
            
            // generate minimum and delta cuts for this variable

            // retrieve signal events
            Bool_t isSignal = kFALSE;
            Int_t    ievt1, ievt2;
            Double_t evt1, evt2;
            Int_t nbreak = 0;
            while (!isSignal) {
               ievt1 = Int_t(rnd->Uniform(0.,1.)*nevents);
               ievt2 = Int_t(rnd->Uniform(0.,1.)*nevents);

               const Event *ev1 = GetEvent(ievt1);
               isSignal = DataInfo().IsSignal(ev1);
               evt1 = ev1->GetValue( ivar );

               const Event *ev2 = GetEvent(ievt2);
               isSignal &= DataInfo().IsSignal(ev2);
               evt2 = ev2->GetValue( ivar );
               
               if (nbreak++ > 10000) Log() << kFATAL << "<MCEvents>: could not find signal events" 
                                             << " after 10000 trials - do you have signal events in your sample ?" 
                                             << Endl;
               isSignal = 1;
            }

            // sort
            if (evt1 > evt2) { Double_t z = evt1; evt1 = evt2; evt2 = z; }
            pars[2*ivar]   = evt1;
            pars[2*ivar+1] = evt2 - evt1;
         }

         // compute estimator
         EstimatorFunction( pars );
         
         // what's the time please?
         ic++;
         if ((nsamples<1000) || ic%1000 == 0) timer.DrawProgressBar( ic );
      }

      delete rnd;
   }
   // --------------------------------------------------------------------------
   else Log() << kFATAL << "Unknown minimisation method: " << fFitMethod << Endl;

   if (fBinaryTreeS != 0) { delete fBinaryTreeS; fBinaryTreeS = 0; }
   if (fBinaryTreeB != 0) { delete fBinaryTreeB; fBinaryTreeB = 0; }

   // force cut ranges within limits
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      for (Int_t ibin=0; ibin<fNbins; ibin++) {

         if ((*fFitParams)[ivar] == kForceMin && fCutMin[ivar][ibin] > -fgMaxAbsCutVal) {
            fCutMin[ivar][ibin] = -fgMaxAbsCutVal;
         }
         if ((*fFitParams)[ivar] == kForceMax && fCutMax[ivar][ibin] < fgMaxAbsCutVal) {
            fCutMax[ivar][ibin] = fgMaxAbsCutVal;
         }
      }
   }

   // some output
   // the efficiency which is asked for has to be slightly higher than the bin-borders.
   // if not, then the wrong bin is taken in some cases.
   Double_t epsilon = 0.0001;
   for (Double_t eff=0.1; eff<0.95; eff += 0.1) PrintCuts( eff+epsilon );
}

//_______________________________________________________________________
void TMVA::MethodCuts::TestClassification()
{
   // nothing to test
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::EstimatorFunction( Int_t ievt1, Int_t ievt2 )
{
   // for full event scan
   const Event *ev1 = GetEvent(ievt1);
   if (!DataInfo().IsSignal(ev1)) return -1;

   const Event *ev2 = GetEvent(ievt2);
   if (!DataInfo().IsSignal(ev2)) return -1;

   const Int_t nvar = GetNvar();
   Double_t* evt1 = new Double_t[nvar];
   Double_t* evt2 = new Double_t[nvar];

   for (Int_t ivar=0; ivar<nvar; ivar++) {
      evt1[ivar] = ev1->GetValue( ivar );
      evt2[ivar] = ev2->GetValue( ivar );
   }

   // determine cuts
   std::vector<Double_t> pars;
   for (Int_t ivar=0; ivar<nvar; ivar++) {
      Double_t cutMin;
      Double_t cutMax;
      if (evt1[ivar] < evt2[ivar]) {
         cutMin = evt1[ivar];
         cutMax = evt2[ivar];
      }
      else {
         cutMin = evt2[ivar];
         cutMax = evt1[ivar];
      }

      pars.push_back( cutMin );
      pars.push_back( cutMax - cutMin );
   }

   delete [] evt1;
   delete [] evt2;

   return ComputeEstimator( pars );
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::EstimatorFunction( std::vector<Double_t>& pars )
{
   // returns estimator for "cut fitness" used by GA
   return ComputeEstimator( pars );
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::ComputeEstimator( std::vector<Double_t>& pars )
{
   // returns estimator for "cut fitness" used by GA
   // there are two requirements:
   // 1) the signal efficiency must be equal to the required one in the 
   //    efficiency scan
   // 2) the background efficiency must be as small as possible
   // the requirement 1) has priority over 2)

   // caution: the npar gives the _free_ parameters
   // however: the "pars" array contains all parameters

   // determine cuts
   Double_t effS = 0, effB = 0;
   this->MatchParsToCuts( pars, &fTmpCutMin[0], &fTmpCutMax[0] );

   // retrieve signal and background efficiencies for given cut
   switch (fEffMethod) {
   case kUsePDFs:
      this->GetEffsfromPDFs      (&fTmpCutMin[0], &fTmpCutMax[0], effS, effB);
      break;
   case kUseEventSelection:
      this->GetEffsfromSelection (&fTmpCutMin[0], &fTmpCutMax[0], effS, effB);
      break;
   default:
      this->GetEffsfromSelection (&fTmpCutMin[0], &fTmpCutMax[0], effS, effB);
   }

   Double_t eta = 0;      
   
   // test for a estimator function which optimizes on the whole background-rejection signal-efficiency plot
   
   // get the backg-reject. and sig-eff for the parameters given to this function
   // effS, effB
      
   // get best background rejection for given signal efficiency
   Int_t ibinS = fEffBvsSLocal->FindBin( effS );      
      
   Double_t effBH       = fEffBvsSLocal->GetBinContent( ibinS );
   Double_t effBH_left  = (ibinS > 1     ) ? fEffBvsSLocal->GetBinContent( ibinS-1 ) : effBH;
   Double_t effBH_right = (ibinS < fNbins) ? fEffBvsSLocal->GetBinContent( ibinS+1 ) : effBH;

   Double_t average = 0.5*(effBH_left + effBH_right);
   if (effBH < effB) average = effBH;

   // if the average of the bin right and left is larger than this one, add the difference to 
   // the current value of the estimator (because you can do at least so much better)
   eta = ( -TMath::Abs(effBH-average) + (1.0 - (effBH - effB))) / (1.0 + effS); 
   // alternative idea
   //if (effBH<0) eta = (1.e-6+effB)/(1.0 + effS);
   //else eta =  (effB - effBH) * (1.0 + 10.* effS);

   // if a point is found which is better than an existing one, ... replace it. 
   // preliminary best event -> backup
   if (effBH < 0 || effBH > effB) {
      fEffBvsSLocal->SetBinContent( ibinS, effB );
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
         fCutMin[ivar][ibinS-1] = fTmpCutMin[ivar]; // bin 1 stored in index 0
         fCutMax[ivar][ibinS-1] = fTmpCutMax[ivar];
      }
   }
   
   // caution (!) this value is not good for a decision for MC, .. it is designed for GA
   // but .. it doesn't matter, as MC samplings are independent from the former ones
   // and the replacement of the best variables by better ones is done about 10 lines above. 
   // ( if (effBH < 0 || effBH > effB) { .... )

   if (ibinS<=1) {
      // add penalty for effS=0 bin 
      // to avoid that the minimizer gets stuck in the zero-bin
      // force it towards higher efficiency
      Double_t penalty=0.,diff=0.;
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
         diff=(fCutRange[ivar]->GetMax()-fTmpCutMax[ivar])/(fCutRange[ivar]->GetMax()-fCutRange[ivar]->GetMin());
         penalty+=diff*diff;
         diff=(fCutRange[ivar]->GetMin()-fTmpCutMin[ivar])/(fCutRange[ivar]->GetMax()-fCutRange[ivar]->GetMin());
         penalty+=4.*diff*diff;
      }

      if (effS<1.e-4) return 10.0+penalty;
      else return 10.*(1.-10.*effS);
   }
   return eta;
}

//_______________________________________________________________________
void TMVA::MethodCuts::MatchParsToCuts( const std::vector<Double_t> & pars, 
                                        Double_t* cutMin, Double_t* cutMax )
{
   // translates parameters into cuts
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      Int_t ipar = 2*ivar;
      cutMin[ivar] = ((*fRangeSign)[ivar] > 0) ? pars[ipar] : pars[ipar] - pars[ipar+1];
      cutMax[ivar] = ((*fRangeSign)[ivar] > 0) ? pars[ipar] + pars[ipar+1] : pars[ipar]; 
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::MatchCutsToPars( std::vector<Double_t>& pars, 
                                        Double_t** cutMinAll, Double_t** cutMaxAll, Int_t ibin )
{
   // translate the cuts into parameters (obsolete function)
   if (ibin < 1 || ibin > fNbins) Log() << kFATAL << "::MatchCutsToPars: bin error: "
                                          << ibin << Endl;
   
   const UInt_t nvar = GetNvar();
   Double_t *cutMin = new Double_t[nvar];
   Double_t *cutMax = new Double_t[nvar];
   for (UInt_t ivar=0; ivar<nvar; ivar++) {
      cutMin[ivar] = cutMinAll[ivar][ibin-1];
      cutMax[ivar] = cutMaxAll[ivar][ibin-1];
   }
   
   MatchCutsToPars( pars, cutMin, cutMax );
   delete [] cutMin;
   delete [] cutMax;
}

//_______________________________________________________________________
void TMVA::MethodCuts::MatchCutsToPars( std::vector<Double_t>& pars, 
                                        Double_t* cutMin, Double_t* cutMax )
{
   // translates cuts into parameters
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      Int_t ipar = 2*ivar;
      pars[ipar]   = ((*fRangeSign)[ivar] > 0) ? cutMin[ivar] : cutMax[ivar];
      pars[ipar+1] = cutMax[ivar] - cutMin[ivar];
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::GetEffsfromPDFs( Double_t* cutMin, Double_t* cutMax,
                                        Double_t& effS, Double_t& effB )
{
   // compute signal and background efficiencies from PDFs 
   // for given cut sample
   effS = 1.0;
   effB = 1.0;
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      effS *= (*fVarPdfS)[ivar]->GetIntegral( cutMin[ivar], cutMax[ivar] );
      effB *= (*fVarPdfB)[ivar]->GetIntegral( cutMin[ivar], cutMax[ivar] );
   }

   // quick fix to prevent from efficiencies < 0
   if( effS < 0.0 ) {
      effS = 0.0;
      if( !fNegEffWarning ) Log() << kWARNING << "Negative signal efficiency found and set to 0. This is probably due to many events with negative weights in a certain cut-region." << Endl;
      fNegEffWarning = kTRUE;
   }
   if( effB < 0.0 ) {
      effB = 0.0;
      if( !fNegEffWarning ) Log() << kWARNING << "Negative background efficiency found and set to 0. This is probably due to many events with negative weights in a certain cut-region." << Endl;
      fNegEffWarning = kTRUE;
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::GetEffsfromSelection( Double_t* cutMin, Double_t* cutMax,
                                             Double_t& effS, Double_t& effB)
{
   // compute signal and background efficiencies from event counting 
   // for given cut sample
   Float_t nTotS = 0, nTotB = 0;
   Float_t nSelS = 0, nSelB = 0;  
   
   Volume* volume = new Volume( cutMin, cutMax, GetNvar() );
  
   // search for all events lying in the volume, and add up their weights
   nSelS = fBinaryTreeS->SearchVolume( volume );
   nSelB = fBinaryTreeB->SearchVolume( volume );

   delete volume;

   // total number of "events" (sum of weights) as reference to compute efficiency
   nTotS = fBinaryTreeS->GetSumOfWeights();
   nTotB = fBinaryTreeB->GetSumOfWeights();
   
   // sanity check
   if (nTotS == 0 && nTotB == 0) {
      Log() << kFATAL << "<GetEffsfromSelection> fatal error in zero total number of events:"
              << " nTotS, nTotB: " << nTotS << " " << nTotB << " ***" << Endl;
   }

   // efficiencies
   if (nTotS == 0 ) {
      effS = 0;
      effB = nSelB/nTotB;
      Log() << kWARNING << "<ComputeEstimator> zero number of signal events" << Endl;
   }
   else if (nTotB == 0) {
      effB = 0;
      effS = nSelS/nTotS;
      Log() << kWARNING << "<ComputeEstimator> zero number of background events" << Endl;
   }
   else {
      effS = nSelS/nTotS;
      effB = nSelB/nTotB;
   }  

   // quick fix to prevent from efficiencies < 0
   if( effS < 0.0 ) {
      effS = 0.0;
      if( !fNegEffWarning ) Log() << kWARNING << "Negative signal efficiency found and set to 0. This is probably due to many events with negative weights in a certain cut-region." << Endl;
      fNegEffWarning = kTRUE;
   }
   if( effB < 0.0 ) {
      effB = 0.0;
      if( !fNegEffWarning ) Log() << kWARNING << "Negative background efficiency found and set to 0. This is probably due to many events with negative weights in a certain cut-region." << Endl;
      fNegEffWarning = kTRUE;
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::CreateVariablePDFs( void )
{
   // for PDF method: create efficiency reference histograms and PDFs

   // create list of histograms and PDFs
   fVarHistS        = new std::vector<TH1*>( GetNvar() );
   fVarHistB        = new std::vector<TH1*>( GetNvar() );
   fVarHistS_smooth = new std::vector<TH1*>( GetNvar() );
   fVarHistB_smooth = new std::vector<TH1*>( GetNvar() );
   fVarPdfS         = new std::vector<PDF*>( GetNvar() );
   fVarPdfB         = new std::vector<PDF*>( GetNvar() );

   Int_t nsmooth = 0;

   // get min and max values of all events
   Double_t minVal = DBL_MAX;
   Double_t maxVal = -DBL_MAX;
   for( UInt_t ievt=0; ievt<Data()->GetNEvents(); ievt++ ){
      const Event *ev = GetEvent(ievt);
      Float_t val = ev->GetValue(ievt);
      if( val > minVal ) minVal = val;
      if( val < maxVal ) maxVal = val;
   }

   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) { 

      // ---- signal
      TString histTitle = (*fInputVars)[ivar] + " signal training";
      TString histName  = (*fInputVars)[ivar] + "_sig";
      //      TString drawOpt   = (*fInputVars)[ivar] + ">>h(";
      //      drawOpt += fNbins;
      //      drawOpt += ")";

      // selection
      //      Data().GetTrainingTree()->Draw( drawOpt, "type==1", "goff" );
      //      (*fVarHistS)[ivar] = (TH1F*)gDirectory->Get("h");
      //      (*fVarHistS)[ivar]->SetName(histName);
      //      (*fVarHistS)[ivar]->SetTitle(histTitle);

      (*fVarHistS)[ivar] = new TH1F(histName.Data(), histTitle.Data(), fNbins, minVal, maxVal );

      // ---- background
      histTitle = (*fInputVars)[ivar] + " background training";
      histName  = (*fInputVars)[ivar] + "_bgd";
      //      drawOpt   = (*fInputVars)[ivar] + ">>h(";
      //      drawOpt += fNbins;
      //      drawOpt += ")";

      //      Data().GetTrainingTree()->Draw( drawOpt, "type==0", "goff" );
      //      (*fVarHistB)[ivar] = (TH1F*)gDirectory->Get("h");
      //      (*fVarHistB)[ivar]->SetName(histName);
      //      (*fVarHistB)[ivar]->SetTitle(histTitle);


      (*fVarHistB)[ivar] = new TH1F(histName.Data(), histTitle.Data(), fNbins, minVal, maxVal );
      
      for( UInt_t ievt=0; ievt<Data()->GetNEvents(); ievt++ ){
         const Event *ev = GetEvent(ievt);
         Float_t val = ev->GetValue(ievt);
         if( DataInfo().IsSignal(ev) ){
            (*fVarHistS)[ivar]->Fill( val );
         }else{
            (*fVarHistB)[ivar]->Fill( val );
         }
      }



      // make copy for smoothed histos
      (*fVarHistS_smooth)[ivar] = (TH1F*)(*fVarHistS)[ivar]->Clone();
      histTitle =  (*fInputVars)[ivar] + " signal training  smoothed ";
      histTitle += nsmooth;
      histTitle +=" times";
      histName =  (*fInputVars)[ivar] + "_sig_smooth";
      (*fVarHistS_smooth)[ivar]->SetName(histName);
      (*fVarHistS_smooth)[ivar]->SetTitle(histTitle);

      // smooth
      (*fVarHistS_smooth)[ivar]->Smooth(nsmooth);

      // ---- background
      //      histTitle = (*fInputVars)[ivar] + " background training";
      //      histName  = (*fInputVars)[ivar] + "_bgd";
      //      drawOpt   = (*fInputVars)[ivar] + ">>h(";
      //      drawOpt += fNbins;
      //      drawOpt += ")";

      //      Data().GetTrainingTree()->Draw( drawOpt, "type==0", "goff" );
      //      (*fVarHistB)[ivar] = (TH1F*)gDirectory->Get("h");
      //      (*fVarHistB)[ivar]->SetName(histName);
      //      (*fVarHistB)[ivar]->SetTitle(histTitle);

      // make copy for smoothed histos
      (*fVarHistB_smooth)[ivar] = (TH1F*)(*fVarHistB)[ivar]->Clone();
      histTitle  = (*fInputVars)[ivar]+" background training  smoothed ";
      histTitle += nsmooth;
      histTitle +=" times";
      histName   = (*fInputVars)[ivar]+"_bgd_smooth";
      (*fVarHistB_smooth)[ivar]->SetName(histName);
      (*fVarHistB_smooth)[ivar]->SetTitle(histTitle);

      // smooth
      (*fVarHistB_smooth)[ivar]->Smooth(nsmooth);

      // create PDFs
      (*fVarPdfS)[ivar] = new PDF( TString(GetName()) + " PDF Var Sig " + GetInputVar( ivar ), (*fVarHistS_smooth)[ivar], PDF::kSpline2 );
      (*fVarPdfB)[ivar] = new PDF( TString(GetName()) + " PDF Var Bkg " + GetInputVar( ivar ), (*fVarHistB_smooth)[ivar], PDF::kSpline2 );
   }
}

//_______________________________________________________________________
void  TMVA::MethodCuts::ReadWeightsFromStream( std::istream& istr )
{
   // read the cuts from stream
   TString dummy;
   UInt_t  dummyInt;

   // first the dimensions
   istr >> dummy >> dummy;
   // coverity[tainted_data_argument]
   istr >> dummy >> fNbins;

   // get rid of one read-in here because we read in once all ready to check for decorrelation
   istr >> dummy >> dummy >> dummy >> dummy >> dummy >> dummy >> dummyInt >> dummy ;

   // sanity check
   if (dummyInt != Data()->GetNVariables()) {
      Log() << kFATAL << "<ReadWeightsFromStream> fatal error: mismatch "
              << "in number of variables: " << dummyInt << " != " << Data()->GetNVariables() << Endl;
   }
   //SetNvar(dummyInt);

   // print some information
   if (fFitMethod == kUseMonteCarlo) {
      Log() << kINFO << "Read cuts optimised using sample of MC events" << Endl;
   }
   else if (fFitMethod == kUseMonteCarloEvents) {
      Log() << kINFO << "Read cuts optimised using sample of MC events" << Endl;
   }
   else if (fFitMethod == kUseGeneticAlgorithm) {
      Log() << kINFO << "Read cuts optimised using Genetic Algorithm" << Endl;
   }
   else if (fFitMethod == kUseSimulatedAnnealing) {
      Log() << kINFO << "Read cuts optimised using Simulated Annealing algorithm" << Endl;
   }
   else if (fFitMethod == kUseEventScan) {
      Log() << kINFO << "Read cuts optimised using Full Event Scan" << Endl;
   }
   else {
      Log() << kWARNING << "unknown method: " << fFitMethod << Endl;
   }
   Log() << kINFO << "in " << fNbins << " signal efficiency bins and for " << GetNvar() << " variables" << Endl;
   
   // now read the cuts
   char buffer[200];
   istr.getline(buffer,200);
   istr.getline(buffer,200);

   Int_t   tmpbin;
   Float_t tmpeffS, tmpeffB;
   if (fEffBvsSLocal != 0) delete fEffBvsSLocal;
   fEffBvsSLocal = new TH1F( GetTestvarName() + "_effBvsSLocal", 
                             TString(GetName()) + " efficiency of B vs S", fNbins, 0.0, 1.0 );
   fEffBvsSLocal->SetDirectory(0); // it's local

   for (Int_t ibin=0; ibin<fNbins; ibin++) {
      istr >> tmpbin >> tmpeffS >> tmpeffB;
      fEffBvsSLocal->SetBinContent( ibin+1, tmpeffB );

      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
         istr >> fCutMin[ivar][ibin] >> fCutMax[ivar][ibin];
      }
   }

   fEffSMin = fEffBvsSLocal->GetBinCenter(1);
   fEffSMax = fEffBvsSLocal->GetBinCenter(fNbins);
}

//_______________________________________________________________________
void TMVA::MethodCuts::AddWeightsXMLTo( void* parent ) const 
{
   // create XML description for LD classification and regression 
   // (for arbitrary number of output classes/targets)

   // write all necessary information to the stream
   std::vector<Double_t> cutsMin;
   std::vector<Double_t> cutsMax;

   void* wght = gTools().AddChild(parent, "Weights");
   gTools().AddAttr( wght, "OptimisationMethod", (Int_t)fEffMethod);
   gTools().AddAttr( wght, "FitMethod",          (Int_t)fFitMethod );
   gTools().AddAttr( wght, "nbins",              fNbins );
   gTools().AddComment( wght, Form( "Below are the optimised cuts for %i variables: Format: ibin(hist) effS effB cutMin[ivar=0] cutMax[ivar=0] ... cutMin[ivar=n-1] cutMax[ivar=n-1]", GetNvar() ) );

   // NOTE: The signal efficiency written out into 
   //       the weight file does not correspond to the center of the bin within which the 
   //       background rejection is maximised (as before) but to the lower left edge of it. 
   //       This is because the cut optimisation algorithm determines the best background 
   //       rejection for all signal efficiencies belonging into a bin. Since the best background 
   //       rejection is in general obtained for the lowest possible signal efficiency, the 
   //       reference signal efficeincy is the lowest value in the bin.

   for (Int_t ibin=0; ibin<fNbins; ibin++) {
      Double_t effS     = fEffBvsSLocal->GetBinCenter ( ibin + 1 );
      Double_t trueEffS = GetCuts( effS, cutsMin, cutsMax );
      if (TMath::Abs(trueEffS) < 1e-10) trueEffS = 0;
      
      void* binxml = gTools().AddChild( wght, "Bin" );
      gTools().AddAttr( binxml, "ibin", ibin+1   );
      gTools().AddAttr( binxml, "effS", trueEffS );
      gTools().AddAttr( binxml, "effB", fEffBvsSLocal->GetBinContent( ibin + 1 ) );
      void* cutsxml = gTools().AddChild( binxml, "Cuts" );
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
         gTools().AddAttr( cutsxml, Form( "cutMin_%i", ivar ), cutsMin[ivar] );
         gTools().AddAttr( cutsxml, Form( "cutMax_%i", ivar ), cutsMax[ivar] );
      }      
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::ReadWeightsFromXML( void* wghtnode ) 
{
   // read coefficients from xml weight file

   // delete old min and max
   for (UInt_t i=0; i<GetNvar(); i++) {
      if (fCutMin[i] != 0) delete [] fCutMin[i];
      if (fCutMax[i] != 0) delete [] fCutMax[i];
   }
   if (fCutMin != 0) delete [] fCutMin;
   if (fCutMax != 0) delete [] fCutMax;

   Int_t tmpEffMethod, tmpFitMethod;
   gTools().ReadAttr( wghtnode, "OptimisationMethod", tmpEffMethod );
   gTools().ReadAttr( wghtnode, "FitMethod",          tmpFitMethod );
   gTools().ReadAttr( wghtnode, "nbins",              fNbins       );
   
   fEffMethod = (EEffMethod)tmpEffMethod;
   fFitMethod = (EFitMethodType)tmpFitMethod;

   // print some information
   if (fFitMethod == kUseMonteCarlo) {
      Log() << kINFO << "Read cuts optimised using sample of MC events" << Endl;
   }
   else if (fFitMethod == kUseMonteCarloEvents) {
      Log() << kINFO << "Read cuts optimised using sample of MC-Event events" << Endl;
   }
   else if (fFitMethod == kUseGeneticAlgorithm) {
      Log() << kINFO << "Read cuts optimised using Genetic Algorithm" << Endl;
   }
   else if (fFitMethod == kUseSimulatedAnnealing) {
      Log() << kINFO << "Read cuts optimised using Simulated Annealing algorithm" << Endl;
   }
   else if (fFitMethod == kUseEventScan) {
      Log() << kINFO << "Read cuts optimised using Full Event Scan" << Endl;
   }
   else {
      Log() << kWARNING << "unknown method: " << fFitMethod << Endl;
   }
   Log() << kINFO << "Reading " << fNbins << " signal efficiency bins for " << GetNvar() << " variables" << Endl;

   delete fEffBvsSLocal;
   fEffBvsSLocal = new TH1F( GetTestvarName() + "_effBvsSLocal", 
                             TString(GetName()) + " efficiency of B vs S", fNbins, 0.0, 1.0 );
   fEffBvsSLocal->SetDirectory(0); // it's local
   for (Int_t ibin=1; ibin<=fNbins; ibin++) fEffBvsSLocal->SetBinContent( ibin, -0.1 ); // Init

   fCutMin = new Double_t*[GetNvar()];
   fCutMax = new Double_t*[GetNvar()];
   for (UInt_t i=0;i<GetNvar();i++) {
      fCutMin[i] = new Double_t[fNbins];
      fCutMax[i] = new Double_t[fNbins];
   }

   // read efficeincies and cuts
   Int_t   tmpbin;
   Float_t tmpeffS, tmpeffB;
   void* ch = gTools().GetChild(wghtnode,"Bin");
   while (ch) {
//       if (strcmp(gTools().GetName(ch),"Bin") !=0) {
//          ch = gTools().GetNextChild(ch);
//          continue;
//       }

      gTools().ReadAttr( ch, "ibin", tmpbin  );
      gTools().ReadAttr( ch, "effS", tmpeffS );
      gTools().ReadAttr( ch, "effB", tmpeffB );

      // sanity check
      if (tmpbin-1 >= fNbins || tmpbin-1 < 0) {
         Log() << kFATAL << "Mismatch in bins: " << tmpbin-1 << " >= " << fNbins << Endl;
      }

      fEffBvsSLocal->SetBinContent( tmpbin, tmpeffB );
      void* ct = gTools().GetChild(ch);
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
         gTools().ReadAttr( ct, Form( "cutMin_%i", ivar ), fCutMin[ivar][tmpbin-1] );
         gTools().ReadAttr( ct, Form( "cutMax_%i", ivar ), fCutMax[ivar][tmpbin-1] );
      }
      ch = gTools().GetNextChild(ch, "Bin");
   }
}

//_______________________________________________________________________
void TMVA::MethodCuts::WriteMonitoringHistosToFile( void ) const
{
   // write histograms and PDFs to file for monitoring purposes

   Log() << kINFO << "Write monitoring histograms to file: " << BaseDir()->GetPath() << Endl;
  
   fEffBvsSLocal->Write();

   // save reference histograms to file
   if (fEffMethod == kUsePDFs) {
      for (UInt_t ivar=0; ivar<GetNvar(); ivar++) { 
         (*fVarHistS)[ivar]->Write();    
         (*fVarHistB)[ivar]->Write();
         (*fVarHistS_smooth)[ivar]->Write();    
         (*fVarHistB_smooth)[ivar]->Write();
         (*fVarPdfS)[ivar]->GetPDFHist()->Write();
         (*fVarPdfB)[ivar]->GetPDFHist()->Write();
      }
   }  
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::GetTrainingEfficiency(const TString& theString)
{
   // - overloaded function to create background efficiency (rejection) versus
   //   signal efficiency plot (first call of this function)
   // - the function returns the signal efficiency at background efficiency
   //   indicated in theString
   //
   // "theString" must have two entries:
   // [0]: "Efficiency"
   // [1]: the value of background efficiency at which the signal efficiency 
   //      is to be returned

   // parse input string for required background efficiency
   TList* list  = gTools().ParseFormatLine( theString );
   // sanity check
   if (list->GetSize() != 2) {
      Log() << kFATAL << "<GetTrainingEfficiency> wrong number of arguments"
              << " in string: " << theString
              << " | required format, e.g., Efficiency:0.05" << Endl;
      return -1;
   }

   Results* results = Data()->GetResults(GetMethodName(), Types::kTesting, GetAnalysisType());
   
   // that will be the value of the efficiency retured (does not affect
   // the efficiency-vs-bkg plot which is done anyway.
   Float_t effBref  = atof( ((TObjString*)list->At(1))->GetString() );

   delete list;

   // first round ? --> create histograms
   if (results->GetHist("EFF_BVSS_TR")==0) {

      if (fBinaryTreeS != 0) { delete fBinaryTreeS; fBinaryTreeS = 0; }
      if (fBinaryTreeB != 0) { delete fBinaryTreeB; fBinaryTreeB = 0; }

      fBinaryTreeS = new BinarySearchTree();
      fBinaryTreeS->Fill( GetEventCollection(Types::kTraining), fSignalClass );
      fBinaryTreeB = new BinarySearchTree();
      fBinaryTreeB->Fill( GetEventCollection(Types::kTraining), fBackgroundClass );
      // there is no really good equivalent to the fEffS; fEffB (efficiency vs cutvalue)
      // for the "Cuts" method (unless we had only one cut). Maybe later I might add here
      // histograms for each of the cuts...but this would require also a change in the 
      // base class, and it is not really necessary, as we get exactly THIS info from the
      // "evaluateAllVariables" anyway.

      // now create efficiency curve: background versus signal
      TH1* eff_bvss_tr = new TH1F( GetTestvarName() + "_trainingEffBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      for (Int_t ibin=1; ibin<=fNbins; ibin++) eff_bvss_tr->SetBinContent( ibin, -0.1 ); // Init
      TH1* rej_bvss_tr = new TH1F( GetTestvarName() + "_trainingRejBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      for (Int_t ibin=1; ibin<=fNbins; ibin++) rej_bvss_tr->SetBinContent( ibin, 0. ); // Init
      results->Store(eff_bvss_tr, "EFF_BVSS_TR");
      results->Store(rej_bvss_tr, "REJ_BVSS_TR");

      // use root finder

      // make the background-vs-signal efficiency plot
      Double_t* tmpCutMin = new Double_t[GetNvar()];
      Double_t* tmpCutMax = new Double_t[GetNvar()];
      Int_t nFailedBins=0;
      for (Int_t bini=1; bini<=fNbins; bini++) {
         for (UInt_t ivar=0; ivar <GetNvar(); ivar++){
            tmpCutMin[ivar] = fCutMin[ivar][bini-1];
            tmpCutMax[ivar] = fCutMax[ivar][bini-1];
         }
         // find cut value corresponding to a given signal efficiency
         Double_t effS, effB;
         this->GetEffsfromSelection( &tmpCutMin[0], &tmpCutMax[0], effS, effB);    
         // check that effS matches bini
         Int_t effBin = eff_bvss_tr->GetXaxis()->FindBin(effS);
         if (effBin != bini){
            Log()<< kVERBOSE << "unable to fill efficiency bin " << bini<< " " << effBin <<Endl; 
            nFailedBins++;
         }
         else{
            // and fill histograms
            eff_bvss_tr->SetBinContent( bini, effB     );    
            rej_bvss_tr->SetBinContent( bini, 1.0-effB ); 
         }
      }
      if (nFailedBins>0) Log()<< kWARNING << " unable to fill "<< nFailedBins <<" efficiency bins " <<Endl;  

      delete [] tmpCutMin;
      delete [] tmpCutMax;

      // create splines for histogram
      fSplTrainEffBvsS = new TSpline1( "trainEffBvsS", new TGraph( eff_bvss_tr ) );
   }

   // must exist...
   if (NULL == fSplTrainEffBvsS) return 0.0;

   // now find signal efficiency that corresponds to required background efficiency
   Double_t effS, effB, effS_ = 0, effB_ = 0;
   Int_t    nbins_ = 1000;

   // loop over efficiency bins until the background eff. matches the requirement
   for (Int_t bini=1; bini<=nbins_; bini++) {
      // get corresponding signal and background efficiencies
      effS = (bini - 0.5)/Float_t(nbins_);
      effB = fSplTrainEffBvsS->Eval( effS );

      // find signal efficiency that corresponds to required background efficiency
      if ((effB - effBref)*(effB_ - effBref) < 0) break;
      effS_ = effS;
      effB_ = effB;  
   }

   return 0.5*(effS + effS_);
}

//_______________________________________________________________________
Double_t TMVA::MethodCuts::GetEfficiency( const TString& theString, Types::ETreeType type, Double_t& effSerr )
{
   // - overloaded function to create background efficiency (rejection) versus
   //   signal efficiency plot (first call of this function)
   // - the function returns the signal efficiency at background efficiency
   //   indicated in theString
   //
   // "theString" must have two entries:
   // [0]: "Efficiency"
   // [1]: the value of background efficiency at which the signal efficiency 
   //      is to be returned

   Data()->SetCurrentType(type);

   Results* results = Data()->GetResults( GetMethodName(), Types::kTesting, GetAnalysisType() );

   // parse input string for required background efficiency
   TList* list  = gTools().ParseFormatLine( theString, ":" );

   if (list->GetSize() > 2) {
      delete list;
      Log() << kFATAL << "<GetEfficiency> wrong number of arguments"
              << " in string: " << theString
              << " | required format, e.g., Efficiency:0.05, or empty string" << Endl;
      return -1;
   }
   
   // sanity check
   Bool_t computeArea = (list->GetSize() < 2); // the area is computed 

   // that will be the value of the efficiency retured (does not affect
   // the efficiency-vs-bkg plot which is done anyway.
   Float_t effBref = (computeArea?1.:atof( ((TObjString*)list->At(1))->GetString() ));

   delete list;


   // first round ? --> create histograms
   if (results->GetHist("MVA_EFF_BvsS")==0) {

      if (fBinaryTreeS!=0) { delete fBinaryTreeS; fBinaryTreeS = 0; }
      if (fBinaryTreeB!=0) { delete fBinaryTreeB; fBinaryTreeB = 0; }

      // the variables may be transformed by a transformation method: to coherently 
      // treat signal and background one must decide which transformation type shall 
      // be used: our default is signal-type
      fBinaryTreeS = new BinarySearchTree();
      fBinaryTreeS->Fill( GetEventCollection(Types::kTesting), fSignalClass );
      fBinaryTreeB = new BinarySearchTree();
      fBinaryTreeB->Fill( GetEventCollection(Types::kTesting), fBackgroundClass );

      // there is no really good equivalent to the fEffS; fEffB (efficiency vs cutvalue)
      // for the "Cuts" method (unless we had only one cut). Maybe later I might add here
      // histograms for each of the cuts...but this would require also a change in the 
      // base class, and it is not really necessary, as we get exactly THIS info from the
      // "evaluateAllVariables" anyway.

      // now create efficiency curve: background versus signal
      TH1* eff_BvsS = new TH1F( GetTestvarName() + "_effBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      for (Int_t ibin=1; ibin<=fNbins; ibin++) eff_BvsS->SetBinContent( ibin, -0.1 ); // Init
      TH1* rej_BvsS = new TH1F( GetTestvarName() + "_rejBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      for (Int_t ibin=1; ibin<=fNbins; ibin++) rej_BvsS->SetBinContent( ibin, 0.0 ); // Init
      results->Store(eff_BvsS, "MVA_EFF_BvsS");
      results->Store(rej_BvsS);

      Double_t xmin = 0.;
      Double_t xmax = 1.000001;
      
      TH1* eff_s = new TH1F( GetTestvarName() + "_effS", GetTestvarName() + " (signal)",     fNbins, xmin, xmax);
      for (Int_t ibin=1; ibin<=fNbins; ibin++) eff_s->SetBinContent( ibin, -0.1 ); // Init
      TH1* eff_b = new TH1F( GetTestvarName() + "_effB", GetTestvarName() + " (background)", fNbins, xmin, xmax);
      for (Int_t ibin=1; ibin<=fNbins; ibin++) eff_b->SetBinContent( ibin, -0.1 ); // Init
      results->Store(eff_s, "MVA_S");
      results->Store(eff_b, "MVA_B");

      // use root finder

      // make the background-vs-signal efficiency plot
      Double_t* tmpCutMin = new Double_t[GetNvar()];
      Double_t* tmpCutMax = new Double_t[GetNvar()];
      TGraph* tmpBvsS = new TGraph(fNbins+1);      
      tmpBvsS->SetPoint(0, 0., 0.);

      for (Int_t bini=1; bini<=fNbins; bini++) {
         for (UInt_t ivar=0; ivar <GetNvar(); ivar++) {
            tmpCutMin[ivar] = fCutMin[ivar][bini-1];
            tmpCutMax[ivar] = fCutMax[ivar][bini-1];
         }
         // find cut value corresponding to a given signal efficiency
         Double_t effS, effB;
         this->GetEffsfromSelection( &tmpCutMin[0], &tmpCutMax[0], effS, effB);             
         tmpBvsS->SetPoint(bini, effS, effB);

         eff_s->SetBinContent(bini, effS);
         eff_b->SetBinContent(bini, effB);
      }
      tmpBvsS->SetPoint(fNbins+1, 1., 1.);

      delete [] tmpCutMin;
      delete [] tmpCutMax;

      // create splines for histogram
      fSpleffBvsS = new TSpline1( "effBvsS", tmpBvsS );
      for (Int_t bini=1; bini<=fNbins; bini++) {
         Double_t effS = (bini - 0.5)/Float_t(fNbins);
         Double_t effB = fSpleffBvsS->Eval( effS );
         eff_BvsS->SetBinContent( bini, effB     );    
         rej_BvsS->SetBinContent( bini, 1.0-effB ); 
      }
   }

   // must exist...
   if (NULL == fSpleffBvsS) return 0.0;

   // now find signal efficiency that corresponds to required background efficiency
   Double_t effS = 0, effB = 0, effS_ = 0, effB_ = 0;
   Int_t    nbins_ = 1000;

   if (computeArea) {

      // compute area of rej-vs-eff plot
      Double_t integral = 0;
      for (Int_t bini=1; bini<=nbins_; bini++) {
         
         // get corresponding signal and background efficiencies
         effS = (bini - 0.5)/Float_t(nbins_);
         effB = fSpleffBvsS->Eval( effS );
         integral += (1.0 - effB);
      }   
      integral /= nbins_;      
      
      return integral;
   }
   else {

      // loop over efficiency bins until the background eff. matches the requirement
      for (Int_t bini=1; bini<=nbins_; bini++) {
         // get corresponding signal and background efficiencies
         effS = (bini - 0.5)/Float_t(nbins_);
         effB = fSpleffBvsS->Eval( effS );
         
         // find signal efficiency that corresponds to required background efficiency
         if ((effB - effBref)*(effB_ - effBref) < 0) break;
         effS_ = effS;
         effB_ = effB;  
      }

      effS    = 0.5*(effS + effS_);
      effSerr = 0;
      if (Data()->GetNEvtSigTest() > 0) 
         effSerr = TMath::Sqrt( effS*(1.0 - effS)/Double_t(Data()->GetNEvtSigTest()) );
   
      return effS;

   }

   return -1;
}
 
//_______________________________________________________________________
void TMVA::MethodCuts::MakeClassSpecific( std::ostream& fout, const TString& className ) const
{
   // write specific classifier response
   fout << "   // not implemented for class: \"" << className << "\"" << std::endl;
   fout << "};" << std::endl;
}

//_______________________________________________________________________
void TMVA::MethodCuts::GetHelpMessage() const
{
   // get help message text
   //
   // typical length of text line: 
   //         "|--------------------------------------------------------------|"
   TString bold    = gConfig().WriteOptionsReference() ? "<b>" : "";
   TString resbold = gConfig().WriteOptionsReference() ? "</b>" : "";
   TString brk     = gConfig().WriteOptionsReference() ? "<br>" : "";

   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Short description:" << gTools().Color("reset") << Endl;
   Log() << Endl;
   Log() << "The optimisation of rectangular cuts performed by TMVA maximises " << Endl;
   Log() << "the background rejection at given signal efficiency, and scans " << Endl;
   Log() << "over the full range of the latter quantity. Three optimisation" << Endl;
   Log() << "methods are optional: Monte Carlo sampling (MC), a Genetics" << Endl;
   Log() << "Algorithm (GA), and Simulated Annealing (SA). GA and SA are"  << Endl;
   Log() << "expected to perform best." << Endl;
   Log() << Endl;
   Log() << "The difficulty to find the optimal cuts strongly increases with" << Endl;
   Log() << "the dimensionality (number of input variables) of the problem." << Endl;
   Log() << "This behavior is due to the non-uniqueness of the solution space."<<  Endl;
   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Performance optimisation:" << gTools().Color("reset") << Endl;
   Log() << Endl;
   Log() << "If the dimensionality exceeds, say, 4 input variables, it is " << Endl;
   Log() << "advisable to scrutinize the separation power of the variables," << Endl;
   Log() << "and to remove the weakest ones. If some among the input variables" << Endl;
   Log() << "can be described by a single cut (e.g., because signal tends to be" << Endl;
   Log() << "larger than background), this can be indicated to MethodCuts via" << Endl;
   Log() << "the \"Fsmart\" options (see option string). Choosing this option" << Endl;
   Log() << "reduces the number of requirements for the variable from 2 (min/max)" << Endl;
   Log() << "to a single one (TMVA finds out whether it is to be interpreted as" << Endl;
   Log() << "min or max)." << Endl;
   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Performance tuning via configuration options:" << gTools().Color("reset") << Endl;
   Log() << "" << Endl;
   Log() << bold << "Monte Carlo sampling:" << resbold << Endl;
   Log() << "" << Endl;
   Log() << "Apart form the \"Fsmart\" option for the variables, the only way" << Endl;
   Log() << "to improve the MC sampling is to increase the sampling rate. This" << Endl;
   Log() << "is done via the configuration option \"MC_NRandCuts\". The execution" << Endl;
   Log() << "time scales linearly with the sampling rate." << Endl;
   Log() << "" << Endl;
   Log() << bold << "Genetic Algorithm:" << resbold << Endl;
   Log() << "" << Endl;
   Log() << "The algorithm terminates if no significant fitness increase has" << Endl;
   Log() << "been achieved within the last \"nsteps\" steps of the calculation." << Endl;
   Log() << "Wiggles in the ROC curve or constant background rejection of 1" << Endl;
   Log() << "indicate that the GA failed to always converge at the true maximum" << Endl;
   Log() << "fitness. In such a case, it is recommended to broaden the search " << Endl;
   Log() << "by increasing the population size (\"popSize\") and to give the GA " << Endl;
   Log() << "more time to find improvements by increasing the number of steps" << Endl;
   Log() << "(\"nsteps\")" << Endl;
   Log() << "  -> increase \"popSize\" (at least >10 * number of variables)" << Endl;
   Log() << "  -> increase \"nsteps\"" << Endl;
   Log() << "" << Endl;
   Log() << bold << "Simulated Annealing (SA) algorithm:" << resbold << Endl;
   Log() << "" << Endl;
   Log() << "\"Increasing Adaptive\" approach:" << Endl;
   Log() << "" << Endl;
   Log() << "The algorithm seeks local minima and explores their neighborhood, while" << Endl;
   Log() << "changing the ambient temperature depending on the number of failures" << Endl;
   Log() << "in the previous steps. The performance can be improved by increasing" << Endl;
   Log() << "the number of iteration steps (\"MaxCalls\"), or by adjusting the" << Endl;
   Log() << "minimal temperature (\"MinTemperature\"). Manual adjustments of the" << Endl;
   Log() << "speed of the temperature increase (\"TemperatureScale\" and \"AdaptiveSpeed\")" << Endl;
   Log() << "to individual data sets should also help. Summary:" << brk << Endl;
   Log() << "  -> increase \"MaxCalls\"" << brk << Endl;
   Log() << "  -> adjust   \"MinTemperature\"" << brk << Endl;
   Log() << "  -> adjust   \"TemperatureScale\"" << brk << Endl;
   Log() << "  -> adjust   \"AdaptiveSpeed\"" << Endl;
   Log() << "" << Endl;   
   Log() << "\"Decreasing Adaptive\" approach:" << Endl;
   Log() << "" << Endl;
   Log() << "The algorithm calculates the initial temperature (based on the effect-" << Endl;
   Log() << "iveness of large steps) and the multiplier that ensures to reach the" << Endl;
   Log() << "minimal temperature with the requested number of iteration steps." << Endl;
   Log() << "The performance can be improved by adjusting the minimal temperature" << Endl;
   Log() << " (\"MinTemperature\") and by increasing number of steps (\"MaxCalls\"):" << brk << Endl;
   Log() << "  -> increase \"MaxCalls\"" << brk << Endl;
   Log() << "  -> adjust   \"MinTemperature\"" << Endl;
   Log() << " " << Endl;
   Log() << "Other kernels:" << Endl;
   Log() << "" << Endl;
   Log() << "Alternative ways of counting the temperature change are implemented. " << Endl;
   Log() << "Each of them starts with the maximum temperature (\"MaxTemperature\")" << Endl;
   Log() << "and descreases while changing the temperature according to a given" << Endl;
   Log() << "prescription:" << brk << Endl;
   Log() << "CurrentTemperature =" << brk << Endl;
   Log() << "  - Sqrt: InitialTemperature / Sqrt(StepNumber+2) * TemperatureScale" << brk << Endl;
   Log() << "  - Log:  InitialTemperature / Log(StepNumber+2) * TemperatureScale" << brk << Endl;
   Log() << "  - Homo: InitialTemperature / (StepNumber+2) * TemperatureScale" << brk << Endl;
   Log() << "  - Sin:  (Sin(StepNumber / TemperatureScale) + 1) / (StepNumber + 1)*InitialTemperature + Eps" << brk << Endl;
   Log() << "  - Geo:  CurrentTemperature * TemperatureScale" << Endl;
   Log() << "" << Endl;
   Log() << "Their performance can be improved by adjusting initial temperature" << Endl;
   Log() << "(\"InitialTemperature\"), the number of iteration steps (\"MaxCalls\")," << Endl;
   Log() << "and the multiplier that scales the termperature descrease" << Endl;
   Log() << "(\"TemperatureScale\")" << brk << Endl;
   Log() << "  -> increase \"MaxCalls\"" << brk << Endl;
   Log() << "  -> adjust   \"InitialTemperature\"" << brk << Endl;
   Log() << "  -> adjust   \"TemperatureScale\"" << brk << Endl;
   Log() << "  -> adjust   \"KernelTemperature\"" << Endl;
}
 MethodCuts.cxx:1
 MethodCuts.cxx:2
 MethodCuts.cxx:3
 MethodCuts.cxx:4
 MethodCuts.cxx:5
 MethodCuts.cxx:6
 MethodCuts.cxx:7
 MethodCuts.cxx:8
 MethodCuts.cxx:9
 MethodCuts.cxx:10
 MethodCuts.cxx:11
 MethodCuts.cxx:12
 MethodCuts.cxx:13
 MethodCuts.cxx:14
 MethodCuts.cxx:15
 MethodCuts.cxx:16
 MethodCuts.cxx:17
 MethodCuts.cxx:18
 MethodCuts.cxx:19
 MethodCuts.cxx:20
 MethodCuts.cxx:21
 MethodCuts.cxx:22
 MethodCuts.cxx:23
 MethodCuts.cxx:24
 MethodCuts.cxx:25
 MethodCuts.cxx:26
 MethodCuts.cxx:27
 MethodCuts.cxx:28
 MethodCuts.cxx:29
 MethodCuts.cxx:30
 MethodCuts.cxx:31
 MethodCuts.cxx:32
 MethodCuts.cxx:33
 MethodCuts.cxx:34
 MethodCuts.cxx:35
 MethodCuts.cxx:36
 MethodCuts.cxx:37
 MethodCuts.cxx:38
 MethodCuts.cxx:39
 MethodCuts.cxx:40
 MethodCuts.cxx:41
 MethodCuts.cxx:42
 MethodCuts.cxx:43
 MethodCuts.cxx:44
 MethodCuts.cxx:45
 MethodCuts.cxx:46
 MethodCuts.cxx:47
 MethodCuts.cxx:48
 MethodCuts.cxx:49
 MethodCuts.cxx:50
 MethodCuts.cxx:51
 MethodCuts.cxx:52
 MethodCuts.cxx:53
 MethodCuts.cxx:54
 MethodCuts.cxx:55
 MethodCuts.cxx:56
 MethodCuts.cxx:57
 MethodCuts.cxx:58
 MethodCuts.cxx:59
 MethodCuts.cxx:60
 MethodCuts.cxx:61
 MethodCuts.cxx:62
 MethodCuts.cxx:63
 MethodCuts.cxx:64
 MethodCuts.cxx:65
 MethodCuts.cxx:66
 MethodCuts.cxx:67
 MethodCuts.cxx:68
 MethodCuts.cxx:69
 MethodCuts.cxx:70
 MethodCuts.cxx:71
 MethodCuts.cxx:72
 MethodCuts.cxx:73
 MethodCuts.cxx:74
 MethodCuts.cxx:75
 MethodCuts.cxx:76
 MethodCuts.cxx:77
 MethodCuts.cxx:78
 MethodCuts.cxx:79
 MethodCuts.cxx:80
 MethodCuts.cxx:81
 MethodCuts.cxx:82
 MethodCuts.cxx:83
 MethodCuts.cxx:84
 MethodCuts.cxx:85
 MethodCuts.cxx:86
 MethodCuts.cxx:87
 MethodCuts.cxx:88
 MethodCuts.cxx:89
 MethodCuts.cxx:90
 MethodCuts.cxx:91
 MethodCuts.cxx:92
 MethodCuts.cxx:93
 MethodCuts.cxx:94
 MethodCuts.cxx:95
 MethodCuts.cxx:96
 MethodCuts.cxx:97
 MethodCuts.cxx:98
 MethodCuts.cxx:99
 MethodCuts.cxx:100
 MethodCuts.cxx:101
 MethodCuts.cxx:102
 MethodCuts.cxx:103
 MethodCuts.cxx:104
 MethodCuts.cxx:105
 MethodCuts.cxx:106
 MethodCuts.cxx:107
 MethodCuts.cxx:108
 MethodCuts.cxx:109
 MethodCuts.cxx:110
 MethodCuts.cxx:111
 MethodCuts.cxx:112
 MethodCuts.cxx:113
 MethodCuts.cxx:114
 MethodCuts.cxx:115
 MethodCuts.cxx:116
 MethodCuts.cxx:117
 MethodCuts.cxx:118
 MethodCuts.cxx:119
 MethodCuts.cxx:120
 MethodCuts.cxx:121
 MethodCuts.cxx:122
 MethodCuts.cxx:123
 MethodCuts.cxx:124
 MethodCuts.cxx:125
 MethodCuts.cxx:126
 MethodCuts.cxx:127
 MethodCuts.cxx:128
 MethodCuts.cxx:129
 MethodCuts.cxx:130
 MethodCuts.cxx:131
 MethodCuts.cxx:132
 MethodCuts.cxx:133
 MethodCuts.cxx:134
 MethodCuts.cxx:135
 MethodCuts.cxx:136
 MethodCuts.cxx:137
 MethodCuts.cxx:138
 MethodCuts.cxx:139
 MethodCuts.cxx:140
 MethodCuts.cxx:141
 MethodCuts.cxx:142
 MethodCuts.cxx:143
 MethodCuts.cxx:144
 MethodCuts.cxx:145
 MethodCuts.cxx:146
 MethodCuts.cxx:147
 MethodCuts.cxx:148
 MethodCuts.cxx:149
 MethodCuts.cxx:150
 MethodCuts.cxx:151
 MethodCuts.cxx:152
 MethodCuts.cxx:153
 MethodCuts.cxx:154
 MethodCuts.cxx:155
 MethodCuts.cxx:156
 MethodCuts.cxx:157
 MethodCuts.cxx:158
 MethodCuts.cxx:159
 MethodCuts.cxx:160
 MethodCuts.cxx:161
 MethodCuts.cxx:162
 MethodCuts.cxx:163
 MethodCuts.cxx:164
 MethodCuts.cxx:165
 MethodCuts.cxx:166
 MethodCuts.cxx:167
 MethodCuts.cxx:168
 MethodCuts.cxx:169
 MethodCuts.cxx:170
 MethodCuts.cxx:171
 MethodCuts.cxx:172
 MethodCuts.cxx:173
 MethodCuts.cxx:174
 MethodCuts.cxx:175
 MethodCuts.cxx:176
 MethodCuts.cxx:177
 MethodCuts.cxx:178
 MethodCuts.cxx:179
 MethodCuts.cxx:180
 MethodCuts.cxx:181
 MethodCuts.cxx:182
 MethodCuts.cxx:183
 MethodCuts.cxx:184
 MethodCuts.cxx:185
 MethodCuts.cxx:186
 MethodCuts.cxx:187
 MethodCuts.cxx:188
 MethodCuts.cxx:189
 MethodCuts.cxx:190
 MethodCuts.cxx:191
 MethodCuts.cxx:192
 MethodCuts.cxx:193
 MethodCuts.cxx:194
 MethodCuts.cxx:195
 MethodCuts.cxx:196
 MethodCuts.cxx:197
 MethodCuts.cxx:198
 MethodCuts.cxx:199
 MethodCuts.cxx:200
 MethodCuts.cxx:201
 MethodCuts.cxx:202
 MethodCuts.cxx:203
 MethodCuts.cxx:204
 MethodCuts.cxx:205
 MethodCuts.cxx:206
 MethodCuts.cxx:207
 MethodCuts.cxx:208
 MethodCuts.cxx:209
 MethodCuts.cxx:210
 MethodCuts.cxx:211
 MethodCuts.cxx:212
 MethodCuts.cxx:213
 MethodCuts.cxx:214
 MethodCuts.cxx:215
 MethodCuts.cxx:216
 MethodCuts.cxx:217
 MethodCuts.cxx:218
 MethodCuts.cxx:219
 MethodCuts.cxx:220
 MethodCuts.cxx:221
 MethodCuts.cxx:222
 MethodCuts.cxx:223
 MethodCuts.cxx:224
 MethodCuts.cxx:225
 MethodCuts.cxx:226
 MethodCuts.cxx:227
 MethodCuts.cxx:228
 MethodCuts.cxx:229
 MethodCuts.cxx:230
 MethodCuts.cxx:231
 MethodCuts.cxx:232
 MethodCuts.cxx:233
 MethodCuts.cxx:234
 MethodCuts.cxx:235
 MethodCuts.cxx:236
 MethodCuts.cxx:237
 MethodCuts.cxx:238
 MethodCuts.cxx:239
 MethodCuts.cxx:240
 MethodCuts.cxx:241
 MethodCuts.cxx:242
 MethodCuts.cxx:243
 MethodCuts.cxx:244
 MethodCuts.cxx:245
 MethodCuts.cxx:246
 MethodCuts.cxx:247
 MethodCuts.cxx:248
 MethodCuts.cxx:249
 MethodCuts.cxx:250
 MethodCuts.cxx:251
 MethodCuts.cxx:252
 MethodCuts.cxx:253
 MethodCuts.cxx:254
 MethodCuts.cxx:255
 MethodCuts.cxx:256
 MethodCuts.cxx:257
 MethodCuts.cxx:258
 MethodCuts.cxx:259
 MethodCuts.cxx:260
 MethodCuts.cxx:261
 MethodCuts.cxx:262
 MethodCuts.cxx:263
 MethodCuts.cxx:264
 MethodCuts.cxx:265
 MethodCuts.cxx:266
 MethodCuts.cxx:267
 MethodCuts.cxx:268
 MethodCuts.cxx:269
 MethodCuts.cxx:270
 MethodCuts.cxx:271
 MethodCuts.cxx:272
 MethodCuts.cxx:273
 MethodCuts.cxx:274
 MethodCuts.cxx:275
 MethodCuts.cxx:276
 MethodCuts.cxx:277
 MethodCuts.cxx:278
 MethodCuts.cxx:279
 MethodCuts.cxx:280
 MethodCuts.cxx:281
 MethodCuts.cxx:282
 MethodCuts.cxx:283
 MethodCuts.cxx:284
 MethodCuts.cxx:285
 MethodCuts.cxx:286
 MethodCuts.cxx:287
 MethodCuts.cxx:288
 MethodCuts.cxx:289
 MethodCuts.cxx:290
 MethodCuts.cxx:291
 MethodCuts.cxx:292
 MethodCuts.cxx:293
 MethodCuts.cxx:294
 MethodCuts.cxx:295
 MethodCuts.cxx:296
 MethodCuts.cxx:297
 MethodCuts.cxx:298
 MethodCuts.cxx:299
 MethodCuts.cxx:300
 MethodCuts.cxx:301
 MethodCuts.cxx:302
 MethodCuts.cxx:303
 MethodCuts.cxx:304
 MethodCuts.cxx:305
 MethodCuts.cxx:306
 MethodCuts.cxx:307
 MethodCuts.cxx:308
 MethodCuts.cxx:309
 MethodCuts.cxx:310
 MethodCuts.cxx:311
 MethodCuts.cxx:312
 MethodCuts.cxx:313
 MethodCuts.cxx:314
 MethodCuts.cxx:315
 MethodCuts.cxx:316
 MethodCuts.cxx:317
 MethodCuts.cxx:318
 MethodCuts.cxx:319
 MethodCuts.cxx:320
 MethodCuts.cxx:321
 MethodCuts.cxx:322
 MethodCuts.cxx:323
 MethodCuts.cxx:324
 MethodCuts.cxx:325
 MethodCuts.cxx:326
 MethodCuts.cxx:327
 MethodCuts.cxx:328
 MethodCuts.cxx:329
 MethodCuts.cxx:330
 MethodCuts.cxx:331
 MethodCuts.cxx:332
 MethodCuts.cxx:333
 MethodCuts.cxx:334
 MethodCuts.cxx:335
 MethodCuts.cxx:336
 MethodCuts.cxx:337
 MethodCuts.cxx:338
 MethodCuts.cxx:339
 MethodCuts.cxx:340
 MethodCuts.cxx:341
 MethodCuts.cxx:342
 MethodCuts.cxx:343
 MethodCuts.cxx:344
 MethodCuts.cxx:345
 MethodCuts.cxx:346
 MethodCuts.cxx:347
 MethodCuts.cxx:348
 MethodCuts.cxx:349
 MethodCuts.cxx:350
 MethodCuts.cxx:351
 MethodCuts.cxx:352
 MethodCuts.cxx:353
 MethodCuts.cxx:354
 MethodCuts.cxx:355
 MethodCuts.cxx:356
 MethodCuts.cxx:357
 MethodCuts.cxx:358
 MethodCuts.cxx:359
 MethodCuts.cxx:360
 MethodCuts.cxx:361
 MethodCuts.cxx:362
 MethodCuts.cxx:363
 MethodCuts.cxx:364
 MethodCuts.cxx:365
 MethodCuts.cxx:366
 MethodCuts.cxx:367
 MethodCuts.cxx:368
 MethodCuts.cxx:369
 MethodCuts.cxx:370
 MethodCuts.cxx:371
 MethodCuts.cxx:372
 MethodCuts.cxx:373
 MethodCuts.cxx:374
 MethodCuts.cxx:375
 MethodCuts.cxx:376
 MethodCuts.cxx:377
 MethodCuts.cxx:378
 MethodCuts.cxx:379
 MethodCuts.cxx:380
 MethodCuts.cxx:381
 MethodCuts.cxx:382
 MethodCuts.cxx:383
 MethodCuts.cxx:384
 MethodCuts.cxx:385
 MethodCuts.cxx:386
 MethodCuts.cxx:387
 MethodCuts.cxx:388
 MethodCuts.cxx:389
 MethodCuts.cxx:390
 MethodCuts.cxx:391
 MethodCuts.cxx:392
 MethodCuts.cxx:393
 MethodCuts.cxx:394
 MethodCuts.cxx:395
 MethodCuts.cxx:396
 MethodCuts.cxx:397
 MethodCuts.cxx:398
 MethodCuts.cxx:399
 MethodCuts.cxx:400
 MethodCuts.cxx:401
 MethodCuts.cxx:402
 MethodCuts.cxx:403
 MethodCuts.cxx:404
 MethodCuts.cxx:405
 MethodCuts.cxx:406
 MethodCuts.cxx:407
 MethodCuts.cxx:408
 MethodCuts.cxx:409
 MethodCuts.cxx:410
 MethodCuts.cxx:411
 MethodCuts.cxx:412
 MethodCuts.cxx:413
 MethodCuts.cxx:414
 MethodCuts.cxx:415
 MethodCuts.cxx:416
 MethodCuts.cxx:417
 MethodCuts.cxx:418
 MethodCuts.cxx:419
 MethodCuts.cxx:420
 MethodCuts.cxx:421
 MethodCuts.cxx:422
 MethodCuts.cxx:423
 MethodCuts.cxx:424
 MethodCuts.cxx:425
 MethodCuts.cxx:426
 MethodCuts.cxx:427
 MethodCuts.cxx:428
 MethodCuts.cxx:429
 MethodCuts.cxx:430
 MethodCuts.cxx:431
 MethodCuts.cxx:432
 MethodCuts.cxx:433
 MethodCuts.cxx:434
 MethodCuts.cxx:435
 MethodCuts.cxx:436
 MethodCuts.cxx:437
 MethodCuts.cxx:438
 MethodCuts.cxx:439
 MethodCuts.cxx:440
 MethodCuts.cxx:441
 MethodCuts.cxx:442
 MethodCuts.cxx:443
 MethodCuts.cxx:444
 MethodCuts.cxx:445
 MethodCuts.cxx:446
 MethodCuts.cxx:447
 MethodCuts.cxx:448
 MethodCuts.cxx:449
 MethodCuts.cxx:450
 MethodCuts.cxx:451
 MethodCuts.cxx:452
 MethodCuts.cxx:453
 MethodCuts.cxx:454
 MethodCuts.cxx:455
 MethodCuts.cxx:456
 MethodCuts.cxx:457
 MethodCuts.cxx:458
 MethodCuts.cxx:459
 MethodCuts.cxx:460
 MethodCuts.cxx:461
 MethodCuts.cxx:462
 MethodCuts.cxx:463
 MethodCuts.cxx:464
 MethodCuts.cxx:465
 MethodCuts.cxx:466
 MethodCuts.cxx:467
 MethodCuts.cxx:468
 MethodCuts.cxx:469
 MethodCuts.cxx:470
 MethodCuts.cxx:471
 MethodCuts.cxx:472
 MethodCuts.cxx:473
 MethodCuts.cxx:474
 MethodCuts.cxx:475
 MethodCuts.cxx:476
 MethodCuts.cxx:477
 MethodCuts.cxx:478
 MethodCuts.cxx:479
 MethodCuts.cxx:480
 MethodCuts.cxx:481
 MethodCuts.cxx:482
 MethodCuts.cxx:483
 MethodCuts.cxx:484
 MethodCuts.cxx:485
 MethodCuts.cxx:486
 MethodCuts.cxx:487
 MethodCuts.cxx:488
 MethodCuts.cxx:489
 MethodCuts.cxx:490
 MethodCuts.cxx:491
 MethodCuts.cxx:492
 MethodCuts.cxx:493
 MethodCuts.cxx:494
 MethodCuts.cxx:495
 MethodCuts.cxx:496
 MethodCuts.cxx:497
 MethodCuts.cxx:498
 MethodCuts.cxx:499
 MethodCuts.cxx:500
 MethodCuts.cxx:501
 MethodCuts.cxx:502
 MethodCuts.cxx:503
 MethodCuts.cxx:504
 MethodCuts.cxx:505
 MethodCuts.cxx:506
 MethodCuts.cxx:507
 MethodCuts.cxx:508
 MethodCuts.cxx:509
 MethodCuts.cxx:510
 MethodCuts.cxx:511
 MethodCuts.cxx:512
 MethodCuts.cxx:513
 MethodCuts.cxx:514
 MethodCuts.cxx:515
 MethodCuts.cxx:516
 MethodCuts.cxx:517
 MethodCuts.cxx:518
 MethodCuts.cxx:519
 MethodCuts.cxx:520
 MethodCuts.cxx:521
 MethodCuts.cxx:522
 MethodCuts.cxx:523
 MethodCuts.cxx:524
 MethodCuts.cxx:525
 MethodCuts.cxx:526
 MethodCuts.cxx:527
 MethodCuts.cxx:528
 MethodCuts.cxx:529
 MethodCuts.cxx:530
 MethodCuts.cxx:531
 MethodCuts.cxx:532
 MethodCuts.cxx:533
 MethodCuts.cxx:534
 MethodCuts.cxx:535
 MethodCuts.cxx:536
 MethodCuts.cxx:537
 MethodCuts.cxx:538
 MethodCuts.cxx:539
 MethodCuts.cxx:540
 MethodCuts.cxx:541
 MethodCuts.cxx:542
 MethodCuts.cxx:543
 MethodCuts.cxx:544
 MethodCuts.cxx:545
 MethodCuts.cxx:546
 MethodCuts.cxx:547
 MethodCuts.cxx:548
 MethodCuts.cxx:549
 MethodCuts.cxx:550
 MethodCuts.cxx:551
 MethodCuts.cxx:552
 MethodCuts.cxx:553
 MethodCuts.cxx:554
 MethodCuts.cxx:555
 MethodCuts.cxx:556
 MethodCuts.cxx:557
 MethodCuts.cxx:558
 MethodCuts.cxx:559
 MethodCuts.cxx:560
 MethodCuts.cxx:561
 MethodCuts.cxx:562
 MethodCuts.cxx:563
 MethodCuts.cxx:564
 MethodCuts.cxx:565
 MethodCuts.cxx:566
 MethodCuts.cxx:567
 MethodCuts.cxx:568
 MethodCuts.cxx:569
 MethodCuts.cxx:570
 MethodCuts.cxx:571
 MethodCuts.cxx:572
 MethodCuts.cxx:573
 MethodCuts.cxx:574
 MethodCuts.cxx:575
 MethodCuts.cxx:576
 MethodCuts.cxx:577
 MethodCuts.cxx:578
 MethodCuts.cxx:579
 MethodCuts.cxx:580
 MethodCuts.cxx:581
 MethodCuts.cxx:582
 MethodCuts.cxx:583
 MethodCuts.cxx:584
 MethodCuts.cxx:585
 MethodCuts.cxx:586
 MethodCuts.cxx:587
 MethodCuts.cxx:588
 MethodCuts.cxx:589
 MethodCuts.cxx:590
 MethodCuts.cxx:591
 MethodCuts.cxx:592
 MethodCuts.cxx:593
 MethodCuts.cxx:594
 MethodCuts.cxx:595
 MethodCuts.cxx:596
 MethodCuts.cxx:597
 MethodCuts.cxx:598
 MethodCuts.cxx:599
 MethodCuts.cxx:600
 MethodCuts.cxx:601
 MethodCuts.cxx:602
 MethodCuts.cxx:603
 MethodCuts.cxx:604
 MethodCuts.cxx:605
 MethodCuts.cxx:606
 MethodCuts.cxx:607
 MethodCuts.cxx:608
 MethodCuts.cxx:609
 MethodCuts.cxx:610
 MethodCuts.cxx:611
 MethodCuts.cxx:612
 MethodCuts.cxx:613
 MethodCuts.cxx:614
 MethodCuts.cxx:615
 MethodCuts.cxx:616
 MethodCuts.cxx:617
 MethodCuts.cxx:618
 MethodCuts.cxx:619
 MethodCuts.cxx:620
 MethodCuts.cxx:621
 MethodCuts.cxx:622
 MethodCuts.cxx:623
 MethodCuts.cxx:624
 MethodCuts.cxx:625
 MethodCuts.cxx:626
 MethodCuts.cxx:627
 MethodCuts.cxx:628
 MethodCuts.cxx:629
 MethodCuts.cxx:630
 MethodCuts.cxx:631
 MethodCuts.cxx:632
 MethodCuts.cxx:633
 MethodCuts.cxx:634
 MethodCuts.cxx:635
 MethodCuts.cxx:636
 MethodCuts.cxx:637
 MethodCuts.cxx:638
 MethodCuts.cxx:639
 MethodCuts.cxx:640
 MethodCuts.cxx:641
 MethodCuts.cxx:642
 MethodCuts.cxx:643
 MethodCuts.cxx:644
 MethodCuts.cxx:645
 MethodCuts.cxx:646
 MethodCuts.cxx:647
 MethodCuts.cxx:648
 MethodCuts.cxx:649
 MethodCuts.cxx:650
 MethodCuts.cxx:651
 MethodCuts.cxx:652
 MethodCuts.cxx:653
 MethodCuts.cxx:654
 MethodCuts.cxx:655
 MethodCuts.cxx:656
 MethodCuts.cxx:657
 MethodCuts.cxx:658
 MethodCuts.cxx:659
 MethodCuts.cxx:660
 MethodCuts.cxx:661
 MethodCuts.cxx:662
 MethodCuts.cxx:663
 MethodCuts.cxx:664
 MethodCuts.cxx:665
 MethodCuts.cxx:666
 MethodCuts.cxx:667
 MethodCuts.cxx:668
 MethodCuts.cxx:669
 MethodCuts.cxx:670
 MethodCuts.cxx:671
 MethodCuts.cxx:672
 MethodCuts.cxx:673
 MethodCuts.cxx:674
 MethodCuts.cxx:675
 MethodCuts.cxx:676
 MethodCuts.cxx:677
 MethodCuts.cxx:678
 MethodCuts.cxx:679
 MethodCuts.cxx:680
 MethodCuts.cxx:681
 MethodCuts.cxx:682
 MethodCuts.cxx:683
 MethodCuts.cxx:684
 MethodCuts.cxx:685
 MethodCuts.cxx:686
 MethodCuts.cxx:687
 MethodCuts.cxx:688
 MethodCuts.cxx:689
 MethodCuts.cxx:690
 MethodCuts.cxx:691
 MethodCuts.cxx:692
 MethodCuts.cxx:693
 MethodCuts.cxx:694
 MethodCuts.cxx:695
 MethodCuts.cxx:696
 MethodCuts.cxx:697
 MethodCuts.cxx:698
 MethodCuts.cxx:699
 MethodCuts.cxx:700
 MethodCuts.cxx:701
 MethodCuts.cxx:702
 MethodCuts.cxx:703
 MethodCuts.cxx:704
 MethodCuts.cxx:705
 MethodCuts.cxx:706
 MethodCuts.cxx:707
 MethodCuts.cxx:708
 MethodCuts.cxx:709
 MethodCuts.cxx:710
 MethodCuts.cxx:711
 MethodCuts.cxx:712
 MethodCuts.cxx:713
 MethodCuts.cxx:714
 MethodCuts.cxx:715
 MethodCuts.cxx:716
 MethodCuts.cxx:717
 MethodCuts.cxx:718
 MethodCuts.cxx:719
 MethodCuts.cxx:720
 MethodCuts.cxx:721
 MethodCuts.cxx:722
 MethodCuts.cxx:723
 MethodCuts.cxx:724
 MethodCuts.cxx:725
 MethodCuts.cxx:726
 MethodCuts.cxx:727
 MethodCuts.cxx:728
 MethodCuts.cxx:729
 MethodCuts.cxx:730
 MethodCuts.cxx:731
 MethodCuts.cxx:732
 MethodCuts.cxx:733
 MethodCuts.cxx:734
 MethodCuts.cxx:735
 MethodCuts.cxx:736
 MethodCuts.cxx:737
 MethodCuts.cxx:738
 MethodCuts.cxx:739
 MethodCuts.cxx:740
 MethodCuts.cxx:741
 MethodCuts.cxx:742
 MethodCuts.cxx:743
 MethodCuts.cxx:744
 MethodCuts.cxx:745
 MethodCuts.cxx:746
 MethodCuts.cxx:747
 MethodCuts.cxx:748
 MethodCuts.cxx:749
 MethodCuts.cxx:750
 MethodCuts.cxx:751
 MethodCuts.cxx:752
 MethodCuts.cxx:753
 MethodCuts.cxx:754
 MethodCuts.cxx:755
 MethodCuts.cxx:756
 MethodCuts.cxx:757
 MethodCuts.cxx:758
 MethodCuts.cxx:759
 MethodCuts.cxx:760
 MethodCuts.cxx:761
 MethodCuts.cxx:762
 MethodCuts.cxx:763
 MethodCuts.cxx:764
 MethodCuts.cxx:765
 MethodCuts.cxx:766
 MethodCuts.cxx:767
 MethodCuts.cxx:768
 MethodCuts.cxx:769
 MethodCuts.cxx:770
 MethodCuts.cxx:771
 MethodCuts.cxx:772
 MethodCuts.cxx:773
 MethodCuts.cxx:774
 MethodCuts.cxx:775
 MethodCuts.cxx:776
 MethodCuts.cxx:777
 MethodCuts.cxx:778
 MethodCuts.cxx:779
 MethodCuts.cxx:780
 MethodCuts.cxx:781
 MethodCuts.cxx:782
 MethodCuts.cxx:783
 MethodCuts.cxx:784
 MethodCuts.cxx:785
 MethodCuts.cxx:786
 MethodCuts.cxx:787
 MethodCuts.cxx:788
 MethodCuts.cxx:789
 MethodCuts.cxx:790
 MethodCuts.cxx:791
 MethodCuts.cxx:792
 MethodCuts.cxx:793
 MethodCuts.cxx:794
 MethodCuts.cxx:795
 MethodCuts.cxx:796
 MethodCuts.cxx:797
 MethodCuts.cxx:798
 MethodCuts.cxx:799
 MethodCuts.cxx:800
 MethodCuts.cxx:801
 MethodCuts.cxx:802
 MethodCuts.cxx:803
 MethodCuts.cxx:804
 MethodCuts.cxx:805
 MethodCuts.cxx:806
 MethodCuts.cxx:807
 MethodCuts.cxx:808
 MethodCuts.cxx:809
 MethodCuts.cxx:810
 MethodCuts.cxx:811
 MethodCuts.cxx:812
 MethodCuts.cxx:813
 MethodCuts.cxx:814
 MethodCuts.cxx:815
 MethodCuts.cxx:816
 MethodCuts.cxx:817
 MethodCuts.cxx:818
 MethodCuts.cxx:819
 MethodCuts.cxx:820
 MethodCuts.cxx:821
 MethodCuts.cxx:822
 MethodCuts.cxx:823
 MethodCuts.cxx:824
 MethodCuts.cxx:825
 MethodCuts.cxx:826
 MethodCuts.cxx:827
 MethodCuts.cxx:828
 MethodCuts.cxx:829
 MethodCuts.cxx:830
 MethodCuts.cxx:831
 MethodCuts.cxx:832
 MethodCuts.cxx:833
 MethodCuts.cxx:834
 MethodCuts.cxx:835
 MethodCuts.cxx:836
 MethodCuts.cxx:837
 MethodCuts.cxx:838
 MethodCuts.cxx:839
 MethodCuts.cxx:840
 MethodCuts.cxx:841
 MethodCuts.cxx:842
 MethodCuts.cxx:843
 MethodCuts.cxx:844
 MethodCuts.cxx:845
 MethodCuts.cxx:846
 MethodCuts.cxx:847
 MethodCuts.cxx:848
 MethodCuts.cxx:849
 MethodCuts.cxx:850
 MethodCuts.cxx:851
 MethodCuts.cxx:852
 MethodCuts.cxx:853
 MethodCuts.cxx:854
 MethodCuts.cxx:855
 MethodCuts.cxx:856
 MethodCuts.cxx:857
 MethodCuts.cxx:858
 MethodCuts.cxx:859
 MethodCuts.cxx:860
 MethodCuts.cxx:861
 MethodCuts.cxx:862
 MethodCuts.cxx:863
 MethodCuts.cxx:864
 MethodCuts.cxx:865
 MethodCuts.cxx:866
 MethodCuts.cxx:867
 MethodCuts.cxx:868
 MethodCuts.cxx:869
 MethodCuts.cxx:870
 MethodCuts.cxx:871
 MethodCuts.cxx:872
 MethodCuts.cxx:873
 MethodCuts.cxx:874
 MethodCuts.cxx:875
 MethodCuts.cxx:876
 MethodCuts.cxx:877
 MethodCuts.cxx:878
 MethodCuts.cxx:879
 MethodCuts.cxx:880
 MethodCuts.cxx:881
 MethodCuts.cxx:882
 MethodCuts.cxx:883
 MethodCuts.cxx:884
 MethodCuts.cxx:885
 MethodCuts.cxx:886
 MethodCuts.cxx:887
 MethodCuts.cxx:888
 MethodCuts.cxx:889
 MethodCuts.cxx:890
 MethodCuts.cxx:891
 MethodCuts.cxx:892
 MethodCuts.cxx:893
 MethodCuts.cxx:894
 MethodCuts.cxx:895
 MethodCuts.cxx:896
 MethodCuts.cxx:897
 MethodCuts.cxx:898
 MethodCuts.cxx:899
 MethodCuts.cxx:900
 MethodCuts.cxx:901
 MethodCuts.cxx:902
 MethodCuts.cxx:903
 MethodCuts.cxx:904
 MethodCuts.cxx:905
 MethodCuts.cxx:906
 MethodCuts.cxx:907
 MethodCuts.cxx:908
 MethodCuts.cxx:909
 MethodCuts.cxx:910
 MethodCuts.cxx:911
 MethodCuts.cxx:912
 MethodCuts.cxx:913
 MethodCuts.cxx:914
 MethodCuts.cxx:915
 MethodCuts.cxx:916
 MethodCuts.cxx:917
 MethodCuts.cxx:918
 MethodCuts.cxx:919
 MethodCuts.cxx:920
 MethodCuts.cxx:921
 MethodCuts.cxx:922
 MethodCuts.cxx:923
 MethodCuts.cxx:924
 MethodCuts.cxx:925
 MethodCuts.cxx:926
 MethodCuts.cxx:927
 MethodCuts.cxx:928
 MethodCuts.cxx:929
 MethodCuts.cxx:930
 MethodCuts.cxx:931
 MethodCuts.cxx:932
 MethodCuts.cxx:933
 MethodCuts.cxx:934
 MethodCuts.cxx:935
 MethodCuts.cxx:936
 MethodCuts.cxx:937
 MethodCuts.cxx:938
 MethodCuts.cxx:939
 MethodCuts.cxx:940
 MethodCuts.cxx:941
 MethodCuts.cxx:942
 MethodCuts.cxx:943
 MethodCuts.cxx:944
 MethodCuts.cxx:945
 MethodCuts.cxx:946
 MethodCuts.cxx:947
 MethodCuts.cxx:948
 MethodCuts.cxx:949
 MethodCuts.cxx:950
 MethodCuts.cxx:951
 MethodCuts.cxx:952
 MethodCuts.cxx:953
 MethodCuts.cxx:954
 MethodCuts.cxx:955
 MethodCuts.cxx:956
 MethodCuts.cxx:957
 MethodCuts.cxx:958
 MethodCuts.cxx:959
 MethodCuts.cxx:960
 MethodCuts.cxx:961
 MethodCuts.cxx:962
 MethodCuts.cxx:963
 MethodCuts.cxx:964
 MethodCuts.cxx:965
 MethodCuts.cxx:966
 MethodCuts.cxx:967
 MethodCuts.cxx:968
 MethodCuts.cxx:969
 MethodCuts.cxx:970
 MethodCuts.cxx:971
 MethodCuts.cxx:972
 MethodCuts.cxx:973
 MethodCuts.cxx:974
 MethodCuts.cxx:975
 MethodCuts.cxx:976
 MethodCuts.cxx:977
 MethodCuts.cxx:978
 MethodCuts.cxx:979
 MethodCuts.cxx:980
 MethodCuts.cxx:981
 MethodCuts.cxx:982
 MethodCuts.cxx:983
 MethodCuts.cxx:984
 MethodCuts.cxx:985
 MethodCuts.cxx:986
 MethodCuts.cxx:987
 MethodCuts.cxx:988
 MethodCuts.cxx:989
 MethodCuts.cxx:990
 MethodCuts.cxx:991
 MethodCuts.cxx:992
 MethodCuts.cxx:993
 MethodCuts.cxx:994
 MethodCuts.cxx:995
 MethodCuts.cxx:996
 MethodCuts.cxx:997
 MethodCuts.cxx:998
 MethodCuts.cxx:999
 MethodCuts.cxx:1000
 MethodCuts.cxx:1001
 MethodCuts.cxx:1002
 MethodCuts.cxx:1003
 MethodCuts.cxx:1004
 MethodCuts.cxx:1005
 MethodCuts.cxx:1006
 MethodCuts.cxx:1007
 MethodCuts.cxx:1008
 MethodCuts.cxx:1009
 MethodCuts.cxx:1010
 MethodCuts.cxx:1011
 MethodCuts.cxx:1012
 MethodCuts.cxx:1013
 MethodCuts.cxx:1014
 MethodCuts.cxx:1015
 MethodCuts.cxx:1016
 MethodCuts.cxx:1017
 MethodCuts.cxx:1018
 MethodCuts.cxx:1019
 MethodCuts.cxx:1020
 MethodCuts.cxx:1021
 MethodCuts.cxx:1022
 MethodCuts.cxx:1023
 MethodCuts.cxx:1024
 MethodCuts.cxx:1025
 MethodCuts.cxx:1026
 MethodCuts.cxx:1027
 MethodCuts.cxx:1028
 MethodCuts.cxx:1029
 MethodCuts.cxx:1030
 MethodCuts.cxx:1031
 MethodCuts.cxx:1032
 MethodCuts.cxx:1033
 MethodCuts.cxx:1034
 MethodCuts.cxx:1035
 MethodCuts.cxx:1036
 MethodCuts.cxx:1037
 MethodCuts.cxx:1038
 MethodCuts.cxx:1039
 MethodCuts.cxx:1040
 MethodCuts.cxx:1041
 MethodCuts.cxx:1042
 MethodCuts.cxx:1043
 MethodCuts.cxx:1044
 MethodCuts.cxx:1045
 MethodCuts.cxx:1046
 MethodCuts.cxx:1047
 MethodCuts.cxx:1048
 MethodCuts.cxx:1049
 MethodCuts.cxx:1050
 MethodCuts.cxx:1051
 MethodCuts.cxx:1052
 MethodCuts.cxx:1053
 MethodCuts.cxx:1054
 MethodCuts.cxx:1055
 MethodCuts.cxx:1056
 MethodCuts.cxx:1057
 MethodCuts.cxx:1058
 MethodCuts.cxx:1059
 MethodCuts.cxx:1060
 MethodCuts.cxx:1061
 MethodCuts.cxx:1062
 MethodCuts.cxx:1063
 MethodCuts.cxx:1064
 MethodCuts.cxx:1065
 MethodCuts.cxx:1066
 MethodCuts.cxx:1067
 MethodCuts.cxx:1068
 MethodCuts.cxx:1069
 MethodCuts.cxx:1070
 MethodCuts.cxx:1071
 MethodCuts.cxx:1072
 MethodCuts.cxx:1073
 MethodCuts.cxx:1074
 MethodCuts.cxx:1075
 MethodCuts.cxx:1076
 MethodCuts.cxx:1077
 MethodCuts.cxx:1078
 MethodCuts.cxx:1079
 MethodCuts.cxx:1080
 MethodCuts.cxx:1081
 MethodCuts.cxx:1082
 MethodCuts.cxx:1083
 MethodCuts.cxx:1084
 MethodCuts.cxx:1085
 MethodCuts.cxx:1086
 MethodCuts.cxx:1087
 MethodCuts.cxx:1088
 MethodCuts.cxx:1089
 MethodCuts.cxx:1090
 MethodCuts.cxx:1091
 MethodCuts.cxx:1092
 MethodCuts.cxx:1093
 MethodCuts.cxx:1094
 MethodCuts.cxx:1095
 MethodCuts.cxx:1096
 MethodCuts.cxx:1097
 MethodCuts.cxx:1098
 MethodCuts.cxx:1099
 MethodCuts.cxx:1100
 MethodCuts.cxx:1101
 MethodCuts.cxx:1102
 MethodCuts.cxx:1103
 MethodCuts.cxx:1104
 MethodCuts.cxx:1105
 MethodCuts.cxx:1106
 MethodCuts.cxx:1107
 MethodCuts.cxx:1108
 MethodCuts.cxx:1109
 MethodCuts.cxx:1110
 MethodCuts.cxx:1111
 MethodCuts.cxx:1112
 MethodCuts.cxx:1113
 MethodCuts.cxx:1114
 MethodCuts.cxx:1115
 MethodCuts.cxx:1116
 MethodCuts.cxx:1117
 MethodCuts.cxx:1118
 MethodCuts.cxx:1119
 MethodCuts.cxx:1120
 MethodCuts.cxx:1121
 MethodCuts.cxx:1122
 MethodCuts.cxx:1123
 MethodCuts.cxx:1124
 MethodCuts.cxx:1125
 MethodCuts.cxx:1126
 MethodCuts.cxx:1127
 MethodCuts.cxx:1128
 MethodCuts.cxx:1129
 MethodCuts.cxx:1130
 MethodCuts.cxx:1131
 MethodCuts.cxx:1132
 MethodCuts.cxx:1133
 MethodCuts.cxx:1134
 MethodCuts.cxx:1135
 MethodCuts.cxx:1136
 MethodCuts.cxx:1137
 MethodCuts.cxx:1138
 MethodCuts.cxx:1139
 MethodCuts.cxx:1140
 MethodCuts.cxx:1141
 MethodCuts.cxx:1142
 MethodCuts.cxx:1143
 MethodCuts.cxx:1144
 MethodCuts.cxx:1145
 MethodCuts.cxx:1146
 MethodCuts.cxx:1147
 MethodCuts.cxx:1148
 MethodCuts.cxx:1149
 MethodCuts.cxx:1150
 MethodCuts.cxx:1151
 MethodCuts.cxx:1152
 MethodCuts.cxx:1153
 MethodCuts.cxx:1154
 MethodCuts.cxx:1155
 MethodCuts.cxx:1156
 MethodCuts.cxx:1157
 MethodCuts.cxx:1158
 MethodCuts.cxx:1159
 MethodCuts.cxx:1160
 MethodCuts.cxx:1161
 MethodCuts.cxx:1162
 MethodCuts.cxx:1163
 MethodCuts.cxx:1164
 MethodCuts.cxx:1165
 MethodCuts.cxx:1166
 MethodCuts.cxx:1167
 MethodCuts.cxx:1168
 MethodCuts.cxx:1169
 MethodCuts.cxx:1170
 MethodCuts.cxx:1171
 MethodCuts.cxx:1172
 MethodCuts.cxx:1173
 MethodCuts.cxx:1174
 MethodCuts.cxx:1175
 MethodCuts.cxx:1176
 MethodCuts.cxx:1177
 MethodCuts.cxx:1178
 MethodCuts.cxx:1179
 MethodCuts.cxx:1180
 MethodCuts.cxx:1181
 MethodCuts.cxx:1182
 MethodCuts.cxx:1183
 MethodCuts.cxx:1184
 MethodCuts.cxx:1185
 MethodCuts.cxx:1186
 MethodCuts.cxx:1187
 MethodCuts.cxx:1188
 MethodCuts.cxx:1189
 MethodCuts.cxx:1190
 MethodCuts.cxx:1191
 MethodCuts.cxx:1192
 MethodCuts.cxx:1193
 MethodCuts.cxx:1194
 MethodCuts.cxx:1195
 MethodCuts.cxx:1196
 MethodCuts.cxx:1197
 MethodCuts.cxx:1198
 MethodCuts.cxx:1199
 MethodCuts.cxx:1200
 MethodCuts.cxx:1201
 MethodCuts.cxx:1202
 MethodCuts.cxx:1203
 MethodCuts.cxx:1204
 MethodCuts.cxx:1205
 MethodCuts.cxx:1206
 MethodCuts.cxx:1207
 MethodCuts.cxx:1208
 MethodCuts.cxx:1209
 MethodCuts.cxx:1210
 MethodCuts.cxx:1211
 MethodCuts.cxx:1212
 MethodCuts.cxx:1213
 MethodCuts.cxx:1214
 MethodCuts.cxx:1215
 MethodCuts.cxx:1216
 MethodCuts.cxx:1217
 MethodCuts.cxx:1218
 MethodCuts.cxx:1219
 MethodCuts.cxx:1220
 MethodCuts.cxx:1221
 MethodCuts.cxx:1222
 MethodCuts.cxx:1223
 MethodCuts.cxx:1224
 MethodCuts.cxx:1225
 MethodCuts.cxx:1226
 MethodCuts.cxx:1227
 MethodCuts.cxx:1228
 MethodCuts.cxx:1229
 MethodCuts.cxx:1230
 MethodCuts.cxx:1231
 MethodCuts.cxx:1232
 MethodCuts.cxx:1233
 MethodCuts.cxx:1234
 MethodCuts.cxx:1235
 MethodCuts.cxx:1236
 MethodCuts.cxx:1237
 MethodCuts.cxx:1238
 MethodCuts.cxx:1239
 MethodCuts.cxx:1240
 MethodCuts.cxx:1241
 MethodCuts.cxx:1242
 MethodCuts.cxx:1243
 MethodCuts.cxx:1244
 MethodCuts.cxx:1245
 MethodCuts.cxx:1246
 MethodCuts.cxx:1247
 MethodCuts.cxx:1248
 MethodCuts.cxx:1249
 MethodCuts.cxx:1250
 MethodCuts.cxx:1251
 MethodCuts.cxx:1252
 MethodCuts.cxx:1253
 MethodCuts.cxx:1254
 MethodCuts.cxx:1255
 MethodCuts.cxx:1256
 MethodCuts.cxx:1257
 MethodCuts.cxx:1258
 MethodCuts.cxx:1259
 MethodCuts.cxx:1260
 MethodCuts.cxx:1261
 MethodCuts.cxx:1262
 MethodCuts.cxx:1263
 MethodCuts.cxx:1264
 MethodCuts.cxx:1265
 MethodCuts.cxx:1266
 MethodCuts.cxx:1267
 MethodCuts.cxx:1268
 MethodCuts.cxx:1269
 MethodCuts.cxx:1270
 MethodCuts.cxx:1271
 MethodCuts.cxx:1272
 MethodCuts.cxx:1273
 MethodCuts.cxx:1274
 MethodCuts.cxx:1275
 MethodCuts.cxx:1276
 MethodCuts.cxx:1277
 MethodCuts.cxx:1278
 MethodCuts.cxx:1279
 MethodCuts.cxx:1280
 MethodCuts.cxx:1281
 MethodCuts.cxx:1282
 MethodCuts.cxx:1283
 MethodCuts.cxx:1284
 MethodCuts.cxx:1285
 MethodCuts.cxx:1286
 MethodCuts.cxx:1287
 MethodCuts.cxx:1288
 MethodCuts.cxx:1289
 MethodCuts.cxx:1290
 MethodCuts.cxx:1291
 MethodCuts.cxx:1292
 MethodCuts.cxx:1293
 MethodCuts.cxx:1294
 MethodCuts.cxx:1295
 MethodCuts.cxx:1296
 MethodCuts.cxx:1297
 MethodCuts.cxx:1298
 MethodCuts.cxx:1299
 MethodCuts.cxx:1300
 MethodCuts.cxx:1301
 MethodCuts.cxx:1302
 MethodCuts.cxx:1303
 MethodCuts.cxx:1304
 MethodCuts.cxx:1305
 MethodCuts.cxx:1306
 MethodCuts.cxx:1307
 MethodCuts.cxx:1308
 MethodCuts.cxx:1309
 MethodCuts.cxx:1310
 MethodCuts.cxx:1311
 MethodCuts.cxx:1312
 MethodCuts.cxx:1313
 MethodCuts.cxx:1314
 MethodCuts.cxx:1315
 MethodCuts.cxx:1316
 MethodCuts.cxx:1317
 MethodCuts.cxx:1318
 MethodCuts.cxx:1319
 MethodCuts.cxx:1320
 MethodCuts.cxx:1321
 MethodCuts.cxx:1322
 MethodCuts.cxx:1323
 MethodCuts.cxx:1324
 MethodCuts.cxx:1325
 MethodCuts.cxx:1326
 MethodCuts.cxx:1327
 MethodCuts.cxx:1328
 MethodCuts.cxx:1329
 MethodCuts.cxx:1330
 MethodCuts.cxx:1331
 MethodCuts.cxx:1332
 MethodCuts.cxx:1333
 MethodCuts.cxx:1334
 MethodCuts.cxx:1335
 MethodCuts.cxx:1336
 MethodCuts.cxx:1337
 MethodCuts.cxx:1338
 MethodCuts.cxx:1339
 MethodCuts.cxx:1340
 MethodCuts.cxx:1341
 MethodCuts.cxx:1342
 MethodCuts.cxx:1343
 MethodCuts.cxx:1344
 MethodCuts.cxx:1345
 MethodCuts.cxx:1346
 MethodCuts.cxx:1347
 MethodCuts.cxx:1348
 MethodCuts.cxx:1349
 MethodCuts.cxx:1350
 MethodCuts.cxx:1351
 MethodCuts.cxx:1352
 MethodCuts.cxx:1353
 MethodCuts.cxx:1354
 MethodCuts.cxx:1355
 MethodCuts.cxx:1356
 MethodCuts.cxx:1357
 MethodCuts.cxx:1358
 MethodCuts.cxx:1359
 MethodCuts.cxx:1360
 MethodCuts.cxx:1361
 MethodCuts.cxx:1362
 MethodCuts.cxx:1363
 MethodCuts.cxx:1364
 MethodCuts.cxx:1365
 MethodCuts.cxx:1366
 MethodCuts.cxx:1367
 MethodCuts.cxx:1368
 MethodCuts.cxx:1369
 MethodCuts.cxx:1370
 MethodCuts.cxx:1371
 MethodCuts.cxx:1372
 MethodCuts.cxx:1373
 MethodCuts.cxx:1374
 MethodCuts.cxx:1375
 MethodCuts.cxx:1376
 MethodCuts.cxx:1377
 MethodCuts.cxx:1378
 MethodCuts.cxx:1379
 MethodCuts.cxx:1380
 MethodCuts.cxx:1381
 MethodCuts.cxx:1382
 MethodCuts.cxx:1383
 MethodCuts.cxx:1384
 MethodCuts.cxx:1385
 MethodCuts.cxx:1386
 MethodCuts.cxx:1387
 MethodCuts.cxx:1388
 MethodCuts.cxx:1389
 MethodCuts.cxx:1390
 MethodCuts.cxx:1391
 MethodCuts.cxx:1392
 MethodCuts.cxx:1393
 MethodCuts.cxx:1394
 MethodCuts.cxx:1395
 MethodCuts.cxx:1396
 MethodCuts.cxx:1397
 MethodCuts.cxx:1398
 MethodCuts.cxx:1399
 MethodCuts.cxx:1400
 MethodCuts.cxx:1401
 MethodCuts.cxx:1402
 MethodCuts.cxx:1403
 MethodCuts.cxx:1404
 MethodCuts.cxx:1405
 MethodCuts.cxx:1406
 MethodCuts.cxx:1407
 MethodCuts.cxx:1408
 MethodCuts.cxx:1409
 MethodCuts.cxx:1410
 MethodCuts.cxx:1411
 MethodCuts.cxx:1412
 MethodCuts.cxx:1413
 MethodCuts.cxx:1414
 MethodCuts.cxx:1415
 MethodCuts.cxx:1416
 MethodCuts.cxx:1417
 MethodCuts.cxx:1418
 MethodCuts.cxx:1419
 MethodCuts.cxx:1420
 MethodCuts.cxx:1421
 MethodCuts.cxx:1422
 MethodCuts.cxx:1423
 MethodCuts.cxx:1424
 MethodCuts.cxx:1425
 MethodCuts.cxx:1426
 MethodCuts.cxx:1427
 MethodCuts.cxx:1428
 MethodCuts.cxx:1429
 MethodCuts.cxx:1430
 MethodCuts.cxx:1431
 MethodCuts.cxx:1432
 MethodCuts.cxx:1433
 MethodCuts.cxx:1434
 MethodCuts.cxx:1435
 MethodCuts.cxx:1436
 MethodCuts.cxx:1437
 MethodCuts.cxx:1438
 MethodCuts.cxx:1439
 MethodCuts.cxx:1440
 MethodCuts.cxx:1441
 MethodCuts.cxx:1442
 MethodCuts.cxx:1443
 MethodCuts.cxx:1444
 MethodCuts.cxx:1445
 MethodCuts.cxx:1446
 MethodCuts.cxx:1447
 MethodCuts.cxx:1448
 MethodCuts.cxx:1449
 MethodCuts.cxx:1450
 MethodCuts.cxx:1451
 MethodCuts.cxx:1452
 MethodCuts.cxx:1453
 MethodCuts.cxx:1454
 MethodCuts.cxx:1455
 MethodCuts.cxx:1456
 MethodCuts.cxx:1457
 MethodCuts.cxx:1458
 MethodCuts.cxx:1459
 MethodCuts.cxx:1460
 MethodCuts.cxx:1461
 MethodCuts.cxx:1462
 MethodCuts.cxx:1463
 MethodCuts.cxx:1464
 MethodCuts.cxx:1465
 MethodCuts.cxx:1466
 MethodCuts.cxx:1467
 MethodCuts.cxx:1468
 MethodCuts.cxx:1469
 MethodCuts.cxx:1470
 MethodCuts.cxx:1471
 MethodCuts.cxx:1472
 MethodCuts.cxx:1473
 MethodCuts.cxx:1474
 MethodCuts.cxx:1475
 MethodCuts.cxx:1476
 MethodCuts.cxx:1477
 MethodCuts.cxx:1478
 MethodCuts.cxx:1479
 MethodCuts.cxx:1480
 MethodCuts.cxx:1481
 MethodCuts.cxx:1482
 MethodCuts.cxx:1483
 MethodCuts.cxx:1484
 MethodCuts.cxx:1485
 MethodCuts.cxx:1486
 MethodCuts.cxx:1487
 MethodCuts.cxx:1488
 MethodCuts.cxx:1489
 MethodCuts.cxx:1490
 MethodCuts.cxx:1491
 MethodCuts.cxx:1492
 MethodCuts.cxx:1493
 MethodCuts.cxx:1494
 MethodCuts.cxx:1495
 MethodCuts.cxx:1496
 MethodCuts.cxx:1497
 MethodCuts.cxx:1498
 MethodCuts.cxx:1499
 MethodCuts.cxx:1500
 MethodCuts.cxx:1501
 MethodCuts.cxx:1502
 MethodCuts.cxx:1503
 MethodCuts.cxx:1504
 MethodCuts.cxx:1505
 MethodCuts.cxx:1506
 MethodCuts.cxx:1507
 MethodCuts.cxx:1508
 MethodCuts.cxx:1509
 MethodCuts.cxx:1510
 MethodCuts.cxx:1511
 MethodCuts.cxx:1512
 MethodCuts.cxx:1513
 MethodCuts.cxx:1514
 MethodCuts.cxx:1515
 MethodCuts.cxx:1516
 MethodCuts.cxx:1517
 MethodCuts.cxx:1518
 MethodCuts.cxx:1519
 MethodCuts.cxx:1520
 MethodCuts.cxx:1521
 MethodCuts.cxx:1522
 MethodCuts.cxx:1523
 MethodCuts.cxx:1524
 MethodCuts.cxx:1525
 MethodCuts.cxx:1526
 MethodCuts.cxx:1527
 MethodCuts.cxx:1528
 MethodCuts.cxx:1529
 MethodCuts.cxx:1530
 MethodCuts.cxx:1531
 MethodCuts.cxx:1532
 MethodCuts.cxx:1533
 MethodCuts.cxx:1534
 MethodCuts.cxx:1535
 MethodCuts.cxx:1536
 MethodCuts.cxx:1537
 MethodCuts.cxx:1538
 MethodCuts.cxx:1539
 MethodCuts.cxx:1540
 MethodCuts.cxx:1541
 MethodCuts.cxx:1542
 MethodCuts.cxx:1543
 MethodCuts.cxx:1544
 MethodCuts.cxx:1545
 MethodCuts.cxx:1546
 MethodCuts.cxx:1547
 MethodCuts.cxx:1548
 MethodCuts.cxx:1549
 MethodCuts.cxx:1550
 MethodCuts.cxx:1551
 MethodCuts.cxx:1552
 MethodCuts.cxx:1553
 MethodCuts.cxx:1554
 MethodCuts.cxx:1555
 MethodCuts.cxx:1556
 MethodCuts.cxx:1557
 MethodCuts.cxx:1558
 MethodCuts.cxx:1559
 MethodCuts.cxx:1560
 MethodCuts.cxx:1561
 MethodCuts.cxx:1562
 MethodCuts.cxx:1563
 MethodCuts.cxx:1564
 MethodCuts.cxx:1565
 MethodCuts.cxx:1566
 MethodCuts.cxx:1567
 MethodCuts.cxx:1568
 MethodCuts.cxx:1569
 MethodCuts.cxx:1570
 MethodCuts.cxx:1571
 MethodCuts.cxx:1572
 MethodCuts.cxx:1573
 MethodCuts.cxx:1574
 MethodCuts.cxx:1575
 MethodCuts.cxx:1576
 MethodCuts.cxx:1577
 MethodCuts.cxx:1578
 MethodCuts.cxx:1579
 MethodCuts.cxx:1580
 MethodCuts.cxx:1581
 MethodCuts.cxx:1582
 MethodCuts.cxx:1583
 MethodCuts.cxx:1584
 MethodCuts.cxx:1585
 MethodCuts.cxx:1586
 MethodCuts.cxx:1587
 MethodCuts.cxx:1588
 MethodCuts.cxx:1589
 MethodCuts.cxx:1590
 MethodCuts.cxx:1591
 MethodCuts.cxx:1592
 MethodCuts.cxx:1593
 MethodCuts.cxx:1594
 MethodCuts.cxx:1595
 MethodCuts.cxx:1596
 MethodCuts.cxx:1597
 MethodCuts.cxx:1598
 MethodCuts.cxx:1599
 MethodCuts.cxx:1600
 MethodCuts.cxx:1601
 MethodCuts.cxx:1602
 MethodCuts.cxx:1603
 MethodCuts.cxx:1604
 MethodCuts.cxx:1605
 MethodCuts.cxx:1606
 MethodCuts.cxx:1607
 MethodCuts.cxx:1608
 MethodCuts.cxx:1609
 MethodCuts.cxx:1610
 MethodCuts.cxx:1611
 MethodCuts.cxx:1612
 MethodCuts.cxx:1613
 MethodCuts.cxx:1614
 MethodCuts.cxx:1615
 MethodCuts.cxx:1616
 MethodCuts.cxx:1617
 MethodCuts.cxx:1618
 MethodCuts.cxx:1619
 MethodCuts.cxx:1620
 MethodCuts.cxx:1621
 MethodCuts.cxx:1622
 MethodCuts.cxx:1623
 MethodCuts.cxx:1624
 MethodCuts.cxx:1625
 MethodCuts.cxx:1626
 MethodCuts.cxx:1627
 MethodCuts.cxx:1628
 MethodCuts.cxx:1629
 MethodCuts.cxx:1630
 MethodCuts.cxx:1631
 MethodCuts.cxx:1632
 MethodCuts.cxx:1633
 MethodCuts.cxx:1634
 MethodCuts.cxx:1635
 MethodCuts.cxx:1636
 MethodCuts.cxx:1637
 MethodCuts.cxx:1638
 MethodCuts.cxx:1639
 MethodCuts.cxx:1640
 MethodCuts.cxx:1641
 MethodCuts.cxx:1642
 MethodCuts.cxx:1643
 MethodCuts.cxx:1644
 MethodCuts.cxx:1645
 MethodCuts.cxx:1646
 MethodCuts.cxx:1647
 MethodCuts.cxx:1648
 MethodCuts.cxx:1649
 MethodCuts.cxx:1650
 MethodCuts.cxx:1651
 MethodCuts.cxx:1652
 MethodCuts.cxx:1653
 MethodCuts.cxx:1654
 MethodCuts.cxx:1655
 MethodCuts.cxx:1656
 MethodCuts.cxx:1657
 MethodCuts.cxx:1658
 MethodCuts.cxx:1659
 MethodCuts.cxx:1660
 MethodCuts.cxx:1661
 MethodCuts.cxx:1662
 MethodCuts.cxx:1663
 MethodCuts.cxx:1664
 MethodCuts.cxx:1665
 MethodCuts.cxx:1666
 MethodCuts.cxx:1667
 MethodCuts.cxx:1668
 MethodCuts.cxx:1669
 MethodCuts.cxx:1670
 MethodCuts.cxx:1671
 MethodCuts.cxx:1672
 MethodCuts.cxx:1673
 MethodCuts.cxx:1674
 MethodCuts.cxx:1675
 MethodCuts.cxx:1676
 MethodCuts.cxx:1677
 MethodCuts.cxx:1678
 MethodCuts.cxx:1679
 MethodCuts.cxx:1680
 MethodCuts.cxx:1681
 MethodCuts.cxx:1682
 MethodCuts.cxx:1683
 MethodCuts.cxx:1684
 MethodCuts.cxx:1685
 MethodCuts.cxx:1686
 MethodCuts.cxx:1687
 MethodCuts.cxx:1688
 MethodCuts.cxx:1689
 MethodCuts.cxx:1690
 MethodCuts.cxx:1691
 MethodCuts.cxx:1692
 MethodCuts.cxx:1693
 MethodCuts.cxx:1694
 MethodCuts.cxx:1695
 MethodCuts.cxx:1696
 MethodCuts.cxx:1697
 MethodCuts.cxx:1698
 MethodCuts.cxx:1699
 MethodCuts.cxx:1700
 MethodCuts.cxx:1701
 MethodCuts.cxx:1702
 MethodCuts.cxx:1703
 MethodCuts.cxx:1704
 MethodCuts.cxx:1705
 MethodCuts.cxx:1706
 MethodCuts.cxx:1707
 MethodCuts.cxx:1708
 MethodCuts.cxx:1709
 MethodCuts.cxx:1710
 MethodCuts.cxx:1711
 MethodCuts.cxx:1712
 MethodCuts.cxx:1713
 MethodCuts.cxx:1714
 MethodCuts.cxx:1715
 MethodCuts.cxx:1716
 MethodCuts.cxx:1717
 MethodCuts.cxx:1718
 MethodCuts.cxx:1719
 MethodCuts.cxx:1720
 MethodCuts.cxx:1721
 MethodCuts.cxx:1722
 MethodCuts.cxx:1723
 MethodCuts.cxx:1724
 MethodCuts.cxx:1725
 MethodCuts.cxx:1726
 MethodCuts.cxx:1727
 MethodCuts.cxx:1728
 MethodCuts.cxx:1729
 MethodCuts.cxx:1730
 MethodCuts.cxx:1731
 MethodCuts.cxx:1732
 MethodCuts.cxx:1733
 MethodCuts.cxx:1734
 MethodCuts.cxx:1735
 MethodCuts.cxx:1736
 MethodCuts.cxx:1737
 MethodCuts.cxx:1738
 MethodCuts.cxx:1739
 MethodCuts.cxx:1740
 MethodCuts.cxx:1741
 MethodCuts.cxx:1742
 MethodCuts.cxx:1743
 MethodCuts.cxx:1744
 MethodCuts.cxx:1745
 MethodCuts.cxx:1746
 MethodCuts.cxx:1747
 MethodCuts.cxx:1748
 MethodCuts.cxx:1749
 MethodCuts.cxx:1750
 MethodCuts.cxx:1751
 MethodCuts.cxx:1752
 MethodCuts.cxx:1753
 MethodCuts.cxx:1754
 MethodCuts.cxx:1755
 MethodCuts.cxx:1756
 MethodCuts.cxx:1757
 MethodCuts.cxx:1758
 MethodCuts.cxx:1759
 MethodCuts.cxx:1760
 MethodCuts.cxx:1761
 MethodCuts.cxx:1762
 MethodCuts.cxx:1763
 MethodCuts.cxx:1764
 MethodCuts.cxx:1765
 MethodCuts.cxx:1766
 MethodCuts.cxx:1767
 MethodCuts.cxx:1768
 MethodCuts.cxx:1769
 MethodCuts.cxx:1770
 MethodCuts.cxx:1771
 MethodCuts.cxx:1772
 MethodCuts.cxx:1773
 MethodCuts.cxx:1774
 MethodCuts.cxx:1775
 MethodCuts.cxx:1776
 MethodCuts.cxx:1777
 MethodCuts.cxx:1778
 MethodCuts.cxx:1779
 MethodCuts.cxx:1780
 MethodCuts.cxx:1781
 MethodCuts.cxx:1782
 MethodCuts.cxx:1783
 MethodCuts.cxx:1784
 MethodCuts.cxx:1785