ROOT logo
// @(#)root/tmva $Id: MethodCommittee.cxx 29195 2009-06-24 10:39:49Z brun $ 
// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : MethodCommittee                                                       *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation                                                            *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Joerg Stelzer   <Joerg.Stelzer@cern.ch>  - CERN, Switzerland              *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *                                                                                *
 * Copyright (c) 2005:                                                            *
 *      CERN, Switzerland                                                         * 
 *      U. of Victoria, Canada                                                    * 
 *      MPI-K Heidelberg, Germany                                                 * 
 *      LAPP, Annecy, France                                                      *
 *                                                                                *
 * 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)                                          *
 **********************************************************************************/

//_______________________________________________________________________
//                                                                      
// Boosting: 
//
// the idea behind the boosting is, that signal events from the training
// sample, that end up in a background node (and vice versa) are given a
// larger weight than events that are in the correct leave node. This
// results in a re-weighed training event sample, with which then a new
// decision tree can be developed. The boosting can be applied several
// times (typically 100-500 times) and one ends up with a set of decision
// trees (a forest).
//
// Bagging: 
//
// In this particular variant of the Boosted Decision Trees the boosting
// is not done on the basis of previous training results, but by a simple
// stochasitc re-sampling of the initial training event sample.
//_______________________________________________________________________

#include "TMVA/ClassifierFactory.h"
#include "TMVA/MethodCommittee.h"
#include "TMVA/Tools.h"
#include "TMVA/Timer.h"
#include "Riostream.h"
#include "TMath.h"
#include "TRandom3.h"
#include <algorithm>
#include "TObjString.h"
#include "TDirectory.h"
#include "TMVA/Ranking.h"
#include "TMVA/IMethod.h"

using std::vector;

REGISTER_METHOD(Committee)

ClassImp(TMVA::MethodCommittee)
 
//_______________________________________________________________________
TMVA::MethodCommittee::MethodCommittee( const TString& jobName,
                                        const TString& methodTitle,
                                        DataSetInfo& dsi, 
                                        const TString& theOption,
                                        TDirectory* theTargetDir ) :
   TMVA::MethodBase( jobName, Types::kCommittee, methodTitle, dsi, theOption, theTargetDir ),
   fNMembers(100),
   fBoostType("AdaBoost")
{
   // constructor
}

//_______________________________________________________________________
TMVA::MethodCommittee::MethodCommittee( DataSetInfo& theData, 
                                        const TString& theWeightFile,  
                                        TDirectory* theTargetDir ) :
   TMVA::MethodBase( Types::kCommittee, theData, theWeightFile, theTargetDir ),
   fNMembers(100),
   fBoostType("AdaBoost")
{
   // constructor for calculating Committee-MVA using previously generatad decision trees
   // the result of the previous training (the decision trees) are read in via the
   // weightfile. Make sure the "theVariables" correspond to the ones used in 
   // creating the "weight"-file
}

//_______________________________________________________________________
Bool_t TMVA::MethodCommittee::HasAnalysisType( Types::EAnalysisType type, UInt_t numberClasses, UInt_t numberTargets )
{
   // FDA can handle classification with 2 classes and regression with one regression-target
   if( type == Types::kClassification && numberClasses == 2 ) return kTRUE;
   if( type == Types::kRegression && numberTargets == 1 ) return kTRUE;
   return kFALSE;
}

//_______________________________________________________________________
void TMVA::MethodCommittee::DeclareOptions() 
{
   // define the options (their key words) that can be set in the option string 
   // know options:
   // NMembers           <string>     number of members in the committee
   // UseMemberDecision  <bool>       use signal information from event (otherwise assume signal)
   // UseWeightedMembers <bool>       use weighted trees or simple average in classification from the forest
   //
   // BoostType          <string>     boosting type
   //    available values are:        AdaBoost  <default>
   //                                 Bagging

   DeclareOptionRef(fNMembers, "NMembers", "number of members in the committee");
   DeclareOptionRef(fUseMemberDecision=kFALSE, "UseMemberDecision", "use binary information from IsSignal");
   DeclareOptionRef(fUseWeightedMembers=kTRUE, "UseWeightedMembers", "use weighted trees or simple average in classification from the forest");

   DeclareOptionRef(fBoostType, "BoostType", "boosting type");
   AddPreDefVal(TString("AdaBoost"));
   AddPreDefVal(TString("Bagging"));
}

//_______________________________________________________________________
void TMVA::MethodCommittee::ProcessOptions() 
{
   // process user options

   // book monitoring histograms (currently for AdaBost, only)
   fBoostFactorHist = new TH1F("fBoostFactor","Ada Boost weights",100,1,100);
   fErrFractHist    = new TH2F("fErrFractHist","error fraction vs tree number",
                               fNMembers,0,fNMembers,50,0,0.5);
   fMonitorNtuple   = new TTree("fMonitorNtuple","Committee variables");
   fMonitorNtuple->Branch("iTree",&fITree,"iTree/I");
   fMonitorNtuple->Branch("boostFactor",&fBoostFactor,"boostFactor/D");
   fMonitorNtuple->Branch("errorFraction",&fErrorFraction,"errorFraction/D");
}

