// @(#)root/tmva $Id$ // Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard von Toerne, Jan Therhaag /********************************************************************************** * Project: TMVA - a Root-integrated toolkit for multivariate data analysis * * Package: TMVA * * Class : MethodBase * * Web : http://tmva.sourceforge.net * * * * Description: * * Implementation (see header for description) * * * * Authors (alphabetical): * * Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland * * Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland * * Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland * * Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Germany * * Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada * * Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany * * Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany * * * * Copyright (c) 2005-2011: * * CERN, Switzerland * * U. of Victoria, Canada * * MPI-K Heidelberg, Germany * * U. of Bonn, 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 Virtual base Class for all MVA method MethodBase hosts several specific evaluation methods. The kind of MVA that provides optimal performance in an analysis strongly depends on the particular application. The evaluation factory provides a number of numerical benchmark results to directly assess the performance of the MVA training on the independent test sample. These are: <ul> <li> The <i>signal efficiency</i> at three representative background efficiencies (which is 1 − rejection).</li> <li> The <i>significance</I> of an MVA estimator, defined by the difference between the MVA mean values for signal and background, divided by the quadratic sum of their root mean squares.</li> <li> The <i>separation</i> of an MVA <i>x</i>, defined by the integral ½∫(S(x) − B(x))<sup>2</sup>/(S(x) + B(x))dx, where S(x) and B(x) are the signal and background distributions, respectively. The separation is zero for identical signal and background MVA shapes, and it is one for disjunctive shapes. <li> <a name="mu_transform"> The average, ∫x μ(S(x))dx, of the signal μ-transform. The μ-transform of an MVA denotes the transformation that yields a uniform background distribution. In this way, the signal distributions S(x) can be directly compared among the various MVAs. The stronger S(x) peaks towards one, the better is the discrimination of the MVA. The μ-transform is <a href=http://tel.ccsd.cnrs.fr/documents/archives0/00/00/29/91/index_fr.html>documented here</a>. </ul> The MVA standard output also prints the linear correlation coefficients between signal and background, which can be useful to eliminate variables that exhibit too strong correlations. End_Html */ //_______________________________________________________________________ #include <iomanip> #include <iostream> #include <fstream> #include <sstream> #include <cstdlib> #include <algorithm> #include <limits> #include "TROOT.h" #include "TSystem.h" #include "TObjString.h" #include "TQObject.h" #include "TSpline.h" #include "TMatrix.h" #include "TMath.h" #include "TFile.h" #include "TKey.h" #include "TGraph.h" #include "Riostream.h" #include "TXMLEngine.h" #include "TMVA/MsgLogger.h" #include "TMVA/MethodBase.h" #include "TMVA/Config.h" #include "TMVA/Timer.h" #include "TMVA/RootFinder.h" #include "TMVA/PDF.h" #include "TMVA/VariableIdentityTransform.h" #include "TMVA/VariableDecorrTransform.h" #include "TMVA/VariablePCATransform.h" #include "TMVA/VariableGaussTransform.h" #include "TMVA/VariableNormalizeTransform.h" #include "TMVA/Version.h" #include "TMVA/TSpline1.h" #include "TMVA/Ranking.h" #include "TMVA/Factory.h" #include "TMVA/Tools.h" #include "TMVA/ResultsClassification.h" #include "TMVA/ResultsRegression.h" #include "TMVA/ResultsMulticlass.h" ClassImp(TMVA::MethodBase) using std::endl; using std::atof; //const Int_t MethodBase_MaxIterations_ = 200; const Bool_t Use_Splines_for_Eff_ = kTRUE; //const Int_t NBIN_HIST_PLOT = 100; const Int_t NBIN_HIST_HIGH = 10000; #ifdef _WIN32 /* Disable warning C4355: 'this' : used in base member initializer list */ #pragma warning ( disable : 4355 ) #endif //_______________________________________________________________________ TMVA::MethodBase::MethodBase( const TString& jobName, Types::EMVA methodType, const TString& methodTitle, DataSetInfo& dsi, const TString& theOption, TDirectory* theBaseDir) : IMethod(), Configurable ( theOption ), fTmpEvent ( 0 ), fRanking ( 0 ), fInputVars ( 0 ), fAnalysisType ( Types::kNoAnalysisType ), fRegressionReturnVal ( 0 ), fMulticlassReturnVal ( 0 ), fDisableWriting ( kFALSE ), fDataSetInfo ( dsi ), fSignalReferenceCut ( 0.5 ), fSignalReferenceCutOrientation( 1. ), fVariableTransformType ( Types::kSignal ), fJobName ( jobName ), fMethodName ( methodTitle ), fMethodType ( methodType ), fTestvar ( "" ), fTMVATrainingVersion ( TMVA_VERSION_CODE ), fROOTTrainingVersion ( ROOT_VERSION_CODE ), fConstructedFromWeightFile ( kFALSE ), fBaseDir ( 0 ), fMethodBaseDir ( theBaseDir ), fWeightFile ( "" ), fEffS ( 0 ), fDefaultPDF ( 0 ), fMVAPdfS ( 0 ), fMVAPdfB ( 0 ), fSplS ( 0 ), fSplB ( 0 ), fSpleffBvsS ( 0 ), fSplTrainS ( 0 ), fSplTrainB ( 0 ), fSplTrainEffBvsS ( 0 ), fVarTransformString ( "None" ), fTransformationPointer ( 0 ), fTransformation ( dsi, methodTitle ), fVerbose ( kFALSE ), fVerbosityLevelString ( "Default" ), fHelp ( kFALSE ), fHasMVAPdfs ( kFALSE ), fIgnoreNegWeightsInTraining( kFALSE ), fSignalClass ( 0 ), fBackgroundClass ( 0 ), fSplRefS ( 0 ), fSplRefB ( 0 ), fSplTrainRefS ( 0 ), fSplTrainRefB ( 0 ), fSetupCompleted (kFALSE) { // standard constructur SetTestvarName(); // default extension for weight files SetWeightFileDir( gConfig().GetIONames().fWeightFileDir ); gSystem->MakeDirectory( GetWeightFileDir() ); } //_______________________________________________________________________ TMVA::MethodBase::MethodBase( Types::EMVA methodType, DataSetInfo& dsi, const TString& weightFile, TDirectory* theBaseDir ) : IMethod(), Configurable(""), fTmpEvent ( 0 ), fRanking ( 0 ), fInputVars ( 0 ), fAnalysisType ( Types::kNoAnalysisType ), fRegressionReturnVal ( 0 ), fMulticlassReturnVal ( 0 ), fDataSetInfo ( dsi ), fSignalReferenceCut ( 0.5 ), fVariableTransformType ( Types::kSignal ), fJobName ( "" ), fMethodName ( "MethodBase" ), fMethodType ( methodType ), fTestvar ( "" ), fTMVATrainingVersion ( 0 ), fROOTTrainingVersion ( 0 ), fConstructedFromWeightFile ( kTRUE ), fBaseDir ( theBaseDir ), fMethodBaseDir ( 0 ), fWeightFile ( weightFile ), fEffS ( 0 ), fDefaultPDF ( 0 ), fMVAPdfS ( 0 ), fMVAPdfB ( 0 ), fSplS ( 0 ), fSplB ( 0 ), fSpleffBvsS ( 0 ), fSplTrainS ( 0 ), fSplTrainB ( 0 ), fSplTrainEffBvsS ( 0 ), fVarTransformString ( "None" ), fTransformationPointer ( 0 ), fTransformation ( dsi, "" ), fVerbose ( kFALSE ), fVerbosityLevelString ( "Default" ), fHelp ( kFALSE ), fHasMVAPdfs ( kFALSE ), fIgnoreNegWeightsInTraining( kFALSE ), fSignalClass ( 0 ), fBackgroundClass ( 0 ), fSplRefS ( 0 ), fSplRefB ( 0 ), fSplTrainRefS ( 0 ), fSplTrainRefB ( 0 ), fSetupCompleted (kFALSE) { // constructor used for Testing + Application of the MVA, // only (no training), using given WeightFiles } //_______________________________________________________________________ TMVA::MethodBase::~MethodBase( void ) { // destructor if (!fSetupCompleted) Log() << kFATAL << "Calling destructor of method which got never setup" << Endl; // destructor if (fInputVars != 0) { fInputVars->clear(); delete fInputVars; } if (fRanking != 0) delete fRanking; // PDFs if (fDefaultPDF!= 0) { delete fDefaultPDF; fDefaultPDF = 0; } if (fMVAPdfS != 0) { delete fMVAPdfS; fMVAPdfS = 0; } if (fMVAPdfB != 0) { delete fMVAPdfB; fMVAPdfB = 0; } // Splines if (fSplS) { delete fSplS; fSplS = 0; } if (fSplB) { delete fSplB; fSplB = 0; } if (fSpleffBvsS) { delete fSpleffBvsS; fSpleffBvsS = 0; } if (fSplRefS) { delete fSplRefS; fSplRefS = 0; } if (fSplRefB) { delete fSplRefB; fSplRefB = 0; } if (fSplTrainRefS) { delete fSplTrainRefS; fSplTrainRefS = 0; } if (fSplTrainRefB) { delete fSplTrainRefB; fSplTrainRefB = 0; } if (fSplTrainEffBvsS) { delete fSplTrainEffBvsS; fSplTrainEffBvsS = 0; } for (Int_t i = 0; i < 2; i++ ) { if (fEventCollections.at(i)) { for (std::vector<Event*>::const_iterator it = fEventCollections.at(i)->begin(); it != fEventCollections.at(i)->end(); it++) { delete (*it); } delete fEventCollections.at(i); fEventCollections.at(i) = 0; } } if (fRegressionReturnVal) delete fRegressionReturnVal; if (fMulticlassReturnVal) delete fMulticlassReturnVal; } //_______________________________________________________________________ void TMVA::MethodBase::SetupMethod() { // setup of methods if (fSetupCompleted) Log() << kFATAL << "Calling SetupMethod for the second time" << Endl; InitBase(); DeclareBaseOptions(); Init(); DeclareOptions(); fSetupCompleted = kTRUE; } //_______________________________________________________________________ void TMVA::MethodBase::ProcessSetup() { // process all options // the "CheckForUnusedOptions" is done in an independent call, since it may be overridden by derived class // (sometimes, eg, fitters are used which can only be implemented during training phase) ProcessBaseOptions(); ProcessOptions(); } //_______________________________________________________________________ void TMVA::MethodBase::CheckSetup() { // check may be overridden by derived class // (sometimes, eg, fitters are used which can only be implemented during training phase) CheckForUnusedOptions(); } //_______________________________________________________________________ void TMVA::MethodBase::InitBase() { // default initialization called by all constructors SetConfigDescription( "Configuration options for classifier architecture and tuning" ); fNbins = gConfig().fVariablePlotting.fNbinsXOfROCCurve; fNbinsMVAoutput = gConfig().fVariablePlotting.fNbinsMVAoutput; fNbinsH = NBIN_HIST_HIGH; fSplTrainS = 0; fSplTrainB = 0; fSplTrainEffBvsS = 0; fMeanS = -1; fMeanB = -1; fRmsS = -1; fRmsB = -1; fXmin = DBL_MAX; fXmax = -DBL_MAX; fTxtWeightsOnly = kTRUE; fSplRefS = 0; fSplRefB = 0; fTrainTime = -1.; fTestTime = -1.; fRanking = 0; // temporary until the move to DataSet is complete fInputVars = new std::vector<TString>; for (UInt_t ivar=0; ivar<GetNvar(); ivar++) { fInputVars->push_back(DataInfo().GetVariableInfo(ivar).GetLabel()); } fRegressionReturnVal = 0; fMulticlassReturnVal = 0; fEventCollections.resize( 2 ); fEventCollections.at(0) = 0; fEventCollections.at(1) = 0; // define "this" pointer ResetThisBase(); // retrieve signal and background class index if (DataInfo().GetClassInfo("Signal") != 0) { fSignalClass = DataInfo().GetClassInfo("Signal")->GetNumber(); } if (DataInfo().GetClassInfo("Background") != 0) { fBackgroundClass = DataInfo().GetClassInfo("Background")->GetNumber(); } SetConfigDescription( "Configuration options for MVA method" ); SetConfigName( TString("Method") + GetMethodTypeName() ); } //_______________________________________________________________________ void TMVA::MethodBase::DeclareBaseOptions() { // define the options (their key words) that can be set in the option string // here the options valid for ALL MVA methods are declared. // know options: VariableTransform=None,Decorrelated,PCA to use transformed variables // instead of the original ones // VariableTransformType=Signal,Background which decorrelation matrix to use // in the method. Only the Likelihood // Method can make proper use of independent // transformations of signal and background // fNbinsMVAPdf = 50 Number of bins used to create a PDF of MVA // fNsmoothMVAPdf = 2 Number of times a histogram is smoothed before creating the PDF // fHasMVAPdfs create PDFs for the MVA outputs // V for Verbose output (!V) for non verbos // H for Help message DeclareOptionRef( fVerbose, "V", "Verbose output (short form of \"VerbosityLevel\" below - overrides the latter one)" ); DeclareOptionRef( fVerbosityLevelString="Default", "VerbosityLevel", "Verbosity level" ); AddPreDefVal( TString("Default") ); // uses default defined in MsgLogger header AddPreDefVal( TString("Debug") ); AddPreDefVal( TString("Verbose") ); AddPreDefVal( TString("Info") ); AddPreDefVal( TString("Warning") ); AddPreDefVal( TString("Error") ); AddPreDefVal( TString("Fatal") ); // If True (default): write all training results (weights) as text files only; // if False: write also in ROOT format (not available for all methods - will abort if not fTxtWeightsOnly = kTRUE; // OBSOLETE !!! fNormalise = kFALSE; // OBSOLETE !!! DeclareOptionRef( fVarTransformString, "VarTransform", "List of variable transformations performed before training, e.g., \"D_Background,P_Signal,G,N_AllClasses\" for: \"Decorrelation, PCA-transformation, Gaussianisation, Normalisation, each for the given class of events ('AllClasses' denotes all events of all classes, if no class indication is given, 'All' is assumed)\"" ); DeclareOptionRef( fHelp, "H", "Print method-specific help message" ); DeclareOptionRef( fHasMVAPdfs, "CreateMVAPdfs", "Create PDFs for classifier outputs (signal and background)" ); DeclareOptionRef( fIgnoreNegWeightsInTraining, "IgnoreNegWeightsInTraining", "Events with negative weights are ignored in the training (but are included for testing and performance evaluation)" ); } //_______________________________________________________________________ void TMVA::MethodBase::ProcessBaseOptions() { // the option string is decoded, for availabel options see "DeclareOptions" if (HasMVAPdfs()) { // setting the default bin num... maybe should be static ? ==> Please no static (JS) // You can't use the logger in the constructor!!! Log() << kINFO << "Create PDFs" << Endl; // reading every PDF's definition and passing the option string to the next one to be read and marked fDefaultPDF = new PDF( TString(GetName())+"_PDF", GetOptions(), "MVAPdf" ); fDefaultPDF->DeclareOptions(); fDefaultPDF->ParseOptions(); fDefaultPDF->ProcessOptions(); fMVAPdfB = new PDF( TString(GetName())+"_PDFBkg", fDefaultPDF->GetOptions(), "MVAPdfBkg", fDefaultPDF ); fMVAPdfB->DeclareOptions(); fMVAPdfB->ParseOptions(); fMVAPdfB->ProcessOptions(); fMVAPdfS = new PDF( TString(GetName())+"_PDFSig", fMVAPdfB->GetOptions(), "MVAPdfSig", fDefaultPDF ); fMVAPdfS->DeclareOptions(); fMVAPdfS->ParseOptions(); fMVAPdfS->ProcessOptions(); // the final marked option string is written back to the original methodbase SetOptions( fMVAPdfS->GetOptions() ); } TMVA::MethodBase::CreateVariableTransforms( fVarTransformString, DataInfo(), GetTransformationHandler(), Log() ); if (!HasMVAPdfs()) { if (fDefaultPDF!= 0) { delete fDefaultPDF; fDefaultPDF = 0; } if (fMVAPdfS != 0) { delete fMVAPdfS; fMVAPdfS = 0; } if (fMVAPdfB != 0) { delete fMVAPdfB; fMVAPdfB = 0; } } if (fVerbose) { // overwrites other settings fVerbosityLevelString = TString("Verbose"); Log().SetMinType( kVERBOSE ); } else if (fVerbosityLevelString == "Debug" ) Log().SetMinType( kDEBUG ); else if (fVerbosityLevelString == "Verbose" ) Log().SetMinType( kVERBOSE ); else if (fVerbosityLevelString == "Info" ) Log().SetMinType( kINFO ); else if (fVerbosityLevelString == "Warning" ) Log().SetMinType( kWARNING ); else if (fVerbosityLevelString == "Error" ) Log().SetMinType( kERROR ); else if (fVerbosityLevelString == "Fatal" ) Log().SetMinType( kFATAL ); else if (fVerbosityLevelString != "Default" ) { Log() << kFATAL << "<ProcessOptions> Verbosity level type '" << fVerbosityLevelString << "' unknown." << Endl; } Event::SetIgnoreNegWeightsInTraining(fIgnoreNegWeightsInTraining); } //_______________________________________________________________________ void TMVA::MethodBase::CreateVariableTransforms( const TString& trafoDefinitionIn, TMVA::DataSetInfo& dataInfo, TMVA::TransformationHandler& transformationHandler, TMVA::MsgLogger& log ) { // create variable transformations TString trafoDefinition(trafoDefinitionIn); if (trafoDefinition == "None") return; // no transformations // workaround for transformations to complicated to be handled by makeclass // count number of transformations with incomplete set of variables TString trafoDefinitionCheck(trafoDefinitionIn); int npartial = 0, ntrafo=0; for (Int_t pos = 0, siz = trafoDefinition.Sizeof(); pos < siz; ++pos) { TString ch = trafoDefinition(pos,1); if ( ch == "(" ) npartial++; if ( ch == "+" || ch == ",") ntrafo++; } if (npartial>1) { log << kWARNING << "The use of multiple partial variable transformations during the application phase can be properly invoked via the \"Reader\", but it is not yet implemented in \"MakeClass\", the creation mechanism for standalone C++ application classes. The standalone C++ class produced by this training job is thus INCOMPLETE AND MUST NOT BE USED! The transformation in question is: " << trafoDefinitionIn << Endl; // ToDo make info and do not write the standalone class // // this does not work since this function is static // fDisableWriting=true; // disable creation of stand-alone class // ToDo we need to tell the transformation that it cannot write itself } // workaround end Int_t parenthesisCount = 0; for (Int_t position = 0, size = trafoDefinition.Sizeof(); position < size; ++position) { TString ch = trafoDefinition(position,1); if (ch == "(") ++parenthesisCount; else if (ch == ")") --parenthesisCount; else if (ch == "," && parenthesisCount == 0) trafoDefinition.Replace(position,1,'+'); } TList* trList = gTools().ParseFormatLine( trafoDefinition, "+" ); TListIter trIt(trList); while (TObjString* os = (TObjString*)trIt()) { TString tdef = os->GetString(); Int_t idxCls = -1; TString variables = ""; if (tdef.Contains("(")) { // contains selection of variables Ssiz_t parStart = tdef.Index( "(" ); Ssiz_t parLen = tdef.Index( ")", parStart )-parStart+1; variables = tdef(parStart,parLen); tdef.Remove(parStart,parLen); variables.Remove(parLen-1,1); variables.Remove(0,1); } TList* trClsList = gTools().ParseFormatLine( tdef, "_" ); // split entry to get trf-name and class-name TListIter trClsIt(trClsList); if (trClsList->GetSize() < 1) log << kFATAL << "Incorrect transformation string provided." << Endl; const TString& trName = ((TObjString*)trClsList->At(0))->GetString(); if (trClsList->GetEntries() > 1) { TString trCls = "AllClasses"; ClassInfo *ci = NULL; trCls = ((TObjString*)trClsList->At(1))->GetString(); if (trCls != "AllClasses") { ci = dataInfo.GetClassInfo( trCls ); if (ci == NULL) log << kFATAL << "Class " << trCls << " not known for variable transformation " << trName << ", please check." << Endl; else idxCls = ci->GetNumber(); } } VariableTransformBase* transformation = NULL; if (trName == "I" || trName == "Ident" || trName == "Identity") { if (variables.Length() == 0) variables = "_V_"; transformation = new VariableIdentityTransform( dataInfo); } else if (trName == "D" || trName == "Deco" || trName == "Decorrelate") { if (variables.Length() == 0) variables = "_V_"; transformation = new VariableDecorrTransform( dataInfo); } else if (trName == "P" || trName == "PCA") { if (variables.Length() == 0) variables = "_V_"; transformation = new VariablePCATransform ( dataInfo); } else if (trName == "U" || trName == "Uniform") { if (variables.Length() == 0) variables = "_V_,_T_"; transformation = new VariableGaussTransform ( dataInfo, "Uniform" ); } else if (trName == "G" || trName == "Gauss") { if (variables.Length() == 0) variables = "_V_"; transformation = new VariableGaussTransform ( dataInfo); } else if (trName == "N" || trName == "Norm" || trName == "Normalise" || trName == "Normalize") { if (variables.Length() == 0) variables = "_V_,_T_"; transformation = new VariableNormalizeTransform( dataInfo); } else log << kFATAL << "<ProcessOptions> Variable transform '" << trName << "' unknown." << Endl; if (transformation) { ClassInfo* clsInfo = dataInfo.GetClassInfo(idxCls); if (clsInfo ) log << kINFO << "Create Transformation \"" << trName << "\" with reference class " << clsInfo->GetName() << "=("<< idxCls <<")"<<Endl; else log << kINFO << "Create Transformation \"" << trName << "\" with events from all classes." << Endl; transformation->SelectInput( variables ); transformationHandler.AddTransformation(transformation, idxCls); } } return; } //_______________________________________________________________________ void TMVA::MethodBase::DeclareCompatibilityOptions() { // options that are used ONLY for the READER to ensure backward compatibility // they are hence without any effect (the reader is only reading the training // options that HAD been used at the training of the .xml weightfile at hand DeclareOptionRef( fNormalise=kFALSE, "Normalise", "Normalise input variables" ); // don't change the default !!! DeclareOptionRef( fUseDecorr=kFALSE, "D", "Use-decorrelated-variables flag" ); DeclareOptionRef( fVariableTransformTypeString="Signal", "VarTransformType", "Use signal or background events to derive for variable transformation (the transformation is applied on both types of, course)" ); AddPreDefVal( TString("Signal") ); AddPreDefVal( TString("Background") ); DeclareOptionRef( fTxtWeightsOnly=kTRUE, "TxtWeightFilesOnly", "If True: write all training results (weights) as text files (False: some are written in ROOT format)" ); // Why on earth ?? was this here? Was the verbosity level option meant to 'disapear? Not a good idea i think.. // DeclareOptionRef( fVerbosityLevelString="Default", "VerboseLevel", "Verbosity level" ); // AddPreDefVal( TString("Default") ); // uses default defined in MsgLogger header // AddPreDefVal( TString("Debug") ); // AddPreDefVal( TString("Verbose") ); // AddPreDefVal( TString("Info") ); // AddPreDefVal( TString("Warning") ); // AddPreDefVal( TString("Error") ); // AddPreDefVal( TString("Fatal") ); DeclareOptionRef( fNbinsMVAPdf = 60, "NbinsMVAPdf", "Number of bins used for the PDFs of classifier outputs" ); DeclareOptionRef( fNsmoothMVAPdf = 2, "NsmoothMVAPdf", "Number of smoothing iterations for classifier PDFs" ); } //_______________________________________________________________________ std::map<TString,Double_t> TMVA::MethodBase::OptimizeTuningParameters(TString /* fomType */ , TString /* fitType */) { // call the Optimzier with the set of paremeters and ranges that // are meant to be tuned. // this is just a dummy... needs to be implemented for each method // individually (as long as we don't have it automatized via the // configuraion string Log() << kWARNING << "Parameter optimization is not yet implemented for method " << GetName() << Endl; Log() << kWARNING << "Currently we need to set hardcoded which parameter is tuned in which ranges"<<Endl; std::map<TString,Double_t> tunedParameters; tunedParameters.size(); // just to get rid of "unused" warning return tunedParameters; } //_______________________________________________________________________ void TMVA::MethodBase::SetTuneParameters(std::map<TString,Double_t> /* tuneParameters */) { // set the tuning parameters accoding to the argument // This is just a dummy .. have a look at the MethodBDT how you could // perhaps implment the same thing for the other Classifiers.. } //_______________________________________________________________________ void TMVA::MethodBase::TrainMethod() { Data()->SetCurrentType(Types::kTraining); Event::SetIsTraining(kTRUE); // used to set negative event weights to zero if chosen to do so // train the MVA method if (Help()) PrintHelpMessage(); // all histograms should be created in the method's subdirectory BaseDir()->cd(); // once calculate all the transformation (e.g. the sequence of Decorr:Gauss:Decorr) // needed for this classifier GetTransformationHandler().CalcTransformations(Data()->GetEventCollection()); // call training of derived MVA Log() << kINFO << "Begin training" << Endl; Long64_t nEvents = Data()->GetNEvents(); Timer traintimer( nEvents, GetName(), kTRUE ); Train(); Log() << kINFO << "End of training " << Endl; SetTrainTime(traintimer.ElapsedSeconds()); Log() << kINFO << "Elapsed time for training with " << nEvents << " events: " << traintimer.GetElapsedTime() << " " << Endl; Log() << kINFO << "Create MVA output for "; // create PDFs for the signal and background MVA distributions (if required) if (DoMulticlass()) { Log() << "Multiclass classification on training sample" << Endl; AddMulticlassOutput(Types::kTraining); } else if (!DoRegression()) { Log() << "classification on training sample" << Endl; AddClassifierOutput(Types::kTraining); if (HasMVAPdfs()) { CreateMVAPdfs(); AddClassifierOutputProb(Types::kTraining); } } else { Log() << "regression on training sample" << Endl; AddRegressionOutput( Types::kTraining ); if (HasMVAPdfs() ) { Log() << "Create PDFs" << Endl; CreateMVAPdfs(); } } // write the current MVA state into stream // produced are one text file and one ROOT file if (!fDisableWriting ) WriteStateToFile(); // produce standalone make class (presently only supported for classification) if ((!DoRegression()) && (!fDisableWriting)) MakeClass(); // write additional monitoring histograms to main target file (not the weight file) // again, make sure the histograms go into the method's subdirectory BaseDir()->cd(); WriteMonitoringHistosToFile(); } //_______________________________________________________________________ void TMVA::MethodBase::GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType type, Double_t& stddev, Double_t& stddev90Percent ) const { if (!DoRegression()) Log() << kFATAL << "Trying to use GetRegressionDeviation() with a classification job" << Endl; Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl; ResultsRegression* regRes = (ResultsRegression*)Data()->GetResults(GetMethodName(), Types::kTesting, Types::kRegression); bool truncate = false; TH1F* h1 = regRes->QuadraticDeviation( tgtNum , truncate, 1.); stddev = sqrt(h1->GetMean()); truncate = true; Double_t yq[1], xq[]={0.9}; h1->GetQuantiles(1,yq,xq); TH1F* h2 = regRes->QuadraticDeviation( tgtNum , truncate, yq[0]); stddev90Percent = sqrt(h2->GetMean()); delete h1; delete h2; } //_______________________________________________________________________ void TMVA::MethodBase::AddRegressionOutput(Types::ETreeType type) { // prepare tree branch with the method's discriminating variable Data()->SetCurrentType(type); Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl; ResultsRegression* regRes = (ResultsRegression*)Data()->GetResults(GetMethodName(), type, Types::kRegression); Long64_t nEvents = Data()->GetNEvents(); // use timer Timer timer( nEvents, GetName(), kTRUE ); Log() << kINFO << "Evaluation of " << GetMethodName() << " on " << (type==Types::kTraining?"training":"testing") << " sample" << Endl; regRes->Resize( nEvents ); for (Int_t ievt=0; ievt<nEvents; ievt++) { Data()->SetCurrentEvent(ievt); std::vector< Float_t > vals = GetRegressionValues(); regRes->SetValue( vals, ievt ); timer.DrawProgressBar( ievt ); } Log() << kINFO << "Elapsed time for evaluation of " << nEvents << " events: " << timer.GetElapsedTime() << " " << Endl; // store time used for testing if (type==Types::kTesting) SetTestTime(timer.ElapsedSeconds()); TString histNamePrefix(GetTestvarName()); histNamePrefix += (type==Types::kTraining?"train":"test"); regRes->CreateDeviationHistograms( histNamePrefix ); } //_______________________________________________________________________ void TMVA::MethodBase::AddMulticlassOutput(Types::ETreeType type) { // prepare tree branch with the method's discriminating variable Data()->SetCurrentType(type); Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl; ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), type, Types::kMulticlass)); if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in AddMulticlassOutput, exiting."<<Endl; Long64_t nEvents = Data()->GetNEvents(); // use timer Timer timer( nEvents, GetName(), kTRUE ); Log() << kINFO << "Multiclass evaluation of " << GetMethodName() << " on " << (type==Types::kTraining?"training":"testing") << " sample" << Endl; resMulticlass->Resize( nEvents ); for (Int_t ievt=0; ievt<nEvents; ievt++) { Data()->SetCurrentEvent(ievt); std::vector< Float_t > vals = GetMulticlassValues(); resMulticlass->SetValue( vals, ievt ); timer.DrawProgressBar( ievt ); } Log() << kINFO << "Elapsed time for evaluation of " << nEvents << " events: " << timer.GetElapsedTime() << " " << Endl; // store time used for testing if (type==Types::kTesting) SetTestTime(timer.ElapsedSeconds()); TString histNamePrefix(GetTestvarName()); histNamePrefix += (type==Types::kTraining?"_Train":"_Test"); resMulticlass->CreateMulticlassHistos( histNamePrefix, fNbinsMVAoutput, fNbinsH ); } //_______________________________________________________________________ void TMVA::MethodBase::NoErrorCalc(Double_t* const err, Double_t* const errUpper) { if (err) *err=-1; if (errUpper) *errUpper=-1; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetMvaValue( const Event* const ev, Double_t* err, Double_t* errUpper ) { fTmpEvent = ev; Double_t val = GetMvaValue(err, errUpper); fTmpEvent = 0; return val; } //_______________________________________________________________________ Bool_t TMVA::MethodBase::IsSignalLike() { // uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation) // for a quick determination if an event would be selected as signal or background return GetMvaValue()*GetSignalReferenceCutOrientation() > GetSignalReferenceCut()*GetSignalReferenceCutOrientation() ? kTRUE : kFALSE; } //_______________________________________________________________________ Bool_t TMVA::MethodBase::IsSignalLike(Double_t mvaVal) { // uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation) // for a quick determination if an event with this mva output value would tbe selected as signal or background return mvaVal*GetSignalReferenceCutOrientation() > GetSignalReferenceCut()*GetSignalReferenceCutOrientation() ? kTRUE : kFALSE; } //_______________________________________________________________________ void TMVA::MethodBase::AddClassifierOutput( Types::ETreeType type ) { // prepare tree branch with the method's discriminating variable Data()->SetCurrentType(type); ResultsClassification* clRes = (ResultsClassification*)Data()->GetResults(GetMethodName(), type, Types::kClassification ); Long64_t nEvents = Data()->GetNEvents(); // use timer Timer timer( nEvents, GetName(), kTRUE ); Log() << kINFO << "Evaluation of " << GetMethodName() << " on " << (type==Types::kTraining?"training":"testing") << " sample (" << nEvents << " events)" << Endl; clRes->Resize( nEvents ); for (Int_t ievt=0; ievt<nEvents; ievt++) { Data()->SetCurrentEvent(ievt); clRes->SetValue( GetMvaValue(), ievt ); // print progress Int_t modulo = Int_t(nEvents/100); if (modulo <= 0 ) modulo = 1; if (ievt%modulo == 0) timer.DrawProgressBar( ievt ); } Log() << kINFO << "Elapsed time for evaluation of " << nEvents << " events: " << timer.GetElapsedTime() << " " << Endl; // store time used for testing if (type==Types::kTesting) SetTestTime(timer.ElapsedSeconds()); } //_______________________________________________________________________ void TMVA::MethodBase::AddClassifierOutputProb( Types::ETreeType type ) { // prepare tree branch with the method's discriminating variable Data()->SetCurrentType(type); ResultsClassification* mvaProb = (ResultsClassification*)Data()->GetResults(TString("prob_")+GetMethodName(), type, Types::kClassification ); Long64_t nEvents = Data()->GetNEvents(); // use timer Timer timer( nEvents, GetName(), kTRUE ); Log() << kINFO << "Evaluation of " << GetMethodName() << " on " << (type==Types::kTraining?"training":"testing") << " sample" << Endl; mvaProb->Resize( nEvents ); for (Int_t ievt=0; ievt<nEvents; ievt++) { Data()->SetCurrentEvent(ievt); Float_t proba = ((Float_t)GetProba( GetMvaValue(), 0.5 )); if (proba < 0) break; mvaProb->SetValue( proba, ievt ); // print progress Int_t modulo = Int_t(nEvents/100); if (modulo <= 0 ) modulo = 1; if (ievt%modulo == 0) timer.DrawProgressBar( ievt ); } Log() << kINFO << "Elapsed time for evaluation of " << nEvents << " events: " << timer.GetElapsedTime() << " " << Endl; } //_______________________________________________________________________ void TMVA::MethodBase::TestRegression( Double_t& bias, Double_t& biasT, Double_t& dev, Double_t& devT, Double_t& rms, Double_t& rmsT, Double_t& mInf, Double_t& mInfT, Double_t& corr, Types::ETreeType type ) { // calculate <sum-of-deviation-squared> of regression output versus "true" value from test sample // // bias = average deviation // dev = average absolute deviation // rms = rms of deviation // Types::ETreeType savedType = Data()->GetCurrentType(); Data()->SetCurrentType(type); bias = 0; biasT = 0; dev = 0; devT = 0; rms = 0; rmsT = 0; Double_t sumw = 0; Double_t m1 = 0, m2 = 0, s1 = 0, s2 = 0, s12 = 0; // for correlation const Int_t nevt = GetNEvents(); Float_t* rV = new Float_t[nevt]; Float_t* tV = new Float_t[nevt]; Float_t* wV = new Float_t[nevt]; Float_t xmin = 1e30, xmax = -1e30; for (Long64_t ievt=0; ievt<nevt; ievt++) { const Event* ev = Data()->GetEvent(ievt); // NOTE: need untransformed event here ! Float_t t = ev->GetTarget(0); Float_t w = ev->GetWeight(); Float_t r = GetRegressionValues()[0]; Float_t d = (r-t); // find min/max xmin = TMath::Min(xmin, TMath::Min(t, r)); xmax = TMath::Max(xmax, TMath::Max(t, r)); // store for truncated RMS computation rV[ievt] = r; tV[ievt] = t; wV[ievt] = w; // compute deviation-squared sumw += w; bias += w * d; dev += w * TMath::Abs(d); rms += w * d * d; // compute correlation between target and regression estimate m1 += t*w; s1 += t*t*w; m2 += r*w; s2 += r*r*w; s12 += t*r; } // standard quantities bias /= sumw; dev /= sumw; rms /= sumw; rms = TMath::Sqrt(rms - bias*bias); // correlation m1 /= sumw; m2 /= sumw; corr = s12/sumw - m1*m2; corr /= TMath::Sqrt( (s1/sumw - m1*m1) * (s2/sumw - m2*m2) ); // create histogram required for computeation of mutual information TH2F* hist = new TH2F( "hist", "hist", 150, xmin, xmax, 100, xmin, xmax ); TH2F* histT = new TH2F( "histT", "histT", 150, xmin, xmax, 100, xmin, xmax ); // compute truncated RMS and fill histogram Double_t devMax = bias + 2*rms; Double_t devMin = bias - 2*rms; sumw = 0; int ic=0; for (Long64_t ievt=0; ievt<nevt; ievt++) { Float_t d = (rV[ievt] - tV[ievt]); hist->Fill( rV[ievt], tV[ievt], wV[ievt] ); if (d >= devMin && d <= devMax) { sumw += wV[ievt]; biasT += wV[ievt] * d; devT += wV[ievt] * TMath::Abs(d); rmsT += wV[ievt] * d * d; histT->Fill( rV[ievt], tV[ievt], wV[ievt] ); ic++; } } biasT /= sumw; devT /= sumw; rmsT /= sumw; rmsT = TMath::Sqrt(rmsT - biasT*biasT); mInf = gTools().GetMutualInformation( *hist ); mInfT = gTools().GetMutualInformation( *histT ); delete hist; delete histT; delete [] rV; delete [] tV; delete [] wV; Data()->SetCurrentType(savedType); } //_______________________________________________________________________ void TMVA::MethodBase::TestMulticlass() { // test multiclass classification ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTesting, Types::kMulticlass)); if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in TestMulticlass, exiting."<<Endl; Log() << kINFO << "Determine optimal multiclass cuts for test data..." << Endl; for (UInt_t icls = 0; icls<DataInfo().GetNClasses(); ++icls) { resMulticlass->GetBestMultiClassCuts(icls); } } //_______________________________________________________________________ void TMVA::MethodBase::TestClassification() { // initialization Data()->SetCurrentType(Types::kTesting); ResultsClassification* mvaRes = dynamic_cast<ResultsClassification*> ( Data()->GetResults(GetMethodName(),Types::kTesting, Types::kClassification) ); // sanity checks: tree must exist, and theVar must be in tree if (0==mvaRes && !(GetMethodTypeName().Contains("Cuts"))) { Log() << "mvaRes " << mvaRes << " GetMethodTypeName " << GetMethodTypeName() << " contains " << !(GetMethodTypeName().Contains("Cuts")) << Endl; Log() << kFATAL << "<TestInit> Test variable " << GetTestvarName() << " not found in tree" << Endl; } // basic statistics operations are made in base class gTools().ComputeStat( GetEventCollection(Types::kTesting), mvaRes->GetValueVector(), fMeanS, fMeanB, fRmsS, fRmsB, fXmin, fXmax, fSignalClass ); // choose reasonable histogram ranges, by removing outliers Double_t nrms = 10; fXmin = TMath::Max( TMath::Min( fMeanS - nrms*fRmsS, fMeanB - nrms*fRmsB ), fXmin ); fXmax = TMath::Min( TMath::Max( fMeanS + nrms*fRmsS, fMeanB + nrms*fRmsB ), fXmax ); // determine cut orientation fCutOrientation = (fMeanS > fMeanB) ? kPositive : kNegative; // fill 2 types of histograms for the various analyses // this one is for actual plotting Double_t sxmax = fXmax+0.00001; // classifier response distributions for training sample // MVA plots used for graphics representation (signal) TH1* mva_s = new TH1D( GetTestvarName() + "_S",GetTestvarName() + "_S", fNbinsMVAoutput, fXmin, sxmax ); TH1* mva_b = new TH1D( GetTestvarName() + "_B",GetTestvarName() + "_B", fNbinsMVAoutput, fXmin, sxmax ); mvaRes->Store(mva_s, "MVA_S"); mvaRes->Store(mva_b, "MVA_B"); mva_s->Sumw2(); mva_b->Sumw2(); TH1* proba_s = 0; TH1* proba_b = 0; TH1* rarity_s = 0; TH1* rarity_b = 0; if (HasMVAPdfs()) { // P(MVA) plots used for graphics representation proba_s = new TH1D( GetTestvarName() + "_Proba_S", GetTestvarName() + "_Proba_S", fNbinsMVAoutput, 0.0, 1.0 ); proba_b = new TH1D( GetTestvarName() + "_Proba_B", GetTestvarName() + "_Proba_B", fNbinsMVAoutput, 0.0, 1.0 ); mvaRes->Store(proba_s, "Prob_S"); mvaRes->Store(proba_b, "Prob_B"); proba_s->Sumw2(); proba_b->Sumw2(); // R(MVA) plots used for graphics representation rarity_s = new TH1D( GetTestvarName() + "_Rarity_S", GetTestvarName() + "_Rarity_S", fNbinsMVAoutput, 0.0, 1.0 ); rarity_b = new TH1D( GetTestvarName() + "_Rarity_B", GetTestvarName() + "_Rarity_B", fNbinsMVAoutput, 0.0, 1.0 ); mvaRes->Store(rarity_s, "Rar_S"); mvaRes->Store(rarity_b, "Rar_B"); rarity_s->Sumw2(); rarity_b->Sumw2(); } // MVA plots used for efficiency calculations (large number of bins) TH1* mva_eff_s = new TH1D( GetTestvarName() + "_S_high", GetTestvarName() + "_S_high", fNbinsH, fXmin, sxmax ); TH1* mva_eff_b = new TH1D( GetTestvarName() + "_B_high", GetTestvarName() + "_B_high", fNbinsH, fXmin, sxmax ); mvaRes->Store(mva_eff_s, "MVA_HIGHBIN_S"); mvaRes->Store(mva_eff_b, "MVA_HIGHBIN_B"); mva_eff_s->Sumw2(); mva_eff_b->Sumw2(); // fill the histograms ResultsClassification* mvaProb = dynamic_cast<ResultsClassification*> (Data()->GetResults( TString("prob_")+GetMethodName(), Types::kTesting, Types::kMaxAnalysisType ) ); Log() << kINFO << "Loop over test events and fill histograms with classifier response..." << Endl; if (mvaProb) Log() << kINFO << "Also filling probability and rarity histograms (on request)..." << Endl; for (Long64_t ievt=0; ievt<GetNEvents(); ievt++) { const Event* ev = GetEvent(ievt); Float_t v = (*mvaRes)[ievt][0]; Float_t w = ev->GetWeight(); if (DataInfo().IsSignal(ev)) { mva_s ->Fill( v, w ); if (mvaProb) { proba_s->Fill( (*mvaProb)[ievt][0], w ); rarity_s->Fill( GetRarity( v ), w ); } mva_eff_s ->Fill( v, w ); } else { mva_b ->Fill( v, w ); if (mvaProb) { proba_b->Fill( (*mvaProb)[ievt][0], w ); rarity_b->Fill( GetRarity( v ), w ); } mva_eff_b ->Fill( v, w ); } } // uncomment those (and several others if you want unnormalized output gTools().NormHist( mva_s ); gTools().NormHist( mva_b ); gTools().NormHist( proba_s ); gTools().NormHist( proba_b ); gTools().NormHist( rarity_s ); gTools().NormHist( rarity_b ); gTools().NormHist( mva_eff_s ); gTools().NormHist( mva_eff_b ); // create PDFs from histograms, using default splines, and no additional smoothing if (fSplS) { delete fSplS; fSplS = 0; } if (fSplB) { delete fSplB; fSplB = 0; } fSplS = new PDF( TString(GetName()) + " PDF Sig", mva_s, PDF::kSpline2 ); fSplB = new PDF( TString(GetName()) + " PDF Bkg", mva_b, PDF::kSpline2 ); } //_______________________________________________________________________ void TMVA::MethodBase::WriteStateToStream( std::ostream& tf ) const { // general method used in writing the header of the weight files where // the used variables, variable transformation type etc. is specified TString prefix = ""; UserGroup_t * userInfo = gSystem->GetUserInfo(); tf << prefix << "#GEN -*-*-*-*-*-*-*-*-*-*-*- general info -*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl; tf << prefix << "Method : " << GetMethodTypeName() << "::" << GetMethodName() << std::endl; tf.setf(std::ios::left); tf << prefix << "TMVA Release : " << std::setw(10) << GetTrainingTMVAVersionString() << " [" << GetTrainingTMVAVersionCode() << "]" << std::endl; tf << prefix << "ROOT Release : " << std::setw(10) << GetTrainingROOTVersionString() << " [" << GetTrainingROOTVersionCode() << "]" << std::endl; tf << prefix << "Creator : " << userInfo->fUser << std::endl; tf << prefix << "Date : "; TDatime *d = new TDatime; tf << d->AsString() << std::endl; delete d; tf << prefix << "Host : " << gSystem->GetBuildNode() << std::endl; tf << prefix << "Dir : " << gSystem->WorkingDirectory() << std::endl; tf << prefix << "Training events: " << Data()->GetNTrainingEvents() << std::endl; TString analysisType(((const_cast<TMVA::MethodBase*>(this)->GetAnalysisType()==Types::kRegression) ? "Regression" : "Classification")); tf << prefix << "Analysis type : " << "[" << ((GetAnalysisType()==Types::kRegression) ? "Regression" : "Classification") << "]" << std::endl; tf << prefix << std::endl; delete userInfo; // First write all options tf << prefix << std::endl << prefix << "#OPT -*-*-*-*-*-*-*-*-*-*-*-*- options -*-*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl; WriteOptionsToStream( tf, prefix ); tf << prefix << std::endl; // Second write variable info tf << prefix << std::endl << prefix << "#VAR -*-*-*-*-*-*-*-*-*-*-*-* variables *-*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl; WriteVarsToStream( tf, prefix ); tf << prefix << std::endl; } //_______________________________________________________________________ void TMVA::MethodBase::AddInfoItem( void* gi, const TString& name, const TString& value) const { // xml writing void* it = gTools().AddChild(gi,"Info"); gTools().AddAttr(it,"name", name); gTools().AddAttr(it,"value", value); } //_______________________________________________________________________ void TMVA::MethodBase::AddOutput( Types::ETreeType type, Types::EAnalysisType analysisType ) { if (analysisType == Types::kRegression) { AddRegressionOutput( type ); } else if (analysisType == Types::kMulticlass) { AddMulticlassOutput( type ); } else { AddClassifierOutput( type ); if (HasMVAPdfs()) AddClassifierOutputProb( type ); } } //_______________________________________________________________________ void TMVA::MethodBase::WriteStateToXML( void* parent ) const { // general method used in writing the header of the weight files where // the used variables, variable transformation type etc. is specified if (!parent) return; UserGroup_t* userInfo = gSystem->GetUserInfo(); void* gi = gTools().AddChild(parent, "GeneralInfo"); AddInfoItem( gi, "TMVA Release", GetTrainingTMVAVersionString() + " [" + gTools().StringFromInt(GetTrainingTMVAVersionCode()) + "]" ); AddInfoItem( gi, "ROOT Release", GetTrainingROOTVersionString() + " [" + gTools().StringFromInt(GetTrainingROOTVersionCode()) + "]"); AddInfoItem( gi, "Creator", userInfo->fUser); TDatime dt; AddInfoItem( gi, "Date", dt.AsString()); AddInfoItem( gi, "Host", gSystem->GetBuildNode() ); AddInfoItem( gi, "Dir", gSystem->WorkingDirectory()); AddInfoItem( gi, "Training events", gTools().StringFromInt(Data()->GetNTrainingEvents())); AddInfoItem( gi, "TrainingTime", gTools().StringFromDouble(const_cast<TMVA::MethodBase*>(this)->GetTrainTime())); Types::EAnalysisType aType = const_cast<TMVA::MethodBase*>(this)->GetAnalysisType(); TString analysisType((aType==Types::kRegression) ? "Regression" : (aType==Types::kMulticlass ? "Multiclass" : "Classification")); AddInfoItem( gi, "AnalysisType", analysisType ); delete userInfo; // write options AddOptionsXMLTo( parent ); // write variable info AddVarsXMLTo( parent ); // write spectator info if (!fDisableWriting) AddSpectatorsXMLTo( parent ); // write class info if in multiclass mode AddClassesXMLTo(parent); // write target info if in regression mode if (DoRegression()) AddTargetsXMLTo(parent); // write transformations GetTransformationHandler(false).AddXMLTo( parent ); // write MVA variable distributions void* pdfs = gTools().AddChild(parent, "MVAPdfs"); if (fMVAPdfS) fMVAPdfS->AddXMLTo(pdfs); if (fMVAPdfB) fMVAPdfB->AddXMLTo(pdfs); // write weights AddWeightsXMLTo( parent ); } //_______________________________________________________________________ void TMVA::MethodBase::ReadStateFromStream( TFile& rf ) { // write reference MVA distributions (and other information) // to a ROOT type weight file Bool_t addDirStatus = TH1::AddDirectoryStatus(); TH1::AddDirectory( 0 ); // this avoids the binding of the hists in PDF to the current ROOT file fMVAPdfS = (TMVA::PDF*)rf.Get( "MVA_PDF_Signal" ); fMVAPdfB = (TMVA::PDF*)rf.Get( "MVA_PDF_Background" ); TH1::AddDirectory( addDirStatus ); ReadWeightsFromStream( rf ); SetTestvarName(); } //_______________________________________________________________________ void TMVA::MethodBase::WriteStateToFile() const { // write options and weights to file // note that each one text file for the main configuration information // and one ROOT file for ROOT objects are created // ---- create the text file TString tfname( GetWeightFileName() ); // writing xml file TString xmlfname( tfname ); xmlfname.ReplaceAll( ".txt", ".xml" ); Log() << kINFO << "Creating weight file in xml format: " << gTools().Color("lightblue") << xmlfname << gTools().Color("reset") << Endl; void* doc = gTools().xmlengine().NewDoc(); void* rootnode = gTools().AddChild(0,"MethodSetup", "", true); gTools().xmlengine().DocSetRootElement(doc,rootnode); gTools().AddAttr(rootnode,"Method", GetMethodTypeName() + "::" + GetMethodName()); WriteStateToXML(rootnode); gTools().xmlengine().SaveDoc(doc,xmlfname); gTools().xmlengine().FreeDoc(doc); } //_______________________________________________________________________ void TMVA::MethodBase::ReadStateFromFile() { // Function to write options and weights to file // get the filename TString tfname(GetWeightFileName()); Log() << kINFO << "Reading weight file: " << gTools().Color("lightblue") << tfname << gTools().Color("reset") << Endl; if (tfname.EndsWith(".xml") ) { #if ROOT_VERSION_CODE >= ROOT_VERSION(5,29,0) void* doc = gTools().xmlengine().ParseFile(tfname,gTools().xmlenginebuffersize()); // the default buffer size in TXMLEngine::ParseFile is 100k. Starting with ROOT 5.29 one can set the buffer size, see: http://savannah.cern.ch/bugs/?78864. This might be necessary for large XML files #else void* doc = gTools().xmlengine().ParseFile(tfname); #endif void* rootnode = gTools().xmlengine().DocGetRootElement(doc); // node "MethodSetup" ReadStateFromXML(rootnode); gTools().xmlengine().FreeDoc(doc); } else { std::filebuf fb; fb.open(tfname.Data(),std::ios::in); if (!fb.is_open()) { // file not found --> Error Log() << kFATAL << "<ReadStateFromFile> " << "Unable to open input weight file: " << tfname << Endl; } std::istream fin(&fb); ReadStateFromStream(fin); fb.close(); } if (!fTxtWeightsOnly) { // ---- read the ROOT file TString rfname( tfname ); rfname.ReplaceAll( ".txt", ".root" ); Log() << kINFO << "Reading root weight file: " << gTools().Color("lightblue") << rfname << gTools().Color("reset") << Endl; TFile* rfile = TFile::Open( rfname, "READ" ); ReadStateFromStream( *rfile ); rfile->Close(); } } //_______________________________________________________________________ void TMVA::MethodBase::ReadStateFromXMLString( const char* xmlstr ) { // for reading from memory #if (ROOT_SVN_REVISION >= 32259) && (ROOT_VERSION_CODE >= 334336) // 5.26/00 void* doc = gTools().xmlengine().ParseString(xmlstr); void* rootnode = gTools().xmlengine().DocGetRootElement(doc); // node "MethodSetup" ReadStateFromXML(rootnode); gTools().xmlengine().FreeDoc(doc); #else Log() << kFATAL << "Method MethodBase::ReadStateFromXMLString( const char* xmlstr = " << xmlstr << " ) is not available for ROOT versions prior to 5.26/00." << Endl; #endif return; } //_______________________________________________________________________ void TMVA::MethodBase::ReadStateFromXML( void* methodNode ) { TString fullMethodName; gTools().ReadAttr( methodNode, "Method", fullMethodName ); fMethodName = fullMethodName(fullMethodName.Index("::")+2,fullMethodName.Length()); // update logger Log().SetSource( GetName() ); Log() << kINFO << "Read method \"" << GetMethodName() << "\" of type \"" << GetMethodTypeName() << "\"" << Endl; // after the method name is read, the testvar can be set SetTestvarName(); TString nodeName(""); void* ch = gTools().GetChild(methodNode); while (ch!=0) { nodeName = TString( gTools().GetName(ch) ); if (nodeName=="GeneralInfo") { // read analysis type TString name(""),val(""); void* antypeNode = gTools().GetChild(ch); while (antypeNode) { gTools().ReadAttr( antypeNode, "name", name ); if (name == "TrainingTime") gTools().ReadAttr( antypeNode, "value", fTrainTime ); if (name == "AnalysisType") { gTools().ReadAttr( antypeNode, "value", val ); val.ToLower(); if (val == "regression" ) SetAnalysisType( Types::kRegression ); else if (val == "classification" ) SetAnalysisType( Types::kClassification ); else if (val == "multiclass" ) SetAnalysisType( Types::kMulticlass ); else Log() << kFATAL << "Analysis type " << val << " is not known." << Endl; } if (name == "TMVA Release" || name == "TMVA") { TString s; gTools().ReadAttr( antypeNode, "value", s); fTMVATrainingVersion = TString(s(s.Index("[")+1,s.Index("]")-s.Index("[")-1)).Atoi(); Log() << kINFO << "MVA method was trained with TMVA Version: " << GetTrainingTMVAVersionString() << Endl; } if (name == "ROOT Release" || name == "ROOT") { TString s; gTools().ReadAttr( antypeNode, "value", s); fROOTTrainingVersion = TString(s(s.Index("[")+1,s.Index("]")-s.Index("[")-1)).Atoi(); Log() << kINFO << "MVA method was trained with ROOT Version: " << GetTrainingROOTVersionString() << Endl; } antypeNode = gTools().GetNextChild(antypeNode); } } else if (nodeName=="Options") { ReadOptionsFromXML(ch); ParseOptions(); } else if (nodeName=="Variables") { ReadVariablesFromXML(ch); } else if (nodeName=="Spectators") { ReadSpectatorsFromXML(ch); } else if (nodeName=="Classes") { if (DataInfo().GetNClasses()==0) ReadClassesFromXML(ch); } else if (nodeName=="Targets") { if (DataInfo().GetNTargets()==0 && DoRegression()) ReadTargetsFromXML(ch); } else if (nodeName=="Transformations") { GetTransformationHandler().ReadFromXML(ch); } else if (nodeName=="MVAPdfs") { TString pdfname; if (fMVAPdfS) { delete fMVAPdfS; fMVAPdfS=0; } if (fMVAPdfB) { delete fMVAPdfB; fMVAPdfB=0; } void* pdfnode = gTools().GetChild(ch); if (pdfnode) { gTools().ReadAttr(pdfnode, "Name", pdfname); fMVAPdfS = new PDF(pdfname); fMVAPdfS->ReadXML(pdfnode); pdfnode = gTools().GetNextChild(pdfnode); gTools().ReadAttr(pdfnode, "Name", pdfname); fMVAPdfB = new PDF(pdfname); fMVAPdfB->ReadXML(pdfnode); } } else if (nodeName=="Weights") { ReadWeightsFromXML(ch); } else { Log() << kWARNING << "Unparsed XML node: '" << nodeName << "'" << Endl; } ch = gTools().GetNextChild(ch); } // update transformation handler if (GetTransformationHandler().GetCallerName() == "") GetTransformationHandler().SetCallerName( GetName() ); } //_______________________________________________________________________ void TMVA::MethodBase::ReadStateFromStream( std::istream& fin ) { // read the header from the weight files of the different MVA methods char buf[512]; // when reading from stream, we assume the files are produced with TMVA<=397 SetAnalysisType(Types::kClassification); // first read the method name GetLine(fin,buf); while (!TString(buf).BeginsWith("Method")) GetLine(fin,buf); TString namestr(buf); TString methodType = namestr(0,namestr.Index("::")); methodType = methodType(methodType.Last(' '),methodType.Length()); methodType = methodType.Strip(TString::kLeading); TString methodName = namestr(namestr.Index("::")+2,namestr.Length()); methodName = methodName.Strip(TString::kLeading); if (methodName == "") methodName = methodType; fMethodName = methodName; Log() << kINFO << "Read method \"" << GetMethodName() << "\" of type \"" << GetMethodTypeName() << "\"" << Endl; // update logger Log().SetSource( GetName() ); // now the question is whether to read the variables first or the options (well, of course the order // of writing them needs to agree) // // the option "Decorrelation" is needed to decide if the variables we // read are decorrelated or not // // the variables are needed by some methods (TMLP) to build the NN // which is done in ProcessOptions so for the time being we first Read and Parse the options then // we read the variables, and then we process the options // now read all options GetLine(fin,buf); while (!TString(buf).BeginsWith("#OPT")) GetLine(fin,buf); ReadOptionsFromStream(fin); ParseOptions(); // Now read variable info fin.getline(buf,512); while (!TString(buf).BeginsWith("#VAR")) fin.getline(buf,512); ReadVarsFromStream(fin); // now we process the options (of the derived class) ProcessOptions(); if (IsNormalised()) { VariableNormalizeTransform* norm = (VariableNormalizeTransform*) GetTransformationHandler().AddTransformation( new VariableNormalizeTransform(DataInfo()), -1 ); norm->BuildTransformationFromVarInfo( DataInfo().GetVariableInfos() ); } VariableTransformBase *varTrafo(0), *varTrafo2(0); if ( fVarTransformString == "None") { if (fUseDecorr) varTrafo = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 ); } else if ( fVarTransformString == "Decorrelate" ) { varTrafo = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 ); } else if ( fVarTransformString == "PCA" ) { varTrafo = GetTransformationHandler().AddTransformation( new VariablePCATransform(DataInfo()), -1 ); } else if ( fVarTransformString == "Uniform" ) { varTrafo = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo(),"Uniform"), -1 ); } else if ( fVarTransformString == "Gauss" ) { varTrafo = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo()), -1 ); } else if ( fVarTransformString == "GaussDecorr" ) { varTrafo = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo()), -1 ); varTrafo2 = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 ); } else { Log() << kFATAL << "<ProcessOptions> Variable transform '" << fVarTransformString << "' unknown." << Endl; } // Now read decorrelation matrix if available if (GetTransformationHandler().GetTransformationList().GetSize() > 0) { fin.getline(buf,512); while (!TString(buf).BeginsWith("#MAT")) fin.getline(buf,512); if (varTrafo) { TString trafo(fVariableTransformTypeString); trafo.ToLower(); varTrafo->ReadTransformationFromStream(fin, trafo ); } if (varTrafo2) { TString trafo(fVariableTransformTypeString); trafo.ToLower(); varTrafo2->ReadTransformationFromStream(fin, trafo ); } } if (HasMVAPdfs()) { // Now read the MVA PDFs fin.getline(buf,512); while (!TString(buf).BeginsWith("#MVAPDFS")) fin.getline(buf,512); if (fMVAPdfS != 0) { delete fMVAPdfS; fMVAPdfS = 0; } if (fMVAPdfB != 0) { delete fMVAPdfB; fMVAPdfB = 0; } fMVAPdfS = new PDF(TString(GetName()) + " MVA PDF Sig"); fMVAPdfB = new PDF(TString(GetName()) + " MVA PDF Bkg"); fMVAPdfS->SetReadingVersion( GetTrainingTMVAVersionCode() ); fMVAPdfB->SetReadingVersion( GetTrainingTMVAVersionCode() ); fin >> *fMVAPdfS; fin >> *fMVAPdfB; } // Now read weights fin.getline(buf,512); while (!TString(buf).BeginsWith("#WGT")) fin.getline(buf,512); fin.getline(buf,512); ReadWeightsFromStream( fin );; // update transformation handler if (GetTransformationHandler().GetCallerName() == "") GetTransformationHandler().SetCallerName( GetName() ); } //_______________________________________________________________________ void TMVA::MethodBase::WriteVarsToStream( std::ostream& o, const TString& prefix ) const { // write the list of variables (name, min, max) for a given data // transformation method to the stream o << prefix << "NVar " << DataInfo().GetNVariables() << std::endl; std::vector<VariableInfo>::const_iterator varIt = DataInfo().GetVariableInfos().begin(); for (; varIt!=DataInfo().GetVariableInfos().end(); varIt++) { o << prefix; varIt->WriteToStream(o); } o << prefix << "NSpec " << DataInfo().GetNSpectators() << std::endl; varIt = DataInfo().GetSpectatorInfos().begin(); for (; varIt!=DataInfo().GetSpectatorInfos().end(); varIt++) { o << prefix; varIt->WriteToStream(o); } } //_______________________________________________________________________ void TMVA::MethodBase::ReadVarsFromStream( std::istream& istr ) { // Read the variables (name, min, max) for a given data // transformation method from the stream. In the stream we only // expect the limits which will be set TString dummy; UInt_t readNVar; istr >> dummy >> readNVar; if (readNVar!=DataInfo().GetNVariables()) { Log() << kFATAL << "You declared "<< DataInfo().GetNVariables() << " variables in the Reader" << " while there are " << readNVar << " variables declared in the file" << Endl; } // we want to make sure all variables are read in the order they are defined VariableInfo varInfo; std::vector<VariableInfo>::iterator varIt = DataInfo().GetVariableInfos().begin(); int varIdx = 0; for (; varIt!=DataInfo().GetVariableInfos().end(); varIt++, varIdx++) { varInfo.ReadFromStream(istr); if (varIt->GetExpression() == varInfo.GetExpression()) { varInfo.SetExternalLink((*varIt).GetExternalLink()); (*varIt) = varInfo; } else { Log() << kINFO << "ERROR in <ReadVarsFromStream>" << Endl; Log() << kINFO << "The definition (or the order) of the variables found in the input file is" << Endl; Log() << kINFO << "is not the same as the one declared in the Reader (which is necessary for" << Endl; Log() << kINFO << "the correct working of the method):" << Endl; Log() << kINFO << " var #" << varIdx <<" declared in Reader: " << varIt->GetExpression() << Endl; Log() << kINFO << " var #" << varIdx <<" declared in file : " << varInfo.GetExpression() << Endl; Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl; } } } //_______________________________________________________________________ void TMVA::MethodBase::AddVarsXMLTo( void* parent ) const { // write variable info to XML void* vars = gTools().AddChild(parent, "Variables"); gTools().AddAttr( vars, "NVar", gTools().StringFromInt(DataInfo().GetNVariables()) ); for (UInt_t idx=0; idx<DataInfo().GetVariableInfos().size(); idx++) { VariableInfo& vi = DataInfo().GetVariableInfos()[idx]; void* var = gTools().AddChild( vars, "Variable" ); gTools().AddAttr( var, "VarIndex", idx ); vi.AddToXML( var ); } } //_______________________________________________________________________ void TMVA::MethodBase::AddSpectatorsXMLTo( void* parent ) const { // write spectator info to XML void* specs = gTools().AddChild(parent, "Spectators"); UInt_t writeIdx=0; for (UInt_t idx=0; idx<DataInfo().GetSpectatorInfos().size(); idx++) { VariableInfo& vi = DataInfo().GetSpectatorInfos()[idx]; // we do not want to write spectators that are category-cuts, // except if the method is the category method and the spectators belong to it if (vi.GetVarType()=='C') continue; void* spec = gTools().AddChild( specs, "Spectator" ); gTools().AddAttr( spec, "SpecIndex", writeIdx++ ); vi.AddToXML( spec ); } gTools().AddAttr( specs, "NSpec", gTools().StringFromInt(writeIdx) ); } //_______________________________________________________________________ void TMVA::MethodBase::AddClassesXMLTo( void* parent ) const { // write class info to XML UInt_t nClasses=DataInfo().GetNClasses(); void* classes = gTools().AddChild(parent, "Classes"); gTools().AddAttr( classes, "NClass", nClasses ); for (UInt_t iCls=0; iCls<nClasses; ++iCls) { ClassInfo *classInfo=DataInfo().GetClassInfo (iCls); TString className =classInfo->GetName(); UInt_t classNumber=classInfo->GetNumber(); void* classNode=gTools().AddChild(classes, "Class"); gTools().AddAttr( classNode, "Name", className ); gTools().AddAttr( classNode, "Index", classNumber ); } } //_______________________________________________________________________ void TMVA::MethodBase::AddTargetsXMLTo( void* parent ) const { // write target info to XML void* targets = gTools().AddChild(parent, "Targets"); gTools().AddAttr( targets, "NTrgt", gTools().StringFromInt(DataInfo().GetNTargets()) ); for (UInt_t idx=0; idx<DataInfo().GetTargetInfos().size(); idx++) { VariableInfo& vi = DataInfo().GetTargetInfos()[idx]; void* tar = gTools().AddChild( targets, "Target" ); gTools().AddAttr( tar, "TargetIndex", idx ); vi.AddToXML( tar ); } } //_______________________________________________________________________ void TMVA::MethodBase::ReadVariablesFromXML( void* varnode ) { // read variable info from XML UInt_t readNVar; gTools().ReadAttr( varnode, "NVar", readNVar); if (readNVar!=DataInfo().GetNVariables()) { Log() << kFATAL << "You declared "<< DataInfo().GetNVariables() << " variables in the Reader" << " while there are " << readNVar << " variables declared in the file" << Endl; } // we want to make sure all variables are read in the order they are defined VariableInfo readVarInfo, existingVarInfo; int varIdx = 0; void* ch = gTools().GetChild(varnode); while (ch) { gTools().ReadAttr( ch, "VarIndex", varIdx); existingVarInfo = DataInfo().GetVariableInfos()[varIdx]; readVarInfo.ReadFromXML(ch); if (existingVarInfo.GetExpression() == readVarInfo.GetExpression()) { readVarInfo.SetExternalLink(existingVarInfo.GetExternalLink()); existingVarInfo = readVarInfo; } else { Log() << kINFO << "ERROR in <ReadVariablesFromXML>" << Endl; Log() << kINFO << "The definition (or the order) of the variables found in the input file is" << Endl; Log() << kINFO << "not the same as the one declared in the Reader (which is necessary for the" << Endl; Log() << kINFO << "correct working of the method):" << Endl; Log() << kINFO << " var #" << varIdx <<" declared in Reader: " << existingVarInfo.GetExpression() << Endl; Log() << kINFO << " var #" << varIdx <<" declared in file : " << readVarInfo.GetExpression() << Endl; Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl; } ch = gTools().GetNextChild(ch); } } //_______________________________________________________________________ void TMVA::MethodBase::ReadSpectatorsFromXML( void* specnode ) { // read spectator info from XML UInt_t readNSpec; gTools().ReadAttr( specnode, "NSpec", readNSpec); if (readNSpec!=DataInfo().GetNSpectators(kFALSE)) { Log() << kFATAL << "You declared "<< DataInfo().GetNSpectators(kFALSE) << " spectators in the Reader" << " while there are " << readNSpec << " spectators declared in the file" << Endl; } // we want to make sure all variables are read in the order they are defined VariableInfo readSpecInfo, existingSpecInfo; int specIdx = 0; void* ch = gTools().GetChild(specnode); while (ch) { gTools().ReadAttr( ch, "SpecIndex", specIdx); existingSpecInfo = DataInfo().GetSpectatorInfos()[specIdx]; readSpecInfo.ReadFromXML(ch); if (existingSpecInfo.GetExpression() == readSpecInfo.GetExpression()) { readSpecInfo.SetExternalLink(existingSpecInfo.GetExternalLink()); existingSpecInfo = readSpecInfo; } else { Log() << kINFO << "ERROR in <ReadSpectatorsFromXML>" << Endl; Log() << kINFO << "The definition (or the order) of the spectators found in the input file is" << Endl; Log() << kINFO << "not the same as the one declared in the Reader (which is necessary for the" << Endl; Log() << kINFO << "correct working of the method):" << Endl; Log() << kINFO << " spec #" << specIdx <<" declared in Reader: " << existingSpecInfo.GetExpression() << Endl; Log() << kINFO << " spec #" << specIdx <<" declared in file : " << readSpecInfo.GetExpression() << Endl; Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl; } ch = gTools().GetNextChild(ch); } } //_______________________________________________________________________ void TMVA::MethodBase::ReadClassesFromXML( void* clsnode ) { // read number of classes from XML UInt_t readNCls; // coverity[tainted_data_argument] gTools().ReadAttr( clsnode, "NClass", readNCls); TString className=""; UInt_t classIndex=0; void* ch = gTools().GetChild(clsnode); if (!ch) { for (UInt_t icls = 0; icls<readNCls;++icls) { TString classname = Form("class%i",icls); DataInfo().AddClass(classname); } } else{ while (ch) { gTools().ReadAttr( ch, "Index", classIndex); gTools().ReadAttr( ch, "Name", className ); DataInfo().AddClass(className); ch = gTools().GetNextChild(ch); } } // retrieve signal and background class index if (DataInfo().GetClassInfo("Signal") != 0) { fSignalClass = DataInfo().GetClassInfo("Signal")->GetNumber(); } else fSignalClass=0; if (DataInfo().GetClassInfo("Background") != 0) { fBackgroundClass = DataInfo().GetClassInfo("Background")->GetNumber(); } else fBackgroundClass=1; } //_______________________________________________________________________ void TMVA::MethodBase::ReadTargetsFromXML( void* tarnode ) { // read target info from XML UInt_t readNTar; gTools().ReadAttr( tarnode, "NTrgt", readNTar); int tarIdx = 0; TString expression; void* ch = gTools().GetChild(tarnode); while (ch) { gTools().ReadAttr( ch, "TargetIndex", tarIdx); gTools().ReadAttr( ch, "Expression", expression); DataInfo().AddTarget(expression,"","",0,0); ch = gTools().GetNextChild(ch); } } //_______________________________________________________________________ TDirectory* TMVA::MethodBase::BaseDir() const { // returns the ROOT directory where info/histograms etc of the // corresponding MVA method instance are stored if (fBaseDir != 0) return fBaseDir; Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " not set yet --> check if already there.." <<Endl; TDirectory* methodDir = MethodBaseDir(); if (methodDir==0) Log() << kFATAL << "MethodBase::BaseDir() - MethodBaseDir() return a NULL pointer!" << Endl; TDirectory* dir = 0; TString defaultDir = GetMethodName(); TObject* o = methodDir->FindObject(defaultDir); if (o!=0 && o->InheritsFrom(TDirectory::Class())) dir = (TDirectory*)o; if (dir != 0) { Log()<<kDEBUG<<" Base Directory for " << GetMethodName() << " existed, return it.." <<Endl; return dir; } Log()<<kDEBUG<<" Base Directory for " << GetMethodName() << " does not exist yet--> created it" <<Endl; TDirectory *sdir = methodDir->mkdir(defaultDir); // write weight file name into target file sdir->cd(); TObjString wfilePath( gSystem->WorkingDirectory() ); TObjString wfileName( GetWeightFileName() ); wfilePath.Write( "TrainingPath" ); wfileName.Write( "WeightFileName" ); return sdir; } //_______________________________________________________________________ TDirectory* TMVA::MethodBase::MethodBaseDir() const { // returns the ROOT directory where all instances of the // corresponding MVA method are stored if (fMethodBaseDir != 0) return fMethodBaseDir; Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " not set yet --> check if already there.." <<Endl; const TString dirName(Form("Method_%s",GetMethodTypeName().Data())); TDirectory * dir = Factory::RootBaseDir()->GetDirectory(dirName); if (dir != 0) { Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " existed, return it.." <<Endl; return dir; } Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " does not exist yet--> created it" <<Endl; fMethodBaseDir = Factory::RootBaseDir()->mkdir(dirName,Form("Directory for all %s methods", GetMethodTypeName().Data())); Log()<<kDEBUG<<"Return from MethodBaseDir() after creating base directory "<<Endl; return fMethodBaseDir; } //_______________________________________________________________________ void TMVA::MethodBase::SetWeightFileDir( TString fileDir ) { // set directory of weight file fFileDir = fileDir; gSystem->MakeDirectory( fFileDir ); } //_______________________________________________________________________ void TMVA::MethodBase::SetWeightFileName( TString theWeightFile) { // set the weight file name (depreciated) fWeightFile = theWeightFile; } //_______________________________________________________________________ TString TMVA::MethodBase::GetWeightFileName() const { // retrieve weight file name if (fWeightFile!="") return fWeightFile; // the default consists of // directory/jobname_methodname_suffix.extension.{root/txt} TString suffix = ""; TString wFileDir(GetWeightFileDir()); return ( wFileDir + (wFileDir[wFileDir.Length()-1]=='/' ? "" : "/") + GetJobName() + "_" + GetMethodName() + suffix + "." + gConfig().GetIONames().fWeightFileExtension + ".xml" ); } //_______________________________________________________________________ void TMVA::MethodBase::WriteEvaluationHistosToFile(Types::ETreeType treetype) { // writes all MVA evaluation histograms to file BaseDir()->cd(); // write MVA PDFs to file - if exist if (0 != fMVAPdfS) { fMVAPdfS->GetOriginalHist()->Write(); fMVAPdfS->GetSmoothedHist()->Write(); fMVAPdfS->GetPDFHist()->Write(); } if (0 != fMVAPdfB) { fMVAPdfB->GetOriginalHist()->Write(); fMVAPdfB->GetSmoothedHist()->Write(); fMVAPdfB->GetPDFHist()->Write(); } // write result-histograms Results* results = Data()->GetResults( GetMethodName(), treetype, Types::kMaxAnalysisType ); if (!results) Log() << kFATAL << "<WriteEvaluationHistosToFile> Unknown result: " << GetMethodName() << (treetype==Types::kTraining?"/kTraining":"/kTesting") << "/kMaxAnalysisType" << Endl; results->GetStorage()->Write(); if (treetype==Types::kTesting) { GetTransformationHandler().PlotVariables (GetEventCollection( Types::kTesting ), BaseDir() ); } } //_______________________________________________________________________ void TMVA::MethodBase::WriteMonitoringHistosToFile( void ) const { // write special monitoring histograms to file // dummy implementation here ----------------- } //_______________________________________________________________________ Bool_t TMVA::MethodBase::GetLine(std::istream& fin, char* buf ) { // reads one line from the input stream // checks for certain keywords and interprets // the line if keywords are found fin.getline(buf,512); TString line(buf); if (line.BeginsWith("TMVA Release")) { Ssiz_t start = line.First('[')+1; Ssiz_t length = line.Index("]",start)-start; TString code = line(start,length); std::stringstream s(code.Data()); s >> fTMVATrainingVersion; Log() << kINFO << "MVA method was trained with TMVA Version: " << GetTrainingTMVAVersionString() << Endl; } if (line.BeginsWith("ROOT Release")) { Ssiz_t start = line.First('[')+1; Ssiz_t length = line.Index("]",start)-start; TString code = line(start,length); std::stringstream s(code.Data()); s >> fROOTTrainingVersion; Log() << kINFO << "MVA method was trained with ROOT Version: " << GetTrainingROOTVersionString() << Endl; } if (line.BeginsWith("Analysis type")) { Ssiz_t start = line.First('[')+1; Ssiz_t length = line.Index("]",start)-start; TString code = line(start,length); std::stringstream s(code.Data()); std::string analysisType; s >> analysisType; if (analysisType == "regression" || analysisType == "Regression") SetAnalysisType( Types::kRegression ); else if (analysisType == "classification" || analysisType == "Classification") SetAnalysisType( Types::kClassification ); else if (analysisType == "multiclass" || analysisType == "Multiclass") SetAnalysisType( Types::kMulticlass ); else Log() << kFATAL << "Analysis type " << analysisType << " from weight-file not known!" << std::endl; Log() << kINFO << "Method was trained for " << (GetAnalysisType() == Types::kRegression ? "Regression" : (GetAnalysisType() == Types::kMulticlass ? "Multiclass" : "Classification")) << Endl; } return true; } //_______________________________________________________________________ void TMVA::MethodBase::CreateMVAPdfs() { // Create PDFs of the MVA output variables Data()->SetCurrentType(Types::kTraining); // the PDF's are stored as results ONLY if the corresponding "results" are booked, // otherwise they will be only used 'online' ResultsClassification * mvaRes = dynamic_cast<ResultsClassification*> ( Data()->GetResults(GetMethodName(), Types::kTraining, Types::kClassification) ); if (mvaRes==0 || mvaRes->GetSize()==0) { Log() << kERROR<< "<CreateMVAPdfs> No result of classifier testing available" << Endl; } Double_t minVal = *std::min_element(mvaRes->GetValueVector()->begin(),mvaRes->GetValueVector()->end()); Double_t maxVal = *std::max_element(mvaRes->GetValueVector()->begin(),mvaRes->GetValueVector()->end()); // create histograms that serve as basis to create the MVA Pdfs TH1* histMVAPdfS = new TH1D( GetMethodTypeName() + "_tr_S", GetMethodTypeName() + "_tr_S", fMVAPdfS->GetHistNBins( mvaRes->GetSize() ), minVal, maxVal ); TH1* histMVAPdfB = new TH1D( GetMethodTypeName() + "_tr_B", GetMethodTypeName() + "_tr_B", fMVAPdfB->GetHistNBins( mvaRes->GetSize() ), minVal, maxVal ); // compute sum of weights properly histMVAPdfS->Sumw2(); histMVAPdfB->Sumw2(); // fill histograms for (UInt_t ievt=0; ievt<mvaRes->GetSize(); ievt++) { Double_t theVal = mvaRes->GetValueVector()->at(ievt); Double_t theWeight = Data()->GetEvent(ievt)->GetWeight(); if (DataInfo().IsSignal(Data()->GetEvent(ievt))) histMVAPdfS->Fill( theVal, theWeight ); else histMVAPdfB->Fill( theVal, theWeight ); } gTools().NormHist( histMVAPdfS ); gTools().NormHist( histMVAPdfB ); // momentary hack for ROOT problem histMVAPdfS->Write(); histMVAPdfB->Write(); // create PDFs fMVAPdfS->BuildPDF ( histMVAPdfS ); fMVAPdfB->BuildPDF ( histMVAPdfB ); fMVAPdfS->ValidatePDF( histMVAPdfS ); fMVAPdfB->ValidatePDF( histMVAPdfB ); if (DataInfo().GetNClasses() == 2) { // TODO: this is an ugly hack.. adapt this to new framework Log() << kINFO << Form( "<CreateMVAPdfs> Separation from histogram (PDF): %1.3f (%1.3f)", GetSeparation( histMVAPdfS, histMVAPdfB ), GetSeparation( fMVAPdfS, fMVAPdfB ) ) << Endl; } delete histMVAPdfS; delete histMVAPdfB; } Double_t TMVA::MethodBase::GetProba(const Event *ev){ // the simple one, automatically calcualtes the mvaVal and uses the // SAME sig/bkg ratio as given in the training sample (typically 50/50 // .. (NormMode=EqualNumEvents) but can be different) if (!fMVAPdfS || !fMVAPdfB) { Log() << kINFO << "<GetProba> MVA PDFs for Signal and Background don't exist yet, we'll create them on demand" << Endl; CreateMVAPdfs(); } Double_t sigFraction = DataInfo().GetTrainingSumSignalWeights() / (DataInfo().GetTrainingSumSignalWeights() + DataInfo().GetTrainingSumBackgrWeights() ); Double_t mvaVal = GetMvaValue(ev); return GetProba(mvaVal,sigFraction); } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetProba( Double_t mvaVal, Double_t ap_sig ) { // compute likelihood ratio if (!fMVAPdfS || !fMVAPdfB) { Log() << kWARNING << "<GetProba> MVA PDFs for Signal and Background don't exist" << Endl; return -1.0; } Double_t p_s = fMVAPdfS->GetVal( mvaVal ); Double_t p_b = fMVAPdfB->GetVal( mvaVal ); Double_t denom = p_s*ap_sig + p_b*(1 - ap_sig); return (denom > 0) ? (p_s*ap_sig) / denom : -1; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetRarity( Double_t mvaVal, Types::ESBType reftype ) const { // compute rarity: // R(x) = Integrate_[-oo..x] { PDF(x') dx' } // where PDF(x) is the PDF of the classifier's signal or background distribution if ((reftype == Types::kSignal && !fMVAPdfS) || (reftype == Types::kBackground && !fMVAPdfB)) { Log() << kWARNING << "<GetRarity> Required MVA PDF for Signal or Backgroud does not exist: " << "select option \"CreateMVAPdfs\"" << Endl; return 0.0; } PDF* thePdf = ((reftype == Types::kSignal) ? fMVAPdfS : fMVAPdfB); return thePdf->GetIntegral( thePdf->GetXmin(), mvaVal ); } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetEfficiency( const TString& theString, Types::ETreeType type,Double_t& effSerr ) { // fill background efficiency (resp. rejection) versus signal efficiency plots // returns signal efficiency at background efficiency indicated in theString Data()->SetCurrentType(type); Results* results = Data()->GetResults( GetMethodName(), type, Types::kClassification ); std::vector<Float_t>* mvaRes = dynamic_cast<ResultsClassification*>(results)->GetValueVector(); // parse input string for required background efficiency TList* list = gTools().ParseFormatLine( theString ); // sanity check Bool_t computeArea = kFALSE; if (!list || list->GetSize() < 2) computeArea = kTRUE; // the area is computed else if (list->GetSize() > 2) { Log() << kFATAL << "<GetEfficiency> Wrong number of arguments" << " in string: " << theString << " | required format, e.g., Efficiency:0.05, or empty string" << Endl; delete list; return -1; } // sanity check if ( results->GetHist("MVA_S")->GetNbinsX() != results->GetHist("MVA_B")->GetNbinsX() || results->GetHist("MVA_HIGHBIN_S")->GetNbinsX() != results->GetHist("MVA_HIGHBIN_B")->GetNbinsX() ) { Log() << kFATAL << "<GetEfficiency> Binning mismatch between signal and background histos" << Endl; delete list; return -1.0; } // create histograms // first, get efficiency histograms for signal and background TH1 * effhist = results->GetHist("MVA_HIGHBIN_S"); Double_t xmin = effhist->GetXaxis()->GetXmin(); Double_t xmax = effhist->GetXaxis()->GetXmax(); static Double_t nevtS; // first round ? --> create histograms if (results->DoesExist("MVA_EFF_S")==0) { // for efficiency plot TH1* eff_s = new TH1D( GetTestvarName() + "_effS", GetTestvarName() + " (signal)", fNbinsH, xmin, xmax ); TH1* eff_b = new TH1D( GetTestvarName() + "_effB", GetTestvarName() + " (background)", fNbinsH, xmin, xmax ); results->Store(eff_s, "MVA_EFF_S"); results->Store(eff_b, "MVA_EFF_B"); // sign if cut Int_t sign = (fCutOrientation == kPositive) ? +1 : -1; // this method is unbinned nevtS = 0; for (UInt_t ievt=0; ievt<Data()->GetNEvents(); ievt++) { // read the tree Bool_t isSignal = DataInfo().IsSignal(GetEvent(ievt)); Float_t theWeight = GetEvent(ievt)->GetWeight(); Float_t theVal = (*mvaRes)[ievt]; // select histogram depending on if sig or bgd TH1* theHist = isSignal ? eff_s : eff_b; // count signal and background events in tree if (isSignal) nevtS+=theWeight; TAxis* axis = theHist->GetXaxis(); Int_t maxbin = Int_t((theVal - axis->GetXmin())/(axis->GetXmax() - axis->GetXmin())*fNbinsH) + 1; if (sign > 0 && maxbin > fNbinsH) continue; // can happen... event doesn't count if (sign < 0 && maxbin < 1 ) continue; // can happen... event doesn't count if (sign > 0 && maxbin < 1 ) maxbin = 1; if (sign < 0 && maxbin > fNbinsH) maxbin = fNbinsH; if (sign > 0) for (Int_t ibin=1; ibin<=maxbin; ibin++) theHist->AddBinContent( ibin , theWeight); else if (sign < 0) for (Int_t ibin=maxbin+1; ibin<=fNbinsH; ibin++) theHist->AddBinContent( ibin , theWeight ); else Log() << kFATAL << "<GetEfficiency> Mismatch in sign" << Endl; } // renormalise maximum to <=1 // eff_s->Scale( 1.0/TMath::Max(1.,eff_s->GetMaximum()) ); // eff_b->Scale( 1.0/TMath::Max(1.,eff_b->GetMaximum()) ); eff_s->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(),eff_s->GetMaximum()) ); eff_b->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(),eff_b->GetMaximum()) ); // background efficiency versus signal efficiency TH1* eff_BvsS = new TH1D( GetTestvarName() + "_effBvsS", GetTestvarName() + "", fNbins, 0, 1 ); results->Store(eff_BvsS, "MVA_EFF_BvsS"); eff_BvsS->SetXTitle( "Signal eff" ); eff_BvsS->SetYTitle( "Backgr eff" ); // background rejection (=1-eff.) versus signal efficiency TH1* rej_BvsS = new TH1D( GetTestvarName() + "_rejBvsS", GetTestvarName() + "", fNbins, 0, 1 ); results->Store(rej_BvsS); rej_BvsS->SetXTitle( "Signal eff" ); rej_BvsS->SetYTitle( "Backgr rejection (1-eff)" ); // inverse background eff (1/eff.) versus signal efficiency TH1* inveff_BvsS = new TH1D( GetTestvarName() + "_invBeffvsSeff", GetTestvarName(), fNbins, 0, 1 ); results->Store(inveff_BvsS); inveff_BvsS->SetXTitle( "Signal eff" ); inveff_BvsS->SetYTitle( "Inverse backgr. eff (1/eff)" ); // use root finder // spline background efficiency plot // note that there is a bin shift when going from a TH1D object to a TGraph :-( if (Use_Splines_for_Eff_) { fSplRefS = new TSpline1( "spline2_signal", new TGraph( eff_s ) ); fSplRefB = new TSpline1( "spline2_background", new TGraph( eff_b ) ); // verify spline sanity gTools().CheckSplines( eff_s, fSplRefS ); gTools().CheckSplines( eff_b, fSplRefB ); } // make the background-vs-signal efficiency plot // create root finder // reset static "this" pointer before calling external function ResetThisBase(); RootFinder rootFinder( &IGetEffForRoot, fXmin, fXmax ); Double_t effB = 0; fEffS = eff_s; // to be set for the root finder for (Int_t bini=1; bini<=fNbins; bini++) { // find cut value corresponding to a given signal efficiency Double_t effS = eff_BvsS->GetBinCenter( bini ); Double_t cut = rootFinder.Root( effS ); // retrieve background efficiency for given cut if (Use_Splines_for_Eff_) effB = fSplRefB->Eval( cut ); else effB = eff_b->GetBinContent( eff_b->FindBin( cut ) ); // and fill histograms eff_BvsS->SetBinContent( bini, effB ); rej_BvsS->SetBinContent( bini, 1.0-effB ); if (effB>std::numeric_limits<double>::epsilon()) inveff_BvsS->SetBinContent( bini, 1.0/effB ); } // create splines for histogram fSpleffBvsS = new TSpline1( "effBvsS", new TGraph( eff_BvsS ) ); // search for overlap point where, when cutting on it, // one would obtain: eff_S = rej_B = 1 - eff_B Double_t effS, rejB, effS_ = 0, rejB_ = 0; Int_t nbins_ = 5000; for (Int_t bini=1; bini<=nbins_; bini++) { // get corresponding signal and background efficiencies effS = (bini - 0.5)/Float_t(nbins_); rejB = 1.0 - fSpleffBvsS->Eval( effS ); // find signal efficiency that corresponds to required background efficiency if ((effS - rejB)*(effS_ - rejB_) < 0) break; effS_ = effS; rejB_ = rejB; } // find cut that corresponds to signal efficiency and update signal-like criterion Double_t cut = rootFinder.Root( 0.5*(effS + effS_) ); SetSignalReferenceCut( cut ); fEffS = 0; } // must exist... if (0 == fSpleffBvsS) { delete list; 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_; delete list; return integral; } else { // 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() ); // find precise efficiency value 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; } // take mean between bin above and bin below effS = 0.5*(effS + effS_); effSerr = 0; if (nevtS > 0) effSerr = TMath::Sqrt( effS*(1.0 - effS)/nevtS ); delete list; return effS; } return -1; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetTrainingEfficiency(const TString& theString) { Data()->SetCurrentType(Types::kTraining); Results* results = Data()->GetResults(GetMethodName(), Types::kTesting, Types::kNoAnalysisType); // fill background efficiency (resp. rejection) versus signal efficiency plots // returns signal efficiency at background efficiency indicated in theString // 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; delete list; return -1; } // 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; // sanity check if (results->GetHist("MVA_S")->GetNbinsX() != results->GetHist("MVA_B")->GetNbinsX() || results->GetHist("MVA_HIGHBIN_S")->GetNbinsX() != results->GetHist("MVA_HIGHBIN_B")->GetNbinsX() ) { Log() << kFATAL << "<GetTrainingEfficiency> Binning mismatch between signal and background histos" << Endl; return -1.0; } // create histogram // first, get efficiency histograms for signal and background TH1 * effhist = results->GetHist("MVA_HIGHBIN_S"); Double_t xmin = effhist->GetXaxis()->GetXmin(); Double_t xmax = effhist->GetXaxis()->GetXmax(); // first round ? --> create and fill histograms if (results->DoesExist("MVA_TRAIN_S")==0) { // classifier response distributions for test sample Double_t sxmax = fXmax+0.00001; // MVA plots on the training sample (check for overtraining) TH1* mva_s_tr = new TH1D( GetTestvarName() + "_Train_S",GetTestvarName() + "_Train_S", fNbinsMVAoutput, fXmin, sxmax ); TH1* mva_b_tr = new TH1D( GetTestvarName() + "_Train_B",GetTestvarName() + "_Train_B", fNbinsMVAoutput, fXmin, sxmax ); results->Store(mva_s_tr, "MVA_TRAIN_S"); results->Store(mva_b_tr, "MVA_TRAIN_B"); mva_s_tr->Sumw2(); mva_b_tr->Sumw2(); // Training efficiency plots TH1* mva_eff_tr_s = new TH1D( GetTestvarName() + "_trainingEffS", GetTestvarName() + " (signal)", fNbinsH, xmin, xmax ); TH1* mva_eff_tr_b = new TH1D( GetTestvarName() + "_trainingEffB", GetTestvarName() + " (background)", fNbinsH, xmin, xmax ); results->Store(mva_eff_tr_s, "MVA_TRAINEFF_S"); results->Store(mva_eff_tr_b, "MVA_TRAINEFF_B"); // sign if cut Int_t sign = (fCutOrientation == kPositive) ? +1 : -1; // this method is unbinned for (Int_t ievt=0; ievt<Data()->GetNEvents(); ievt++) { Data()->SetCurrentEvent(ievt); const Event* ev = GetEvent(); Double_t theVal = GetMvaValue(); Double_t theWeight = ev->GetWeight(); TH1* theEffHist = DataInfo().IsSignal(ev) ? mva_eff_tr_s : mva_eff_tr_b; TH1* theClsHist = DataInfo().IsSignal(ev) ? mva_s_tr : mva_b_tr; theClsHist->Fill( theVal, theWeight ); TAxis* axis = theEffHist->GetXaxis(); Int_t maxbin = Int_t((theVal - axis->GetXmin())/(axis->GetXmax() - axis->GetXmin())*fNbinsH) + 1; if (sign > 0 && maxbin > fNbinsH) continue; // can happen... event doesn't count if (sign < 0 && maxbin < 1 ) continue; // can happen... event doesn't count if (sign > 0 && maxbin < 1 ) maxbin = 1; if (sign < 0 && maxbin > fNbinsH) maxbin = fNbinsH; if (sign > 0) for (Int_t ibin=1; ibin<=maxbin; ibin++) theEffHist->AddBinContent( ibin , theWeight ); else for (Int_t ibin=maxbin+1; ibin<=fNbinsH; ibin++) theEffHist->AddBinContent( ibin , theWeight ); } // normalise output distributions // uncomment those (and several others if you want unnormalized output gTools().NormHist( mva_s_tr ); gTools().NormHist( mva_b_tr ); // renormalise to maximum mva_eff_tr_s->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(), mva_eff_tr_s->GetMaximum()) ); mva_eff_tr_b->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(), mva_eff_tr_b->GetMaximum()) ); // Training background efficiency versus signal efficiency TH1* eff_bvss = new TH1D( GetTestvarName() + "_trainingEffBvsS", GetTestvarName() + "", fNbins, 0, 1 ); // Training background rejection (=1-eff.) versus signal efficiency TH1* rej_bvss = new TH1D( GetTestvarName() + "_trainingRejBvsS", GetTestvarName() + "", fNbins, 0, 1 ); results->Store(eff_bvss, "EFF_BVSS_TR"); results->Store(rej_bvss, "REJ_BVSS_TR"); // use root finder // spline background efficiency plot // note that there is a bin shift when going from a TH1D object to a TGraph :-( if (Use_Splines_for_Eff_) { if (fSplTrainRefS) delete fSplTrainRefS; if (fSplTrainRefB) delete fSplTrainRefB; fSplTrainRefS = new TSpline1( "spline2_signal", new TGraph( mva_eff_tr_s ) ); fSplTrainRefB = new TSpline1( "spline2_background", new TGraph( mva_eff_tr_b ) ); // verify spline sanity gTools().CheckSplines( mva_eff_tr_s, fSplTrainRefS ); gTools().CheckSplines( mva_eff_tr_b, fSplTrainRefB ); } // make the background-vs-signal efficiency plot // create root finder // reset static "this" pointer before calling external function ResetThisBase(); RootFinder rootFinder(&IGetEffForRoot, fXmin, fXmax ); Double_t effB = 0; fEffS = results->GetHist("MVA_TRAINEFF_S"); for (Int_t bini=1; bini<=fNbins; bini++) { // find cut value corresponding to a given signal efficiency Double_t effS = eff_bvss->GetBinCenter( bini ); Double_t cut = rootFinder.Root( effS ); // retrieve background efficiency for given cut if (Use_Splines_for_Eff_) effB = fSplTrainRefB->Eval( cut ); else effB = mva_eff_tr_b->GetBinContent( mva_eff_tr_b->FindBin( cut ) ); // and fill histograms eff_bvss->SetBinContent( bini, effB ); rej_bvss->SetBinContent( bini, 1.0-effB ); } fEffS = 0; // create splines for histogram fSplTrainEffBvsS = new TSpline1( "effBvsS", new TGraph( eff_bvss ) ); } // must exist... if (0 == 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; 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_); // the mean between bin above and bin below } //_______________________________________________________________________ std::vector<Float_t> TMVA::MethodBase::GetMulticlassEfficiency(std::vector<std::vector<Float_t> >& purity) { Data()->SetCurrentType(Types::kTesting); ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTesting, Types::kMulticlass)); if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in GetMulticlassEfficiency, exiting."<<Endl; purity.push_back(resMulticlass->GetAchievablePur()); return resMulticlass->GetAchievableEff(); } //_______________________________________________________________________ std::vector<Float_t> TMVA::MethodBase::GetMulticlassTrainingEfficiency(std::vector<std::vector<Float_t> >& purity) { Data()->SetCurrentType(Types::kTraining); ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTraining, Types::kMulticlass)); if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in GetMulticlassTrainingEfficiency, exiting."<<Endl; Log() << kINFO << "Determine optimal multiclass cuts for training data..." << Endl; for (UInt_t icls = 0; icls<DataInfo().GetNClasses(); ++icls) { resMulticlass->GetBestMultiClassCuts(icls); } purity.push_back(resMulticlass->GetAchievablePur()); return resMulticlass->GetAchievableEff(); } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetSignificance( void ) const { // compute significance of mean difference // significance = |<S> - <B>|/Sqrt(RMS_S2 + RMS_B2) Double_t rms = sqrt( fRmsS*fRmsS + fRmsB*fRmsB ); return (rms > 0) ? TMath::Abs(fMeanS - fMeanB)/rms : 0; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetSeparation( TH1* histoS, TH1* histoB ) const { // compute "separation" defined as // <s2> = (1/2) Int_-oo..+oo { (S(x) - B(x))^2/(S(x) + B(x)) dx } return gTools().GetSeparation( histoS, histoB ); } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetSeparation( PDF* pdfS, PDF* pdfB ) const { // compute "separation" defined as // <s2> = (1/2) Int_-oo..+oo { (S(x) - B(x))^2/(S(x) + B(x)) dx } // note, if zero pointers given, use internal pdf // sanity check first if ((!pdfS && pdfB) || (pdfS && !pdfB)) Log() << kFATAL << "<GetSeparation> Mismatch in pdfs" << Endl; if (!pdfS) pdfS = fSplS; if (!pdfB) pdfB = fSplB; if (!fSplS || !fSplB) { Log()<<kWARNING<< "could not calculate the separation, distributions" << " fSplS or fSplB are not yet filled" << Endl; return 0; }else{ return gTools().GetSeparation( *pdfS, *pdfB ); } } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetROCIntegral(TH1D *histS, TH1D *histB) const { // calculate the area (integral) under the ROC curve as a // overall quality measure of the classification // note, if zero pointers given, use internal pdf // sanity check first if ((!histS && histB) || (histS && !histB)) Log() << kFATAL << "<GetROCIntegral(TH1D*, TH1D*)> Mismatch in hists" << Endl; if (histS==0 || histB==0) return 0.; TMVA::PDF *pdfS = new TMVA::PDF( " PDF Sig", histS, TMVA::PDF::kSpline3 ); TMVA::PDF *pdfB = new TMVA::PDF( " PDF Bkg", histB, TMVA::PDF::kSpline3 ); Double_t xmin = TMath::Min(pdfS->GetXmin(), pdfB->GetXmin()); Double_t xmax = TMath::Max(pdfS->GetXmax(), pdfB->GetXmax()); Double_t integral = 0; UInt_t nsteps = 1000; Double_t step = (xmax-xmin)/Double_t(nsteps); Double_t cut = xmin; for (UInt_t i=0; i<nsteps; i++) { integral += (1-pdfB->GetIntegral(cut,xmax)) * pdfS->GetVal(cut); cut+=step; } return integral*step; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetROCIntegral(PDF *pdfS, PDF *pdfB) const { // calculate the area (integral) under the ROC curve as a // overall quality measure of the classification // note, if zero pointers given, use internal pdf // sanity check first if ((!pdfS && pdfB) || (pdfS && !pdfB)) Log() << kFATAL << "<GetSeparation> Mismatch in pdfs" << Endl; if (!pdfS) pdfS = fSplS; if (!pdfB) pdfB = fSplB; if (pdfS==0 || pdfB==0) return 0.; Double_t xmin = TMath::Min(pdfS->GetXmin(), pdfB->GetXmin()); Double_t xmax = TMath::Max(pdfS->GetXmax(), pdfB->GetXmax()); Double_t integral = 0; UInt_t nsteps = 1000; Double_t step = (xmax-xmin)/Double_t(nsteps); Double_t cut = xmin; for (UInt_t i=0; i<nsteps; i++) { integral += (1-pdfB->GetIntegral(cut,xmax)) * pdfS->GetVal(cut); cut+=step; } return integral*step; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetMaximumSignificance( Double_t SignalEvents, Double_t BackgroundEvents, Double_t& max_significance_value ) const { // plot significance, S/Sqrt(S^2 + B^2), curve for given number // of signal and background events; returns cut for maximum significance // also returned via reference is the maximum significance Results* results = Data()->GetResults( GetMethodName(), Types::kTesting, Types::kMaxAnalysisType ); Double_t max_significance(0); Double_t effS(0),effB(0),significance(0); TH1D *temp_histogram = new TH1D("temp", "temp", fNbinsH, fXmin, fXmax ); if (SignalEvents <= 0 || BackgroundEvents <= 0) { Log() << kFATAL << "<GetMaximumSignificance> " << "Number of signal or background events is <= 0 ==> abort" << Endl; } Log() << kINFO << "Using ratio SignalEvents/BackgroundEvents = " << SignalEvents/BackgroundEvents << Endl; TH1* eff_s = results->GetHist("MVA_EFF_S"); TH1* eff_b = results->GetHist("MVA_EFF_B"); if ( (eff_s==0) || (eff_b==0) ) { Log() << kWARNING << "Efficiency histograms empty !" << Endl; Log() << kWARNING << "no maximum cut found, return 0" << Endl; return 0; } for (Int_t bin=1; bin<=fNbinsH; bin++) { effS = eff_s->GetBinContent( bin ); effB = eff_b->GetBinContent( bin ); // put significance into a histogram significance = sqrt(SignalEvents)*( effS )/sqrt( effS + ( BackgroundEvents / SignalEvents) * effB ); temp_histogram->SetBinContent(bin,significance); } // find maximum in histogram max_significance = temp_histogram->GetBinCenter( temp_histogram->GetMaximumBin() ); max_significance_value = temp_histogram->GetBinContent( temp_histogram->GetMaximumBin() ); // delete delete temp_histogram; Log() << kINFO << "Optimal cut at : " << max_significance << Endl; Log() << kINFO << "Maximum significance: " << max_significance_value << Endl; return max_significance; } //_______________________________________________________________________ void TMVA::MethodBase::Statistics( Types::ETreeType treeType, const TString& theVarName, Double_t& meanS, Double_t& meanB, Double_t& rmsS, Double_t& rmsB, Double_t& xmin, Double_t& xmax ) { // calculates rms,mean, xmin, xmax of the event variable // this can be either done for the variables as they are or for // normalised variables (in the range of 0-1) if "norm" is set to kTRUE Types::ETreeType previousTreeType = Data()->GetCurrentType(); Data()->SetCurrentType(treeType); Long64_t entries = Data()->GetNEvents(); // sanity check if (entries <=0) Log() << kFATAL << "<CalculateEstimator> Wrong tree type: " << treeType << Endl; // index of the wanted variable UInt_t varIndex = DataInfo().FindVarIndex( theVarName ); // first fill signal and background in arrays before analysis xmin = +DBL_MAX; xmax = -DBL_MAX; Long64_t nEventsS = -1; Long64_t nEventsB = -1; // take into account event weights meanS = 0; meanB = 0; rmsS = 0; rmsB = 0; Double_t sumwS = 0, sumwB = 0; // loop over all training events for (Int_t ievt = 0; ievt < entries; ievt++) { const Event* ev = GetEvent(ievt); Double_t theVar = ev->GetValue(varIndex); Double_t weight = ev->GetWeight(); if (DataInfo().IsSignal(ev)) { sumwS += weight; meanS += weight*theVar; rmsS += weight*theVar*theVar; } else { sumwB += weight; meanB += weight*theVar; rmsB += weight*theVar*theVar; } xmin = TMath::Min( xmin, theVar ); xmax = TMath::Max( xmax, theVar ); } ++nEventsS; ++nEventsB; meanS = meanS/sumwS; meanB = meanB/sumwB; rmsS = TMath::Sqrt( rmsS/sumwS - meanS*meanS ); rmsB = TMath::Sqrt( rmsB/sumwB - meanB*meanB ); Data()->SetCurrentType(previousTreeType); } //_______________________________________________________________________ void TMVA::MethodBase::MakeClass( const TString& theClassFileName ) const { // create reader class for method (classification only at present) // the default consists of TString classFileName = ""; if (theClassFileName == "") classFileName = GetWeightFileDir() + "/" + GetJobName() + "_" + GetMethodName() + ".class.C"; else classFileName = theClassFileName; TString className = TString("Read") + GetMethodName(); TString tfname( classFileName ); Log() << kINFO << "Creating standalone response class: " << gTools().Color("lightblue") << classFileName << gTools().Color("reset") << Endl; std::ofstream fout( classFileName ); if (!fout.good()) { // file could not be opened --> Error Log() << kFATAL << "<MakeClass> Unable to open file: " << classFileName << Endl; } // now create the class // preamble fout << "// Class: " << className << std::endl; fout << "// Automatically generated by MethodBase::MakeClass" << std::endl << "//" << std::endl; // print general information and configuration state fout << std::endl; fout << "/* configuration options =====================================================" << std::endl << std::endl; WriteStateToStream( fout ); fout << std::endl; fout << "============================================================================ */" << std::endl; // generate the class fout << "" << std::endl; fout << "#include <vector>" << std::endl; fout << "#include <cmath>" << std::endl; fout << "#include <string>" << std::endl; fout << "#include <iostream>" << std::endl; fout << "" << std::endl; // now if the classifier needs to write some addicional classes for its response implementation // this code goes here: (at least the header declarations need to come before the main class this->MakeClassSpecificHeader( fout, className ); fout << "#ifndef IClassifierReader__def" << std::endl; fout << "#define IClassifierReader__def" << std::endl; fout << std::endl; fout << "class IClassifierReader {" << std::endl; fout << std::endl; fout << " public:" << std::endl; fout << std::endl; fout << " // constructor" << std::endl; fout << " IClassifierReader() : fStatusIsClean( true ) {}" << std::endl; fout << " virtual ~IClassifierReader() {}" << std::endl; fout << std::endl; fout << " // return classifier response" << std::endl; fout << " virtual double GetMvaValue( const std::vector<double>& inputValues ) const = 0;" << std::endl; fout << std::endl; fout << " // returns classifier status" << std::endl; fout << " bool IsStatusClean() const { return fStatusIsClean; }" << std::endl; fout << std::endl; fout << " protected:" << std::endl; fout << std::endl; fout << " bool fStatusIsClean;" << std::endl; fout << "};" << std::endl; fout << std::endl; fout << "#endif" << std::endl; fout << std::endl; fout << "class " << className << " : public IClassifierReader {" << std::endl; fout << std::endl; fout << " public:" << std::endl; fout << std::endl; fout << " // constructor" << std::endl; fout << " " << className << "( std::vector<std::string>& theInputVars ) " << std::endl; fout << " : IClassifierReader()," << std::endl; fout << " fClassName( \"" << className << "\" )," << std::endl; fout << " fNvars( " << GetNvar() << " )," << std::endl; fout << " fIsNormalised( " << (IsNormalised() ? "true" : "false") << " )" << std::endl; fout << " { " << std::endl; fout << " // the training input variables" << std::endl; fout << " const char* inputVars[] = { "; for (UInt_t ivar=0; ivar<GetNvar(); ivar++) { fout << "\"" << GetOriginalVarName(ivar) << "\""; if (ivar<GetNvar()-1) fout << ", "; } fout << " };" << std::endl; fout << std::endl; fout << " // sanity checks" << std::endl; fout << " if (theInputVars.size() <= 0) {" << std::endl; fout << " std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": empty input vector\" << std::endl;" << std::endl; fout << " fStatusIsClean = false;" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " if (theInputVars.size() != fNvars) {" << std::endl; fout << " std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": mismatch in number of input values: \"" << std::endl; fout << " << theInputVars.size() << \" != \" << fNvars << std::endl;" << std::endl; fout << " fStatusIsClean = false;" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " // validate input variables" << std::endl; fout << " for (size_t ivar = 0; ivar < theInputVars.size(); ivar++) {" << std::endl; fout << " if (theInputVars[ivar] != inputVars[ivar]) {" << std::endl; fout << " std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": mismatch in input variable names\" << std::endl" << std::endl; fout << " << \" for variable [\" << ivar << \"]: \" << theInputVars[ivar].c_str() << \" != \" << inputVars[ivar] << std::endl;" << std::endl; fout << " fStatusIsClean = false;" << std::endl; fout << " }" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " // initialize min and max vectors (for normalisation)" << std::endl; for (UInt_t ivar = 0; ivar < GetNvar(); ivar++) { fout << " fVmin[" << ivar << "] = " << std::setprecision(15) << GetXmin( ivar ) << ";" << std::endl; fout << " fVmax[" << ivar << "] = " << std::setprecision(15) << GetXmax( ivar ) << ";" << std::endl; } fout << std::endl; fout << " // initialize input variable types" << std::endl; for (UInt_t ivar=0; ivar<GetNvar(); ivar++) { fout << " fType[" << ivar << "] = \'" << DataInfo().GetVariableInfo(ivar).GetVarType() << "\';" << std::endl; } fout << std::endl; fout << " // initialize constants" << std::endl; fout << " Initialize();" << std::endl; fout << std::endl; if (GetTransformationHandler().GetTransformationList().GetSize() != 0) { fout << " // initialize transformation" << std::endl; fout << " InitTransform();" << std::endl; } fout << " }" << std::endl; fout << std::endl; fout << " // destructor" << std::endl; fout << " virtual ~" << className << "() {" << std::endl; fout << " Clear(); // method-specific" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " // the classifier response" << std::endl; fout << " // \"inputValues\" is a vector of input values in the same order as the " << std::endl; fout << " // variables given to the constructor" << std::endl; fout << " double GetMvaValue( const std::vector<double>& inputValues ) const;" << std::endl; fout << std::endl; fout << " private:" << std::endl; fout << std::endl; fout << " // method-specific destructor" << std::endl; fout << " void Clear();" << std::endl; fout << std::endl; if (GetTransformationHandler().GetTransformationList().GetSize()!=0) { fout << " // input variable transformation" << std::endl; GetTransformationHandler().MakeFunction(fout, className,1); fout << " void InitTransform();" << std::endl; fout << " void Transform( std::vector<double> & iv, int sigOrBgd ) const;" << std::endl; fout << std::endl; } fout << " // common member variables" << std::endl; fout << " const char* fClassName;" << std::endl; fout << std::endl; fout << " const size_t fNvars;" << std::endl; fout << " size_t GetNvar() const { return fNvars; }" << std::endl; fout << " char GetType( int ivar ) const { return fType[ivar]; }" << std::endl; fout << std::endl; fout << " // normalisation of input variables" << std::endl; fout << " const bool fIsNormalised;" << std::endl; fout << " bool IsNormalised() const { return fIsNormalised; }" << std::endl; fout << " double fVmin[" << GetNvar() << "];" << std::endl; fout << " double fVmax[" << GetNvar() << "];" << std::endl; fout << " double NormVariable( double x, double xmin, double xmax ) const {" << std::endl; fout << " // normalise to output range: [-1, 1]" << std::endl; fout << " return 2*(x - xmin)/(xmax - xmin) - 1.0;" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " // type of input variable: 'F' or 'I'" << std::endl; fout << " char fType[" << GetNvar() << "];" << std::endl; fout << std::endl; fout << " // initialize internal variables" << std::endl; fout << " void Initialize();" << std::endl; fout << " double GetMvaValue__( const std::vector<double>& inputValues ) const;" << std::endl; fout << "" << std::endl; fout << " // private members (method specific)" << std::endl; // call the classifier specific output (the classifier must close the class !) MakeClassSpecific( fout, className ); fout << " inline double " << className << "::GetMvaValue( const std::vector<double>& inputValues ) const" << std::endl; fout << " {" << std::endl; fout << " // classifier response value" << std::endl; fout << " double retval = 0;" << std::endl; fout << std::endl; fout << " // classifier response, sanity check first" << std::endl; fout << " if (!IsStatusClean()) {" << std::endl; fout << " std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": cannot return classifier response\"" << std::endl; fout << " << \" because status is dirty\" << std::endl;" << std::endl; fout << " retval = 0;" << std::endl; fout << " }" << std::endl; fout << " else {" << std::endl; fout << " if (IsNormalised()) {" << std::endl; fout << " // normalise variables" << std::endl; fout << " std::vector<double> iV;" << std::endl; fout << " iV.reserve(inputValues.size());" << std::endl; fout << " int ivar = 0;" << std::endl; fout << " for (std::vector<double>::const_iterator varIt = inputValues.begin();" << std::endl; fout << " varIt != inputValues.end(); varIt++, ivar++) {" << std::endl; fout << " iV.push_back(NormVariable( *varIt, fVmin[ivar], fVmax[ivar] ));" << std::endl; fout << " }" << std::endl; if (GetTransformationHandler().GetTransformationList().GetSize()!=0 && GetMethodType() != Types::kLikelihood && GetMethodType() != Types::kHMatrix) { fout << " Transform( iV, -1 );" << std::endl; } fout << " retval = GetMvaValue__( iV );" << std::endl; fout << " }" << std::endl; fout << " else {" << std::endl; if (GetTransformationHandler().GetTransformationList().GetSize()!=0 && GetMethodType() != Types::kLikelihood && GetMethodType() != Types::kHMatrix) { fout << " std::vector<double> iV;" << std::endl; fout << " int ivar = 0;" << std::endl; fout << " for (std::vector<double>::const_iterator varIt = inputValues.begin();" << std::endl; fout << " varIt != inputValues.end(); varIt++, ivar++) {" << std::endl; fout << " iV.push_back(*varIt);" << std::endl; fout << " }" << std::endl; fout << " Transform( iV, -1 );" << std::endl; fout << " retval = GetMvaValue__( iV );" << std::endl; } else { fout << " retval = GetMvaValue__( inputValues );" << std::endl; } fout << " }" << std::endl; fout << " }" << std::endl; fout << std::endl; fout << " return retval;" << std::endl; fout << " }" << std::endl; // create output for transformation - if any if (GetTransformationHandler().GetTransformationList().GetSize()!=0) GetTransformationHandler().MakeFunction(fout, className,2); // close the file fout.close(); } //_______________________________________________________________________ void TMVA::MethodBase::PrintHelpMessage() const { // prints out method-specific help method // if options are written to reference file, also append help info std::streambuf* cout_sbuf = std::cout.rdbuf(); // save original sbuf std::ofstream* o = 0; if (gConfig().WriteOptionsReference()) { Log() << kINFO << "Print Help message for class " << GetName() << " into file: " << GetReferenceFile() << Endl; o = new std::ofstream( GetReferenceFile(), std::ios::app ); if (!o->good()) { // file could not be opened --> Error Log() << kFATAL << "<PrintHelpMessage> Unable to append to output file: " << GetReferenceFile() << Endl; } std::cout.rdbuf( o->rdbuf() ); // redirect 'std::cout' to file } // "|--------------------------------------------------------------|" if (!o) { Log() << kINFO << Endl; Log() << gTools().Color("bold") << "================================================================" << gTools().Color( "reset" ) << Endl; Log() << gTools().Color("bold") << "H e l p f o r M V A m e t h o d [ " << GetName() << " ] :" << gTools().Color( "reset" ) << Endl; } else { Log() << "Help for MVA method [ " << GetName() << " ] :" << Endl; } // print method-specific help message GetHelpMessage(); if (!o) { Log() << Endl; Log() << "<Suppress this message by specifying \"!H\" in the booking option>" << Endl; Log() << gTools().Color("bold") << "================================================================" << gTools().Color( "reset" ) << Endl; Log() << Endl; } else { // indicate END Log() << "# End of Message___" << Endl; } std::cout.rdbuf( cout_sbuf ); // restore the original stream buffer if (o) o->close(); } // ----------------------- r o o t f i n d i n g ---------------------------- TMVA::MethodBase* TMVA::MethodBase::fgThisBase = 0; //_______________________________________________________________________ Double_t TMVA::MethodBase::IGetEffForRoot( Double_t theCut ) { // interface for RootFinder return MethodBase::GetThisBase()->GetEffForRoot( theCut ); } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetEffForRoot( Double_t theCut ) { // returns efficiency as function of cut Double_t retval=0; // retrieve the class object if (Use_Splines_for_Eff_) { retval = fSplRefS->Eval( theCut ); } else retval = fEffS->GetBinContent( fEffS->FindBin( theCut ) ); // caution: here we take some "forbidden" action to hide a problem: // in some cases, in particular for likelihood, the binned efficiency distributions // do not equal 1, at xmin, and 0 at xmax; of course, in principle we have the // unbinned information available in the trees, but the unbinned minimization is // too slow, and we don't need to do a precision measurement here. Hence, we force // this property. Double_t eps = 1.0e-5; if (theCut-fXmin < eps) retval = (GetCutOrientation() == kPositive) ? 1.0 : 0.0; else if (fXmax-theCut < eps) retval = (GetCutOrientation() == kPositive) ? 0.0 : 1.0; return retval; } //_______________________________________________________________________ const std::vector<TMVA::Event*>& TMVA::MethodBase::GetEventCollection( Types::ETreeType type) { // returns the event collection (i.e. the dataset) TRANSFORMED using the // classifiers specific Variable Transformation (e.g. Decorr or Decorr:Gauss:Decorr) // if there's no variable transformation for this classifier, just hand back the // event collection of the data set if (GetTransformationHandler().GetTransformationList().GetEntries() <= 0) { return (Data()->GetEventCollection(type)); } // otherwise, transform ALL the events and hand back the vector of the pointers to the // transformed events. If the pointer is already != 0, i.e. the whole thing has been // done before, I don't need to do it again, but just "hand over" the pointer to those events. Int_t idx = Data()->TreeIndex(type); //index indicating Training,Testing,... events/datasets if (fEventCollections.at(idx) == 0) { fEventCollections.at(idx) = &(Data()->GetEventCollection(type)); fEventCollections.at(idx) = GetTransformationHandler().CalcTransformations(*(fEventCollections.at(idx)),kTRUE); } return *(fEventCollections.at(idx)); } //_______________________________________________________________________ TString TMVA::MethodBase::GetTrainingTMVAVersionString() const { // calculates the TMVA version string from the training version code on the fly UInt_t a = GetTrainingTMVAVersionCode() & 0xff0000; a>>=16; UInt_t b = GetTrainingTMVAVersionCode() & 0x00ff00; b>>=8; UInt_t c = GetTrainingTMVAVersionCode() & 0x0000ff; return TString(Form("%i.%i.%i",a,b,c)); } //_______________________________________________________________________ TString TMVA::MethodBase::GetTrainingROOTVersionString() const { // calculates the ROOT version string from the training version code on the fly UInt_t a = GetTrainingROOTVersionCode() & 0xff0000; a>>=16; UInt_t b = GetTrainingROOTVersionCode() & 0x00ff00; b>>=8; UInt_t c = GetTrainingROOTVersionCode() & 0x0000ff; return TString(Form("%i.%02i/%02i",a,b,c)); } //_______________________________________________________________________ TMVA::MethodBase* TMVA::MethodBase::GetThisBase() { // return a pointer the base class of this method return fgThisBase; } //_______________________________________________________________________ void TMVA::MethodBase::ResetThisBase() { // reset required for RootFinder fgThisBase = this; } //_______________________________________________________________________ Double_t TMVA::MethodBase::GetKSTrainingVsTest(Char_t SorB, TString opt){ ResultsClassification* mvaRes = dynamic_cast<ResultsClassification*> ( Data()->GetResults(GetMethodName(),Types::kTesting, Types::kClassification) ); if (mvaRes != NULL) { TH1D *mva_s = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_S")); TH1D *mva_b = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_B")); TH1D *mva_s_tr = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_TRAIN_S")); TH1D *mva_b_tr = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_TRAIN_B")); if ( !mva_s || !mva_b || !mva_s_tr || !mva_b_tr) return -1; if (SorB == 's' || SorB == 'S') return mva_s->KolmogorovTest( mva_s_tr, opt.Data() ); else return mva_b->KolmogorovTest( mva_b_tr, opt.Data() ); } return -1; }
MethodBase.cxx:1
MethodBase.cxx:2
MethodBase.cxx:3
MethodBase.cxx:4
MethodBase.cxx:5
MethodBase.cxx:6
MethodBase.cxx:7
MethodBase.cxx:8
MethodBase.cxx:9
MethodBase.cxx:10
MethodBase.cxx:11
MethodBase.cxx:12
MethodBase.cxx:13
MethodBase.cxx:14
MethodBase.cxx:15
MethodBase.cxx:16
MethodBase.cxx:17
MethodBase.cxx:18
MethodBase.cxx:19
MethodBase.cxx:20
MethodBase.cxx:21
MethodBase.cxx:22
MethodBase.cxx:23
MethodBase.cxx:24
MethodBase.cxx:25
MethodBase.cxx:26
MethodBase.cxx:27
MethodBase.cxx:28
MethodBase.cxx:29
MethodBase.cxx:30
MethodBase.cxx:31
MethodBase.cxx:32
MethodBase.cxx:33
MethodBase.cxx:34
MethodBase.cxx:35
MethodBase.cxx:36
MethodBase.cxx:37
MethodBase.cxx:38
MethodBase.cxx:39
MethodBase.cxx:40
MethodBase.cxx:41
MethodBase.cxx:42
MethodBase.cxx:43
MethodBase.cxx:44
MethodBase.cxx:45
MethodBase.cxx:46
MethodBase.cxx:47
MethodBase.cxx:48
MethodBase.cxx:49
MethodBase.cxx:50
MethodBase.cxx:51
MethodBase.cxx:52
MethodBase.cxx:53
MethodBase.cxx:54
MethodBase.cxx:55
MethodBase.cxx:56
MethodBase.cxx:57
MethodBase.cxx:58
MethodBase.cxx:59
MethodBase.cxx:60
MethodBase.cxx:61
MethodBase.cxx:62
MethodBase.cxx:63
MethodBase.cxx:64
MethodBase.cxx:65
MethodBase.cxx:66
MethodBase.cxx:67
MethodBase.cxx:68
MethodBase.cxx:69
MethodBase.cxx:70
MethodBase.cxx:71
MethodBase.cxx:72
MethodBase.cxx:73
MethodBase.cxx:74
MethodBase.cxx:75
MethodBase.cxx:76
MethodBase.cxx:77
MethodBase.cxx:78
MethodBase.cxx:79
MethodBase.cxx:80
MethodBase.cxx:81
MethodBase.cxx:82
MethodBase.cxx:83
MethodBase.cxx:84
MethodBase.cxx:85
MethodBase.cxx:86
MethodBase.cxx:87
MethodBase.cxx:88
MethodBase.cxx:89
MethodBase.cxx:90
MethodBase.cxx:91
MethodBase.cxx:92
MethodBase.cxx:93
MethodBase.cxx:94
MethodBase.cxx:95
MethodBase.cxx:96
MethodBase.cxx:97
MethodBase.cxx:98
MethodBase.cxx:99
MethodBase.cxx:100
MethodBase.cxx:101
MethodBase.cxx:102
MethodBase.cxx:103
MethodBase.cxx:104
MethodBase.cxx:105
MethodBase.cxx:106
MethodBase.cxx:107
MethodBase.cxx:108
MethodBase.cxx:109
MethodBase.cxx:110
MethodBase.cxx:111
MethodBase.cxx:112
MethodBase.cxx:113
MethodBase.cxx:114
MethodBase.cxx:115
MethodBase.cxx:116
MethodBase.cxx:117
MethodBase.cxx:118
MethodBase.cxx:119
MethodBase.cxx:120
MethodBase.cxx:121
MethodBase.cxx:122
MethodBase.cxx:123
MethodBase.cxx:124
MethodBase.cxx:125
MethodBase.cxx:126
MethodBase.cxx:127
MethodBase.cxx:128
MethodBase.cxx:129
MethodBase.cxx:130
MethodBase.cxx:131
MethodBase.cxx:132
MethodBase.cxx:133
MethodBase.cxx:134
MethodBase.cxx:135
MethodBase.cxx:136
MethodBase.cxx:137
MethodBase.cxx:138
MethodBase.cxx:139
MethodBase.cxx:140
MethodBase.cxx:141
MethodBase.cxx:142
MethodBase.cxx:143
MethodBase.cxx:144
MethodBase.cxx:145
MethodBase.cxx:146
MethodBase.cxx:147
MethodBase.cxx:148
MethodBase.cxx:149
MethodBase.cxx:150
MethodBase.cxx:151
MethodBase.cxx:152
MethodBase.cxx:153
MethodBase.cxx:154
MethodBase.cxx:155
MethodBase.cxx:156
MethodBase.cxx:157
MethodBase.cxx:158
MethodBase.cxx:159
MethodBase.cxx:160
MethodBase.cxx:161
MethodBase.cxx:162
MethodBase.cxx:163
MethodBase.cxx:164
MethodBase.cxx:165
MethodBase.cxx:166
MethodBase.cxx:167
MethodBase.cxx:168
MethodBase.cxx:169
MethodBase.cxx:170
MethodBase.cxx:171
MethodBase.cxx:172
MethodBase.cxx:173
MethodBase.cxx:174
MethodBase.cxx:175
MethodBase.cxx:176
MethodBase.cxx:177
MethodBase.cxx:178
MethodBase.cxx:179
MethodBase.cxx:180
MethodBase.cxx:181
MethodBase.cxx:182
MethodBase.cxx:183
MethodBase.cxx:184
MethodBase.cxx:185
MethodBase.cxx:186
MethodBase.cxx:187
MethodBase.cxx:188
MethodBase.cxx:189
MethodBase.cxx:190
MethodBase.cxx:191
MethodBase.cxx:192
MethodBase.cxx:193
MethodBase.cxx:194
MethodBase.cxx:195
MethodBase.cxx:196
MethodBase.cxx:197
MethodBase.cxx:198
MethodBase.cxx:199
MethodBase.cxx:200
MethodBase.cxx:201
MethodBase.cxx:202
MethodBase.cxx:203
MethodBase.cxx:204
MethodBase.cxx:205
MethodBase.cxx:206
MethodBase.cxx:207
MethodBase.cxx:208
MethodBase.cxx:209
MethodBase.cxx:210
MethodBase.cxx:211
MethodBase.cxx:212
MethodBase.cxx:213
MethodBase.cxx:214
MethodBase.cxx:215
MethodBase.cxx:216
MethodBase.cxx:217
MethodBase.cxx:218
MethodBase.cxx:219
MethodBase.cxx:220
MethodBase.cxx:221
MethodBase.cxx:222
MethodBase.cxx:223
MethodBase.cxx:224
MethodBase.cxx:225
MethodBase.cxx:226
MethodBase.cxx:227
MethodBase.cxx:228
MethodBase.cxx:229
MethodBase.cxx:230
MethodBase.cxx:231
MethodBase.cxx:232
MethodBase.cxx:233
MethodBase.cxx:234
MethodBase.cxx:235
MethodBase.cxx:236
MethodBase.cxx:237
MethodBase.cxx:238
MethodBase.cxx:239
MethodBase.cxx:240
MethodBase.cxx:241
MethodBase.cxx:242
MethodBase.cxx:243
MethodBase.cxx:244
MethodBase.cxx:245
MethodBase.cxx:246
MethodBase.cxx:247
MethodBase.cxx:248
MethodBase.cxx:249
MethodBase.cxx:250
MethodBase.cxx:251
MethodBase.cxx:252
MethodBase.cxx:253
MethodBase.cxx:254
MethodBase.cxx:255
MethodBase.cxx:256
MethodBase.cxx:257
MethodBase.cxx:258
MethodBase.cxx:259
MethodBase.cxx:260
MethodBase.cxx:261
MethodBase.cxx:262
MethodBase.cxx:263
MethodBase.cxx:264
MethodBase.cxx:265
MethodBase.cxx:266
MethodBase.cxx:267
MethodBase.cxx:268
MethodBase.cxx:269
MethodBase.cxx:270
MethodBase.cxx:271
MethodBase.cxx:272
MethodBase.cxx:273
MethodBase.cxx:274
MethodBase.cxx:275
MethodBase.cxx:276
MethodBase.cxx:277
MethodBase.cxx:278
MethodBase.cxx:279
MethodBase.cxx:280
MethodBase.cxx:281
MethodBase.cxx:282
MethodBase.cxx:283
MethodBase.cxx:284
MethodBase.cxx:285
MethodBase.cxx:286
MethodBase.cxx:287
MethodBase.cxx:288
MethodBase.cxx:289
MethodBase.cxx:290
MethodBase.cxx:291
MethodBase.cxx:292
MethodBase.cxx:293
MethodBase.cxx:294
MethodBase.cxx:295
MethodBase.cxx:296
MethodBase.cxx:297
MethodBase.cxx:298
MethodBase.cxx:299
MethodBase.cxx:300
MethodBase.cxx:301
MethodBase.cxx:302
MethodBase.cxx:303
MethodBase.cxx:304
MethodBase.cxx:305
MethodBase.cxx:306
MethodBase.cxx:307
MethodBase.cxx:308
MethodBase.cxx:309
MethodBase.cxx:310
MethodBase.cxx:311
MethodBase.cxx:312
MethodBase.cxx:313
MethodBase.cxx:314
MethodBase.cxx:315
MethodBase.cxx:316
MethodBase.cxx:317
MethodBase.cxx:318
MethodBase.cxx:319
MethodBase.cxx:320
MethodBase.cxx:321
MethodBase.cxx:322
MethodBase.cxx:323
MethodBase.cxx:324
MethodBase.cxx:325
MethodBase.cxx:326
MethodBase.cxx:327
MethodBase.cxx:328
MethodBase.cxx:329
MethodBase.cxx:330
MethodBase.cxx:331
MethodBase.cxx:332
MethodBase.cxx:333
MethodBase.cxx:334
MethodBase.cxx:335
MethodBase.cxx:336
MethodBase.cxx:337
MethodBase.cxx:338
MethodBase.cxx:339
MethodBase.cxx:340
MethodBase.cxx:341
MethodBase.cxx:342
MethodBase.cxx:343
MethodBase.cxx:344
MethodBase.cxx:345
MethodBase.cxx:346
MethodBase.cxx:347
MethodBase.cxx:348
MethodBase.cxx:349
MethodBase.cxx:350
MethodBase.cxx:351
MethodBase.cxx:352
MethodBase.cxx:353
MethodBase.cxx:354
MethodBase.cxx:355
MethodBase.cxx:356
MethodBase.cxx:357
MethodBase.cxx:358
MethodBase.cxx:359
MethodBase.cxx:360
MethodBase.cxx:361
MethodBase.cxx:362
MethodBase.cxx:363
MethodBase.cxx:364
MethodBase.cxx:365
MethodBase.cxx:366
MethodBase.cxx:367
MethodBase.cxx:368
MethodBase.cxx:369
MethodBase.cxx:370
MethodBase.cxx:371
MethodBase.cxx:372
MethodBase.cxx:373
MethodBase.cxx:374
MethodBase.cxx:375
MethodBase.cxx:376
MethodBase.cxx:377
MethodBase.cxx:378
MethodBase.cxx:379
MethodBase.cxx:380
MethodBase.cxx:381
MethodBase.cxx:382
MethodBase.cxx:383
MethodBase.cxx:384
MethodBase.cxx:385
MethodBase.cxx:386
MethodBase.cxx:387
MethodBase.cxx:388
MethodBase.cxx:389
MethodBase.cxx:390
MethodBase.cxx:391
MethodBase.cxx:392
MethodBase.cxx:393
MethodBase.cxx:394
MethodBase.cxx:395
MethodBase.cxx:396
MethodBase.cxx:397
MethodBase.cxx:398
MethodBase.cxx:399
MethodBase.cxx:400
MethodBase.cxx:401
MethodBase.cxx:402
MethodBase.cxx:403
MethodBase.cxx:404
MethodBase.cxx:405
MethodBase.cxx:406
MethodBase.cxx:407
MethodBase.cxx:408
MethodBase.cxx:409
MethodBase.cxx:410
MethodBase.cxx:411
MethodBase.cxx:412
MethodBase.cxx:413
MethodBase.cxx:414
MethodBase.cxx:415
MethodBase.cxx:416
MethodBase.cxx:417
MethodBase.cxx:418
MethodBase.cxx:419
MethodBase.cxx:420
MethodBase.cxx:421
MethodBase.cxx:422
MethodBase.cxx:423
MethodBase.cxx:424
MethodBase.cxx:425
MethodBase.cxx:426
MethodBase.cxx:427
MethodBase.cxx:428
MethodBase.cxx:429
MethodBase.cxx:430
MethodBase.cxx:431
MethodBase.cxx:432
MethodBase.cxx:433
MethodBase.cxx:434
MethodBase.cxx:435
MethodBase.cxx:436
MethodBase.cxx:437
MethodBase.cxx:438
MethodBase.cxx:439
MethodBase.cxx:440
MethodBase.cxx:441
MethodBase.cxx:442
MethodBase.cxx:443
MethodBase.cxx:444
MethodBase.cxx:445
MethodBase.cxx:446
MethodBase.cxx:447
MethodBase.cxx:448
MethodBase.cxx:449
MethodBase.cxx:450
MethodBase.cxx:451
MethodBase.cxx:452
MethodBase.cxx:453
MethodBase.cxx:454
MethodBase.cxx:455
MethodBase.cxx:456
MethodBase.cxx:457
MethodBase.cxx:458
MethodBase.cxx:459
MethodBase.cxx:460
MethodBase.cxx:461
MethodBase.cxx:462
MethodBase.cxx:463
MethodBase.cxx:464
MethodBase.cxx:465
MethodBase.cxx:466
MethodBase.cxx:467
MethodBase.cxx:468
MethodBase.cxx:469
MethodBase.cxx:470
MethodBase.cxx:471
MethodBase.cxx:472
MethodBase.cxx:473
MethodBase.cxx:474
MethodBase.cxx:475
MethodBase.cxx:476
MethodBase.cxx:477
MethodBase.cxx:478
MethodBase.cxx:479
MethodBase.cxx:480
MethodBase.cxx:481
MethodBase.cxx:482
MethodBase.cxx:483
MethodBase.cxx:484
MethodBase.cxx:485
MethodBase.cxx:486
MethodBase.cxx:487
MethodBase.cxx:488
MethodBase.cxx:489
MethodBase.cxx:490
MethodBase.cxx:491
MethodBase.cxx:492
MethodBase.cxx:493
MethodBase.cxx:494
MethodBase.cxx:495
MethodBase.cxx:496
MethodBase.cxx:497
MethodBase.cxx:498
MethodBase.cxx:499
MethodBase.cxx:500
MethodBase.cxx:501
MethodBase.cxx:502
MethodBase.cxx:503
MethodBase.cxx:504
MethodBase.cxx:505
MethodBase.cxx:506
MethodBase.cxx:507
MethodBase.cxx:508
MethodBase.cxx:509
MethodBase.cxx:510
MethodBase.cxx:511
MethodBase.cxx:512
MethodBase.cxx:513
MethodBase.cxx:514
MethodBase.cxx:515
MethodBase.cxx:516
MethodBase.cxx:517
MethodBase.cxx:518
MethodBase.cxx:519
MethodBase.cxx:520
MethodBase.cxx:521
MethodBase.cxx:522
MethodBase.cxx:523
MethodBase.cxx:524
MethodBase.cxx:525
MethodBase.cxx:526
MethodBase.cxx:527
MethodBase.cxx:528
MethodBase.cxx:529
MethodBase.cxx:530
MethodBase.cxx:531
MethodBase.cxx:532
MethodBase.cxx:533
MethodBase.cxx:534
MethodBase.cxx:535
MethodBase.cxx:536
MethodBase.cxx:537
MethodBase.cxx:538
MethodBase.cxx:539
MethodBase.cxx:540
MethodBase.cxx:541
MethodBase.cxx:542
MethodBase.cxx:543
MethodBase.cxx:544
MethodBase.cxx:545
MethodBase.cxx:546
MethodBase.cxx:547
MethodBase.cxx:548
MethodBase.cxx:549
MethodBase.cxx:550
MethodBase.cxx:551
MethodBase.cxx:552
MethodBase.cxx:553
MethodBase.cxx:554
MethodBase.cxx:555
MethodBase.cxx:556
MethodBase.cxx:557
MethodBase.cxx:558
MethodBase.cxx:559
MethodBase.cxx:560
MethodBase.cxx:561
MethodBase.cxx:562
MethodBase.cxx:563
MethodBase.cxx:564
MethodBase.cxx:565
MethodBase.cxx:566
MethodBase.cxx:567
MethodBase.cxx:568
MethodBase.cxx:569
MethodBase.cxx:570
MethodBase.cxx:571
MethodBase.cxx:572
MethodBase.cxx:573
MethodBase.cxx:574
MethodBase.cxx:575
MethodBase.cxx:576
MethodBase.cxx:577
MethodBase.cxx:578
MethodBase.cxx:579
MethodBase.cxx:580
MethodBase.cxx:581
MethodBase.cxx:582
MethodBase.cxx:583
MethodBase.cxx:584
MethodBase.cxx:585
MethodBase.cxx:586
MethodBase.cxx:587
MethodBase.cxx:588
MethodBase.cxx:589
MethodBase.cxx:590
MethodBase.cxx:591
MethodBase.cxx:592
MethodBase.cxx:593
MethodBase.cxx:594
MethodBase.cxx:595
MethodBase.cxx:596
MethodBase.cxx:597
MethodBase.cxx:598
MethodBase.cxx:599
MethodBase.cxx:600
MethodBase.cxx:601
MethodBase.cxx:602
MethodBase.cxx:603
MethodBase.cxx:604
MethodBase.cxx:605
MethodBase.cxx:606
MethodBase.cxx:607
MethodBase.cxx:608
MethodBase.cxx:609
MethodBase.cxx:610
MethodBase.cxx:611
MethodBase.cxx:612
MethodBase.cxx:613
MethodBase.cxx:614
MethodBase.cxx:615
MethodBase.cxx:616
MethodBase.cxx:617
MethodBase.cxx:618
MethodBase.cxx:619
MethodBase.cxx:620
MethodBase.cxx:621
MethodBase.cxx:622
MethodBase.cxx:623
MethodBase.cxx:624
MethodBase.cxx:625
MethodBase.cxx:626
MethodBase.cxx:627
MethodBase.cxx:628
MethodBase.cxx:629
MethodBase.cxx:630
MethodBase.cxx:631
MethodBase.cxx:632
MethodBase.cxx:633
MethodBase.cxx:634
MethodBase.cxx:635
MethodBase.cxx:636
MethodBase.cxx:637
MethodBase.cxx:638
MethodBase.cxx:639
MethodBase.cxx:640
MethodBase.cxx:641
MethodBase.cxx:642
MethodBase.cxx:643
MethodBase.cxx:644
MethodBase.cxx:645
MethodBase.cxx:646
MethodBase.cxx:647
MethodBase.cxx:648
MethodBase.cxx:649
MethodBase.cxx:650
MethodBase.cxx:651
MethodBase.cxx:652
MethodBase.cxx:653
MethodBase.cxx:654
MethodBase.cxx:655
MethodBase.cxx:656
MethodBase.cxx:657
MethodBase.cxx:658
MethodBase.cxx:659
MethodBase.cxx:660
MethodBase.cxx:661
MethodBase.cxx:662
MethodBase.cxx:663
MethodBase.cxx:664
MethodBase.cxx:665
MethodBase.cxx:666
MethodBase.cxx:667
MethodBase.cxx:668
MethodBase.cxx:669
MethodBase.cxx:670
MethodBase.cxx:671
MethodBase.cxx:672
MethodBase.cxx:673
MethodBase.cxx:674
MethodBase.cxx:675
MethodBase.cxx:676
MethodBase.cxx:677
MethodBase.cxx:678
MethodBase.cxx:679
MethodBase.cxx:680
MethodBase.cxx:681
MethodBase.cxx:682
MethodBase.cxx:683
MethodBase.cxx:684
MethodBase.cxx:685
MethodBase.cxx:686
MethodBase.cxx:687
MethodBase.cxx:688
MethodBase.cxx:689
MethodBase.cxx:690
MethodBase.cxx:691
MethodBase.cxx:692
MethodBase.cxx:693
MethodBase.cxx:694
MethodBase.cxx:695
MethodBase.cxx:696
MethodBase.cxx:697
MethodBase.cxx:698
MethodBase.cxx:699
MethodBase.cxx:700
MethodBase.cxx:701
MethodBase.cxx:702
MethodBase.cxx:703
MethodBase.cxx:704
MethodBase.cxx:705
MethodBase.cxx:706
MethodBase.cxx:707
MethodBase.cxx:708
MethodBase.cxx:709
MethodBase.cxx:710
MethodBase.cxx:711
MethodBase.cxx:712
MethodBase.cxx:713
MethodBase.cxx:714
MethodBase.cxx:715
MethodBase.cxx:716
MethodBase.cxx:717
MethodBase.cxx:718
MethodBase.cxx:719
MethodBase.cxx:720
MethodBase.cxx:721
MethodBase.cxx:722
MethodBase.cxx:723
MethodBase.cxx:724
MethodBase.cxx:725
MethodBase.cxx:726
MethodBase.cxx:727
MethodBase.cxx:728
MethodBase.cxx:729
MethodBase.cxx:730
MethodBase.cxx:731
MethodBase.cxx:732
MethodBase.cxx:733
MethodBase.cxx:734
MethodBase.cxx:735
MethodBase.cxx:736
MethodBase.cxx:737
MethodBase.cxx:738
MethodBase.cxx:739
MethodBase.cxx:740
MethodBase.cxx:741
MethodBase.cxx:742
MethodBase.cxx:743
MethodBase.cxx:744
MethodBase.cxx:745
MethodBase.cxx:746
MethodBase.cxx:747
MethodBase.cxx:748
MethodBase.cxx:749
MethodBase.cxx:750
MethodBase.cxx:751
MethodBase.cxx:752
MethodBase.cxx:753
MethodBase.cxx:754
MethodBase.cxx:755
MethodBase.cxx:756
MethodBase.cxx:757
MethodBase.cxx:758
MethodBase.cxx:759
MethodBase.cxx:760
MethodBase.cxx:761
MethodBase.cxx:762
MethodBase.cxx:763
MethodBase.cxx:764
MethodBase.cxx:765
MethodBase.cxx:766
MethodBase.cxx:767
MethodBase.cxx:768
MethodBase.cxx:769
MethodBase.cxx:770
MethodBase.cxx:771
MethodBase.cxx:772
MethodBase.cxx:773
MethodBase.cxx:774
MethodBase.cxx:775
MethodBase.cxx:776
MethodBase.cxx:777
MethodBase.cxx:778
MethodBase.cxx:779
MethodBase.cxx:780
MethodBase.cxx:781
MethodBase.cxx:782
MethodBase.cxx:783
MethodBase.cxx:784
MethodBase.cxx:785
MethodBase.cxx:786
MethodBase.cxx:787
MethodBase.cxx:788
MethodBase.cxx:789
MethodBase.cxx:790
MethodBase.cxx:791
MethodBase.cxx:792
MethodBase.cxx:793
MethodBase.cxx:794
MethodBase.cxx:795
MethodBase.cxx:796
MethodBase.cxx:797
MethodBase.cxx:798
MethodBase.cxx:799
MethodBase.cxx:800
MethodBase.cxx:801
MethodBase.cxx:802
MethodBase.cxx:803
MethodBase.cxx:804
MethodBase.cxx:805
MethodBase.cxx:806
MethodBase.cxx:807
MethodBase.cxx:808
MethodBase.cxx:809
MethodBase.cxx:810
MethodBase.cxx:811
MethodBase.cxx:812
MethodBase.cxx:813
MethodBase.cxx:814
MethodBase.cxx:815
MethodBase.cxx:816
MethodBase.cxx:817
MethodBase.cxx:818
MethodBase.cxx:819
MethodBase.cxx:820
MethodBase.cxx:821
MethodBase.cxx:822
MethodBase.cxx:823
MethodBase.cxx:824
MethodBase.cxx:825
MethodBase.cxx:826
MethodBase.cxx:827
MethodBase.cxx:828
MethodBase.cxx:829
MethodBase.cxx:830
MethodBase.cxx:831
MethodBase.cxx:832
MethodBase.cxx:833
MethodBase.cxx:834
MethodBase.cxx:835
MethodBase.cxx:836
MethodBase.cxx:837
MethodBase.cxx:838
MethodBase.cxx:839
MethodBase.cxx:840
MethodBase.cxx:841
MethodBase.cxx:842
MethodBase.cxx:843
MethodBase.cxx:844
MethodBase.cxx:845
MethodBase.cxx:846
MethodBase.cxx:847
MethodBase.cxx:848
MethodBase.cxx:849
MethodBase.cxx:850
MethodBase.cxx:851
MethodBase.cxx:852
MethodBase.cxx:853
MethodBase.cxx:854
MethodBase.cxx:855
MethodBase.cxx:856
MethodBase.cxx:857
MethodBase.cxx:858
MethodBase.cxx:859
MethodBase.cxx:860
MethodBase.cxx:861
MethodBase.cxx:862
MethodBase.cxx:863
MethodBase.cxx:864
MethodBase.cxx:865
MethodBase.cxx:866
MethodBase.cxx:867
MethodBase.cxx:868
MethodBase.cxx:869
MethodBase.cxx:870
MethodBase.cxx:871
MethodBase.cxx:872
MethodBase.cxx:873
MethodBase.cxx:874
MethodBase.cxx:875
MethodBase.cxx:876
MethodBase.cxx:877
MethodBase.cxx:878
MethodBase.cxx:879
MethodBase.cxx:880
MethodBase.cxx:881
MethodBase.cxx:882
MethodBase.cxx:883
MethodBase.cxx:884
MethodBase.cxx:885
MethodBase.cxx:886
MethodBase.cxx:887
MethodBase.cxx:888
MethodBase.cxx:889
MethodBase.cxx:890
MethodBase.cxx:891
MethodBase.cxx:892
MethodBase.cxx:893
MethodBase.cxx:894
MethodBase.cxx:895
MethodBase.cxx:896
MethodBase.cxx:897
MethodBase.cxx:898
MethodBase.cxx:899
MethodBase.cxx:900
MethodBase.cxx:901
MethodBase.cxx:902
MethodBase.cxx:903
MethodBase.cxx:904
MethodBase.cxx:905
MethodBase.cxx:906
MethodBase.cxx:907
MethodBase.cxx:908
MethodBase.cxx:909
MethodBase.cxx:910
MethodBase.cxx:911
MethodBase.cxx:912
MethodBase.cxx:913
MethodBase.cxx:914
MethodBase.cxx:915
MethodBase.cxx:916
MethodBase.cxx:917
MethodBase.cxx:918
MethodBase.cxx:919
MethodBase.cxx:920
MethodBase.cxx:921
MethodBase.cxx:922
MethodBase.cxx:923
MethodBase.cxx:924
MethodBase.cxx:925
MethodBase.cxx:926
MethodBase.cxx:927
MethodBase.cxx:928
MethodBase.cxx:929
MethodBase.cxx:930
MethodBase.cxx:931
MethodBase.cxx:932
MethodBase.cxx:933
MethodBase.cxx:934
MethodBase.cxx:935
MethodBase.cxx:936
MethodBase.cxx:937
MethodBase.cxx:938
MethodBase.cxx:939
MethodBase.cxx:940
MethodBase.cxx:941
MethodBase.cxx:942
MethodBase.cxx:943
MethodBase.cxx:944
MethodBase.cxx:945
MethodBase.cxx:946
MethodBase.cxx:947
MethodBase.cxx:948
MethodBase.cxx:949
MethodBase.cxx:950
MethodBase.cxx:951
MethodBase.cxx:952
MethodBase.cxx:953
MethodBase.cxx:954
MethodBase.cxx:955
MethodBase.cxx:956
MethodBase.cxx:957
MethodBase.cxx:958
MethodBase.cxx:959
MethodBase.cxx:960
MethodBase.cxx:961
MethodBase.cxx:962
MethodBase.cxx:963
MethodBase.cxx:964
MethodBase.cxx:965
MethodBase.cxx:966
MethodBase.cxx:967
MethodBase.cxx:968
MethodBase.cxx:969
MethodBase.cxx:970
MethodBase.cxx:971
MethodBase.cxx:972
MethodBase.cxx:973
MethodBase.cxx:974
MethodBase.cxx:975
MethodBase.cxx:976
MethodBase.cxx:977
MethodBase.cxx:978
MethodBase.cxx:979
MethodBase.cxx:980
MethodBase.cxx:981
MethodBase.cxx:982
MethodBase.cxx:983
MethodBase.cxx:984
MethodBase.cxx:985
MethodBase.cxx:986
MethodBase.cxx:987
MethodBase.cxx:988
MethodBase.cxx:989
MethodBase.cxx:990
MethodBase.cxx:991
MethodBase.cxx:992
MethodBase.cxx:993
MethodBase.cxx:994
MethodBase.cxx:995
MethodBase.cxx:996
MethodBase.cxx:997
MethodBase.cxx:998
MethodBase.cxx:999
MethodBase.cxx:1000
MethodBase.cxx:1001
MethodBase.cxx:1002
MethodBase.cxx:1003
MethodBase.cxx:1004
MethodBase.cxx:1005
MethodBase.cxx:1006
MethodBase.cxx:1007
MethodBase.cxx:1008
MethodBase.cxx:1009
MethodBase.cxx:1010
MethodBase.cxx:1011
MethodBase.cxx:1012
MethodBase.cxx:1013
MethodBase.cxx:1014
MethodBase.cxx:1015
MethodBase.cxx:1016
MethodBase.cxx:1017
MethodBase.cxx:1018
MethodBase.cxx:1019
MethodBase.cxx:1020
MethodBase.cxx:1021
MethodBase.cxx:1022
MethodBase.cxx:1023
MethodBase.cxx:1024
MethodBase.cxx:1025
MethodBase.cxx:1026
MethodBase.cxx:1027
MethodBase.cxx:1028
MethodBase.cxx:1029
MethodBase.cxx:1030
MethodBase.cxx:1031
MethodBase.cxx:1032
MethodBase.cxx:1033
MethodBase.cxx:1034
MethodBase.cxx:1035
MethodBase.cxx:1036
MethodBase.cxx:1037
MethodBase.cxx:1038
MethodBase.cxx:1039
MethodBase.cxx:1040
MethodBase.cxx:1041
MethodBase.cxx:1042
MethodBase.cxx:1043
MethodBase.cxx:1044
MethodBase.cxx:1045
MethodBase.cxx:1046
MethodBase.cxx:1047
MethodBase.cxx:1048
MethodBase.cxx:1049
MethodBase.cxx:1050
MethodBase.cxx:1051
MethodBase.cxx:1052
MethodBase.cxx:1053
MethodBase.cxx:1054
MethodBase.cxx:1055
MethodBase.cxx:1056
MethodBase.cxx:1057
MethodBase.cxx:1058
MethodBase.cxx:1059
MethodBase.cxx:1060
MethodBase.cxx:1061
MethodBase.cxx:1062
MethodBase.cxx:1063
MethodBase.cxx:1064
MethodBase.cxx:1065
MethodBase.cxx:1066
MethodBase.cxx:1067
MethodBase.cxx:1068
MethodBase.cxx:1069
MethodBase.cxx:1070
MethodBase.cxx:1071
MethodBase.cxx:1072
MethodBase.cxx:1073
MethodBase.cxx:1074
MethodBase.cxx:1075
MethodBase.cxx:1076
MethodBase.cxx:1077
MethodBase.cxx:1078
MethodBase.cxx:1079
MethodBase.cxx:1080
MethodBase.cxx:1081
MethodBase.cxx:1082
MethodBase.cxx:1083
MethodBase.cxx:1084
MethodBase.cxx:1085
MethodBase.cxx:1086
MethodBase.cxx:1087
MethodBase.cxx:1088
MethodBase.cxx:1089
MethodBase.cxx:1090
MethodBase.cxx:1091
MethodBase.cxx:1092
MethodBase.cxx:1093
MethodBase.cxx:1094
MethodBase.cxx:1095
MethodBase.cxx:1096
MethodBase.cxx:1097
MethodBase.cxx:1098
MethodBase.cxx:1099
MethodBase.cxx:1100
MethodBase.cxx:1101
MethodBase.cxx:1102
MethodBase.cxx:1103
MethodBase.cxx:1104
MethodBase.cxx:1105
MethodBase.cxx:1106
MethodBase.cxx:1107
MethodBase.cxx:1108
MethodBase.cxx:1109
MethodBase.cxx:1110
MethodBase.cxx:1111
MethodBase.cxx:1112
MethodBase.cxx:1113
MethodBase.cxx:1114
MethodBase.cxx:1115
MethodBase.cxx:1116
MethodBase.cxx:1117
MethodBase.cxx:1118
MethodBase.cxx:1119
MethodBase.cxx:1120
MethodBase.cxx:1121
MethodBase.cxx:1122
MethodBase.cxx:1123
MethodBase.cxx:1124
MethodBase.cxx:1125
MethodBase.cxx:1126
MethodBase.cxx:1127
MethodBase.cxx:1128
MethodBase.cxx:1129
MethodBase.cxx:1130
MethodBase.cxx:1131
MethodBase.cxx:1132
MethodBase.cxx:1133
MethodBase.cxx:1134
MethodBase.cxx:1135
MethodBase.cxx:1136
MethodBase.cxx:1137
MethodBase.cxx:1138
MethodBase.cxx:1139
MethodBase.cxx:1140
MethodBase.cxx:1141
MethodBase.cxx:1142
MethodBase.cxx:1143
MethodBase.cxx:1144
MethodBase.cxx:1145
MethodBase.cxx:1146
MethodBase.cxx:1147
MethodBase.cxx:1148
MethodBase.cxx:1149
MethodBase.cxx:1150
MethodBase.cxx:1151
MethodBase.cxx:1152
MethodBase.cxx:1153
MethodBase.cxx:1154
MethodBase.cxx:1155
MethodBase.cxx:1156
MethodBase.cxx:1157
MethodBase.cxx:1158
MethodBase.cxx:1159
MethodBase.cxx:1160
MethodBase.cxx:1161
MethodBase.cxx:1162
MethodBase.cxx:1163
MethodBase.cxx:1164
MethodBase.cxx:1165
MethodBase.cxx:1166
MethodBase.cxx:1167
MethodBase.cxx:1168
MethodBase.cxx:1169
MethodBase.cxx:1170
MethodBase.cxx:1171
MethodBase.cxx:1172
MethodBase.cxx:1173
MethodBase.cxx:1174
MethodBase.cxx:1175
MethodBase.cxx:1176
MethodBase.cxx:1177
MethodBase.cxx:1178
MethodBase.cxx:1179
MethodBase.cxx:1180
MethodBase.cxx:1181
MethodBase.cxx:1182
MethodBase.cxx:1183
MethodBase.cxx:1184
MethodBase.cxx:1185
MethodBase.cxx:1186
MethodBase.cxx:1187
MethodBase.cxx:1188
MethodBase.cxx:1189
MethodBase.cxx:1190
MethodBase.cxx:1191
MethodBase.cxx:1192
MethodBase.cxx:1193
MethodBase.cxx:1194
MethodBase.cxx:1195
MethodBase.cxx:1196
MethodBase.cxx:1197
MethodBase.cxx:1198
MethodBase.cxx:1199
MethodBase.cxx:1200
MethodBase.cxx:1201
MethodBase.cxx:1202
MethodBase.cxx:1203
MethodBase.cxx:1204
MethodBase.cxx:1205
MethodBase.cxx:1206
MethodBase.cxx:1207
MethodBase.cxx:1208
MethodBase.cxx:1209
MethodBase.cxx:1210
MethodBase.cxx:1211
MethodBase.cxx:1212
MethodBase.cxx:1213
MethodBase.cxx:1214
MethodBase.cxx:1215
MethodBase.cxx:1216
MethodBase.cxx:1217
MethodBase.cxx:1218
MethodBase.cxx:1219
MethodBase.cxx:1220
MethodBase.cxx:1221
MethodBase.cxx:1222
MethodBase.cxx:1223
MethodBase.cxx:1224
MethodBase.cxx:1225
MethodBase.cxx:1226
MethodBase.cxx:1227
MethodBase.cxx:1228
MethodBase.cxx:1229
MethodBase.cxx:1230
MethodBase.cxx:1231
MethodBase.cxx:1232
MethodBase.cxx:1233
MethodBase.cxx:1234
MethodBase.cxx:1235
MethodBase.cxx:1236
MethodBase.cxx:1237
MethodBase.cxx:1238
MethodBase.cxx:1239
MethodBase.cxx:1240
MethodBase.cxx:1241
MethodBase.cxx:1242
MethodBase.cxx:1243
MethodBase.cxx:1244
MethodBase.cxx:1245
MethodBase.cxx:1246
MethodBase.cxx:1247
MethodBase.cxx:1248
MethodBase.cxx:1249
MethodBase.cxx:1250
MethodBase.cxx:1251
MethodBase.cxx:1252
MethodBase.cxx:1253
MethodBase.cxx:1254
MethodBase.cxx:1255
MethodBase.cxx:1256
MethodBase.cxx:1257
MethodBase.cxx:1258
MethodBase.cxx:1259
MethodBase.cxx:1260
MethodBase.cxx:1261
MethodBase.cxx:1262
MethodBase.cxx:1263
MethodBase.cxx:1264
MethodBase.cxx:1265
MethodBase.cxx:1266
MethodBase.cxx:1267
MethodBase.cxx:1268
MethodBase.cxx:1269
MethodBase.cxx:1270
MethodBase.cxx:1271
MethodBase.cxx:1272
MethodBase.cxx:1273
MethodBase.cxx:1274
MethodBase.cxx:1275
MethodBase.cxx:1276
MethodBase.cxx:1277
MethodBase.cxx:1278
MethodBase.cxx:1279
MethodBase.cxx:1280
MethodBase.cxx:1281
MethodBase.cxx:1282
MethodBase.cxx:1283
MethodBase.cxx:1284
MethodBase.cxx:1285
MethodBase.cxx:1286
MethodBase.cxx:1287
MethodBase.cxx:1288
MethodBase.cxx:1289
MethodBase.cxx:1290
MethodBase.cxx:1291
MethodBase.cxx:1292
MethodBase.cxx:1293
MethodBase.cxx:1294
MethodBase.cxx:1295
MethodBase.cxx:1296
MethodBase.cxx:1297
MethodBase.cxx:1298
MethodBase.cxx:1299
MethodBase.cxx:1300
MethodBase.cxx:1301
MethodBase.cxx:1302
MethodBase.cxx:1303
MethodBase.cxx:1304
MethodBase.cxx:1305
MethodBase.cxx:1306
MethodBase.cxx:1307
MethodBase.cxx:1308
MethodBase.cxx:1309
MethodBase.cxx:1310
MethodBase.cxx:1311
MethodBase.cxx:1312
MethodBase.cxx:1313
MethodBase.cxx:1314
MethodBase.cxx:1315
MethodBase.cxx:1316
MethodBase.cxx:1317
MethodBase.cxx:1318
MethodBase.cxx:1319
MethodBase.cxx:1320
MethodBase.cxx:1321
MethodBase.cxx:1322
MethodBase.cxx:1323
MethodBase.cxx:1324
MethodBase.cxx:1325
MethodBase.cxx:1326
MethodBase.cxx:1327
MethodBase.cxx:1328
MethodBase.cxx:1329
MethodBase.cxx:1330
MethodBase.cxx:1331
MethodBase.cxx:1332
MethodBase.cxx:1333
MethodBase.cxx:1334
MethodBase.cxx:1335
MethodBase.cxx:1336
MethodBase.cxx:1337
MethodBase.cxx:1338
MethodBase.cxx:1339
MethodBase.cxx:1340
MethodBase.cxx:1341
MethodBase.cxx:1342
MethodBase.cxx:1343
MethodBase.cxx:1344
MethodBase.cxx:1345
MethodBase.cxx:1346
MethodBase.cxx:1347
MethodBase.cxx:1348
MethodBase.cxx:1349
MethodBase.cxx:1350
MethodBase.cxx:1351
MethodBase.cxx:1352
MethodBase.cxx:1353
MethodBase.cxx:1354
MethodBase.cxx:1355
MethodBase.cxx:1356
MethodBase.cxx:1357
MethodBase.cxx:1358
MethodBase.cxx:1359
MethodBase.cxx:1360
MethodBase.cxx:1361
MethodBase.cxx:1362
MethodBase.cxx:1363
MethodBase.cxx:1364
MethodBase.cxx:1365
MethodBase.cxx:1366
MethodBase.cxx:1367
MethodBase.cxx:1368
MethodBase.cxx:1369
MethodBase.cxx:1370
MethodBase.cxx:1371
MethodBase.cxx:1372
MethodBase.cxx:1373
MethodBase.cxx:1374
MethodBase.cxx:1375
MethodBase.cxx:1376
MethodBase.cxx:1377
MethodBase.cxx:1378
MethodBase.cxx:1379
MethodBase.cxx:1380
MethodBase.cxx:1381
MethodBase.cxx:1382
MethodBase.cxx:1383
MethodBase.cxx:1384
MethodBase.cxx:1385
MethodBase.cxx:1386
MethodBase.cxx:1387
MethodBase.cxx:1388
MethodBase.cxx:1389
MethodBase.cxx:1390
MethodBase.cxx:1391
MethodBase.cxx:1392
MethodBase.cxx:1393
MethodBase.cxx:1394
MethodBase.cxx:1395
MethodBase.cxx:1396
MethodBase.cxx:1397
MethodBase.cxx:1398
MethodBase.cxx:1399
MethodBase.cxx:1400
MethodBase.cxx:1401
MethodBase.cxx:1402
MethodBase.cxx:1403
MethodBase.cxx:1404
MethodBase.cxx:1405
MethodBase.cxx:1406
MethodBase.cxx:1407
MethodBase.cxx:1408
MethodBase.cxx:1409
MethodBase.cxx:1410
MethodBase.cxx:1411
MethodBase.cxx:1412
MethodBase.cxx:1413
MethodBase.cxx:1414
MethodBase.cxx:1415
MethodBase.cxx:1416
MethodBase.cxx:1417
MethodBase.cxx:1418
MethodBase.cxx:1419
MethodBase.cxx:1420
MethodBase.cxx:1421
MethodBase.cxx:1422
MethodBase.cxx:1423
MethodBase.cxx:1424
MethodBase.cxx:1425
MethodBase.cxx:1426
MethodBase.cxx:1427
MethodBase.cxx:1428
MethodBase.cxx:1429
MethodBase.cxx:1430
MethodBase.cxx:1431
MethodBase.cxx:1432
MethodBase.cxx:1433
MethodBase.cxx:1434
MethodBase.cxx:1435
MethodBase.cxx:1436
MethodBase.cxx:1437
MethodBase.cxx:1438
MethodBase.cxx:1439
MethodBase.cxx:1440
MethodBase.cxx:1441
MethodBase.cxx:1442
MethodBase.cxx:1443
MethodBase.cxx:1444
MethodBase.cxx:1445
MethodBase.cxx:1446
MethodBase.cxx:1447
MethodBase.cxx:1448
MethodBase.cxx:1449
MethodBase.cxx:1450
MethodBase.cxx:1451
MethodBase.cxx:1452
MethodBase.cxx:1453
MethodBase.cxx:1454
MethodBase.cxx:1455
MethodBase.cxx:1456
MethodBase.cxx:1457
MethodBase.cxx:1458
MethodBase.cxx:1459
MethodBase.cxx:1460
MethodBase.cxx:1461
MethodBase.cxx:1462
MethodBase.cxx:1463
MethodBase.cxx:1464
MethodBase.cxx:1465
MethodBase.cxx:1466
MethodBase.cxx:1467
MethodBase.cxx:1468
MethodBase.cxx:1469
MethodBase.cxx:1470
MethodBase.cxx:1471
MethodBase.cxx:1472
MethodBase.cxx:1473
MethodBase.cxx:1474
MethodBase.cxx:1475
MethodBase.cxx:1476
MethodBase.cxx:1477
MethodBase.cxx:1478
MethodBase.cxx:1479
MethodBase.cxx:1480
MethodBase.cxx:1481
MethodBase.cxx:1482
MethodBase.cxx:1483
MethodBase.cxx:1484
MethodBase.cxx:1485
MethodBase.cxx:1486
MethodBase.cxx:1487
MethodBase.cxx:1488
MethodBase.cxx:1489
MethodBase.cxx:1490
MethodBase.cxx:1491
MethodBase.cxx:1492
MethodBase.cxx:1493
MethodBase.cxx:1494
MethodBase.cxx:1495
MethodBase.cxx:1496
MethodBase.cxx:1497
MethodBase.cxx:1498
MethodBase.cxx:1499
MethodBase.cxx:1500
MethodBase.cxx:1501
MethodBase.cxx:1502
MethodBase.cxx:1503
MethodBase.cxx:1504
MethodBase.cxx:1505
MethodBase.cxx:1506
MethodBase.cxx:1507
MethodBase.cxx:1508
MethodBase.cxx:1509
MethodBase.cxx:1510
MethodBase.cxx:1511
MethodBase.cxx:1512
MethodBase.cxx:1513
MethodBase.cxx:1514
MethodBase.cxx:1515
MethodBase.cxx:1516
MethodBase.cxx:1517
MethodBase.cxx:1518
MethodBase.cxx:1519
MethodBase.cxx:1520
MethodBase.cxx:1521
MethodBase.cxx:1522
MethodBase.cxx:1523
MethodBase.cxx:1524
MethodBase.cxx:1525
MethodBase.cxx:1526
MethodBase.cxx:1527
MethodBase.cxx:1528
MethodBase.cxx:1529
MethodBase.cxx:1530
MethodBase.cxx:1531
MethodBase.cxx:1532
MethodBase.cxx:1533
MethodBase.cxx:1534
MethodBase.cxx:1535
MethodBase.cxx:1536
MethodBase.cxx:1537
MethodBase.cxx:1538
MethodBase.cxx:1539
MethodBase.cxx:1540
MethodBase.cxx:1541
MethodBase.cxx:1542
MethodBase.cxx:1543
MethodBase.cxx:1544
MethodBase.cxx:1545
MethodBase.cxx:1546
MethodBase.cxx:1547
MethodBase.cxx:1548
MethodBase.cxx:1549
MethodBase.cxx:1550
MethodBase.cxx:1551
MethodBase.cxx:1552
MethodBase.cxx:1553
MethodBase.cxx:1554
MethodBase.cxx:1555
MethodBase.cxx:1556
MethodBase.cxx:1557
MethodBase.cxx:1558
MethodBase.cxx:1559
MethodBase.cxx:1560
MethodBase.cxx:1561
MethodBase.cxx:1562
MethodBase.cxx:1563
MethodBase.cxx:1564
MethodBase.cxx:1565
MethodBase.cxx:1566
MethodBase.cxx:1567
MethodBase.cxx:1568
MethodBase.cxx:1569
MethodBase.cxx:1570
MethodBase.cxx:1571
MethodBase.cxx:1572
MethodBase.cxx:1573
MethodBase.cxx:1574
MethodBase.cxx:1575
MethodBase.cxx:1576
MethodBase.cxx:1577
MethodBase.cxx:1578
MethodBase.cxx:1579
MethodBase.cxx:1580
MethodBase.cxx:1581
MethodBase.cxx:1582
MethodBase.cxx:1583
MethodBase.cxx:1584
MethodBase.cxx:1585
MethodBase.cxx:1586
MethodBase.cxx:1587
MethodBase.cxx:1588
MethodBase.cxx:1589
MethodBase.cxx:1590
MethodBase.cxx:1591
MethodBase.cxx:1592
MethodBase.cxx:1593
MethodBase.cxx:1594
MethodBase.cxx:1595
MethodBase.cxx:1596
MethodBase.cxx:1597
MethodBase.cxx:1598
MethodBase.cxx:1599
MethodBase.cxx:1600
MethodBase.cxx:1601
MethodBase.cxx:1602
MethodBase.cxx:1603
MethodBase.cxx:1604
MethodBase.cxx:1605
MethodBase.cxx:1606
MethodBase.cxx:1607
MethodBase.cxx:1608
MethodBase.cxx:1609
MethodBase.cxx:1610
MethodBase.cxx:1611
MethodBase.cxx:1612
MethodBase.cxx:1613
MethodBase.cxx:1614
MethodBase.cxx:1615
MethodBase.cxx:1616
MethodBase.cxx:1617
MethodBase.cxx:1618
MethodBase.cxx:1619
MethodBase.cxx:1620
MethodBase.cxx:1621
MethodBase.cxx:1622
MethodBase.cxx:1623
MethodBase.cxx:1624
MethodBase.cxx:1625
MethodBase.cxx:1626
MethodBase.cxx:1627
MethodBase.cxx:1628
MethodBase.cxx:1629
MethodBase.cxx:1630
MethodBase.cxx:1631
MethodBase.cxx:1632
MethodBase.cxx:1633
MethodBase.cxx:1634
MethodBase.cxx:1635
MethodBase.cxx:1636
MethodBase.cxx:1637
MethodBase.cxx:1638
MethodBase.cxx:1639
MethodBase.cxx:1640
MethodBase.cxx:1641
MethodBase.cxx:1642
MethodBase.cxx:1643
MethodBase.cxx:1644
MethodBase.cxx:1645
MethodBase.cxx:1646
MethodBase.cxx:1647
MethodBase.cxx:1648
MethodBase.cxx:1649
MethodBase.cxx:1650
MethodBase.cxx:1651
MethodBase.cxx:1652
MethodBase.cxx:1653
MethodBase.cxx:1654
MethodBase.cxx:1655
MethodBase.cxx:1656
MethodBase.cxx:1657
MethodBase.cxx:1658
MethodBase.cxx:1659
MethodBase.cxx:1660
MethodBase.cxx:1661
MethodBase.cxx:1662
MethodBase.cxx:1663
MethodBase.cxx:1664
MethodBase.cxx:1665
MethodBase.cxx:1666
MethodBase.cxx:1667
MethodBase.cxx:1668
MethodBase.cxx:1669
MethodBase.cxx:1670
MethodBase.cxx:1671
MethodBase.cxx:1672
MethodBase.cxx:1673
MethodBase.cxx:1674
MethodBase.cxx:1675
MethodBase.cxx:1676
MethodBase.cxx:1677
MethodBase.cxx:1678
MethodBase.cxx:1679
MethodBase.cxx:1680
MethodBase.cxx:1681
MethodBase.cxx:1682
MethodBase.cxx:1683
MethodBase.cxx:1684
MethodBase.cxx:1685
MethodBase.cxx:1686
MethodBase.cxx:1687
MethodBase.cxx:1688
MethodBase.cxx:1689
MethodBase.cxx:1690
MethodBase.cxx:1691
MethodBase.cxx:1692
MethodBase.cxx:1693
MethodBase.cxx:1694
MethodBase.cxx:1695
MethodBase.cxx:1696
MethodBase.cxx:1697
MethodBase.cxx:1698
MethodBase.cxx:1699
MethodBase.cxx:1700
MethodBase.cxx:1701
MethodBase.cxx:1702
MethodBase.cxx:1703
MethodBase.cxx:1704
MethodBase.cxx:1705
MethodBase.cxx:1706
MethodBase.cxx:1707
MethodBase.cxx:1708
MethodBase.cxx:1709
MethodBase.cxx:1710
MethodBase.cxx:1711
MethodBase.cxx:1712
MethodBase.cxx:1713
MethodBase.cxx:1714
MethodBase.cxx:1715
MethodBase.cxx:1716
MethodBase.cxx:1717
MethodBase.cxx:1718
MethodBase.cxx:1719
MethodBase.cxx:1720
MethodBase.cxx:1721
MethodBase.cxx:1722
MethodBase.cxx:1723
MethodBase.cxx:1724
MethodBase.cxx:1725
MethodBase.cxx:1726
MethodBase.cxx:1727
MethodBase.cxx:1728
MethodBase.cxx:1729
MethodBase.cxx:1730
MethodBase.cxx:1731
MethodBase.cxx:1732
MethodBase.cxx:1733
MethodBase.cxx:1734
MethodBase.cxx:1735
MethodBase.cxx:1736
MethodBase.cxx:1737
MethodBase.cxx:1738
MethodBase.cxx:1739
MethodBase.cxx:1740
MethodBase.cxx:1741
MethodBase.cxx:1742
MethodBase.cxx:1743
MethodBase.cxx:1744
MethodBase.cxx:1745
MethodBase.cxx:1746
MethodBase.cxx:1747
MethodBase.cxx:1748
MethodBase.cxx:1749
MethodBase.cxx:1750
MethodBase.cxx:1751
MethodBase.cxx:1752
MethodBase.cxx:1753
MethodBase.cxx:1754
MethodBase.cxx:1755
MethodBase.cxx:1756
MethodBase.cxx:1757
MethodBase.cxx:1758
MethodBase.cxx:1759
MethodBase.cxx:1760
MethodBase.cxx:1761
MethodBase.cxx:1762
MethodBase.cxx:1763
MethodBase.cxx:1764
MethodBase.cxx:1765
MethodBase.cxx:1766
MethodBase.cxx:1767
MethodBase.cxx:1768
MethodBase.cxx:1769
MethodBase.cxx:1770
MethodBase.cxx:1771
MethodBase.cxx:1772
MethodBase.cxx:1773
MethodBase.cxx:1774
MethodBase.cxx:1775
MethodBase.cxx:1776
MethodBase.cxx:1777
MethodBase.cxx:1778
MethodBase.cxx:1779
MethodBase.cxx:1780
MethodBase.cxx:1781
MethodBase.cxx:1782
MethodBase.cxx:1783
MethodBase.cxx:1784
MethodBase.cxx:1785
MethodBase.cxx:1786
MethodBase.cxx:1787
MethodBase.cxx:1788
MethodBase.cxx:1789
MethodBase.cxx:1790
MethodBase.cxx:1791
MethodBase.cxx:1792
MethodBase.cxx:1793
MethodBase.cxx:1794
MethodBase.cxx:1795
MethodBase.cxx:1796
MethodBase.cxx:1797
MethodBase.cxx:1798
MethodBase.cxx:1799
MethodBase.cxx:1800
MethodBase.cxx:1801
MethodBase.cxx:1802
MethodBase.cxx:1803
MethodBase.cxx:1804
MethodBase.cxx:1805
MethodBase.cxx:1806
MethodBase.cxx:1807
MethodBase.cxx:1808
MethodBase.cxx:1809
MethodBase.cxx:1810
MethodBase.cxx:1811
MethodBase.cxx:1812
MethodBase.cxx:1813
MethodBase.cxx:1814
MethodBase.cxx:1815
MethodBase.cxx:1816
MethodBase.cxx:1817
MethodBase.cxx:1818
MethodBase.cxx:1819
MethodBase.cxx:1820
MethodBase.cxx:1821
MethodBase.cxx:1822
MethodBase.cxx:1823
MethodBase.cxx:1824
MethodBase.cxx:1825
MethodBase.cxx:1826
MethodBase.cxx:1827
MethodBase.cxx:1828
MethodBase.cxx:1829
MethodBase.cxx:1830
MethodBase.cxx:1831
MethodBase.cxx:1832
MethodBase.cxx:1833
MethodBase.cxx:1834
MethodBase.cxx:1835
MethodBase.cxx:1836
MethodBase.cxx:1837
MethodBase.cxx:1838
MethodBase.cxx:1839
MethodBase.cxx:1840
MethodBase.cxx:1841
MethodBase.cxx:1842
MethodBase.cxx:1843
MethodBase.cxx:1844
MethodBase.cxx:1845
MethodBase.cxx:1846
MethodBase.cxx:1847
MethodBase.cxx:1848
MethodBase.cxx:1849
MethodBase.cxx:1850
MethodBase.cxx:1851
MethodBase.cxx:1852
MethodBase.cxx:1853
MethodBase.cxx:1854
MethodBase.cxx:1855
MethodBase.cxx:1856
MethodBase.cxx:1857
MethodBase.cxx:1858
MethodBase.cxx:1859
MethodBase.cxx:1860
MethodBase.cxx:1861
MethodBase.cxx:1862
MethodBase.cxx:1863
MethodBase.cxx:1864
MethodBase.cxx:1865
MethodBase.cxx:1866
MethodBase.cxx:1867
MethodBase.cxx:1868
MethodBase.cxx:1869
MethodBase.cxx:1870
MethodBase.cxx:1871
MethodBase.cxx:1872
MethodBase.cxx:1873
MethodBase.cxx:1874
MethodBase.cxx:1875
MethodBase.cxx:1876
MethodBase.cxx:1877
MethodBase.cxx:1878
MethodBase.cxx:1879
MethodBase.cxx:1880
MethodBase.cxx:1881
MethodBase.cxx:1882
MethodBase.cxx:1883
MethodBase.cxx:1884
MethodBase.cxx:1885
MethodBase.cxx:1886
MethodBase.cxx:1887
MethodBase.cxx:1888
MethodBase.cxx:1889
MethodBase.cxx:1890
MethodBase.cxx:1891
MethodBase.cxx:1892
MethodBase.cxx:1893
MethodBase.cxx:1894
MethodBase.cxx:1895
MethodBase.cxx:1896
MethodBase.cxx:1897
MethodBase.cxx:1898
MethodBase.cxx:1899
MethodBase.cxx:1900
MethodBase.cxx:1901
MethodBase.cxx:1902
MethodBase.cxx:1903
MethodBase.cxx:1904
MethodBase.cxx:1905
MethodBase.cxx:1906
MethodBase.cxx:1907
MethodBase.cxx:1908
MethodBase.cxx:1909
MethodBase.cxx:1910
MethodBase.cxx:1911
MethodBase.cxx:1912
MethodBase.cxx:1913
MethodBase.cxx:1914
MethodBase.cxx:1915
MethodBase.cxx:1916
MethodBase.cxx:1917
MethodBase.cxx:1918
MethodBase.cxx:1919
MethodBase.cxx:1920
MethodBase.cxx:1921
MethodBase.cxx:1922
MethodBase.cxx:1923
MethodBase.cxx:1924
MethodBase.cxx:1925
MethodBase.cxx:1926
MethodBase.cxx:1927
MethodBase.cxx:1928
MethodBase.cxx:1929
MethodBase.cxx:1930
MethodBase.cxx:1931
MethodBase.cxx:1932
MethodBase.cxx:1933
MethodBase.cxx:1934
MethodBase.cxx:1935
MethodBase.cxx:1936
MethodBase.cxx:1937
MethodBase.cxx:1938
MethodBase.cxx:1939
MethodBase.cxx:1940
MethodBase.cxx:1941
MethodBase.cxx:1942
MethodBase.cxx:1943
MethodBase.cxx:1944
MethodBase.cxx:1945
MethodBase.cxx:1946
MethodBase.cxx:1947
MethodBase.cxx:1948
MethodBase.cxx:1949
MethodBase.cxx:1950
MethodBase.cxx:1951
MethodBase.cxx:1952
MethodBase.cxx:1953
MethodBase.cxx:1954
MethodBase.cxx:1955
MethodBase.cxx:1956
MethodBase.cxx:1957
MethodBase.cxx:1958
MethodBase.cxx:1959
MethodBase.cxx:1960
MethodBase.cxx:1961
MethodBase.cxx:1962
MethodBase.cxx:1963
MethodBase.cxx:1964
MethodBase.cxx:1965
MethodBase.cxx:1966
MethodBase.cxx:1967
MethodBase.cxx:1968
MethodBase.cxx:1969
MethodBase.cxx:1970
MethodBase.cxx:1971
MethodBase.cxx:1972
MethodBase.cxx:1973
MethodBase.cxx:1974
MethodBase.cxx:1975
MethodBase.cxx:1976
MethodBase.cxx:1977
MethodBase.cxx:1978
MethodBase.cxx:1979
MethodBase.cxx:1980
MethodBase.cxx:1981
MethodBase.cxx:1982
MethodBase.cxx:1983
MethodBase.cxx:1984
MethodBase.cxx:1985
MethodBase.cxx:1986
MethodBase.cxx:1987
MethodBase.cxx:1988
MethodBase.cxx:1989
MethodBase.cxx:1990
MethodBase.cxx:1991
MethodBase.cxx:1992
MethodBase.cxx:1993
MethodBase.cxx:1994
MethodBase.cxx:1995
MethodBase.cxx:1996
MethodBase.cxx:1997
MethodBase.cxx:1998
MethodBase.cxx:1999
MethodBase.cxx:2000
MethodBase.cxx:2001
MethodBase.cxx:2002
MethodBase.cxx:2003
MethodBase.cxx:2004
MethodBase.cxx:2005
MethodBase.cxx:2006
MethodBase.cxx:2007
MethodBase.cxx:2008
MethodBase.cxx:2009
MethodBase.cxx:2010
MethodBase.cxx:2011
MethodBase.cxx:2012
MethodBase.cxx:2013
MethodBase.cxx:2014
MethodBase.cxx:2015
MethodBase.cxx:2016
MethodBase.cxx:2017
MethodBase.cxx:2018
MethodBase.cxx:2019
MethodBase.cxx:2020
MethodBase.cxx:2021
MethodBase.cxx:2022
MethodBase.cxx:2023
MethodBase.cxx:2024
MethodBase.cxx:2025
MethodBase.cxx:2026
MethodBase.cxx:2027
MethodBase.cxx:2028
MethodBase.cxx:2029
MethodBase.cxx:2030
MethodBase.cxx:2031
MethodBase.cxx:2032
MethodBase.cxx:2033
MethodBase.cxx:2034
MethodBase.cxx:2035
MethodBase.cxx:2036
MethodBase.cxx:2037
MethodBase.cxx:2038
MethodBase.cxx:2039
MethodBase.cxx:2040
MethodBase.cxx:2041
MethodBase.cxx:2042
MethodBase.cxx:2043
MethodBase.cxx:2044
MethodBase.cxx:2045
MethodBase.cxx:2046
MethodBase.cxx:2047
MethodBase.cxx:2048
MethodBase.cxx:2049
MethodBase.cxx:2050
MethodBase.cxx:2051
MethodBase.cxx:2052
MethodBase.cxx:2053
MethodBase.cxx:2054
MethodBase.cxx:2055
MethodBase.cxx:2056
MethodBase.cxx:2057
MethodBase.cxx:2058
MethodBase.cxx:2059
MethodBase.cxx:2060
MethodBase.cxx:2061
MethodBase.cxx:2062
MethodBase.cxx:2063
MethodBase.cxx:2064
MethodBase.cxx:2065
MethodBase.cxx:2066
MethodBase.cxx:2067
MethodBase.cxx:2068
MethodBase.cxx:2069
MethodBase.cxx:2070
MethodBase.cxx:2071
MethodBase.cxx:2072
MethodBase.cxx:2073
MethodBase.cxx:2074
MethodBase.cxx:2075
MethodBase.cxx:2076
MethodBase.cxx:2077
MethodBase.cxx:2078
MethodBase.cxx:2079
MethodBase.cxx:2080
MethodBase.cxx:2081
MethodBase.cxx:2082
MethodBase.cxx:2083
MethodBase.cxx:2084
MethodBase.cxx:2085
MethodBase.cxx:2086
MethodBase.cxx:2087
MethodBase.cxx:2088
MethodBase.cxx:2089
MethodBase.cxx:2090
MethodBase.cxx:2091
MethodBase.cxx:2092
MethodBase.cxx:2093
MethodBase.cxx:2094
MethodBase.cxx:2095
MethodBase.cxx:2096
MethodBase.cxx:2097
MethodBase.cxx:2098
MethodBase.cxx:2099
MethodBase.cxx:2100
MethodBase.cxx:2101
MethodBase.cxx:2102
MethodBase.cxx:2103
MethodBase.cxx:2104
MethodBase.cxx:2105
MethodBase.cxx:2106
MethodBase.cxx:2107
MethodBase.cxx:2108
MethodBase.cxx:2109
MethodBase.cxx:2110
MethodBase.cxx:2111
MethodBase.cxx:2112
MethodBase.cxx:2113
MethodBase.cxx:2114
MethodBase.cxx:2115
MethodBase.cxx:2116
MethodBase.cxx:2117
MethodBase.cxx:2118
MethodBase.cxx:2119
MethodBase.cxx:2120
MethodBase.cxx:2121
MethodBase.cxx:2122
MethodBase.cxx:2123
MethodBase.cxx:2124
MethodBase.cxx:2125
MethodBase.cxx:2126
MethodBase.cxx:2127
MethodBase.cxx:2128
MethodBase.cxx:2129
MethodBase.cxx:2130
MethodBase.cxx:2131
MethodBase.cxx:2132
MethodBase.cxx:2133
MethodBase.cxx:2134
MethodBase.cxx:2135
MethodBase.cxx:2136
MethodBase.cxx:2137
MethodBase.cxx:2138
MethodBase.cxx:2139
MethodBase.cxx:2140
MethodBase.cxx:2141
MethodBase.cxx:2142
MethodBase.cxx:2143
MethodBase.cxx:2144
MethodBase.cxx:2145
MethodBase.cxx:2146
MethodBase.cxx:2147
MethodBase.cxx:2148
MethodBase.cxx:2149
MethodBase.cxx:2150
MethodBase.cxx:2151
MethodBase.cxx:2152
MethodBase.cxx:2153
MethodBase.cxx:2154
MethodBase.cxx:2155
MethodBase.cxx:2156
MethodBase.cxx:2157
MethodBase.cxx:2158
MethodBase.cxx:2159
MethodBase.cxx:2160
MethodBase.cxx:2161
MethodBase.cxx:2162
MethodBase.cxx:2163
MethodBase.cxx:2164
MethodBase.cxx:2165
MethodBase.cxx:2166
MethodBase.cxx:2167
MethodBase.cxx:2168
MethodBase.cxx:2169
MethodBase.cxx:2170
MethodBase.cxx:2171
MethodBase.cxx:2172
MethodBase.cxx:2173
MethodBase.cxx:2174
MethodBase.cxx:2175
MethodBase.cxx:2176
MethodBase.cxx:2177
MethodBase.cxx:2178
MethodBase.cxx:2179
MethodBase.cxx:2180
MethodBase.cxx:2181
MethodBase.cxx:2182
MethodBase.cxx:2183
MethodBase.cxx:2184
MethodBase.cxx:2185
MethodBase.cxx:2186
MethodBase.cxx:2187
MethodBase.cxx:2188
MethodBase.cxx:2189
MethodBase.cxx:2190
MethodBase.cxx:2191
MethodBase.cxx:2192
MethodBase.cxx:2193
MethodBase.cxx:2194
MethodBase.cxx:2195
MethodBase.cxx:2196
MethodBase.cxx:2197
MethodBase.cxx:2198
MethodBase.cxx:2199
MethodBase.cxx:2200
MethodBase.cxx:2201
MethodBase.cxx:2202
MethodBase.cxx:2203
MethodBase.cxx:2204
MethodBase.cxx:2205
MethodBase.cxx:2206
MethodBase.cxx:2207
MethodBase.cxx:2208
MethodBase.cxx:2209
MethodBase.cxx:2210
MethodBase.cxx:2211
MethodBase.cxx:2212
MethodBase.cxx:2213
MethodBase.cxx:2214
MethodBase.cxx:2215
MethodBase.cxx:2216
MethodBase.cxx:2217
MethodBase.cxx:2218
MethodBase.cxx:2219
MethodBase.cxx:2220
MethodBase.cxx:2221
MethodBase.cxx:2222
MethodBase.cxx:2223
MethodBase.cxx:2224
MethodBase.cxx:2225
MethodBase.cxx:2226
MethodBase.cxx:2227
MethodBase.cxx:2228
MethodBase.cxx:2229
MethodBase.cxx:2230
MethodBase.cxx:2231
MethodBase.cxx:2232
MethodBase.cxx:2233
MethodBase.cxx:2234
MethodBase.cxx:2235
MethodBase.cxx:2236
MethodBase.cxx:2237
MethodBase.cxx:2238
MethodBase.cxx:2239
MethodBase.cxx:2240
MethodBase.cxx:2241
MethodBase.cxx:2242
MethodBase.cxx:2243
MethodBase.cxx:2244
MethodBase.cxx:2245
MethodBase.cxx:2246
MethodBase.cxx:2247
MethodBase.cxx:2248
MethodBase.cxx:2249
MethodBase.cxx:2250
MethodBase.cxx:2251
MethodBase.cxx:2252
MethodBase.cxx:2253
MethodBase.cxx:2254
MethodBase.cxx:2255
MethodBase.cxx:2256
MethodBase.cxx:2257
MethodBase.cxx:2258
MethodBase.cxx:2259
MethodBase.cxx:2260
MethodBase.cxx:2261
MethodBase.cxx:2262
MethodBase.cxx:2263
MethodBase.cxx:2264
MethodBase.cxx:2265
MethodBase.cxx:2266
MethodBase.cxx:2267
MethodBase.cxx:2268
MethodBase.cxx:2269
MethodBase.cxx:2270
MethodBase.cxx:2271
MethodBase.cxx:2272
MethodBase.cxx:2273
MethodBase.cxx:2274
MethodBase.cxx:2275
MethodBase.cxx:2276
MethodBase.cxx:2277
MethodBase.cxx:2278
MethodBase.cxx:2279
MethodBase.cxx:2280
MethodBase.cxx:2281
MethodBase.cxx:2282
MethodBase.cxx:2283
MethodBase.cxx:2284
MethodBase.cxx:2285
MethodBase.cxx:2286
MethodBase.cxx:2287
MethodBase.cxx:2288
MethodBase.cxx:2289
MethodBase.cxx:2290
MethodBase.cxx:2291
MethodBase.cxx:2292
MethodBase.cxx:2293
MethodBase.cxx:2294
MethodBase.cxx:2295
MethodBase.cxx:2296
MethodBase.cxx:2297
MethodBase.cxx:2298
MethodBase.cxx:2299
MethodBase.cxx:2300
MethodBase.cxx:2301
MethodBase.cxx:2302
MethodBase.cxx:2303
MethodBase.cxx:2304
MethodBase.cxx:2305
MethodBase.cxx:2306
MethodBase.cxx:2307
MethodBase.cxx:2308
MethodBase.cxx:2309
MethodBase.cxx:2310
MethodBase.cxx:2311
MethodBase.cxx:2312
MethodBase.cxx:2313
MethodBase.cxx:2314
MethodBase.cxx:2315
MethodBase.cxx:2316
MethodBase.cxx:2317
MethodBase.cxx:2318
MethodBase.cxx:2319
MethodBase.cxx:2320
MethodBase.cxx:2321
MethodBase.cxx:2322
MethodBase.cxx:2323
MethodBase.cxx:2324
MethodBase.cxx:2325
MethodBase.cxx:2326
MethodBase.cxx:2327
MethodBase.cxx:2328
MethodBase.cxx:2329
MethodBase.cxx:2330
MethodBase.cxx:2331
MethodBase.cxx:2332
MethodBase.cxx:2333
MethodBase.cxx:2334
MethodBase.cxx:2335
MethodBase.cxx:2336
MethodBase.cxx:2337
MethodBase.cxx:2338
MethodBase.cxx:2339
MethodBase.cxx:2340
MethodBase.cxx:2341
MethodBase.cxx:2342
MethodBase.cxx:2343
MethodBase.cxx:2344
MethodBase.cxx:2345
MethodBase.cxx:2346
MethodBase.cxx:2347
MethodBase.cxx:2348
MethodBase.cxx:2349
MethodBase.cxx:2350
MethodBase.cxx:2351
MethodBase.cxx:2352
MethodBase.cxx:2353
MethodBase.cxx:2354
MethodBase.cxx:2355
MethodBase.cxx:2356
MethodBase.cxx:2357
MethodBase.cxx:2358
MethodBase.cxx:2359
MethodBase.cxx:2360
MethodBase.cxx:2361
MethodBase.cxx:2362
MethodBase.cxx:2363
MethodBase.cxx:2364
MethodBase.cxx:2365
MethodBase.cxx:2366
MethodBase.cxx:2367
MethodBase.cxx:2368
MethodBase.cxx:2369
MethodBase.cxx:2370
MethodBase.cxx:2371
MethodBase.cxx:2372
MethodBase.cxx:2373
MethodBase.cxx:2374
MethodBase.cxx:2375
MethodBase.cxx:2376
MethodBase.cxx:2377
MethodBase.cxx:2378
MethodBase.cxx:2379
MethodBase.cxx:2380
MethodBase.cxx:2381
MethodBase.cxx:2382
MethodBase.cxx:2383
MethodBase.cxx:2384
MethodBase.cxx:2385
MethodBase.cxx:2386
MethodBase.cxx:2387
MethodBase.cxx:2388
MethodBase.cxx:2389
MethodBase.cxx:2390
MethodBase.cxx:2391
MethodBase.cxx:2392
MethodBase.cxx:2393
MethodBase.cxx:2394
MethodBase.cxx:2395
MethodBase.cxx:2396
MethodBase.cxx:2397
MethodBase.cxx:2398
MethodBase.cxx:2399
MethodBase.cxx:2400
MethodBase.cxx:2401
MethodBase.cxx:2402
MethodBase.cxx:2403
MethodBase.cxx:2404
MethodBase.cxx:2405
MethodBase.cxx:2406
MethodBase.cxx:2407
MethodBase.cxx:2408
MethodBase.cxx:2409
MethodBase.cxx:2410
MethodBase.cxx:2411
MethodBase.cxx:2412
MethodBase.cxx:2413
MethodBase.cxx:2414
MethodBase.cxx:2415
MethodBase.cxx:2416
MethodBase.cxx:2417
MethodBase.cxx:2418
MethodBase.cxx:2419
MethodBase.cxx:2420
MethodBase.cxx:2421
MethodBase.cxx:2422
MethodBase.cxx:2423
MethodBase.cxx:2424
MethodBase.cxx:2425
MethodBase.cxx:2426
MethodBase.cxx:2427
MethodBase.cxx:2428
MethodBase.cxx:2429
MethodBase.cxx:2430
MethodBase.cxx:2431
MethodBase.cxx:2432
MethodBase.cxx:2433
MethodBase.cxx:2434
MethodBase.cxx:2435
MethodBase.cxx:2436
MethodBase.cxx:2437
MethodBase.cxx:2438
MethodBase.cxx:2439
MethodBase.cxx:2440
MethodBase.cxx:2441
MethodBase.cxx:2442
MethodBase.cxx:2443
MethodBase.cxx:2444
MethodBase.cxx:2445
MethodBase.cxx:2446
MethodBase.cxx:2447
MethodBase.cxx:2448
MethodBase.cxx:2449
MethodBase.cxx:2450
MethodBase.cxx:2451
MethodBase.cxx:2452
MethodBase.cxx:2453
MethodBase.cxx:2454
MethodBase.cxx:2455
MethodBase.cxx:2456
MethodBase.cxx:2457
MethodBase.cxx:2458
MethodBase.cxx:2459
MethodBase.cxx:2460
MethodBase.cxx:2461
MethodBase.cxx:2462
MethodBase.cxx:2463
MethodBase.cxx:2464
MethodBase.cxx:2465
MethodBase.cxx:2466
MethodBase.cxx:2467
MethodBase.cxx:2468
MethodBase.cxx:2469
MethodBase.cxx:2470
MethodBase.cxx:2471
MethodBase.cxx:2472
MethodBase.cxx:2473
MethodBase.cxx:2474
MethodBase.cxx:2475
MethodBase.cxx:2476
MethodBase.cxx:2477
MethodBase.cxx:2478
MethodBase.cxx:2479
MethodBase.cxx:2480
MethodBase.cxx:2481
MethodBase.cxx:2482
MethodBase.cxx:2483
MethodBase.cxx:2484
MethodBase.cxx:2485
MethodBase.cxx:2486
MethodBase.cxx:2487
MethodBase.cxx:2488
MethodBase.cxx:2489
MethodBase.cxx:2490
MethodBase.cxx:2491
MethodBase.cxx:2492
MethodBase.cxx:2493
MethodBase.cxx:2494
MethodBase.cxx:2495
MethodBase.cxx:2496
MethodBase.cxx:2497
MethodBase.cxx:2498
MethodBase.cxx:2499
MethodBase.cxx:2500
MethodBase.cxx:2501
MethodBase.cxx:2502
MethodBase.cxx:2503
MethodBase.cxx:2504
MethodBase.cxx:2505
MethodBase.cxx:2506
MethodBase.cxx:2507
MethodBase.cxx:2508
MethodBase.cxx:2509
MethodBase.cxx:2510
MethodBase.cxx:2511
MethodBase.cxx:2512
MethodBase.cxx:2513
MethodBase.cxx:2514
MethodBase.cxx:2515
MethodBase.cxx:2516
MethodBase.cxx:2517
MethodBase.cxx:2518
MethodBase.cxx:2519
MethodBase.cxx:2520
MethodBase.cxx:2521
MethodBase.cxx:2522
MethodBase.cxx:2523
MethodBase.cxx:2524
MethodBase.cxx:2525
MethodBase.cxx:2526
MethodBase.cxx:2527
MethodBase.cxx:2528
MethodBase.cxx:2529
MethodBase.cxx:2530
MethodBase.cxx:2531
MethodBase.cxx:2532
MethodBase.cxx:2533
MethodBase.cxx:2534
MethodBase.cxx:2535
MethodBase.cxx:2536
MethodBase.cxx:2537
MethodBase.cxx:2538
MethodBase.cxx:2539
MethodBase.cxx:2540
MethodBase.cxx:2541
MethodBase.cxx:2542
MethodBase.cxx:2543
MethodBase.cxx:2544
MethodBase.cxx:2545
MethodBase.cxx:2546
MethodBase.cxx:2547
MethodBase.cxx:2548
MethodBase.cxx:2549
MethodBase.cxx:2550
MethodBase.cxx:2551
MethodBase.cxx:2552
MethodBase.cxx:2553
MethodBase.cxx:2554
MethodBase.cxx:2555
MethodBase.cxx:2556
MethodBase.cxx:2557
MethodBase.cxx:2558
MethodBase.cxx:2559
MethodBase.cxx:2560
MethodBase.cxx:2561
MethodBase.cxx:2562
MethodBase.cxx:2563
MethodBase.cxx:2564
MethodBase.cxx:2565
MethodBase.cxx:2566
MethodBase.cxx:2567
MethodBase.cxx:2568
MethodBase.cxx:2569
MethodBase.cxx:2570
MethodBase.cxx:2571
MethodBase.cxx:2572
MethodBase.cxx:2573
MethodBase.cxx:2574
MethodBase.cxx:2575
MethodBase.cxx:2576
MethodBase.cxx:2577
MethodBase.cxx:2578
MethodBase.cxx:2579
MethodBase.cxx:2580
MethodBase.cxx:2581
MethodBase.cxx:2582
MethodBase.cxx:2583
MethodBase.cxx:2584
MethodBase.cxx:2585
MethodBase.cxx:2586
MethodBase.cxx:2587
MethodBase.cxx:2588
MethodBase.cxx:2589
MethodBase.cxx:2590
MethodBase.cxx:2591
MethodBase.cxx:2592
MethodBase.cxx:2593
MethodBase.cxx:2594
MethodBase.cxx:2595
MethodBase.cxx:2596
MethodBase.cxx:2597
MethodBase.cxx:2598
MethodBase.cxx:2599
MethodBase.cxx:2600
MethodBase.cxx:2601
MethodBase.cxx:2602
MethodBase.cxx:2603
MethodBase.cxx:2604
MethodBase.cxx:2605
MethodBase.cxx:2606
MethodBase.cxx:2607
MethodBase.cxx:2608
MethodBase.cxx:2609
MethodBase.cxx:2610
MethodBase.cxx:2611
MethodBase.cxx:2612
MethodBase.cxx:2613
MethodBase.cxx:2614
MethodBase.cxx:2615
MethodBase.cxx:2616
MethodBase.cxx:2617
MethodBase.cxx:2618
MethodBase.cxx:2619
MethodBase.cxx:2620
MethodBase.cxx:2621
MethodBase.cxx:2622
MethodBase.cxx:2623
MethodBase.cxx:2624
MethodBase.cxx:2625
MethodBase.cxx:2626
MethodBase.cxx:2627
MethodBase.cxx:2628
MethodBase.cxx:2629
MethodBase.cxx:2630
MethodBase.cxx:2631
MethodBase.cxx:2632
MethodBase.cxx:2633
MethodBase.cxx:2634
MethodBase.cxx:2635
MethodBase.cxx:2636
MethodBase.cxx:2637
MethodBase.cxx:2638
MethodBase.cxx:2639
MethodBase.cxx:2640
MethodBase.cxx:2641
MethodBase.cxx:2642
MethodBase.cxx:2643
MethodBase.cxx:2644
MethodBase.cxx:2645
MethodBase.cxx:2646
MethodBase.cxx:2647
MethodBase.cxx:2648
MethodBase.cxx:2649
MethodBase.cxx:2650
MethodBase.cxx:2651
MethodBase.cxx:2652
MethodBase.cxx:2653
MethodBase.cxx:2654
MethodBase.cxx:2655
MethodBase.cxx:2656
MethodBase.cxx:2657
MethodBase.cxx:2658
MethodBase.cxx:2659
MethodBase.cxx:2660
MethodBase.cxx:2661
MethodBase.cxx:2662
MethodBase.cxx:2663
MethodBase.cxx:2664
MethodBase.cxx:2665
MethodBase.cxx:2666
MethodBase.cxx:2667
MethodBase.cxx:2668
MethodBase.cxx:2669
MethodBase.cxx:2670
MethodBase.cxx:2671
MethodBase.cxx:2672
MethodBase.cxx:2673
MethodBase.cxx:2674
MethodBase.cxx:2675
MethodBase.cxx:2676
MethodBase.cxx:2677
MethodBase.cxx:2678
MethodBase.cxx:2679
MethodBase.cxx:2680
MethodBase.cxx:2681
MethodBase.cxx:2682
MethodBase.cxx:2683
MethodBase.cxx:2684
MethodBase.cxx:2685
MethodBase.cxx:2686
MethodBase.cxx:2687
MethodBase.cxx:2688
MethodBase.cxx:2689
MethodBase.cxx:2690
MethodBase.cxx:2691
MethodBase.cxx:2692
MethodBase.cxx:2693
MethodBase.cxx:2694
MethodBase.cxx:2695
MethodBase.cxx:2696
MethodBase.cxx:2697
MethodBase.cxx:2698
MethodBase.cxx:2699
MethodBase.cxx:2700
MethodBase.cxx:2701
MethodBase.cxx:2702
MethodBase.cxx:2703
MethodBase.cxx:2704
MethodBase.cxx:2705
MethodBase.cxx:2706
MethodBase.cxx:2707
MethodBase.cxx:2708
MethodBase.cxx:2709
MethodBase.cxx:2710
MethodBase.cxx:2711
MethodBase.cxx:2712
MethodBase.cxx:2713
MethodBase.cxx:2714
MethodBase.cxx:2715
MethodBase.cxx:2716
MethodBase.cxx:2717
MethodBase.cxx:2718
MethodBase.cxx:2719
MethodBase.cxx:2720
MethodBase.cxx:2721
MethodBase.cxx:2722
MethodBase.cxx:2723
MethodBase.cxx:2724
MethodBase.cxx:2725
MethodBase.cxx:2726
MethodBase.cxx:2727
MethodBase.cxx:2728
MethodBase.cxx:2729
MethodBase.cxx:2730
MethodBase.cxx:2731
MethodBase.cxx:2732
MethodBase.cxx:2733
MethodBase.cxx:2734
MethodBase.cxx:2735
MethodBase.cxx:2736
MethodBase.cxx:2737
MethodBase.cxx:2738
MethodBase.cxx:2739
MethodBase.cxx:2740
MethodBase.cxx:2741
MethodBase.cxx:2742
MethodBase.cxx:2743
MethodBase.cxx:2744
MethodBase.cxx:2745
MethodBase.cxx:2746
MethodBase.cxx:2747
MethodBase.cxx:2748
MethodBase.cxx:2749
MethodBase.cxx:2750
MethodBase.cxx:2751
MethodBase.cxx:2752
MethodBase.cxx:2753
MethodBase.cxx:2754
MethodBase.cxx:2755
MethodBase.cxx:2756
MethodBase.cxx:2757
MethodBase.cxx:2758
MethodBase.cxx:2759
MethodBase.cxx:2760
MethodBase.cxx:2761
MethodBase.cxx:2762
MethodBase.cxx:2763
MethodBase.cxx:2764
MethodBase.cxx:2765
MethodBase.cxx:2766
MethodBase.cxx:2767
MethodBase.cxx:2768
MethodBase.cxx:2769
MethodBase.cxx:2770
MethodBase.cxx:2771
MethodBase.cxx:2772
MethodBase.cxx:2773
MethodBase.cxx:2774
MethodBase.cxx:2775
MethodBase.cxx:2776
MethodBase.cxx:2777
MethodBase.cxx:2778
MethodBase.cxx:2779
MethodBase.cxx:2780
MethodBase.cxx:2781
MethodBase.cxx:2782
MethodBase.cxx:2783
MethodBase.cxx:2784
MethodBase.cxx:2785
MethodBase.cxx:2786
MethodBase.cxx:2787
MethodBase.cxx:2788
MethodBase.cxx:2789
MethodBase.cxx:2790
MethodBase.cxx:2791
MethodBase.cxx:2792
MethodBase.cxx:2793
MethodBase.cxx:2794
MethodBase.cxx:2795
MethodBase.cxx:2796
MethodBase.cxx:2797
MethodBase.cxx:2798
MethodBase.cxx:2799
MethodBase.cxx:2800
MethodBase.cxx:2801
MethodBase.cxx:2802
MethodBase.cxx:2803
MethodBase.cxx:2804
MethodBase.cxx:2805
MethodBase.cxx:2806
MethodBase.cxx:2807
MethodBase.cxx:2808
MethodBase.cxx:2809
MethodBase.cxx:2810
MethodBase.cxx:2811
MethodBase.cxx:2812
MethodBase.cxx:2813
MethodBase.cxx:2814
MethodBase.cxx:2815
MethodBase.cxx:2816
MethodBase.cxx:2817
MethodBase.cxx:2818
MethodBase.cxx:2819
MethodBase.cxx:2820
MethodBase.cxx:2821
MethodBase.cxx:2822
MethodBase.cxx:2823
MethodBase.cxx:2824
MethodBase.cxx:2825
MethodBase.cxx:2826
MethodBase.cxx:2827
MethodBase.cxx:2828
MethodBase.cxx:2829
MethodBase.cxx:2830
MethodBase.cxx:2831
MethodBase.cxx:2832
MethodBase.cxx:2833
MethodBase.cxx:2834
MethodBase.cxx:2835
MethodBase.cxx:2836
MethodBase.cxx:2837
MethodBase.cxx:2838
MethodBase.cxx:2839
MethodBase.cxx:2840
MethodBase.cxx:2841
MethodBase.cxx:2842
MethodBase.cxx:2843
MethodBase.cxx:2844
MethodBase.cxx:2845
MethodBase.cxx:2846
MethodBase.cxx:2847
MethodBase.cxx:2848
MethodBase.cxx:2849
MethodBase.cxx:2850
MethodBase.cxx:2851
MethodBase.cxx:2852
MethodBase.cxx:2853
MethodBase.cxx:2854
MethodBase.cxx:2855
MethodBase.cxx:2856
MethodBase.cxx:2857
MethodBase.cxx:2858
MethodBase.cxx:2859
MethodBase.cxx:2860
MethodBase.cxx:2861
MethodBase.cxx:2862
MethodBase.cxx:2863
MethodBase.cxx:2864
MethodBase.cxx:2865
MethodBase.cxx:2866
MethodBase.cxx:2867
MethodBase.cxx:2868
MethodBase.cxx:2869
MethodBase.cxx:2870
MethodBase.cxx:2871
MethodBase.cxx:2872
MethodBase.cxx:2873
MethodBase.cxx:2874
MethodBase.cxx:2875
MethodBase.cxx:2876
MethodBase.cxx:2877
MethodBase.cxx:2878
MethodBase.cxx:2879
MethodBase.cxx:2880
MethodBase.cxx:2881
MethodBase.cxx:2882
MethodBase.cxx:2883
MethodBase.cxx:2884
MethodBase.cxx:2885
MethodBase.cxx:2886
MethodBase.cxx:2887
MethodBase.cxx:2888
MethodBase.cxx:2889
MethodBase.cxx:2890
MethodBase.cxx:2891
MethodBase.cxx:2892
MethodBase.cxx:2893
MethodBase.cxx:2894
MethodBase.cxx:2895
MethodBase.cxx:2896
MethodBase.cxx:2897
MethodBase.cxx:2898
MethodBase.cxx:2899
MethodBase.cxx:2900
MethodBase.cxx:2901
MethodBase.cxx:2902
MethodBase.cxx:2903
MethodBase.cxx:2904
MethodBase.cxx:2905
MethodBase.cxx:2906
MethodBase.cxx:2907
MethodBase.cxx:2908
MethodBase.cxx:2909
MethodBase.cxx:2910
MethodBase.cxx:2911
MethodBase.cxx:2912
MethodBase.cxx:2913
MethodBase.cxx:2914
MethodBase.cxx:2915
MethodBase.cxx:2916
MethodBase.cxx:2917
MethodBase.cxx:2918
MethodBase.cxx:2919
MethodBase.cxx:2920
MethodBase.cxx:2921
MethodBase.cxx:2922
MethodBase.cxx:2923
MethodBase.cxx:2924
MethodBase.cxx:2925
MethodBase.cxx:2926
MethodBase.cxx:2927
MethodBase.cxx:2928
MethodBase.cxx:2929
MethodBase.cxx:2930
MethodBase.cxx:2931
MethodBase.cxx:2932
MethodBase.cxx:2933
MethodBase.cxx:2934
MethodBase.cxx:2935
MethodBase.cxx:2936
MethodBase.cxx:2937
MethodBase.cxx:2938
MethodBase.cxx:2939
MethodBase.cxx:2940
MethodBase.cxx:2941
MethodBase.cxx:2942
MethodBase.cxx:2943
MethodBase.cxx:2944
MethodBase.cxx:2945
MethodBase.cxx:2946
MethodBase.cxx:2947
MethodBase.cxx:2948
MethodBase.cxx:2949
MethodBase.cxx:2950
MethodBase.cxx:2951
MethodBase.cxx:2952
MethodBase.cxx:2953
MethodBase.cxx:2954
MethodBase.cxx:2955
MethodBase.cxx:2956
MethodBase.cxx:2957
MethodBase.cxx:2958
MethodBase.cxx:2959
MethodBase.cxx:2960
MethodBase.cxx:2961
MethodBase.cxx:2962
MethodBase.cxx:2963
MethodBase.cxx:2964
MethodBase.cxx:2965
MethodBase.cxx:2966
MethodBase.cxx:2967
MethodBase.cxx:2968
MethodBase.cxx:2969
MethodBase.cxx:2970
MethodBase.cxx:2971
MethodBase.cxx:2972
MethodBase.cxx:2973
MethodBase.cxx:2974
MethodBase.cxx:2975
MethodBase.cxx:2976
MethodBase.cxx:2977
MethodBase.cxx:2978
MethodBase.cxx:2979
MethodBase.cxx:2980
MethodBase.cxx:2981
MethodBase.cxx:2982
MethodBase.cxx:2983
MethodBase.cxx:2984
MethodBase.cxx:2985
MethodBase.cxx:2986
MethodBase.cxx:2987
MethodBase.cxx:2988
MethodBase.cxx:2989
MethodBase.cxx:2990
MethodBase.cxx:2991
MethodBase.cxx:2992
MethodBase.cxx:2993
MethodBase.cxx:2994
MethodBase.cxx:2995
MethodBase.cxx:2996
MethodBase.cxx:2997
MethodBase.cxx:2998
MethodBase.cxx:2999
MethodBase.cxx:3000
MethodBase.cxx:3001
MethodBase.cxx:3002
MethodBase.cxx:3003
MethodBase.cxx:3004
MethodBase.cxx:3005
MethodBase.cxx:3006
MethodBase.cxx:3007
MethodBase.cxx:3008
MethodBase.cxx:3009
MethodBase.cxx:3010
MethodBase.cxx:3011
MethodBase.cxx:3012
MethodBase.cxx:3013
MethodBase.cxx:3014
MethodBase.cxx:3015
MethodBase.cxx:3016
MethodBase.cxx:3017
MethodBase.cxx:3018
MethodBase.cxx:3019
MethodBase.cxx:3020
MethodBase.cxx:3021
MethodBase.cxx:3022
MethodBase.cxx:3023
MethodBase.cxx:3024
MethodBase.cxx:3025
MethodBase.cxx:3026
MethodBase.cxx:3027
MethodBase.cxx:3028
MethodBase.cxx:3029
MethodBase.cxx:3030
MethodBase.cxx:3031
MethodBase.cxx:3032
MethodBase.cxx:3033
MethodBase.cxx:3034
MethodBase.cxx:3035
MethodBase.cxx:3036
MethodBase.cxx:3037
MethodBase.cxx:3038
MethodBase.cxx:3039
MethodBase.cxx:3040
MethodBase.cxx:3041
MethodBase.cxx:3042
MethodBase.cxx:3043
MethodBase.cxx:3044
MethodBase.cxx:3045
MethodBase.cxx:3046
MethodBase.cxx:3047
MethodBase.cxx:3048
MethodBase.cxx:3049
MethodBase.cxx:3050
MethodBase.cxx:3051
MethodBase.cxx:3052
MethodBase.cxx:3053
MethodBase.cxx:3054
MethodBase.cxx:3055
MethodBase.cxx:3056
MethodBase.cxx:3057
MethodBase.cxx:3058
MethodBase.cxx:3059
MethodBase.cxx:3060
MethodBase.cxx:3061
MethodBase.cxx:3062
MethodBase.cxx:3063
MethodBase.cxx:3064
MethodBase.cxx:3065
MethodBase.cxx:3066
MethodBase.cxx:3067
MethodBase.cxx:3068
MethodBase.cxx:3069
MethodBase.cxx:3070
MethodBase.cxx:3071
MethodBase.cxx:3072
MethodBase.cxx:3073
MethodBase.cxx:3074
MethodBase.cxx:3075
MethodBase.cxx:3076
MethodBase.cxx:3077
MethodBase.cxx:3078
MethodBase.cxx:3079
MethodBase.cxx:3080
MethodBase.cxx:3081
MethodBase.cxx:3082
MethodBase.cxx:3083
MethodBase.cxx:3084
MethodBase.cxx:3085
MethodBase.cxx:3086
MethodBase.cxx:3087
MethodBase.cxx:3088
MethodBase.cxx:3089
MethodBase.cxx:3090
MethodBase.cxx:3091
MethodBase.cxx:3092
MethodBase.cxx:3093
MethodBase.cxx:3094
MethodBase.cxx:3095
MethodBase.cxx:3096
MethodBase.cxx:3097
MethodBase.cxx:3098
MethodBase.cxx:3099
MethodBase.cxx:3100
MethodBase.cxx:3101
MethodBase.cxx:3102
MethodBase.cxx:3103
MethodBase.cxx:3104
MethodBase.cxx:3105
MethodBase.cxx:3106
MethodBase.cxx:3107
MethodBase.cxx:3108
MethodBase.cxx:3109
MethodBase.cxx:3110
MethodBase.cxx:3111
MethodBase.cxx:3112
MethodBase.cxx:3113
MethodBase.cxx:3114
MethodBase.cxx:3115
MethodBase.cxx:3116
MethodBase.cxx:3117
MethodBase.cxx:3118
MethodBase.cxx:3119
MethodBase.cxx:3120
MethodBase.cxx:3121
MethodBase.cxx:3122
MethodBase.cxx:3123
MethodBase.cxx:3124
MethodBase.cxx:3125
MethodBase.cxx:3126
MethodBase.cxx:3127
MethodBase.cxx:3128
MethodBase.cxx:3129
MethodBase.cxx:3130
MethodBase.cxx:3131
MethodBase.cxx:3132
MethodBase.cxx:3133
MethodBase.cxx:3134
MethodBase.cxx:3135
MethodBase.cxx:3136
MethodBase.cxx:3137
MethodBase.cxx:3138
MethodBase.cxx:3139
MethodBase.cxx:3140
MethodBase.cxx:3141
MethodBase.cxx:3142
MethodBase.cxx:3143
MethodBase.cxx:3144
MethodBase.cxx:3145
MethodBase.cxx:3146
MethodBase.cxx:3147
MethodBase.cxx:3148
MethodBase.cxx:3149
MethodBase.cxx:3150
MethodBase.cxx:3151
MethodBase.cxx:3152
MethodBase.cxx:3153
MethodBase.cxx:3154
MethodBase.cxx:3155
MethodBase.cxx:3156
MethodBase.cxx:3157
MethodBase.cxx:3158
MethodBase.cxx:3159
MethodBase.cxx:3160
MethodBase.cxx:3161
MethodBase.cxx:3162
MethodBase.cxx:3163
MethodBase.cxx:3164
MethodBase.cxx:3165
MethodBase.cxx:3166
MethodBase.cxx:3167
MethodBase.cxx:3168
MethodBase.cxx:3169
MethodBase.cxx:3170
MethodBase.cxx:3171
MethodBase.cxx:3172
MethodBase.cxx:3173
MethodBase.cxx:3174
MethodBase.cxx:3175
MethodBase.cxx:3176
MethodBase.cxx:3177
MethodBase.cxx:3178
MethodBase.cxx:3179
MethodBase.cxx:3180
MethodBase.cxx:3181
MethodBase.cxx:3182
MethodBase.cxx:3183
MethodBase.cxx:3184
MethodBase.cxx:3185
MethodBase.cxx:3186
MethodBase.cxx:3187
MethodBase.cxx:3188
MethodBase.cxx:3189
MethodBase.cxx:3190
MethodBase.cxx:3191
MethodBase.cxx:3192
MethodBase.cxx:3193
MethodBase.cxx:3194
MethodBase.cxx:3195
MethodBase.cxx:3196
MethodBase.cxx:3197
MethodBase.cxx:3198
MethodBase.cxx:3199
MethodBase.cxx:3200