// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss 

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : RuleFitAPI                                                            *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation (see header file for description)                          *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Fredrik Tegenfeldt <Fredrik.Tegenfeldt@cern.ch>  - Iowa State U., USA     *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      CERN, Switzerland                                                         * 
 *      Iowa State U.                                                             *
 *      MPI-KP 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)                                          *
 **********************************************************************************/

//_______________________________________________________________________
//
// J Friedman's RuleFit method
//_______________________________________________________________________

#include <algorithm>

#include "TROOT.h"
#include "TSystem.h"
#include "TMath.h"

#include "TMVA/MethodRuleFit.h"
#include "TMVA/RuleFitAPI.h"
#include "TMVA/RuleFit.h"
#include "TMVA/Tools.h"
#include "TMVA/Timer.h"

ClassImp(TMVA::RuleFitAPI)

TMVA::RuleFitAPI::RuleFitAPI( const MethodRuleFit *rfbase,
                              RuleFit *rulefit,
                              EMsgType minType = kINFO ) :
   fMethodRuleFit(rfbase),
   fRuleFit(rulefit),
   fRFProgram(kRfTrain),
   fLogger("RuleFitAPI",minType)
{
   // standard constructor
   if (rfbase) {
      SetRFWorkDir(rfbase->GetRFWorkDir());
   } else {
      SetRFWorkDir("./rulefit");
   }
   InitRuleFit();
}