//_______________________________________________________________________
void TMVA::MethodCommittee::Init( void )
{
   // common initialisation with defaults for the Committee-Method

   fNMembers  = 100;
   fBoostType = "AdaBoost";   

   fCommittee.clear();
   fBoostWeights.clear();
}

//_______________________________________________________________________
TMVA::MethodCommittee::~MethodCommittee( void )
{
   //destructor
   for (UInt_t i=0; i<GetCommittee().size(); i++)   delete fCommittee[i];
   fCommittee.clear();
}

//_______________________________________________________________________
void TMVA::MethodCommittee::WriteStateToFile() const
{ 
   // Function to write options and weights to file

   // get the filename
   TString fname(GetWeightFileName());
   Log() << kINFO << "creating weight file: " << fname << Endl;
   
   std::ofstream* fout = new std::ofstream( fname );
   if (!fout->good()) { // file not found --> Error
      Log() << kFATAL << "<WriteStateToFile> "
              << "unable to open output  weight file: " << fname << endl;
   }
   
   WriteStateToStream( *fout );
}


//_______________________________________________________________________
void TMVA::MethodCommittee::Train( void )
{  
   // training

   Log() << kINFO << "will train "<< fNMembers << " committee members ... patience please" << Endl;

   Timer timer( fNMembers, GetName() ); 
   for (UInt_t imember=0; imember<fNMembers; imember++){
      timer.DrawProgressBar( imember );

      IMethod* method = ClassifierFactory::Instance().Create(std::string(Types::Instance().GetMethodName( fMemberType )), 
                                                             GetJobName(),
                                                             GetMethodName(),
                                                             DataInfo(),
                                                             fMemberOption );


      
      // train each of the member methods
      method->Train();

      GetBoostWeights().push_back( this->Boost( dynamic_cast<MethodBase*>(method), imember ) );

      GetCommittee().push_back( method );

      fMonitorNtuple->Fill();
   }

   // get elapsed time
   Log() << kINFO << "elapsed time: " << timer.GetElapsedTime()    
           << "                              " << Endl;    
}

//_______________________________________________________________________
Double_t TMVA::MethodCommittee::Boost( TMVA::MethodBase* method, UInt_t imember )
{
   // apply the boosting alogrithim (the algorithm is selecte via the the "option" given
   // in the constructor. The return value is the boosting weight 
  
   if      (fBoostType=="AdaBoost") return this->AdaBoost( method );
   else if (fBoostType=="Bagging")  return this->Bagging( imember );
   else {
      Log() << kINFO << GetOptions() << Endl;
      Log() << kFATAL << "<Boost> unknown boost option called" << Endl;
   }
   return 1.0;
}

//_______________________________________________________________________
Double_t TMVA::MethodCommittee::AdaBoost( TMVA::MethodBase* method )
{
   // the AdaBoost implementation.
   // a new training sample is generated by weighting 
   // events that are misclassified by the decision tree. The weight
   // applied is w = (1-err)/err or more general:
   //            w = ((1-err)/err)^beta
   // where err is the fracthin of misclassified events in the tree ( <0.5 assuming
   // demanding the that previous selection was better than random guessing)
   // and "beta" beeing a free parameter (standard: beta = 1) that modifies the
   // boosting.

   Double_t adaBoostBeta = 1.;   // that's apparently the standard value :)

   // should never be called without existing trainingTree
   if (Data()->GetNTrainingEvents()) Log() << kFATAL << "<AdaBoost> Data().TrainingTree() is zero pointer" << Endl;

   Double_t err=0, sumw=0, sumwfalse=0, count=0;
   vector<Char_t> correctSelected;

   // loop over all events in training tree
   MethodBase* mbase = (MethodBase*)method;
   for (Int_t ievt=0; ievt<Data()->GetNTrainingEvents(); ievt++) {

      Event* ev = Data()->GetEvent(ievt);

      // total sum of event weights
      sumw += ev->GetBoostWeight();

      // decide whether it is signal or background-like
      Bool_t isSignalType = mbase->IsSignalLike();
      
      // to prevent code duplication
      if (isSignalType == ev->IsSignal())
         correctSelected.push_back( kTRUE );
      else {
         sumwfalse += ev->GetBoostWeight();
         count += 1;
         correctSelected.push_back( kFALSE );
      }
   }

   if (0 == sumw) {
      Log() << kFATAL << "<AdaBoost> fatal error sum of event boostweights is zero" << Endl;
   }

   // compute the boost factor
   err = sumwfalse/sumw;

   Double_t newSumw=0;
   Int_t i=0;
   Double_t boostFactor = 1;
   if (err>0){
      if (adaBoostBeta == 1){
         boostFactor = (1-err)/err ;
      }
      else {
         boostFactor =  TMath::Power((1-err)/err,adaBoostBeta) ;
      }
   }
   else {
      boostFactor = 1000; // default
   }

   // now fill new boostweights
   for (Int_t ievt=0; ievt<Data()->GetNTrainingEvents(); ievt++) {

      Event *ev = Data()->GetEvent(ievt);

      // read the Training Event into "event"
      if (!correctSelected[ievt]) ev->SetBoostWeight( ev->GetBoostWeight() * boostFactor);

      newSumw += ev->GetBoostWeight();    
      i++;
   }

   // re-normalise the boostweights
   for (Int_t ievt=0; ievt<Data()->GetNTrainingEvents(); ievt++) {
      Event *ev = Data()->GetEvent(ievt);
      ev->SetBoostWeight( ev->GetBoostWeight() * sumw / newSumw );      
   }

   fBoostFactorHist->Fill(boostFactor);
   fErrFractHist->Fill(GetCommittee().size(),err);

   // save for ntuple
   fBoostFactor   = boostFactor;
   fErrorFraction = err;
  
   // return weight factor for this committee member
   return TMath::Log(boostFactor);
}

//_______________________________________________________________________
Double_t TMVA::MethodCommittee::Bagging( UInt_t imember )
{
   // call it Bootstrapping, re-sampling or whatever you like, in the end it is nothing
   // else but applying "random boostweights" to each event.
   Double_t newSumw = 0;
   TRandom3* trandom   = new TRandom3( imember );

   // loop over all events in training tree
   for (Int_t ievt=0; ievt<Data()->GetNTrainingEvents(); ievt++) {
      Event* ev = Data()->GetEvent(ievt);

      // read the Training Event into "event"
      Double_t newWeight = trandom->Rndm();
      ev->SetBoostWeight( newWeight );
      newSumw += newWeight;
   }

   // re-normalise the boostweights
   for (Int_t ievt=0; ievt<Data()->GetNTrainingEvents(); ievt++) {
      Event* ev = Data()->GetEvent(ievt);
      ev->SetBoostWeight( ev->GetBoostWeight() * Data()->GetNTrainingEvents() / newSumw );      
   }

   // return weight factor for this committee member
   return 1.0;  // here as there are random weights for each event, just return a constant==1;
}

//_______________________________________________________________________
void TMVA::MethodCommittee::WriteWeightsToStream( ostream& o ) const
{
   // write the state of the method to an output stream
   for (UInt_t imember=0; imember<GetCommittee().size(); imember++) {
      o << endl;
      o << "------------------------------ new member: " << imember << " ---------------" << endl;
      o << "boost weight: " << GetBoostWeights()[imember] << endl;
      (dynamic_cast<MethodBase*>(GetCommittee()[imember]))->WriteStateToStream( o );
   }   
}

//_______________________________________________________________________
void TMVA::MethodCommittee::AddWeightsXMLTo( void* /*parent*/ ) const {
   Log() << kFATAL << "Please implement writing of weights as XML" << Endl;
}
  
//_______________________________________________________________________
void  TMVA::MethodCommittee::ReadWeightsFromStream( istream& istr )
{
   // read the state of the method from an input stream

   // explicitly destroy objects in vector
   std::vector<IMethod*>::iterator member = GetCommittee().begin();
   for (; member != GetCommittee().end(); member++) delete *member;

   GetCommittee().clear();
   GetBoostWeights().clear();

   TString  dummy;
   UInt_t   imember;
   Double_t boostWeight;

   DataSetInfo & dsi = DataInfo(); // this needs to be changed for the different kind of committee methods
   
   // loop over all members in committee
   for (UInt_t i=0; i<fNMembers; i++) {
       
      istr >> dummy >> dummy >> dummy >> imember;
      istr >> dummy >> dummy >> boostWeight;

      if (imember != i) {
         Log() << kFATAL << "<ReadWeightsFromStream> fatal error while reading Weight file \n "
                 << ": mismatch imember: " << imember << " != i: " << i << Endl;
      }

      // initialize methods
      IMethod* method = ClassifierFactory::Instance().Create(std::string(Types::Instance().GetMethodName( fMemberType )), dsi, "" );

      // read weight file
      (dynamic_cast<MethodBase*>(method))->ReadStateFromStream(istr);
      GetCommittee().push_back(method);
      GetBoostWeights().push_back(boostWeight);
   }
}