//_______________________________________________________________________
TMVA::RuleFitAPI::~RuleFitAPI()
{
   // destructor
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::WelcomeMessage()
{
   // welcome message
   fLogger << kINFO
           << "\n"
           << "---------------------------------------------------------------------------\n"
           << "-   You are running the interface to Jerome Friedmans RuleFit(tm) code.   -\n"
           << "-   For a full manual see the following web page:                         -\n"
           << "-                                                                         -\n"
           << "-        http://www-stat.stanford.edu/~jhf/R-RuleFit.html                 -\n"
           << "-                                                                         -\n"
           << "---------------------------------------------------------------------------"
           << Endl;
}
//_______________________________________________________________________
void TMVA::RuleFitAPI::HowtoSetupRF()
{
   // howto message
   fLogger << kINFO
           << "\n"
           << "------------------------ RULEFIT-JF INTERFACE SETUP -----------------------\n"
           << "\n"
           << "1. Create a rulefit directory in your current work directory:\n"
           << "       mkdir " << fRFWorkDir << "\n\n"
           << "   the directory may be set using the option RuleFitDir\n"
           << "\n"
           << "2. Copy (or make a link) the file rf_go.exe into this directory\n"
           << "\n"
           << "The file can be obtained from Jerome Friedmans homepage (linux):\n"
           << "   wget http://www-stat.stanford.edu/~jhf/r-rulefit/linux/rf_go.exe\n"
           << "\n"
           << "Don't forget to do:\n"
           << "   chmod +x rf_go.exe\n"
           << "\n"
           << "For Windows download:\n"
           << "   http://www-stat.stanford.edu/~jhf/r-rulefit/windows/rf_go.exe\n"
           << "\n"
           << "NOTE: other platforms are not supported (see Friedmans homepage)\n"
           << "\n"
           << "---------------------------------------------------------------------------\n"
           << Endl;
}
//_______________________________________________________________________
void TMVA::RuleFitAPI::InitRuleFit()
{
   // default initialisation
   //   SetRFWorkDir("./rulefit");
   CheckRFWorkDir();
   FillIntParmsDef();
   FillRealParmsDef();
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::ImportSetup()
{
   // import setup from MethodRuleFit
   fRFIntParms.p            = fMethodRuleFit->DataInfo().GetNVariables();
   fRFIntParms.max_rules    = fMethodRuleFit->GetRFNrules();
   fRFIntParms.tree_size    = fMethodRuleFit->GetRFNendnodes();
   fRFIntParms.path_steps   = fMethodRuleFit->GetGDNPathSteps();
   //
   fRFRealParms.path_inc    = fMethodRuleFit->GetGDPathStep();
   fRFRealParms.samp_fract  = fMethodRuleFit->GetTreeEveFrac();
   fRFRealParms.trim_qntl   = fMethodRuleFit->GetLinQuantile();
   fRFRealParms.conv_fac    = fMethodRuleFit->GetGDErrScale();
   //
   if      (fRuleFit->GetRuleEnsemblePtr()->DoOnlyLinear() )
      fRFIntParms.lmode = kRfLinear;
   else if (fRuleFit->GetRuleEnsemblePtr()->DoOnlyRules() )
      fRFIntParms.lmode = kRfRules;
   else
      fRFIntParms.lmode = kRfBoth;
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::SetRFWorkDir(const char * wdir)
{
   // set the directory containing rf_go.exe.
   fRFWorkDir = wdir;
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::CheckRFWorkDir()
{
   // check if the rulefit work dir is properly setup.
   // it aborts (kFATAL) if not.
   //
   // Check existance of directory
   TString oldDir = gSystem->pwd();
   if (!gSystem->cd(fRFWorkDir)) {
      fLogger << kWARNING << "Must create a rulefit directory named : " << fRFWorkDir << Endl;
      HowtoSetupRF();
      fLogger << kFATAL << "Setup failed - aborting!" << Endl;
   }
   // check rf_go.exe
   FILE *f = fopen("rf_go.exe","r");
   if (f==0) {
      fLogger << kWARNING << "No rf_go.exe file in directory : " << fRFWorkDir << Endl;
      HowtoSetupRF();
      fLogger << kFATAL << "Setup failed - aborting!" << Endl;
   }
   fclose(f);
   gSystem->cd(oldDir.Data());
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::SetTrainParms()
{
   // set the training parameters
   ImportSetup();
   //
   Int_t    n    = fMethodRuleFit->Data()->GetNTrainingEvents();
   //   Double_t neff = Double_t(n); // When weights are added: should be sum(wt)^2/sum(wt^2)
   fRFIntParms.n = n; // number of data points in tree
   fRFProgram    = kRfTrain;
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::SetTestParms()
{
   // set the test params
   ImportSetup();
   Int_t    n    = fMethodRuleFit->Data()->GetNTestEvents();
   //   Double_t neff = Double_t(n); // When weights are added: should be sum(wt)^2/sum(wt^2)
   fRFIntParms.n = n; // number of data points in tree
   fRFProgram    = kRfPredict;
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::FillRealParmsDef()
{
   // set default real params
   fRFRealParms.xmiss       = 9.0e30;
   fRFRealParms.trim_qntl   = 0.025;
   fRFRealParms.huber       = 0.8;
   fRFRealParms.inter_supp  = 3.0;
   fRFRealParms.memory_par  = 0.01;
   fRFRealParms.samp_fract  = 0.5; // calculated later
   fRFRealParms.path_inc    = 0.01;
   fRFRealParms.conv_fac    = 1.1;
}

//_______________________________________________________________________
void TMVA::RuleFitAPI::FillIntParmsDef()
{
   // set default int params
   fRFIntParms.mode           = (int)kRfClass;
   fRFIntParms.lmode          = (int)kRfBoth;
   //   fRFIntParms.n;
   //   fRFIntParms.p;
   fRFIntParms.max_rules      = 2000;
   fRFIntParms.tree_size      = 4;
   fRFIntParms.path_speed     = 2;
   fRFIntParms.path_xval      = 3;
   fRFIntParms.path_steps     = 50000;
   fRFIntParms.path_testfreq  = 100;
   fRFIntParms.tree_store     = 10000000;
   fRFIntParms.cat_store      = 1000000;

}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteAll()
{
   // write all files read by rf_go.exe
   WriteIntParms();
   WriteRealParms();
   WriteLx();
   WriteProgram();
   WriteVarNames();
   if (fRFProgram==kRfTrain)   WriteTrain();
   if (fRFProgram==kRfPredict) WriteTest();
   if (fRFProgram==kRfVarimp)  WriteRealVarImp();
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteIntParms()
{
   // write int params file
   std::ofstream f;
   if (!OpenRFile("intparms",f)) return kFALSE;
   WriteInt(f,&fRFIntParms.mode,sizeof(fRFIntParms)/sizeof(Int_t));
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRealParms()
{
   // write int params file
   std::ofstream f;
   if (!OpenRFile("realparms",f)) return kFALSE;
   WriteFloat(f,&fRFRealParms.xmiss,sizeof(fRFRealParms)/sizeof(Float_t));
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteLx()
{
   // Save input variable mask
   //
   // If the lx vector size is not the same as inputVars,
   // resize it and fill it with 1
   // NOTE: Always set all to 1
   //  if (fRFLx.size() != m_inputVars->size()) {
   fRFLx.clear();
   fRFLx.resize(fMethodRuleFit->DataInfo().GetNVariables(),1);
   //  }
   std::ofstream f;
   if (!OpenRFile("lx",f)) return kFALSE;
   WriteInt(f,&fRFLx[0],fRFLx.size());
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteProgram()
{
   // write command to rf_go.exe
   std::ofstream f;
   if (!OpenRFile("program",f)) return kFALSE;
   TString program;
   switch (fRFProgram) {
   case kRfTrain:
      program = "rulefit";
      break;
   case kRfPredict:
      program = "rulefit_pred";
      break;
      // calculate variable importance
   case kRfVarimp:
      program = "varimp";
      break;
   default:
      fRFProgram = kRfTrain;
      program="rulefit";
      break;
   }
   f << program;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRealVarImp()
{
   // write the minimum importance to be considered
   std::ofstream f;
   if (!OpenRFile("realvarimp",f)) return kFALSE;
   Float_t rvp[2];
   rvp[0] = 0.0; // Mode: see varimp() in rulefit.r
   rvp[1] = 0.0; // Minimum importance considered (1 is max)
   WriteFloat(f,&rvp[0],2);
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRfOut()
{
   // written by rf_go.exe; write rulefit output (rfout)
   fLogger << kWARNING << "WriteRfOut is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRfStatus()
{
   // written by rf_go.exe; write rulefit status
   fLogger << kWARNING << "WriteRfStatus is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRuleFitMod()
{
   // written by rf_go.exe (NOTE:Format unknown!)
   fLogger << kWARNING << "WriteRuleFitMod is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteRuleFitSum()
{
   // written by rf_go.exe (NOTE: format unknown!)
   fLogger << kWARNING << "WriteRuleFitSum is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteTrain()
{
   // write training data, columnwise
   std::ofstream fx;
   std::ofstream fy;
   std::ofstream fw;
   //
   if (!OpenRFile("train.x",fx)) return kFALSE;
   if (!OpenRFile("train.y",fy)) return kFALSE;
   if (!OpenRFile("train.w",fw)) return kFALSE;
   //
   Float_t x,y,w;
   //
   // The loop order cannot be changed.
   // The data is stored <var1(eve1), var1(eve2), ...var1(eveN), var2(eve1),....
   //
   for (UInt_t ivar=0; ivar<fMethodRuleFit->DataInfo().GetNVariables(); ivar++) {
      for (Int_t ievt=0;ievt<fMethodRuleFit->Data()->GetNTrainingEvents(); ievt++) {
         const Event * ev = fMethodRuleFit->GetTrainingEvent(ievt);
         x = ev->GetValue(ivar);
         WriteFloat(fx,&x,1);
         if (ivar==0) {
            w = ev->GetWeight();
            y = fMethodRuleFit->DataInfo().IsSignal(ev)? 1.0 : -1.0;
            WriteFloat(fy,&y,1);
            WriteFloat(fw,&w,1);
         }
      }
   }
   fLogger << kINFO << "Number of training data written: " << fMethodRuleFit->Data()->GetNTrainingEvents() << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteTest()
{
   // Write test data

   fMethodRuleFit->Data()->SetCurrentType(Types::kTesting);

   std::ofstream f;
   //
   if (!OpenRFile("test.x",f)) return kFALSE;
   //
   Float_t vf;
   Float_t neve;
   //
   neve = static_cast<Float_t>(fMethodRuleFit->Data()->GetNEvents());
   WriteFloat(f,&neve,1);
   // Test data is saved as:
   // 0      : <N> num of events, type float, 4 bytes
   // 1-N    : First variable for all events
   // N+1-2N : Second variable...
   // ...
   for (UInt_t ivar=0; ivar<fMethodRuleFit->DataInfo().GetNVariables(); ivar++) {
      for (Int_t ievt=0;ievt<fMethodRuleFit->Data()->GetNEvents(); ievt++) {
         vf =   fMethodRuleFit->GetEvent(ievt)->GetValue(ivar);
         WriteFloat(f,&vf,1);
      }
   }
   fLogger << kINFO << "Number of test data written: " << fMethodRuleFit->Data()->GetNEvents() << Endl;
   //
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteVarNames()
{
   // write variable names, ascii
   std::ofstream f;
   if (!OpenRFile("varnames",f)) return kFALSE;
   for (UInt_t ivar=0; ivar<fMethodRuleFit->DataInfo().GetNVariables(); ivar++) {
      f << fMethodRuleFit->DataInfo().GetVariableInfo(ivar).GetExpression() << '\n';
   }
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteVarImp()

{
   // written by rf_go.exe
   fLogger << kWARNING << "WriteVarImp is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::WriteYhat()
{
   // written by rf_go.exe
   fLogger << kWARNING << "WriteYhat is not yet implemented" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::ReadYhat()
{
   // read the score
   fRFYhat.clear();
   //
   std::ifstream f;
   if (!OpenRFile("yhat",f)) return kFALSE;
   Int_t   neve;
   Float_t xval;
   ReadFloat(f,&xval,1);
   neve = static_cast<Int_t>(xval);
   if (neve!=fMethodRuleFit->Data()->GetNTestEvents()) {
      fLogger << kWARNING << "Inconsistent size of yhat file and test tree!" << Endl;
      fLogger << kWARNING << "neve = " << neve << " , tree = " << fMethodRuleFit->Data()->GetNTestEvents() << Endl;
      return kFALSE;
   }
   for (Int_t ievt=0; ievt<fMethodRuleFit->Data()->GetNTestEvents(); ievt++) {
      ReadFloat(f,&xval,1);
      fRFYhat.push_back(xval);
   }
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::ReadVarImp()
{
   // read variable importance
   fRFVarImp.clear();
   //
   std::ifstream f;
   if (!OpenRFile("varimp",f)) return kFALSE;
   UInt_t   nvars;
   Float_t xval;
   Float_t xmax=1.0;
   nvars=fMethodRuleFit->DataInfo().GetNVariables();
   //
   // First read all importances
   //
   for (UInt_t ivar=0; ivar<nvars; ivar++) {
      ReadFloat(f,&xval,1);
      if (ivar==0) {
         xmax=xval;
      } else {
         if (xval>xmax) xmax=xval;
      }
      fRFVarImp.push_back(xval);
   }
   //
   // Read the indices.
   // They are saved as float (!) by rf_go.exe.
   //
   for (UInt_t ivar=0; ivar<nvars; ivar++) {
      fRFVarImp[ivar] = fRFVarImp[ivar]/xmax;
      ReadFloat(f,&xval,1);
      fRFVarImpInd.push_back(Int_t(xval)-1);
   }
   return kTRUE;
}

//_______________________________________________________________________
Bool_t TMVA::RuleFitAPI::ReadModelSum()
{
   // read model from rulefit.sum
   fRFVarImp.clear();
   //
   fLogger << kVERBOSE << "Reading RuleFit summary file" << Endl;
   std::ifstream f;
   if (!OpenRFile("rulefit.sum",f)) return kFALSE;
   Int_t    lines=0;
   Int_t    nrules=0;
   Int_t    nvars=0;
   Int_t    nvarsOpt=0;
   Int_t    dumI;
   Float_t  dumF;
   Float_t  offset;
   Double_t impref=-1.0;
   Double_t imp;

   fRuleFit->GetRuleEnsemblePtr()->SetAverageRuleSigma(0.4); // value used by Friedmans RuleFit
   //
   //--------------------------------------------
   //       first read rulefit.sum header
   //--------------------------------------------
   // line      type    val     descr
   //   0       <int>   86      N(rules)x2
   //   1       <int>   155     ???
   //   2       <int>   1       ???
   //   3       <int>   1916    ???
   //   4       <int>   2       N(vars) ?
   //   5       <int>   2       N(vars) ?
   //   6       <float> 9e+30   xmiss
   //   7       <float> 1.1e-1  a0 (model offset)
   //--------------------------------------------
   //
   // NOTE: a model without any rules, will look like
   // for the first four lines:
   //
   //   0        1
   //   1        1
   //   2        1
   //   3        0
   //
   // There will later be one block of dummy data for one rule.
   // In order to catch this situation, some special checks are made below.
   //
   Bool_t norules;
   lines += ReadInt(f,&nrules);
   norules = (nrules==1);
   lines += ReadInt(f,&dumI);
   norules = norules && (dumI==1);
   lines += ReadInt(f,&dumI);
   norules = norules && (dumI==1);
   lines += ReadInt(f,&dumI);
   norules = norules && (dumI==0);
   if (nrules==0) norules=kTRUE; // this ugly construction is needed:(
   if (norules) nrules = 0;
   //
   lines += ReadInt(f,&nvars);
   lines += ReadInt(f,&nvarsOpt);
   lines += ReadFloat(f,&dumF);
   lines += ReadFloat(f,&offset);
   fLogger << kDEBUG << "N(rules) = " << nrules   << Endl;
   fLogger << kDEBUG << "N(vars)  = " << nvars    << Endl;
   fLogger << kDEBUG << "N(varsO) = " << nvarsOpt << Endl;
   fLogger << kDEBUG << "xmiss    = " << dumF     << Endl;
   fLogger << kDEBUG << "offset   = " << offset   << Endl;
   if (nvars!=nvarsOpt) {
      fLogger << kWARNING << "Format of rulefit.sum is ... weird?? Continuing but who knows how it will end...?" << Endl;
   }
   std::vector<Double_t> rfSupp;
   std::vector<Double_t> rfCoef;
   std::vector<Int_t>    rfNcut;
   std::vector<Rule *>   rfRules;
   if (norules) {
      // if no rules, read 8 blocks of data
      // this corresponds to one dummy rule
      for (Int_t t=0; t<8; t++) {
         lines += ReadFloat(f,&dumF);
      }
   }
   //
   //--------------------------------------------
   //       read first part of rule info
   //--------------------------------------------
   // 
   //   8       <int>   10      ???
   //   9       <float> 0.185   support
   //   10      <float> 0.051   coefficient
   //   11      <float> 2       num of cuts in rule
   //   12      <float> 1       ??? not used by this interface
   //
   for (Int_t r=0; r<nrules; r++) {
      lines += ReadFloat(f,&dumF);
      lines += ReadFloat(f,&dumF);
      rfSupp.push_back(dumF);
      lines += ReadFloat(f,&dumF);
      rfCoef.push_back(dumF);
      lines += ReadFloat(f,&dumF);
      rfNcut.push_back(static_cast<int>(dumF+0.5));
      lines += ReadFloat(f,&dumF);
      //
   }
   //--------------------------------------------
   //       read second part of rule info
   //--------------------------------------------
   //
   // Per range (cut):
   //   0    <float> 1       varind
   //   1    <float> -1.0    low
   //   2    <float>  1.56   high
   //

   for (Int_t r=0; r<nrules; r++) {
      Int_t    varind;
      Double_t xmin;
      Double_t xmax;
      Rule *rule = new Rule(fRuleFit->GetRuleEnsemblePtr());
      rfRules.push_back( rule );
      RuleCut *rfcut = new RuleCut();
      rfcut->SetNvars(rfNcut[r]);
      rule->SetRuleCut( rfcut );
      // the below are set to default values since no info is
      // available in rulefit.sum
      rule->SetNorm(1.0);
      rule->SetSupport(0);
      rule->SetSSB(0.0);
      rule->SetSSBNeve(0.0);
      rule->SetImportanceRef(1.0);
      rule->SetSSB(0.0);
      rule->SetSSBNeve(0.0);
      // set support etc
      rule->SetSupport(rfSupp[r]);
      rule->SetCoefficient(rfCoef[r]);
      rule->CalcImportance();
      imp = rule->GetImportance();
      if (imp>impref) impref = imp; // find max importance
      //
      fLogger << kDEBUG << "Rule #" << r << " : " << nvars << Endl;
      fLogger << kDEBUG << "  support  = " << rfSupp[r] << Endl;
      fLogger << kDEBUG << "  sigma    = " << rule->GetSigma() << Endl;
      fLogger << kDEBUG << "  coeff    = " << rfCoef[r] << Endl;
      fLogger << kDEBUG << "  N(cut)   = " << rfNcut[r] << Endl;

      for (Int_t c=0; c<rfNcut[r]; c++) {
         lines += ReadFloat(f,&dumF);
         varind = static_cast<Int_t>(dumF+0.5)-1;
         lines += ReadFloat(f,&dumF);
         xmin   = static_cast<Double_t>(dumF);
         lines += ReadFloat(f,&dumF);
         xmax   = static_cast<Double_t>(dumF);
         // create Rule HERE!
         rfcut->SetSelector(c,varind);
         rfcut->SetCutMin(c,xmin);
         rfcut->SetCutMax(c,xmax);
         // the following is not nice - this is however defined
         // by the rulefit.sum format.
         rfcut->SetCutDoMin(c,(xmin<-8.99e35 ? kFALSE:kTRUE));
         rfcut->SetCutDoMax(c,(xmax> 8.99e35 ? kFALSE:kTRUE));
         //
      }
   }
   fRuleFit->GetRuleEnsemblePtr()->SetRules( rfRules );
   fRuleFit->GetRuleEnsemblePtr()->SetOffset( offset );
   //--------------------------------------------
   //       read second part of rule info
   //--------------------------------------------
   //
   // Per linear term:
   // 73      1               var index
   // 74      -1.99594        min
   // 75      1.99403         max
   // 76      -0.000741858    ??? average ???
   // 77      0.970935        std
   // 78      0               coeff
   //
   std::vector<Int_t>    varind;
   std::vector<Double_t> xmin;
   std::vector<Double_t> xmax;
   std::vector<Double_t> average;
   std::vector<Double_t> stdev;
   std::vector<Double_t> norm;
   std::vector<Double_t> coeff;
   //
   for (Int_t c=0; c<nvars; c++) {
      lines += ReadFloat(f,&dumF);
      varind.push_back(static_cast<Int_t>(dumF+0.5)-1);
      lines += ReadFloat(f,&dumF);
      xmin.push_back(static_cast<Double_t>(dumF));
      lines += ReadFloat(f,&dumF);
      xmax.push_back(static_cast<Double_t>(dumF));
      lines += ReadFloat(f,&dumF);
      average.push_back(static_cast<Double_t>(dumF));
      lines += ReadFloat(f,&dumF);
      stdev.push_back(static_cast<Double_t>(dumF));
      Double_t nv = fRuleFit->GetRuleEnsemblePtr()->CalcLinNorm(stdev.back());
      norm.push_back(nv);
      lines += ReadFloat(f,&dumF);
      coeff.push_back(dumF/nv); // save coefficient for normalised var
      //
      fLogger << kDEBUG << "Linear #" << c << Endl;
      fLogger << kDEBUG << "  varind   = " << varind.back()  << Endl;
      fLogger << kDEBUG << "  xmin     = " << xmin.back()    << Endl;
      fLogger << kDEBUG << "  xmax     = " << xmax.back()    << Endl;
      fLogger << kDEBUG << "  average  = " << average.back() << Endl;
      fLogger << kDEBUG << "  stdev    = " << stdev.back()  << Endl;
      fLogger << kDEBUG << "  coeff    = " << coeff.back()  << Endl;
   }
   if (xmin.size()>0) {      
      fRuleFit->GetRuleEnsemblePtr()->SetLinCoefficients(coeff);
      fRuleFit->GetRuleEnsemblePtr()->SetLinDM(xmin);
      fRuleFit->GetRuleEnsemblePtr()->SetLinDP(xmax);
      fRuleFit->GetRuleEnsemblePtr()->SetLinNorm(norm);
   }
   //   fRuleFit->GetRuleEnsemblePtr()->CalcImportance();
   imp = fRuleFit->GetRuleEnsemblePtr()->CalcLinImportance();
   if (imp>impref) impref=imp;
   fRuleFit->GetRuleEnsemblePtr()->SetImportanceRef(impref);
   fRuleFit->GetRuleEnsemblePtr()->CleanupLinear(); // to fill fLinTermOK vector

   fRuleFit->GetRuleEnsemblePtr()->CalcVarImportance();
   //   fRuleFit->GetRuleEnsemblePtr()->CalcRuleSupport();

   fLogger << kDEBUG << "Reading model done" << Endl;
   return kTRUE;
}

//_______________________________________________________________________
Int_t TMVA::RuleFitAPI::RunRuleFit()
{
   // execute rf_go.exe
   TString oldDir = gSystem->pwd();
   TString cmd = "./rf_go.exe"; 
   gSystem->cd(fRFWorkDir.Data());
   int rval = gSystem->Exec(cmd.Data());
   gSystem->cd(oldDir.Data());
   return rval;
}
 RuleFitAPI.cxx:1
 RuleFitAPI.cxx:2
 RuleFitAPI.cxx:3
 RuleFitAPI.cxx:4
 RuleFitAPI.cxx:5
 RuleFitAPI.cxx:6
 RuleFitAPI.cxx:7
 RuleFitAPI.cxx:8
 RuleFitAPI.cxx:9
 RuleFitAPI.cxx:10
 RuleFitAPI.cxx:11
 RuleFitAPI.cxx:12
 RuleFitAPI.cxx:13
 RuleFitAPI.cxx:14
 RuleFitAPI.cxx:15
 RuleFitAPI.cxx:16
 RuleFitAPI.cxx:17
 RuleFitAPI.cxx:18
 RuleFitAPI.cxx:19
 RuleFitAPI.cxx:20
 RuleFitAPI.cxx:21
 RuleFitAPI.cxx:22
 RuleFitAPI.cxx:23
 RuleFitAPI.cxx:24
 RuleFitAPI.cxx:25
 RuleFitAPI.cxx:26
 RuleFitAPI.cxx:27
 RuleFitAPI.cxx:28
 RuleFitAPI.cxx:29
 RuleFitAPI.cxx:30
 RuleFitAPI.cxx:31
 RuleFitAPI.cxx:32
 RuleFitAPI.cxx:33
 RuleFitAPI.cxx:34
 RuleFitAPI.cxx:35
 RuleFitAPI.cxx:36
 RuleFitAPI.cxx:37
 RuleFitAPI.cxx:38
 RuleFitAPI.cxx:39
 RuleFitAPI.cxx:40
 RuleFitAPI.cxx:41
 RuleFitAPI.cxx:42
 RuleFitAPI.cxx:43
 RuleFitAPI.cxx:44
 RuleFitAPI.cxx:45
 RuleFitAPI.cxx:46
 RuleFitAPI.cxx:47
 RuleFitAPI.cxx:48
 RuleFitAPI.cxx:49
 RuleFitAPI.cxx:50
 RuleFitAPI.cxx:51
 RuleFitAPI.cxx:52
 RuleFitAPI.cxx:53
 RuleFitAPI.cxx:54
 RuleFitAPI.cxx:55
 RuleFitAPI.cxx:56
 RuleFitAPI.cxx:57
 RuleFitAPI.cxx:58
 RuleFitAPI.cxx:59
 RuleFitAPI.cxx:60
 RuleFitAPI.cxx:61
 RuleFitAPI.cxx:62
 RuleFitAPI.cxx:63
 RuleFitAPI.cxx:64
 RuleFitAPI.cxx:65
 RuleFitAPI.cxx:66
 RuleFitAPI.cxx:67
 RuleFitAPI.cxx:68
 RuleFitAPI.cxx:69
 RuleFitAPI.cxx:70
 RuleFitAPI.cxx:71
 RuleFitAPI.cxx:72
 RuleFitAPI.cxx:73
 RuleFitAPI.cxx:74
 RuleFitAPI.cxx:75
 RuleFitAPI.cxx:76
 RuleFitAPI.cxx:77
 RuleFitAPI.cxx:78
 RuleFitAPI.cxx:79
 RuleFitAPI.cxx:80
 RuleFitAPI.cxx:81
 RuleFitAPI.cxx:82
 RuleFitAPI.cxx:83
 RuleFitAPI.cxx:84
 RuleFitAPI.cxx:85
 RuleFitAPI.cxx:86
 RuleFitAPI.cxx:87
 RuleFitAPI.cxx:88
 RuleFitAPI.cxx:89
 RuleFitAPI.cxx:90
 RuleFitAPI.cxx:91
 RuleFitAPI.cxx:92
 RuleFitAPI.cxx:93
 RuleFitAPI.cxx:94
 RuleFitAPI.cxx:95
 RuleFitAPI.cxx:96
 RuleFitAPI.cxx:97
 RuleFitAPI.cxx:98
 RuleFitAPI.cxx:99
 RuleFitAPI.cxx:100
 RuleFitAPI.cxx:101
 RuleFitAPI.cxx:102
 RuleFitAPI.cxx:103
 RuleFitAPI.cxx:104
 RuleFitAPI.cxx:105
 RuleFitAPI.cxx:106
 RuleFitAPI.cxx:107
 RuleFitAPI.cxx:108
 RuleFitAPI.cxx:109
 RuleFitAPI.cxx:110
 RuleFitAPI.cxx:111
 RuleFitAPI.cxx:112
 RuleFitAPI.cxx:113
 RuleFitAPI.cxx:114
 RuleFitAPI.cxx:115
 RuleFitAPI.cxx:116
 RuleFitAPI.cxx:117
 RuleFitAPI.cxx:118
 RuleFitAPI.cxx:119
 RuleFitAPI.cxx:120
 RuleFitAPI.cxx:121
 RuleFitAPI.cxx:122
 RuleFitAPI.cxx:123
 RuleFitAPI.cxx:124
 RuleFitAPI.cxx:125
 RuleFitAPI.cxx:126
 RuleFitAPI.cxx:127
 RuleFitAPI.cxx:128
 RuleFitAPI.cxx:129
 RuleFitAPI.cxx:130
 RuleFitAPI.cxx:131
 RuleFitAPI.cxx:132
 RuleFitAPI.cxx:133
 RuleFitAPI.cxx:134
 RuleFitAPI.cxx:135
 RuleFitAPI.cxx:136
 RuleFitAPI.cxx:137
 RuleFitAPI.cxx:138
 RuleFitAPI.cxx:139
 RuleFitAPI.cxx:140
 RuleFitAPI.cxx:141
 RuleFitAPI.cxx:142
 RuleFitAPI.cxx:143
 RuleFitAPI.cxx:144
 RuleFitAPI.cxx:145
 RuleFitAPI.cxx:146
 RuleFitAPI.cxx:147
 RuleFitAPI.cxx:148
 RuleFitAPI.cxx:149
 RuleFitAPI.cxx:150
 RuleFitAPI.cxx:151
 RuleFitAPI.cxx:152
 RuleFitAPI.cxx:153
 RuleFitAPI.cxx:154
 RuleFitAPI.cxx:155
 RuleFitAPI.cxx:156
 RuleFitAPI.cxx:157
 RuleFitAPI.cxx:158
 RuleFitAPI.cxx:159
 RuleFitAPI.cxx:160
 RuleFitAPI.cxx:161
 RuleFitAPI.cxx:162
 RuleFitAPI.cxx:163
 RuleFitAPI.cxx:164
 RuleFitAPI.cxx:165
 RuleFitAPI.cxx:166
 RuleFitAPI.cxx:167
 RuleFitAPI.cxx:168
 RuleFitAPI.cxx:169
 RuleFitAPI.cxx:170
 RuleFitAPI.cxx:171
 RuleFitAPI.cxx:172
 RuleFitAPI.cxx:173
 RuleFitAPI.cxx:174
 RuleFitAPI.cxx:175
 RuleFitAPI.cxx:176
 RuleFitAPI.cxx:177
 RuleFitAPI.cxx:178
 RuleFitAPI.cxx:179
 RuleFitAPI.cxx:180
 RuleFitAPI.cxx:181
 RuleFitAPI.cxx:182
 RuleFitAPI.cxx:183
 RuleFitAPI.cxx:184
 RuleFitAPI.cxx:185
 RuleFitAPI.cxx:186
 RuleFitAPI.cxx:187
 RuleFitAPI.cxx:188
 RuleFitAPI.cxx:189
 RuleFitAPI.cxx:190
 RuleFitAPI.cxx:191
 RuleFitAPI.cxx:192
 RuleFitAPI.cxx:193
 RuleFitAPI.cxx:194
 RuleFitAPI.cxx:195
 RuleFitAPI.cxx:196
 RuleFitAPI.cxx:197
 RuleFitAPI.cxx:198
 RuleFitAPI.cxx:199
 RuleFitAPI.cxx:200
 RuleFitAPI.cxx:201
 RuleFitAPI.cxx:202
 RuleFitAPI.cxx:203
 RuleFitAPI.cxx:204
 RuleFitAPI.cxx:205
 RuleFitAPI.cxx:206
 RuleFitAPI.cxx:207
 RuleFitAPI.cxx:208
 RuleFitAPI.cxx:209
 RuleFitAPI.cxx:210
 RuleFitAPI.cxx:211
 RuleFitAPI.cxx:212
 RuleFitAPI.cxx:213
 RuleFitAPI.cxx:214
 RuleFitAPI.cxx:215
 RuleFitAPI.cxx:216
 RuleFitAPI.cxx:217
 RuleFitAPI.cxx:218
 RuleFitAPI.cxx:219
 RuleFitAPI.cxx:220
 RuleFitAPI.cxx:221
 RuleFitAPI.cxx:222
 RuleFitAPI.cxx:223
 RuleFitAPI.cxx:224
 RuleFitAPI.cxx:225
 RuleFitAPI.cxx:226
 RuleFitAPI.cxx:227
 RuleFitAPI.cxx:228
 RuleFitAPI.cxx:229
 RuleFitAPI.cxx:230
 RuleFitAPI.cxx:231
 RuleFitAPI.cxx:232
 RuleFitAPI.cxx:233
 RuleFitAPI.cxx:234
 RuleFitAPI.cxx:235
 RuleFitAPI.cxx:236
 RuleFitAPI.cxx:237
 RuleFitAPI.cxx:238
 RuleFitAPI.cxx:239
 RuleFitAPI.cxx:240
 RuleFitAPI.cxx:241
 RuleFitAPI.cxx:242
 RuleFitAPI.cxx:243
 RuleFitAPI.cxx:244
 RuleFitAPI.cxx:245
 RuleFitAPI.cxx:246
 RuleFitAPI.cxx:247
 RuleFitAPI.cxx:248
 RuleFitAPI.cxx:249
 RuleFitAPI.cxx:250
 RuleFitAPI.cxx:251
 RuleFitAPI.cxx:252
 RuleFitAPI.cxx:253
 RuleFitAPI.cxx:254
 RuleFitAPI.cxx:255
 RuleFitAPI.cxx:256
 RuleFitAPI.cxx:257
 RuleFitAPI.cxx:258
 RuleFitAPI.cxx:259
 RuleFitAPI.cxx:260
 RuleFitAPI.cxx:261
 RuleFitAPI.cxx:262
 RuleFitAPI.cxx:263
 RuleFitAPI.cxx:264
 RuleFitAPI.cxx:265
 RuleFitAPI.cxx:266
 RuleFitAPI.cxx:267
 RuleFitAPI.cxx:268
 RuleFitAPI.cxx:269
 RuleFitAPI.cxx:270
 RuleFitAPI.cxx:271
 RuleFitAPI.cxx:272
 RuleFitAPI.cxx:273
 RuleFitAPI.cxx:274
 RuleFitAPI.cxx:275
 RuleFitAPI.cxx:276
 RuleFitAPI.cxx:277
 RuleFitAPI.cxx:278
 RuleFitAPI.cxx:279
 RuleFitAPI.cxx:280
 RuleFitAPI.cxx:281
 RuleFitAPI.cxx:282
 RuleFitAPI.cxx:283
 RuleFitAPI.cxx:284
 RuleFitAPI.cxx:285
 RuleFitAPI.cxx:286
 RuleFitAPI.cxx:287
 RuleFitAPI.cxx:288
 RuleFitAPI.cxx:289
 RuleFitAPI.cxx:290
 RuleFitAPI.cxx:291
 RuleFitAPI.cxx:292
 RuleFitAPI.cxx:293
 RuleFitAPI.cxx:294
 RuleFitAPI.cxx:295
 RuleFitAPI.cxx:296
 RuleFitAPI.cxx:297
 RuleFitAPI.cxx:298
 RuleFitAPI.cxx:299
 RuleFitAPI.cxx:300
 RuleFitAPI.cxx:301
 RuleFitAPI.cxx:302
 RuleFitAPI.cxx:303
 RuleFitAPI.cxx:304
 RuleFitAPI.cxx:305
 RuleFitAPI.cxx:306
 RuleFitAPI.cxx:307
 RuleFitAPI.cxx:308
 RuleFitAPI.cxx:309
 RuleFitAPI.cxx:310
 RuleFitAPI.cxx:311
 RuleFitAPI.cxx:312
 RuleFitAPI.cxx:313
 RuleFitAPI.cxx:314
 RuleFitAPI.cxx:315
 RuleFitAPI.cxx:316
 RuleFitAPI.cxx:317
 RuleFitAPI.cxx:318
 RuleFitAPI.cxx:319
 RuleFitAPI.cxx:320
 RuleFitAPI.cxx:321
 RuleFitAPI.cxx:322
 RuleFitAPI.cxx:323
 RuleFitAPI.cxx:324
 RuleFitAPI.cxx:325
 RuleFitAPI.cxx:326
 RuleFitAPI.cxx:327
 RuleFitAPI.cxx:328
 RuleFitAPI.cxx:329
 RuleFitAPI.cxx:330
 RuleFitAPI.cxx:331
 RuleFitAPI.cxx:332
 RuleFitAPI.cxx:333
 RuleFitAPI.cxx:334
 RuleFitAPI.cxx:335
 RuleFitAPI.cxx:336
 RuleFitAPI.cxx:337
 RuleFitAPI.cxx:338
 RuleFitAPI.cxx:339
 RuleFitAPI.cxx:340
 RuleFitAPI.cxx:341
 RuleFitAPI.cxx:342
 RuleFitAPI.cxx:343
 RuleFitAPI.cxx:344
 RuleFitAPI.cxx:345
 RuleFitAPI.cxx:346
 RuleFitAPI.cxx:347
 RuleFitAPI.cxx:348
 RuleFitAPI.cxx:349
 RuleFitAPI.cxx:350
 RuleFitAPI.cxx:351
 RuleFitAPI.cxx:352
 RuleFitAPI.cxx:353
 RuleFitAPI.cxx:354
 RuleFitAPI.cxx:355
 RuleFitAPI.cxx:356
 RuleFitAPI.cxx:357
 RuleFitAPI.cxx:358
 RuleFitAPI.cxx:359
 RuleFitAPI.cxx:360
 RuleFitAPI.cxx:361
 RuleFitAPI.cxx:362
 RuleFitAPI.cxx:363
 RuleFitAPI.cxx:364
 RuleFitAPI.cxx:365
 RuleFitAPI.cxx:366
 RuleFitAPI.cxx:367
 RuleFitAPI.cxx:368
 RuleFitAPI.cxx:369
 RuleFitAPI.cxx:370
 RuleFitAPI.cxx:371
 RuleFitAPI.cxx:372
 RuleFitAPI.cxx:373
 RuleFitAPI.cxx:374
 RuleFitAPI.cxx:375
 RuleFitAPI.cxx:376
 RuleFitAPI.cxx:377
 RuleFitAPI.cxx:378
 RuleFitAPI.cxx:379
 RuleFitAPI.cxx:380
 RuleFitAPI.cxx:381
 RuleFitAPI.cxx:382
 RuleFitAPI.cxx:383
 RuleFitAPI.cxx:384
 RuleFitAPI.cxx:385
 RuleFitAPI.cxx:386
 RuleFitAPI.cxx:387
 RuleFitAPI.cxx:388
 RuleFitAPI.cxx:389
 RuleFitAPI.cxx:390
 RuleFitAPI.cxx:391
 RuleFitAPI.cxx:392
 RuleFitAPI.cxx:393
 RuleFitAPI.cxx:394
 RuleFitAPI.cxx:395
 RuleFitAPI.cxx:396
 RuleFitAPI.cxx:397
 RuleFitAPI.cxx:398
 RuleFitAPI.cxx:399
 RuleFitAPI.cxx:400
 RuleFitAPI.cxx:401
 RuleFitAPI.cxx:402
 RuleFitAPI.cxx:403
 RuleFitAPI.cxx:404
 RuleFitAPI.cxx:405
 RuleFitAPI.cxx:406
 RuleFitAPI.cxx:407
 RuleFitAPI.cxx:408
 RuleFitAPI.cxx:409
 RuleFitAPI.cxx:410
 RuleFitAPI.cxx:411
 RuleFitAPI.cxx:412
 RuleFitAPI.cxx:413
 RuleFitAPI.cxx:414
 RuleFitAPI.cxx:415
 RuleFitAPI.cxx:416
 RuleFitAPI.cxx:417
 RuleFitAPI.cxx:418
 RuleFitAPI.cxx:419
 RuleFitAPI.cxx:420
 RuleFitAPI.cxx:421
 RuleFitAPI.cxx:422
 RuleFitAPI.cxx:423
 RuleFitAPI.cxx:424
 RuleFitAPI.cxx:425
 RuleFitAPI.cxx:426
 RuleFitAPI.cxx:427
 RuleFitAPI.cxx:428
 RuleFitAPI.cxx:429
 RuleFitAPI.cxx:430
 RuleFitAPI.cxx:431
 RuleFitAPI.cxx:432
 RuleFitAPI.cxx:433
 RuleFitAPI.cxx:434
 RuleFitAPI.cxx:435
 RuleFitAPI.cxx:436
 RuleFitAPI.cxx:437
 RuleFitAPI.cxx:438
 RuleFitAPI.cxx:439
 RuleFitAPI.cxx:440
 RuleFitAPI.cxx:441
 RuleFitAPI.cxx:442
 RuleFitAPI.cxx:443
 RuleFitAPI.cxx:444
 RuleFitAPI.cxx:445
 RuleFitAPI.cxx:446
 RuleFitAPI.cxx:447
 RuleFitAPI.cxx:448
 RuleFitAPI.cxx:449
 RuleFitAPI.cxx:450
 RuleFitAPI.cxx:451
 RuleFitAPI.cxx:452
 RuleFitAPI.cxx:453
 RuleFitAPI.cxx:454
 RuleFitAPI.cxx:455
 RuleFitAPI.cxx:456
 RuleFitAPI.cxx:457
 RuleFitAPI.cxx:458
 RuleFitAPI.cxx:459
 RuleFitAPI.cxx:460
 RuleFitAPI.cxx:461
 RuleFitAPI.cxx:462
 RuleFitAPI.cxx:463
 RuleFitAPI.cxx:464
 RuleFitAPI.cxx:465
 RuleFitAPI.cxx:466
 RuleFitAPI.cxx:467
 RuleFitAPI.cxx:468
 RuleFitAPI.cxx:469
 RuleFitAPI.cxx:470
 RuleFitAPI.cxx:471
 RuleFitAPI.cxx:472
 RuleFitAPI.cxx:473
 RuleFitAPI.cxx:474
 RuleFitAPI.cxx:475
 RuleFitAPI.cxx:476
 RuleFitAPI.cxx:477
 RuleFitAPI.cxx:478
 RuleFitAPI.cxx:479
 RuleFitAPI.cxx:480
 RuleFitAPI.cxx:481
 RuleFitAPI.cxx:482
 RuleFitAPI.cxx:483
 RuleFitAPI.cxx:484
 RuleFitAPI.cxx:485
 RuleFitAPI.cxx:486
 RuleFitAPI.cxx:487
 RuleFitAPI.cxx:488
 RuleFitAPI.cxx:489
 RuleFitAPI.cxx:490
 RuleFitAPI.cxx:491
 RuleFitAPI.cxx:492
 RuleFitAPI.cxx:493
 RuleFitAPI.cxx:494
 RuleFitAPI.cxx:495
 RuleFitAPI.cxx:496
 RuleFitAPI.cxx:497
 RuleFitAPI.cxx:498
 RuleFitAPI.cxx:499
 RuleFitAPI.cxx:500
 RuleFitAPI.cxx:501
 RuleFitAPI.cxx:502
 RuleFitAPI.cxx:503
 RuleFitAPI.cxx:504
 RuleFitAPI.cxx:505
 RuleFitAPI.cxx:506
 RuleFitAPI.cxx:507
 RuleFitAPI.cxx:508
 RuleFitAPI.cxx:509
 RuleFitAPI.cxx:510
 RuleFitAPI.cxx:511
 RuleFitAPI.cxx:512
 RuleFitAPI.cxx:513
 RuleFitAPI.cxx:514
 RuleFitAPI.cxx:515
 RuleFitAPI.cxx:516
 RuleFitAPI.cxx:517
 RuleFitAPI.cxx:518
 RuleFitAPI.cxx:519
 RuleFitAPI.cxx:520
 RuleFitAPI.cxx:521
 RuleFitAPI.cxx:522
 RuleFitAPI.cxx:523
 RuleFitAPI.cxx:524
 RuleFitAPI.cxx:525
 RuleFitAPI.cxx:526
 RuleFitAPI.cxx:527
 RuleFitAPI.cxx:528
 RuleFitAPI.cxx:529
 RuleFitAPI.cxx:530
 RuleFitAPI.cxx:531
 RuleFitAPI.cxx:532
 RuleFitAPI.cxx:533
 RuleFitAPI.cxx:534
 RuleFitAPI.cxx:535
 RuleFitAPI.cxx:536
 RuleFitAPI.cxx:537
 RuleFitAPI.cxx:538
 RuleFitAPI.cxx:539
 RuleFitAPI.cxx:540
 RuleFitAPI.cxx:541
 RuleFitAPI.cxx:542
 RuleFitAPI.cxx:543
 RuleFitAPI.cxx:544
 RuleFitAPI.cxx:545
 RuleFitAPI.cxx:546
 RuleFitAPI.cxx:547
 RuleFitAPI.cxx:548
 RuleFitAPI.cxx:549
 RuleFitAPI.cxx:550
 RuleFitAPI.cxx:551
 RuleFitAPI.cxx:552
 RuleFitAPI.cxx:553
 RuleFitAPI.cxx:554
 RuleFitAPI.cxx:555
 RuleFitAPI.cxx:556
 RuleFitAPI.cxx:557
 RuleFitAPI.cxx:558
 RuleFitAPI.cxx:559
 RuleFitAPI.cxx:560
 RuleFitAPI.cxx:561
 RuleFitAPI.cxx:562
 RuleFitAPI.cxx:563
 RuleFitAPI.cxx:564
 RuleFitAPI.cxx:565
 RuleFitAPI.cxx:566
 RuleFitAPI.cxx:567
 RuleFitAPI.cxx:568
 RuleFitAPI.cxx:569
 RuleFitAPI.cxx:570
 RuleFitAPI.cxx:571
 RuleFitAPI.cxx:572
 RuleFitAPI.cxx:573
 RuleFitAPI.cxx:574
 RuleFitAPI.cxx:575
 RuleFitAPI.cxx:576
 RuleFitAPI.cxx:577
 RuleFitAPI.cxx:578
 RuleFitAPI.cxx:579
 RuleFitAPI.cxx:580
 RuleFitAPI.cxx:581
 RuleFitAPI.cxx:582
 RuleFitAPI.cxx:583
 RuleFitAPI.cxx:584
 RuleFitAPI.cxx:585
 RuleFitAPI.cxx:586
 RuleFitAPI.cxx:587
 RuleFitAPI.cxx:588
 RuleFitAPI.cxx:589
 RuleFitAPI.cxx:590
 RuleFitAPI.cxx:591
 RuleFitAPI.cxx:592
 RuleFitAPI.cxx:593
 RuleFitAPI.cxx:594
 RuleFitAPI.cxx:595
 RuleFitAPI.cxx:596
 RuleFitAPI.cxx:597
 RuleFitAPI.cxx:598
 RuleFitAPI.cxx:599
 RuleFitAPI.cxx:600
 RuleFitAPI.cxx:601
 RuleFitAPI.cxx:602
 RuleFitAPI.cxx:603
 RuleFitAPI.cxx:604
 RuleFitAPI.cxx:605
 RuleFitAPI.cxx:606
 RuleFitAPI.cxx:607
 RuleFitAPI.cxx:608
 RuleFitAPI.cxx:609
 RuleFitAPI.cxx:610
 RuleFitAPI.cxx:611
 RuleFitAPI.cxx:612
 RuleFitAPI.cxx:613
 RuleFitAPI.cxx:614
 RuleFitAPI.cxx:615
 RuleFitAPI.cxx:616
 RuleFitAPI.cxx:617
 RuleFitAPI.cxx:618
 RuleFitAPI.cxx:619
 RuleFitAPI.cxx:620
 RuleFitAPI.cxx:621
 RuleFitAPI.cxx:622
 RuleFitAPI.cxx:623
 RuleFitAPI.cxx:624
 RuleFitAPI.cxx:625
 RuleFitAPI.cxx:626
 RuleFitAPI.cxx:627
 RuleFitAPI.cxx:628
 RuleFitAPI.cxx:629
 RuleFitAPI.cxx:630
 RuleFitAPI.cxx:631
 RuleFitAPI.cxx:632
 RuleFitAPI.cxx:633
 RuleFitAPI.cxx:634
 RuleFitAPI.cxx:635
 RuleFitAPI.cxx:636
 RuleFitAPI.cxx:637
 RuleFitAPI.cxx:638
 RuleFitAPI.cxx:639
 RuleFitAPI.cxx:640
 RuleFitAPI.cxx:641
 RuleFitAPI.cxx:642
 RuleFitAPI.cxx:643
 RuleFitAPI.cxx:644
 RuleFitAPI.cxx:645
 RuleFitAPI.cxx:646
 RuleFitAPI.cxx:647
 RuleFitAPI.cxx:648
 RuleFitAPI.cxx:649
 RuleFitAPI.cxx:650
 RuleFitAPI.cxx:651
 RuleFitAPI.cxx:652
 RuleFitAPI.cxx:653
 RuleFitAPI.cxx:654
 RuleFitAPI.cxx:655
 RuleFitAPI.cxx:656
 RuleFitAPI.cxx:657
 RuleFitAPI.cxx:658
 RuleFitAPI.cxx:659
 RuleFitAPI.cxx:660
 RuleFitAPI.cxx:661
 RuleFitAPI.cxx:662
 RuleFitAPI.cxx:663
 RuleFitAPI.cxx:664
 RuleFitAPI.cxx:665
 RuleFitAPI.cxx:666
 RuleFitAPI.cxx:667
 RuleFitAPI.cxx:668
 RuleFitAPI.cxx:669
 RuleFitAPI.cxx:670
 RuleFitAPI.cxx:671
 RuleFitAPI.cxx:672
 RuleFitAPI.cxx:673
 RuleFitAPI.cxx:674
 RuleFitAPI.cxx:675
 RuleFitAPI.cxx:676
 RuleFitAPI.cxx:677
 RuleFitAPI.cxx:678
 RuleFitAPI.cxx:679
 RuleFitAPI.cxx:680
 RuleFitAPI.cxx:681
 RuleFitAPI.cxx:682
 RuleFitAPI.cxx:683
 RuleFitAPI.cxx:684
 RuleFitAPI.cxx:685
 RuleFitAPI.cxx:686
 RuleFitAPI.cxx:687
 RuleFitAPI.cxx:688
 RuleFitAPI.cxx:689
 RuleFitAPI.cxx:690
 RuleFitAPI.cxx:691
 RuleFitAPI.cxx:692
 RuleFitAPI.cxx:693
 RuleFitAPI.cxx:694
 RuleFitAPI.cxx:695
 RuleFitAPI.cxx:696
 RuleFitAPI.cxx:697
 RuleFitAPI.cxx:698
 RuleFitAPI.cxx:699
 RuleFitAPI.cxx:700
 RuleFitAPI.cxx:701
 RuleFitAPI.cxx:702
 RuleFitAPI.cxx:703
 RuleFitAPI.cxx:704
 RuleFitAPI.cxx:705
 RuleFitAPI.cxx:706
 RuleFitAPI.cxx:707
 RuleFitAPI.cxx:708
 RuleFitAPI.cxx:709
 RuleFitAPI.cxx:710
 RuleFitAPI.cxx:711
 RuleFitAPI.cxx:712
 RuleFitAPI.cxx:713
 RuleFitAPI.cxx:714
 RuleFitAPI.cxx:715
 RuleFitAPI.cxx:716
 RuleFitAPI.cxx:717
 RuleFitAPI.cxx:718
 RuleFitAPI.cxx:719
 RuleFitAPI.cxx:720
 RuleFitAPI.cxx:721
 RuleFitAPI.cxx:722
 RuleFitAPI.cxx:723
 RuleFitAPI.cxx:724
 RuleFitAPI.cxx:725
 RuleFitAPI.cxx:726
 RuleFitAPI.cxx:727
 RuleFitAPI.cxx:728
 RuleFitAPI.cxx:729
 RuleFitAPI.cxx:730
 RuleFitAPI.cxx:731
 RuleFitAPI.cxx:732
 RuleFitAPI.cxx:733
 RuleFitAPI.cxx:734
 RuleFitAPI.cxx:735
 RuleFitAPI.cxx:736
 RuleFitAPI.cxx:737
 RuleFitAPI.cxx:738
 RuleFitAPI.cxx:739
 RuleFitAPI.cxx:740
 RuleFitAPI.cxx:741
 RuleFitAPI.cxx:742
 RuleFitAPI.cxx:743
 RuleFitAPI.cxx:744
 RuleFitAPI.cxx:745
 RuleFitAPI.cxx:746
 RuleFitAPI.cxx:747
 RuleFitAPI.cxx:748