//_______________________________________________________________________
Double_t TMVA::MethodCommittee::GetMvaValue( Double_t* err )
{
   // return the MVA value (range [-1;1]) that classifies the
   // event.according to the majority vote from the total number of
   // decision trees
   // In the literature I found that people actually use the 
   // weighted majority vote (using the boost weights) .. However I
   // did not see any improvement in doing so :(  
   // --> this is currently switched off

   // cannot determine error
   if (err != 0) *err = -1;

   Double_t myMVA = 0;
   Double_t norm  = 0;
   for (UInt_t itree=0; itree<GetCommittee().size(); itree++) {

      Double_t tmpMVA = ( fUseMemberDecision ? ( (dynamic_cast<MethodBase*>(GetCommittee()[itree]))->IsSignalLike() ? 1.0 : -1.0 ) 
                          : GetCommittee()[itree]->GetMvaValue() );

      if (fUseWeightedMembers){ 
         myMVA += GetBoostWeights()[itree] * tmpMVA;
         norm  += GetBoostWeights()[itree];
      }
      else { 
         myMVA += tmpMVA;
         norm  += 1;
      }
   }
   return (norm != 0) ? myMVA /= Double_t(norm) : -999;
}

//_______________________________________________________________________
void  TMVA::MethodCommittee::WriteMonitoringHistosToFile( void ) const
{
   // here we could write some histograms created during the processing
   // to the output file.
   Log() << kINFO << "Write monitoring histograms to file: " << BaseDir()->GetPath() << Endl;

   fBoostFactorHist->Write();
   fErrFractHist->Write();
   fMonitorNtuple->Write();

   BaseDir()->cd();
}

// return the individual relative variable importance 
//_______________________________________________________________________
vector< Double_t > TMVA::MethodCommittee::GetVariableImportance()
{
   // return the relative variable importance, normalized to all
   // variables together having the importance 1. The importance in
   // evaluated as the total separation-gain that this variable had in
   // the decision trees (weighted by the number of events)
  
   fVariableImportance.resize(GetNvar());
   //    Double_t  sum=0;
   //    for (int itree = 0; itree < fNMembers; itree++){
   //       vector<Double_t> relativeImportance(GetCommittee()[itree]->GetVariableImportance());
   //       for (unsigned int i=0; i< relativeImportance.size(); i++) {
   //          fVariableImportance[i] += relativeImportance[i] ;
   //       } 
   //    }   
   //    for (unsigned int i=0; i< fVariableImportance.size(); i++) sum += fVariableImportance[i];
   //    for (unsigned int i=0; i< fVariableImportance.size(); i++) fVariableImportance[i] /= sum;

   return fVariableImportance;
}

//_______________________________________________________________________
Double_t TMVA::MethodCommittee::GetVariableImportance(UInt_t ivar)
{
   // return the variable importance
   vector<Double_t> relativeImportance = this->GetVariableImportance();
   if (ivar < (UInt_t)relativeImportance.size()) return relativeImportance[ivar];
   else  Log() << kFATAL << "<GetVariableImportance> ivar = " << ivar << " is out of range " << Endl;

   return -1;
}

//_______________________________________________________________________
const TMVA::Ranking* TMVA::MethodCommittee::CreateRanking()
{
   // computes ranking of input variables

   // create the ranking object
   fRanking = new Ranking( GetName(), "Variable Importance" );
   vector< Double_t> importance(this->GetVariableImportance());

   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fRanking->AddRank( Rank( GetInputLabel(ivar), importance[ivar] ) );
   }

   return fRanking;
}

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

//_______________________________________________________________________
void TMVA::MethodCommittee::GetHelpMessage() const
{
   // get help message text
   //
   // typical length of text line: 
   //         "|--------------------------------------------------------------|"
   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Short description:" << gTools().Color("reset") << Endl;
   Log() << Endl;
   Log() << "<None>" << Endl;
   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Performance optimisation:" << gTools().Color("reset") << Endl;
   Log() << Endl;
   Log() << "<None>" << Endl;
   Log() << Endl;
   Log() << gTools().Color("bold") << "--- Performance tuning via configuration options:" << gTools().Color("reset") << Endl;
   Log() << Endl;
   Log() << "<None>" << Endl;
}
 MethodCommittee.cxx:1
 MethodCommittee.cxx:2
 MethodCommittee.cxx:3
 MethodCommittee.cxx:4
 MethodCommittee.cxx:5
 MethodCommittee.cxx:6
 MethodCommittee.cxx:7
 MethodCommittee.cxx:8
 MethodCommittee.cxx:9
 MethodCommittee.cxx:10
 MethodCommittee.cxx:11
 MethodCommittee.cxx:12
 MethodCommittee.cxx:13
 MethodCommittee.cxx:14
 MethodCommittee.cxx:15
 MethodCommittee.cxx:16
 MethodCommittee.cxx:17
 MethodCommittee.cxx:18
 MethodCommittee.cxx:19
 MethodCommittee.cxx:20
 MethodCommittee.cxx:21
 MethodCommittee.cxx:22
 MethodCommittee.cxx:23
 MethodCommittee.cxx:24
 MethodCommittee.cxx:25
 MethodCommittee.cxx:26
 MethodCommittee.cxx:27
 MethodCommittee.cxx:28
 MethodCommittee.cxx:29
 MethodCommittee.cxx:30
 MethodCommittee.cxx:31
 MethodCommittee.cxx:32
 MethodCommittee.cxx:33
 MethodCommittee.cxx:34
 MethodCommittee.cxx:35
 MethodCommittee.cxx:36
 MethodCommittee.cxx:37
 MethodCommittee.cxx:38
 MethodCommittee.cxx:39
 MethodCommittee.cxx:40
 MethodCommittee.cxx:41
 MethodCommittee.cxx:42
 MethodCommittee.cxx:43
 MethodCommittee.cxx:44
 MethodCommittee.cxx:45
 MethodCommittee.cxx:46
 MethodCommittee.cxx:47
 MethodCommittee.cxx:48
 MethodCommittee.cxx:49
 MethodCommittee.cxx:50
 MethodCommittee.cxx:51
 MethodCommittee.cxx:52
 MethodCommittee.cxx:53
 MethodCommittee.cxx:54
 MethodCommittee.cxx:55
 MethodCommittee.cxx:56
 MethodCommittee.cxx:57
 MethodCommittee.cxx:58
 MethodCommittee.cxx:59
 MethodCommittee.cxx:60
 MethodCommittee.cxx:61
 MethodCommittee.cxx:62
 MethodCommittee.cxx:63
 MethodCommittee.cxx:64
 MethodCommittee.cxx:65
 MethodCommittee.cxx:66
 MethodCommittee.cxx:67
 MethodCommittee.cxx:68
 MethodCommittee.cxx:69
 MethodCommittee.cxx:70
 MethodCommittee.cxx:71
 MethodCommittee.cxx:72
 MethodCommittee.cxx:73
 MethodCommittee.cxx:74
 MethodCommittee.cxx:75
 MethodCommittee.cxx:76
 MethodCommittee.cxx:77
 MethodCommittee.cxx:78
 MethodCommittee.cxx:79
 MethodCommittee.cxx:80
 MethodCommittee.cxx:81
 MethodCommittee.cxx:82
 MethodCommittee.cxx:83
 MethodCommittee.cxx:84
 MethodCommittee.cxx:85
 MethodCommittee.cxx:86
 MethodCommittee.cxx:87
 MethodCommittee.cxx:88
 MethodCommittee.cxx:89
 MethodCommittee.cxx:90
 MethodCommittee.cxx:91
 MethodCommittee.cxx:92
 MethodCommittee.cxx:93
 MethodCommittee.cxx:94
 MethodCommittee.cxx:95
 MethodCommittee.cxx:96
 MethodCommittee.cxx:97
 MethodCommittee.cxx:98
 MethodCommittee.cxx:99
 MethodCommittee.cxx:100
 MethodCommittee.cxx:101
 MethodCommittee.cxx:102
 MethodCommittee.cxx:103
 MethodCommittee.cxx:104
 MethodCommittee.cxx:105
 MethodCommittee.cxx:106
 MethodCommittee.cxx:107
 MethodCommittee.cxx:108
 MethodCommittee.cxx:109
 MethodCommittee.cxx:110
 MethodCommittee.cxx:111
 MethodCommittee.cxx:112
 MethodCommittee.cxx:113
 MethodCommittee.cxx:114
 MethodCommittee.cxx:115
 MethodCommittee.cxx:116
 MethodCommittee.cxx:117
 MethodCommittee.cxx:118
 MethodCommittee.cxx:119
 MethodCommittee.cxx:120
 MethodCommittee.cxx:121
 MethodCommittee.cxx:122
 MethodCommittee.cxx:123
 MethodCommittee.cxx:124
 MethodCommittee.cxx:125
 MethodCommittee.cxx:126
 MethodCommittee.cxx:127
 MethodCommittee.cxx:128
 MethodCommittee.cxx:129
 MethodCommittee.cxx:130
 MethodCommittee.cxx:131
 MethodCommittee.cxx:132
 MethodCommittee.cxx:133
 MethodCommittee.cxx:134
 MethodCommittee.cxx:135
 MethodCommittee.cxx:136
 MethodCommittee.cxx:137
 MethodCommittee.cxx:138
 MethodCommittee.cxx:139
 MethodCommittee.cxx:140
 MethodCommittee.cxx:141
 MethodCommittee.cxx:142
 MethodCommittee.cxx:143
 MethodCommittee.cxx:144
 MethodCommittee.cxx:145
 MethodCommittee.cxx:146
 MethodCommittee.cxx:147
 MethodCommittee.cxx:148
 MethodCommittee.cxx:149
 MethodCommittee.cxx:150
 MethodCommittee.cxx:151
 MethodCommittee.cxx:152
 MethodCommittee.cxx:153
 MethodCommittee.cxx:154
 MethodCommittee.cxx:155
 MethodCommittee.cxx:156
 MethodCommittee.cxx:157
 MethodCommittee.cxx:158
 MethodCommittee.cxx:159
 MethodCommittee.cxx:160
 MethodCommittee.cxx:161
 MethodCommittee.cxx:162
 MethodCommittee.cxx:163
 MethodCommittee.cxx:164
 MethodCommittee.cxx:165
 MethodCommittee.cxx:166
 MethodCommittee.cxx:167
 MethodCommittee.cxx:168
 MethodCommittee.cxx:169
 MethodCommittee.cxx:170
 MethodCommittee.cxx:171
 MethodCommittee.cxx:172
 MethodCommittee.cxx:173
 MethodCommittee.cxx:174
 MethodCommittee.cxx:175
 MethodCommittee.cxx:176
 MethodCommittee.cxx:177
 MethodCommittee.cxx:178
 MethodCommittee.cxx:179
 MethodCommittee.cxx:180
 MethodCommittee.cxx:181
 MethodCommittee.cxx:182
 MethodCommittee.cxx:183
 MethodCommittee.cxx:184
 MethodCommittee.cxx:185
 MethodCommittee.cxx:186
 MethodCommittee.cxx:187
 MethodCommittee.cxx:188
 MethodCommittee.cxx:189
 MethodCommittee.cxx:190
 MethodCommittee.cxx:191
 MethodCommittee.cxx:192
 MethodCommittee.cxx:193
 MethodCommittee.cxx:194
 MethodCommittee.cxx:195
 MethodCommittee.cxx:196
 MethodCommittee.cxx:197
 MethodCommittee.cxx:198
 MethodCommittee.cxx:199
 MethodCommittee.cxx:200
 MethodCommittee.cxx:201
 MethodCommittee.cxx:202
 MethodCommittee.cxx:203
 MethodCommittee.cxx:204
 MethodCommittee.cxx:205
 MethodCommittee.cxx:206
 MethodCommittee.cxx:207
 MethodCommittee.cxx:208
 MethodCommittee.cxx:209
 MethodCommittee.cxx:210
 MethodCommittee.cxx:211
 MethodCommittee.cxx:212
 MethodCommittee.cxx:213
 MethodCommittee.cxx:214
 MethodCommittee.cxx:215
 MethodCommittee.cxx:216
 MethodCommittee.cxx:217
 MethodCommittee.cxx:218
 MethodCommittee.cxx:219
 MethodCommittee.cxx:220
 MethodCommittee.cxx:221
 MethodCommittee.cxx:222
 MethodCommittee.cxx:223
 MethodCommittee.cxx:224
 MethodCommittee.cxx:225
 MethodCommittee.cxx:226
 MethodCommittee.cxx:227
 MethodCommittee.cxx:228
 MethodCommittee.cxx:229
 MethodCommittee.cxx:230
 MethodCommittee.cxx:231
 MethodCommittee.cxx:232
 MethodCommittee.cxx:233
 MethodCommittee.cxx:234
 MethodCommittee.cxx:235
 MethodCommittee.cxx:236
 MethodCommittee.cxx:237
 MethodCommittee.cxx:238
 MethodCommittee.cxx:239
 MethodCommittee.cxx:240
 MethodCommittee.cxx:241
 MethodCommittee.cxx:242
 MethodCommittee.cxx:243
 MethodCommittee.cxx:244
 MethodCommittee.cxx:245
 MethodCommittee.cxx:246
 MethodCommittee.cxx:247
 MethodCommittee.cxx:248
 MethodCommittee.cxx:249
 MethodCommittee.cxx:250
 MethodCommittee.cxx:251
 MethodCommittee.cxx:252
 MethodCommittee.cxx:253
 MethodCommittee.cxx:254
 MethodCommittee.cxx:255
 MethodCommittee.cxx:256
 MethodCommittee.cxx:257
 MethodCommittee.cxx:258
 MethodCommittee.cxx:259
 MethodCommittee.cxx:260
 MethodCommittee.cxx:261
 MethodCommittee.cxx:262
 MethodCommittee.cxx:263
 MethodCommittee.cxx:264
 MethodCommittee.cxx:265
 MethodCommittee.cxx:266
 MethodCommittee.cxx:267
 MethodCommittee.cxx:268
 MethodCommittee.cxx:269
 MethodCommittee.cxx:270
 MethodCommittee.cxx:271
 MethodCommittee.cxx:272
 MethodCommittee.cxx:273
 MethodCommittee.cxx:274
 MethodCommittee.cxx:275
 MethodCommittee.cxx:276
 MethodCommittee.cxx:277
 MethodCommittee.cxx:278
 MethodCommittee.cxx:279
 MethodCommittee.cxx:280
 MethodCommittee.cxx:281
 MethodCommittee.cxx:282
 MethodCommittee.cxx:283
 MethodCommittee.cxx:284
 MethodCommittee.cxx:285
 MethodCommittee.cxx:286
 MethodCommittee.cxx:287
 MethodCommittee.cxx:288
 MethodCommittee.cxx:289
 MethodCommittee.cxx:290
 MethodCommittee.cxx:291
 MethodCommittee.cxx:292
 MethodCommittee.cxx:293
 MethodCommittee.cxx:294
 MethodCommittee.cxx:295
 MethodCommittee.cxx:296
 MethodCommittee.cxx:297
 MethodCommittee.cxx:298
 MethodCommittee.cxx:299
 MethodCommittee.cxx:300
 MethodCommittee.cxx:301
 MethodCommittee.cxx:302
 MethodCommittee.cxx:303
 MethodCommittee.cxx:304
 MethodCommittee.cxx:305
 MethodCommittee.cxx:306
 MethodCommittee.cxx:307
 MethodCommittee.cxx:308
 MethodCommittee.cxx:309
 MethodCommittee.cxx:310
 MethodCommittee.cxx:311
 MethodCommittee.cxx:312
 MethodCommittee.cxx:313
 MethodCommittee.cxx:314
 MethodCommittee.cxx:315
 MethodCommittee.cxx:316
 MethodCommittee.cxx:317
 MethodCommittee.cxx:318
 MethodCommittee.cxx:319
 MethodCommittee.cxx:320
 MethodCommittee.cxx:321
 MethodCommittee.cxx:322
 MethodCommittee.cxx:323
 MethodCommittee.cxx:324
 MethodCommittee.cxx:325
 MethodCommittee.cxx:326
 MethodCommittee.cxx:327
 MethodCommittee.cxx:328
 MethodCommittee.cxx:329
 MethodCommittee.cxx:330
 MethodCommittee.cxx:331
 MethodCommittee.cxx:332
 MethodCommittee.cxx:333
 MethodCommittee.cxx:334
 MethodCommittee.cxx:335
 MethodCommittee.cxx:336
 MethodCommittee.cxx:337
 MethodCommittee.cxx:338
 MethodCommittee.cxx:339
 MethodCommittee.cxx:340
 MethodCommittee.cxx:341
 MethodCommittee.cxx:342
 MethodCommittee.cxx:343
 MethodCommittee.cxx:344
 MethodCommittee.cxx:345
 MethodCommittee.cxx:346
 MethodCommittee.cxx:347
 MethodCommittee.cxx:348
 MethodCommittee.cxx:349
 MethodCommittee.cxx:350
 MethodCommittee.cxx:351
 MethodCommittee.cxx:352
 MethodCommittee.cxx:353
 MethodCommittee.cxx:354
 MethodCommittee.cxx:355
 MethodCommittee.cxx:356
 MethodCommittee.cxx:357
 MethodCommittee.cxx:358
 MethodCommittee.cxx:359
 MethodCommittee.cxx:360
 MethodCommittee.cxx:361
 MethodCommittee.cxx:362
 MethodCommittee.cxx:363
 MethodCommittee.cxx:364
 MethodCommittee.cxx:365
 MethodCommittee.cxx:366
 MethodCommittee.cxx:367
 MethodCommittee.cxx:368
 MethodCommittee.cxx:369
 MethodCommittee.cxx:370
 MethodCommittee.cxx:371
 MethodCommittee.cxx:372
 MethodCommittee.cxx:373
 MethodCommittee.cxx:374
 MethodCommittee.cxx:375
 MethodCommittee.cxx:376
 MethodCommittee.cxx:377
 MethodCommittee.cxx:378
 MethodCommittee.cxx:379
 MethodCommittee.cxx:380
 MethodCommittee.cxx:381
 MethodCommittee.cxx:382
 MethodCommittee.cxx:383
 MethodCommittee.cxx:384
 MethodCommittee.cxx:385
 MethodCommittee.cxx:386
 MethodCommittee.cxx:387
 MethodCommittee.cxx:388
 MethodCommittee.cxx:389
 MethodCommittee.cxx:390
 MethodCommittee.cxx:391
 MethodCommittee.cxx:392
 MethodCommittee.cxx:393
 MethodCommittee.cxx:394
 MethodCommittee.cxx:395
 MethodCommittee.cxx:396
 MethodCommittee.cxx:397
 MethodCommittee.cxx:398
 MethodCommittee.cxx:399
 MethodCommittee.cxx:400
 MethodCommittee.cxx:401
 MethodCommittee.cxx:402
 MethodCommittee.cxx:403
 MethodCommittee.cxx:404
 MethodCommittee.cxx:405
 MethodCommittee.cxx:406
 MethodCommittee.cxx:407
 MethodCommittee.cxx:408
 MethodCommittee.cxx:409
 MethodCommittee.cxx:410
 MethodCommittee.cxx:411
 MethodCommittee.cxx:412
 MethodCommittee.cxx:413
 MethodCommittee.cxx:414
 MethodCommittee.cxx:415
 MethodCommittee.cxx:416
 MethodCommittee.cxx:417
 MethodCommittee.cxx:418
 MethodCommittee.cxx:419
 MethodCommittee.cxx:420
 MethodCommittee.cxx:421
 MethodCommittee.cxx:422
 MethodCommittee.cxx:423
 MethodCommittee.cxx:424
 MethodCommittee.cxx:425
 MethodCommittee.cxx:426
 MethodCommittee.cxx:427
 MethodCommittee.cxx:428
 MethodCommittee.cxx:429
 MethodCommittee.cxx:430
 MethodCommittee.cxx:431
 MethodCommittee.cxx:432
 MethodCommittee.cxx:433
 MethodCommittee.cxx:434
 MethodCommittee.cxx:435
 MethodCommittee.cxx:436
 MethodCommittee.cxx:437
 MethodCommittee.cxx:438
 MethodCommittee.cxx:439
 MethodCommittee.cxx:440
 MethodCommittee.cxx:441
 MethodCommittee.cxx:442
 MethodCommittee.cxx:443
 MethodCommittee.cxx:444
 MethodCommittee.cxx:445
 MethodCommittee.cxx:446
 MethodCommittee.cxx:447
 MethodCommittee.cxx:448
 MethodCommittee.cxx:449
 MethodCommittee.cxx:450
 MethodCommittee.cxx:451
 MethodCommittee.cxx:452
 MethodCommittee.cxx:453
 MethodCommittee.cxx:454
 MethodCommittee.cxx:455
 MethodCommittee.cxx:456
 MethodCommittee.cxx:457
 MethodCommittee.cxx:458
 MethodCommittee.cxx:459
 MethodCommittee.cxx:460
 MethodCommittee.cxx:461
 MethodCommittee.cxx:462
 MethodCommittee.cxx:463
 MethodCommittee.cxx:464
 MethodCommittee.cxx:465
 MethodCommittee.cxx:466
 MethodCommittee.cxx:467
 MethodCommittee.cxx:468
 MethodCommittee.cxx:469
 MethodCommittee.cxx:470
 MethodCommittee.cxx:471
 MethodCommittee.cxx:472
 MethodCommittee.cxx:473
 MethodCommittee.cxx:474
 MethodCommittee.cxx:475
 MethodCommittee.cxx:476
 MethodCommittee.cxx:477
 MethodCommittee.cxx:478
 MethodCommittee.cxx:479
 MethodCommittee.cxx:480
 MethodCommittee.cxx:481
 MethodCommittee.cxx:482
 MethodCommittee.cxx:483
 MethodCommittee.cxx:484
 MethodCommittee.cxx:485
 MethodCommittee.cxx:486
 MethodCommittee.cxx:487
 MethodCommittee.cxx:488
 MethodCommittee.cxx:489
 MethodCommittee.cxx:490
 MethodCommittee.cxx:491
 MethodCommittee.cxx:492
 MethodCommittee.cxx:493
 MethodCommittee.cxx:494
 MethodCommittee.cxx:495
 MethodCommittee.cxx:496
 MethodCommittee.cxx:497
 MethodCommittee.cxx:498
 MethodCommittee.cxx:499
 MethodCommittee.cxx:500
 MethodCommittee.cxx:501
 MethodCommittee.cxx:502
 MethodCommittee.cxx:503
 MethodCommittee.cxx:504
 MethodCommittee.cxx:505
 MethodCommittee.cxx:506
 MethodCommittee.cxx:507
 MethodCommittee.cxx:508
 MethodCommittee.cxx:509
 MethodCommittee.cxx:510
 MethodCommittee.cxx:511
 MethodCommittee.cxx:512
 MethodCommittee.cxx:513
 MethodCommittee.cxx:514
 MethodCommittee.cxx:515
 MethodCommittee.cxx:516
 MethodCommittee.cxx:517
 MethodCommittee.cxx:518
 MethodCommittee.cxx:519
 MethodCommittee.cxx:520
 MethodCommittee.cxx:521
 MethodCommittee.cxx:522
 MethodCommittee.cxx:523
 MethodCommittee.cxx:524
 MethodCommittee.cxx:525
 MethodCommittee.cxx:526
 MethodCommittee.cxx:527
 MethodCommittee.cxx:528
 MethodCommittee.cxx:529
 MethodCommittee.cxx:530