ROOT: headers diff between 5.25.04 and 5.26.00 versions

	BayesianCalculator.h	BayesianCalculator.h

	// @(#)root/roostats:$Id: BayesianCalculator.h 31276 2009-11-18 15:06:42Z m oneta $	// @(#)root/roostats:$Id: BayesianCalculator.h 31742 2009-12-09 17:34:15Z m oneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_BayesianCalculator	#ifndef ROOSTATS_BayesianCalculator

	skipping to change at line 47	skipping to change at line 47

	class BayesianCalculator : public IntervalCalculator, public TNamed {	class BayesianCalculator : public IntervalCalculator, public TNamed {

	public:	public:

	// constructor	// constructor
	BayesianCalculator( );	BayesianCalculator( );

	BayesianCalculator( RooAbsData& data,	BayesianCalculator( RooAbsData& data,
	RooAbsPdf& pdf,	RooAbsPdf& pdf,

	const RooArgSet & POI,	const RooArgSet& POI,
	RooAbsPdf& priorPOI,	RooAbsPdf& priorPOI,
	const RooArgSet* nuisanceParameters = 0 );	const RooArgSet* nuisanceParameters = 0 );

	BayesianCalculator( RooAbsData& data,	BayesianCalculator( RooAbsData& data,

	ModelConfig & model);	ModelConfig& model );

	// destructor	// destructor

	virtual ~BayesianCalculator() ;	virtual ~BayesianCalculator();

	RooPlot* GetPosteriorPlot() const;	RooPlot* GetPosteriorPlot() const;

	// return posterior pdf (object is managed by the BayesianCalculator class)	// return posterior pdf (object is managed by the BayesianCalculator class)

	RooAbsPdf * GetPosteriorPdf() const;	RooAbsPdf* GetPosteriorPdf() const;

	virtual SimpleInterval* GetInterval() const ;	virtual SimpleInterval* GetInterval() const ;


	virtual void SetData(RooAbsData & data) { fData = &data; }	virtual void SetData( RooAbsData & data ) { fData = &data; }


	virtual void SetModel(const ModelConfig & model);	virtual void SetModel( const ModelConfig& model );

	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)

	virtual void SetTestSize(Double_t size) {	virtual void SetTestSize( Double_t size ) {
	fSize = size;	fSize = size;

	if (fInterval) delete fInterval; fInterval = 0;	if (fInterval) delete fInterval;
		fInterval = 0;
	}	}
	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)

	virtual void SetConfidenceLevel(Double_t cl) { SetTestSize( 1. - cl); }	virtual void SetConfidenceLevel( Double_t cl ) { SetTestSize(1.-cl); }
	// Get the size of the test (eg. rate of Type I error)	// Get the size of the test (eg. rate of Type I error)

	virtual Double_t Size() const {return fSize;}	virtual Double_t Size() const { return fSize; }
	// Get the Confidence level for the test	// Get the Confidence level for the test

	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}	virtual Double_t ConfidenceLevel() const { return 1.-fSize; }

	protected:	protected:

	void ClearAll() const;	void ClearAll() const;

	private:	private:


		// compute the most probable value: move to public once implemented
		// returns a RooArgSet
		RooArgSet* GetMode( RooArgSet* parameters ) const;
		// plan to replace the above: return a SimpleInterval integrating
		// over all other parameters except the one specified as argument
		//virtual SimpleInterval* GetInterval( RooRealVar* parameter ) const
		{ return 0; }

	RooAbsData* fData;	RooAbsData* fData;
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf;
	RooArgSet fPOI;	RooArgSet fPOI;
	RooAbsPdf* fPriorPOI;	RooAbsPdf* fPriorPOI;
	RooArgSet fNuisanceParameters;	RooArgSet fNuisanceParameters;

	mutable RooAbsPdf* fProductPdf;	mutable RooAbsPdf* fProductPdf;
	mutable RooAbsReal* fLogLike;	mutable RooAbsReal* fLogLike;
	mutable RooAbsReal* fLikelihood;	mutable RooAbsReal* fLikelihood;
	mutable RooAbsReal* fIntegratedLikelihood;	mutable RooAbsReal* fIntegratedLikelihood;
	mutable RooAbsPdf* fPosteriorPdf;	mutable RooAbsPdf* fPosteriorPdf;

	mutable SimpleInterval* fInterval; // cached pointer to resulting interval	mutable SimpleInterval* fInterval; // cached pointer to resulting in terval


	double fSize; // size used for getting the interval	double fSize; // size used for getting the interval

	protected:	protected:

	ClassDef(BayesianCalculator,1) // BayesianCalculator class	ClassDef(BayesianCalculator,1) // BayesianCalculator class

	};	};
	}	}

	#endif	#endif

End of changes. 15 change blocks.
	14 lines changed or deleted	23 lines changed or added

	BinarySearchTreeNode.h	BinarySearchTreeNode.h

	// @(#)root/tmva $Id: BinarySearchTreeNode.h 29195 2009-06-24 10:39:49Z bru n $	// @(#)root/tmva $Id: BinarySearchTreeNode.h 31458 2009-11-30 13:58:20Z ste lzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Classes: Node, NodeID *	* Classes: Node, NodeID *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Node for the BinarySearch *	* Node for the BinarySearch *

	skipping to change at line 107	skipping to change at line 107
	virtual void Print( std::ostream& os ) const;	virtual void Print( std::ostream& os ) const;

	// recursive printout of the node and it daughters	// recursive printout of the node and it daughters
	virtual void PrintRec( std::ostream& os ) const;	virtual void PrintRec( std::ostream& os ) const;

	virtual void AddAttributesToNode(void* node) const;	virtual void AddAttributesToNode(void* node) const;
	virtual void AddContentToNode(std::stringstream& s) const;	virtual void AddContentToNode(std::stringstream& s) const;

	private:	private:
	// Read the data block	// Read the data block

	virtual void ReadAttributes(void* node);	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM
	virtual Bool_t ReadDataRecord( std::istream& is );	VA_VERSION_CODE );
		virtual Bool_t ReadDataRecord( std::istream& is, UInt_t tmva_Version_
		Code = TMVA_VERSION_CODE );
	virtual void ReadContent(std::stringstream& s);	virtual void ReadContent(std::stringstream& s);
	std::vector<Float_t> fEventV;	std::vector<Float_t> fEventV;
	std::vector<Float_t> fTargets;	std::vector<Float_t> fTargets;

	Float_t fWeight;	Float_t fWeight;
	// Float_t fIsSignal;	// Float_t fIsSignal;
	Int_t fClass;	Int_t fClass;

	Short_t fSelector; // index of variable used in node select ion (decision tree)	Short_t fSelector; // index of variable used in node select ion (decision tree)


End of changes. 2 change blocks.
	3 lines changed or deleted	5 lines changed or added

	BinaryTree.h	BinaryTree.h

	// @(#)root/tmva $Id: BinaryTree.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: BinaryTree.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : BinaryTree *	* Class : BinaryTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* BinaryTree: A base class for BinarySearch- or Decision-Trees *	* BinaryTree: A base class for BinarySearch- or Decision-Trees *

	skipping to change at line 31	skipping to change at line 31
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_BinaryTree	#ifndef ROOT_TMVA_BinaryTree
	#define ROOT_TMVA_BinaryTree	#define ROOT_TMVA_BinaryTree


		#ifndef ROOT_TMVA_Version
		#include "TMVA/Version.h"
		#endif

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// BinaryTree //	// BinaryTree //
	// //	// //
	// Base class for BinarySearch and Decision Trees //	// Base class for BinarySearch and Decision Trees //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <iosfwd>	#include <iosfwd>
	#ifndef ROOT_TROOT	#ifndef ROOT_TROOT

	skipping to change at line 76	skipping to change at line 80

	public:	public:

	// or a tree with Root node "n", any daughters of this node are autom atically in the tree	// or a tree with Root node "n", any daughters of this node are autom atically in the tree
	BinaryTree( void );	BinaryTree( void );

	virtual ~BinaryTree();	virtual ~BinaryTree();

	virtual Node* CreateNode(UInt_t size=0) const = 0;	virtual Node* CreateNode(UInt_t size=0) const = 0;
	virtual BinaryTree* CreateTree() const = 0;	virtual BinaryTree* CreateTree() const = 0;

	static BinaryTree* CreateFromXML(void* node);	static BinaryTree* CreateFromXML(void* node, UInt_t tmva_Version_Cod e = TMVA_VERSION_CODE);
	virtual const char* ClassName() const = 0;	virtual const char* ClassName() const = 0;

	// set the root node of the tree	// set the root node of the tree
	void SetRoot( Node* r ) { fRoot = r; }	void SetRoot( Node* r ) { fRoot = r; }

	// Retrieves the address of the root node	// Retrieves the address of the root node
	Node* GetRoot() const { return fRoot; }	Node* GetRoot() const { return fRoot; }

	// get number of Nodes in the Tree as counted while booking the nodes ;	// get number of Nodes in the Tree as counted while booking the nodes ;
	UInt_t GetNNodes() const { return fNNodes; }	UInt_t GetNNodes() const { return fNNodes; }

	skipping to change at line 102	skipping to change at line 106

	UInt_t GetTotalTreeDepth() const { return fDepth; }	UInt_t GetTotalTreeDepth() const { return fDepth; }

	void SetTotalTreeDepth( Int_t depth ) { fDepth = depth; }	void SetTotalTreeDepth( Int_t depth ) { fDepth = depth; }
	void SetTotalTreeDepth( Node* n = NULL );	void SetTotalTreeDepth( Node* n = NULL );

	Node* GetLeftDaughter ( Node* n);	Node* GetLeftDaughter ( Node* n);
	Node* GetRightDaughter( Node* n);	Node* GetRightDaughter( Node* n);

	virtual void Print( ostream& os ) const;	virtual void Print( ostream& os ) const;

	virtual void Read ( istream& istr );	virtual void Read ( istream& istr, UInt_t tmva_Version_Code = TMVA_VE RSION_CODE );
	virtual void* AddXMLTo(void* parent) const;	virtual void* AddXMLTo(void* parent) const;

	virtual void ReadXML(void* node);	virtual void ReadXML(void* node, UInt_t tmva_Version_Code = TMVA_VER SION_CODE );

	private:	private:

	Node* fRoot; //the root node of the tree	Node* fRoot; //the root node of the tree
	// the tree only has it's root node, the "daughters" are taken car	// the tree only has it's root node, the "daughters" are taken car
	// of by the "node" properties of the "root"	// of by the "node" properties of the "root"

	protected:	protected:

	// delete a node (and the corresponding event if owned by the tree)	// delete a node (and the corresponding event if owned by the tree)

End of changes. 5 change blocks.
	4 lines changed or deleted	8 lines changed or added

	CCTreeWrapper.h	CCTreeWrapper.h

	skipping to change at line 39	skipping to change at line 39
	#endif	#endif
	#ifndef ROOT_TMVA_SeparationBase	#ifndef ROOT_TMVA_SeparationBase
	#include "TMVA/SeparationBase.h"	#include "TMVA/SeparationBase.h"
	#endif	#endif
	#ifndef ROOT_TMVA_DecisionTree	#ifndef ROOT_TMVA_DecisionTree
	#include "TMVA/DecisionTree.h"	#include "TMVA/DecisionTree.h"
	#endif	#endif
	#ifndef ROOT_TMVA_DataSet	#ifndef ROOT_TMVA_DataSet
	#include "TMVA/DataSet.h"	#include "TMVA/DataSet.h"
	#endif	#endif

		#ifndef ROOT_TMVA_Version
		#include "TMVA/Version.h"
		#endif

	namespace TMVA {	namespace TMVA {

	class CCTreeWrapper {	class CCTreeWrapper {

	public:	public:

	typedef std::vector<Event*> EventList;	typedef std::vector<Event*> EventList;

	/////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////

	skipping to change at line 125	skipping to change at line 128
	inline virtual Bool_t GoesRight( const Event& e ) const { return ( GetDTNode() != NULL ?	inline virtual Bool_t GoesRight( const Event& e ) const { return ( GetDTNode() != NULL ?
	GetDTNode()->GoesRight(e) : false); }	GetDTNode()->GoesRight(e) : false); }

	// test event if it decends the tree at this node to the left	// test event if it decends the tree at this node to the left
	inline virtual Bool_t GoesLeft ( const Event& e ) const { return ( GetDTNode() != NULL ?	inline virtual Bool_t GoesLeft ( const Event& e ) const { return ( GetDTNode() != NULL ?
	GetDTNode()->GoesLeft(e) : false); }	GetDTNode()->GoesLeft(e) : false); }

	private:	private:

	// initialize a node from a data record	// initialize a node from a data record

	virtual void ReadAttributes(void* node);	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code =
	virtual Bool_t ReadDataRecord( std::istream& in );	TMVA_VERSION_CODE);
		virtual Bool_t ReadDataRecord( std::istream& in, UInt_t tmva_Versi
		on_Code = TMVA_VERSION_CODE );
	virtual void ReadContent(std::stringstream& s);	virtual void ReadContent(std::stringstream& s);

	Int_t fNLeafDaughters; //! number of terminal descendants	Int_t fNLeafDaughters; //! number of terminal descendants
	Double_t fNodeResubstitutionEstimate; //! R(t) = misclassification rate for node t	Double_t fNodeResubstitutionEstimate; //! R(t) = misclassification rate for node t
	Double_t fResubstitutionEstimate; //! R(T_t) = sum[t' in ~T_t]{ R( t) }	Double_t fResubstitutionEstimate; //! R(T_t) = sum[t' in ~T_t]{ R( t) }
	Double_t fAlphaC; //! critical point, g(t) = alpha_c(t)	Double_t fAlphaC; //! critical point, g(t) = alpha_c(t)
	Double_t fMinAlphaC; //! G(t), minimum critical point of t and its descendants	Double_t fMinAlphaC; //! G(t), minimum critical point of t and its descendants
	DecisionTreeNode* fDTNode; //! pointer to wrapped node in the deci sion tree	DecisionTreeNode* fDTNode; //! pointer to wrapped node in the deci sion tree
	};	};


End of changes. 2 change blocks.
	2 lines changed or deleted	7 lines changed or added

	DataSetFactory.h	DataSetFactory.h

	// @(#)root/tmva $Id: DataSetFactory.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: DataSetFactory.h 31466 2009-11-30 16:23:35Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Eckhard von To
		erne, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DataSetFactory *	* Class : DataSetFactory *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Contains all the data information *	* Contains all the data information *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *

		* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland
		*
		* Eckhard von Toerne <evt@physik.uni-bonn.de> - U. of Bonn, Germany
		*
	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German y *	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German y *
	* *	* *
	* Copyright (c) 2006: *	* Copyright (c) 2006: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/


		#define ALTERNATIVE_EVENT_VECTOR_BUILDING 1

	#ifndef ROOT_TMVA_DataSetFactory	#ifndef ROOT_TMVA_DataSetFactory
	#define ROOT_TMVA_DataSetFactory	#define ROOT_TMVA_DataSetFactory

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// DataSetFactory //	// DataSetFactory //
	// //	// //
	// Class that contains all the data information //	// Class that contains all the data information //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	skipping to change at line 59	skipping to change at line 63
	#endif	#endif
	#ifndef ROOT_TTreeFormula	#ifndef ROOT_TTreeFormula
	#include "TTreeFormula.h"	#include "TTreeFormula.h"
	#endif	#endif
	#ifndef ROOT_TMatrixDfwd	#ifndef ROOT_TMatrixDfwd
	#include "TMatrixDfwd.h"	#include "TMatrixDfwd.h"
	#endif	#endif
	#ifndef ROOT_TPrincipal	#ifndef ROOT_TPrincipal
	#include "TPrincipal.h"	#include "TPrincipal.h"
	#endif	#endif

		#ifndef ROOT_TRandom3
		#include "TRandom3.h"
		#endif

	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif
	#ifndef ROOT_TMVA_VariableInfo	#ifndef ROOT_TMVA_VariableInfo
	#include "TMVA/VariableInfo.h"	#include "TMVA/VariableInfo.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Event	#ifndef ROOT_TMVA_Event
	#include "TMVA/Event.h"	#include "TMVA/Event.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class DataSet;	class DataSet;
	class DataSetInfo;	class DataSetInfo;
	class DataInputHandler;	class DataInputHandler;
	class TreeInfo;	class TreeInfo;
	class MsgLogger;	class MsgLogger;


		typedef std::vector< Event* > EventVector;
		typedef std::vector< EventVector > EventVectorOf
		Classes;
		typedef std::map<Types::ETreeType, EventVectorOfClasses > EventVectorOf
		ClassesOfTreeType;
		typedef std::map<Types::ETreeType, EventVector > EventVectorOf
		TreeType;

		typedef std::vector< Double_t > ValuePerClass
		;
		typedef std::map<Types::ETreeType, ValuePerClass > ValuePerClass
		OfTreeType;

		typedef std::vector< Int_t > NumberPerClas
		s;
		typedef std::map<Types::ETreeType, NumberPerClass > NumberPerClas
		sOfTreeType;

		// =============== maybe move these elswhere (e.g. into the tools )

		// =============== functors =======================

		class RandomGenerator {
		public:
		RandomGenerator( UInt_t seed ){
		fRandom.SetSeed( seed );
		}
		UInt_t operator() ( UInt_t n ) {
		return fRandom.Integer(n);
		}
		private:
		TRandom3 fRandom; // random generator
		};

		// delete-functor (to be used in e.g. for_each algorithm)
		template<class T>
		struct DeleteFunctor_t
		{
		DeleteFunctor_t& operator()(T* p) {
		delete p;
		return *this;
		}
		};

		template<class T>
		DeleteFunctor_t<T> DeleteFunctor()
		{
		return DeleteFunctor_t<T>();
		}

		template< typename T >
		class Increment {
		T value;
		public:
		Increment( T start ) : value( start ){ }
		T operator()() {
		return value++;
		}
		};

		template <typename F>
		class null_t
		{
		private:
		// returns argF
		public:
		typedef F argument_type;
		F operator()(const F& argF) const
		{
		return argF;
		}
		};

		template <typename F>
		inline null_t<F> null() {
		return null_t<F>();
		}

		template <typename F, typename G, typename H>
		class compose_binary_t : public std::binary_function<typename G::argumen
		t_type,
		typename H::argumen
		t_type,
		typename F::result_
		type>
		{
		private:
		const F& f; // f(g(argG),h(argH))
		const G& g;
		const H& h;
		public:
		compose_binary_t(const F& _f, const G& _g, const H& _h) : f(_f), g(_g
		), h(_h)
		{
		}

		typename F::result_type operator()(const typename G::argument_type& a
		rgG,
		const typename H::argument_type& a
		rgH) const
		{
		return f(g(argG),h(argH));
		}
		};

		template <typename F, typename G, typename H>
		inline compose_binary_t<F,G,H> compose_binary(const F& _f, const G& _g,
		const H& _h) {
		return compose_binary_t<F,G,H>(_f,_g,_h);
		}

		template <typename F, typename G>
		class compose_unary_t : public std::unary_function<typename G::argument_
		type,
		typename F::result_ty
		pe>
		{
		private:
		const F& f; // f(g(argG))
		const G& g;
		public:
		compose_unary_t(const F& _f, const G& _g) : f(_f), g(_g)
		{
		}

		typename F::result_type operator()(const typename G::argument_type&
		argG) const
		{
		return f(g(argG));
		}
		};

		template <typename F, typename G>
		inline compose_unary_t<F,G> compose_unary(const F& _f, const G& _g) {
		return compose_unary_t<F,G>(_f,_g);
		}

		// =============== functors =======================

		// =========================================================

	class DataSetFactory {	class DataSetFactory {

	public:	public:

	// singleton class	// singleton class
	static DataSetFactory& Instance() { if (!fgInstance) fgInstance = new DataSetFactory(); return *fgInstance; }	static DataSetFactory& Instance() { if (!fgInstance) fgInstance = new DataSetFactory(); return *fgInstance; }
	static void destroyInstance() { if (fgInstance) { delete fgInstance; fgInstance=0; } }	static void destroyInstance() { if (fgInstance) { delete fgInstance; fgInstance=0; } }

	DataSet* CreateDataSet( DataSetInfo &, DataInputHandler& );	DataSet* CreateDataSet( DataSetInfo &, DataInputHandler& );


	private:	protected:

	~DataSetFactory();	~DataSetFactory();

	DataSetFactory();	DataSetFactory();
	static DataSetFactory *fgInstance;	static DataSetFactory *fgInstance;

	DataSet* BuildInitialDataSet( DataSetInfo&, TMVA::DataInputHandler& );	DataSet* BuildInitialDataSet( DataSetInfo&, TMVA::DataInputHandler& );
	DataSet* BuildDynamicDataSet( DataSetInfo& );	DataSet* BuildDynamicDataSet( DataSetInfo& );


		#ifndef ALTERNATIVE_EVENT_VECTOR_BUILDING

	void BuildEventVector ( DataSetInfo& dsi,	void BuildEventVector ( DataSetInfo& dsi,
	DataInputHandler& dataInput,	DataInputHandler& dataInput,
	std::vector< std::vector< Event* > >& tmpEventVector,	std::vector< std::vector< Event* > >& tmpEventVector,
	std::vector<Double_t>& sumOfWeights,	std::vector<Double_t>& sumOfWeights,
	std::vector<Double_t>& nTempEvents,	std::vector<Double_t>& nTempEvents,
	std::vector<Double_t>& renormFactor,	std::vector<Double_t>& renormFactor,

	std::vector< std::vector< std::pair< Lo ng64_t, Types::ETreeType > > >& userDefinedEventTypes );	std::vector< std::vector< std::pair< L ong64_t, Types::ETreeType > > >& userDefinedEventTypes );

	DataSet* MixEvents ( DataSetInfo& dsi,	DataSet* MixEvents ( DataSetInfo& dsi,
	std::vector< std::vector< Event* > >& tmpEventVector,	std::vector< std::vector< Event* > >& tmpEventVector,
	std::vector< std::pair< Int_t, Int_t > >& nTrainTestEvents,	std::vector< std::pair< Int_t, Int_t > >& nTrainTestEvents,
	const TString& splitMode, UInt_t split Seed,	const TString& splitMode, UInt_t split Seed,
	std::vector<Double_t>& renormFactor,	std::vector<Double_t>& renormFactor,

	std::vector< std::vector< std::pair< Lo ng64_t, Types::ETreeType > > >& userDefinedEventTypes );	std::vector< std::vector< std::pair< L ong64_t, Types::ETreeType > > >& userDefinedEventTypes );

	void InitOptions ( DataSetInfo& dsi,	void InitOptions ( DataSetInfo& dsi,
	std::vector< std::pair< Int_t, Int_t > >& nTrainTestEvents,	std::vector< std::pair< Int_t, Int_t > >& nTrainTestEvents,
	TString& normMode, UInt_t& splitSeed, TString& splitMode );	TString& normMode, UInt_t& splitSeed, TString& splitMode );


		#else
		// ---------- new versions
		void BuildEventVector ( DataSetInfo& dsi,
		DataInputHandler& dataInput,
		EventVectorOfClassesOfTreeType& tmpEv
		entVector);

		DataSet* MixEvents ( DataSetInfo& dsi,
		EventVectorOfClassesOfTreeType& tmpEv
		entVector,
		NumberPerClassOfTreeType& nTrainTestE
		vents,
		const TString& splitMode,
		const TString& mixMode,
		const TString& normMode,
		UInt_t splitSeed);

		void RenormEvents ( DataSetInfo& dsi,
		EventVectorOfClassesOfTreeType& tmpEv
		entVector,
		const TString& normMode );

		void InitOptions ( DataSetInfo& dsi,
		NumberPerClassOfTreeType& nTrainTestE
		vents,
		TString& normMode, UInt_t& splitSeed,
		TString& splitMode, TString& mixMode );

		// ------------------------
		#endif

	// auxiliary functions to compute correlations	// auxiliary functions to compute correlations
	TMatrixD* CalcCorrelationMatrix( DataSet*, const UInt_t classNumber ) ;	TMatrixD* CalcCorrelationMatrix( DataSet*, const UInt_t classNumber ) ;
	TMatrixD* CalcCovarianceMatrix ( DataSet*, const UInt_t classNumber ) ;	TMatrixD* CalcCovarianceMatrix ( DataSet*, const UInt_t classNumber ) ;
	void CalcMinMax ( DataSet*, DataSetInfo& dsi );	void CalcMinMax ( DataSet*, DataSetInfo& dsi );

	// resets branch addresses to current event	// resets branch addresses to current event

	void ResetBranchAndEventAddresses( TTree* );	void ResetBranchAndEventAddresses( TTree* );
	void ResetCurrentTree() { fCurrentTree = 0; }	void ResetCurrentTree() { fCurrentTree = 0; }
	void ChangeToNewTree( TreeInfo&, const DataSetInfo & );	void ChangeToNewTree( TreeInfo&, const DataSetInfo & );
		Bool_t CheckTTreeFormula( TTreeFormula* ttf, const TString& expressio
		n, Bool_t& hasDollar );

	// verbosity	// verbosity
	Bool_t Verbose() { return fVerbose; }	Bool_t Verbose() { return fVerbose; }

	// data members	// data members

	// verbosity	// verbosity
	Bool_t fVerbose; //! Verbosity	Bool_t fVerbose; //! Verbosity
	TString fVerboseLevel; //! VerboseLevel	TString fVerboseLevel; //! VerboseLevel


End of changes. 11 change blocks.
	8 lines changed or deleted	195 lines changed or added

	DataSetInfo.h	DataSetInfo.h

	// // @(#)root/tmva $Id: DataSetInfo.h 29195 2009-06-24 10:39:49Z brun $	// // @(#)root/tmva $Id: DataSetInfo.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DataSetInfo *	* Class : DataSetInfo *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Contains all the data information *	* Contains all the data information *

	skipping to change at line 96	skipping to change at line 96
	// the data set	// the data set
	void ClearDataSet() const;	void ClearDataSet() const;
	DataSet* GetDataSet() const;	DataSet* GetDataSet() const;

	// ---	// ---
	// the variable data	// the variable data
	// ---	// ---
	VariableInfo& AddVariable( const TString& expression, const TStri ng& title = "", const TString& unit = "",	VariableInfo& AddVariable( const TString& expression, const TStri ng& title = "", const TString& unit = "",
	Double_t min = 0, Double_t max = 0, ch ar varType='F',	Double_t min = 0, Double_t max = 0, ch ar varType='F',
	Bool_t normalized = kTRUE, void* exter nal = 0 );	Bool_t normalized = kTRUE, void* exter nal = 0 );

		VariableInfo& AddVariable( const VariableInfo& varInfo );

	VariableInfo& AddTarget ( const TString& expression, const TStri ng& title, const TString& unit,	VariableInfo& AddTarget ( const TString& expression, const TStri ng& title, const TString& unit,
	Double_t min, Double_t max, Bool_t nor malized = kTRUE, void* external = 0 );	Double_t min, Double_t max, Bool_t nor malized = kTRUE, void* external = 0 );

		VariableInfo& AddTarget ( const VariableInfo& varInfo );

	VariableInfo& AddSpectator ( const TString& expression, const TSt ring& title, const TString& unit,	VariableInfo& AddSpectator ( const TString& expression, const TSt ring& title, const TString& unit,

	Double_t min, Double_t max, Bool_t nor	Double_t min, Double_t max, char typ
	malized = kTRUE, void* external = 0 );	e = 'F', Bool_t normalized = kTRUE, void* external = 0 );
		VariableInfo& AddSpectator ( const VariableInfo& varInfo );

	ClassInfo* AddClass ( const TString& className );	ClassInfo* AddClass ( const TString& className );

	// accessors	// accessors

	// general	// general
	std::vector<VariableInfo>& GetVariableInfos() { return fVariables; }	std::vector<VariableInfo>& GetVariableInfos() { return fVariables; }
	const std::vector<VariableInfo>& GetVariableInfos() const { return fVariables; }	const std::vector<VariableInfo>& GetVariableInfos() const { return fVariables; }
	VariableInfo& GetVariableInfo( Int_t i ) { return fVariables.at(i); }	VariableInfo& GetVariableInfo( Int_t i ) { return fVariables.at(i); }
	const VariableInfo& GetVariableInfo( Int_t i ) const { r eturn fVariables.at(i); }	const VariableInfo& GetVariableInfo( Int_t i ) const { r eturn fVariables.at(i); }

	skipping to change at line 123	skipping to change at line 128
	VariableInfo& GetTargetInfo( Int_t i ) { return fT argets.at(i); }	VariableInfo& GetTargetInfo( Int_t i ) { return fT argets.at(i); }
	const VariableInfo& GetTargetInfo( Int_t i ) const { ret urn fTargets.at(i); }	const VariableInfo& GetTargetInfo( Int_t i ) const { ret urn fTargets.at(i); }

	std::vector<VariableInfo>& GetSpectatorInfos() { return fSpectators; }	std::vector<VariableInfo>& GetSpectatorInfos() { return fSpectators; }
	const std::vector<VariableInfo>& GetSpectatorInfos() const { return fSpectators; }	const std::vector<VariableInfo>& GetSpectatorInfos() const { return fSpectators; }
	VariableInfo& GetSpectatorInfo( Int_t i ) { return fSpectators.at(i); }	VariableInfo& GetSpectatorInfo( Int_t i ) { return fSpectators.at(i); }
	const VariableInfo& GetSpectatorInfo( Int_t i ) const { return fSpectators.at(i); }	const VariableInfo& GetSpectatorInfo( Int_t i ) const { return fSpectators.at(i); }

	UInt_t GetNVariables() const { return fV ariables.size(); }	UInt_t GetNVariables() const { return fV ariables.size(); }
	UInt_t GetNTargets() const { return fT argets.size(); }	UInt_t GetNTargets() const { return fT argets.size(); }

	UInt_t GetNSpectators() const { return fSpectators.size(); }	UInt_t GetNSpectators(bool all=kTRUE) con st;

	const TString& GetNormalization() const { return fN ormalization; }	const TString& GetNormalization() const { return fN ormalization; }

	void SetNormalization( TString& norm ) { fNormalization = norm; }	void SetNormalization( const TString& nor m ) { fNormalization = norm; }

	// classification information	// classification information
	Int_t GetClassNameMaxLength() const;	Int_t GetClassNameMaxLength() const;
	ClassInfo* GetClassInfo( Int_t clNum ) const;	ClassInfo* GetClassInfo( Int_t clNum ) const;
	ClassInfo* GetClassInfo( const TString& name ) const;	ClassInfo* GetClassInfo( const TString& name ) const;
	void PrintClasses() const;	void PrintClasses() const;
	UInt_t GetNClasses() const { return fClasses.size(); }	UInt_t GetNClasses() const { return fClasses.size(); }
	Bool_t IsSignal( const Event* ev ) const;	Bool_t IsSignal( const Event* ev ) const;

	// by variable	// by variable

End of changes. 6 change blocks.
	5 lines changed or deleted	10 lines changed or added

	DecisionTreeNode.h	DecisionTreeNode.h

	// @(#)root/tmva $Id: DecisionTreeNode.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: DecisionTreeNode.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : DecisionTreeNode *	* Class : DecisionTreeNode *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Node for the Decision Tree *	* Node for the Decision Tree *

	skipping to change at line 43	skipping to change at line 43
	// DecisionTreeNode //	// DecisionTreeNode //
	// //	// //
	// Node for the Decision Tree //	// Node for the Decision Tree //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMVA_Node	#ifndef ROOT_TMVA_Node
	#include "TMVA/Node.h"	#include "TMVA/Node.h"
	#endif	#endif


		#ifndef ROOT_TMVA_Version
		#include "TMVA/Version.h"
		#endif

	#include <vector>	#include <vector>
	#include <map>	#include <map>
	namespace TMVA {	namespace TMVA {

	class Event;	class Event;
	class MsgLogger;	class MsgLogger;

	class DecisionTreeNode: public Node {	class DecisionTreeNode: public Node {

	public:	public:

	skipping to change at line 251	skipping to change at line 255
	void SetCC(Double_t cc) {fCC = cc;};	void SetCC(Double_t cc) {fCC = cc;};
	Double_t GetCC() const {return fCC;};	Double_t GetCC() const {return fCC;};

	Float_t GetSampleMin(UInt_t ivar) const;	Float_t GetSampleMin(UInt_t ivar) const;
	Float_t GetSampleMax(UInt_t ivar) const;	Float_t GetSampleMax(UInt_t ivar) const;
	void SetSampleMin(UInt_t ivar, Float_t xmin);	void SetSampleMin(UInt_t ivar, Float_t xmin);
	void SetSampleMax(UInt_t ivar, Float_t xmax);	void SetSampleMax(UInt_t ivar, Float_t xmax);

	private:	private:


	virtual void ReadAttributes(void* node);	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM
	virtual Bool_t ReadDataRecord( istream& is );	VA_VERSION_CODE );
		virtual Bool_t ReadDataRecord( istream& is, UInt_t tmva_Version_Code
		= TMVA_VERSION_CODE );
	virtual void ReadContent(std::stringstream& s);	virtual void ReadContent(std::stringstream& s);

	Double_t fNodeR; // node resubstitution estimate, R(t)	Double_t fNodeR; // node resubstitution estimate, R(t)
	Double_t fSubTreeR; // R(T) = Sum(R(t) : t in ~T)	Double_t fSubTreeR; // R(T) = Sum(R(t) : t in ~T)
	Double_t fAlpha; // critical alpha for this node	Double_t fAlpha; // critical alpha for this node
	Double_t fG; // minimum alpha in subtree rooted at this node	Double_t fG; // minimum alpha in subtree rooted at this node
	Int_t fNTerminal; // number of terminal nodes in subtree roo ted at this node	Int_t fNTerminal; // number of terminal nodes in subtree roo ted at this node
	Double_t fNB; // sum of weights of background events fro m the pruning sample in this node	Double_t fNB; // sum of weights of background events fro m the pruning sample in this node
	Double_t fNS; // ditto for the signal events	Double_t fNS; // ditto for the signal events


End of changes. 3 change blocks.
	3 lines changed or deleted	9 lines changed or added

	Event.h	Event.h

	// @(#)root/tmva $Id: Event.h 29205 2009-06-24 19:33:19Z brun $	// @(#)root/tmva $Id: Event.h 31800 2009-12-10 15:04:44Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Event *	* Class : Event *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Event container *	* Event container *

	skipping to change at line 42	skipping to change at line 42
	#include <iosfwd>	#include <iosfwd>
	#include <vector>	#include <vector>

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif


		class TCut;

	namespace TMVA {	namespace TMVA {

	class Event;	class Event;

	std::ostream& operator<<( std::ostream& os, const Event& event );	std::ostream& operator<<( std::ostream& os, const Event& event );

	std::ostream& operator<<( std::ostream& os, const Event* event );

	class Event {	class Event {

	friend std::ostream& operator<<( std::ostream& os, const Event& event );	friend std::ostream& operator<<( std::ostream& os, const Event& event );

	friend std::ostream& operator<<( std::ostream& os, const Event* event );

	public:	public:

	// constructors	// constructors
	Event();	Event();
	Event( const Event& );	Event( const Event& );

	explicit Event( const std::vector<Float_t>&,	explicit Event( const std::vector<Float_t>& values,
	const std::vector<Float_t>& targetValues,	const std::vector<Float_t>& targetValues,
	const std::vector<Float_t>& spectatorValues,	const std::vector<Float_t>& spectatorValues,
	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );

	explicit Event( const std::vector<Float_t>&,	explicit Event( const std::vector<Float_t>& values,
	const std::vector<Float_t>& targetValues,	const std::vector<Float_t>& targetValues,
	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );	UInt_t theClass = 0, Float_t weight = 1.0, Float_t bo ostweight = 1.0 );
	explicit Event( const std::vector<Float_t>&,	explicit Event( const std::vector<Float_t>&,
	UInt_t theClass, Float_t weight = 1.0, Float_t boostw eight = 1.0 );	UInt_t theClass, Float_t weight = 1.0, Float_t boostw eight = 1.0 );

	explicit Event( const std::vector<Float_t>& );	explicit Event( const std::vector<Float_t>&, UInt_t nvar );

	~Event();	~Event();

	// accessors	// accessors
	Bool_t IsSignal() const { return (fClass==fSignalClass); } // deprecated: use <DataSetInfo>.IsSignal( Event* )	Bool_t IsSignal() const { return (fClass==fSignalClass); } // deprecated: use <DataSetInfo>.IsSignal( Event* )

		Bool_t IsDynamic() const {return fDynamic; }

	Float_t GetWeight() const { return fWeight*fBoostWeight; }	Float_t GetWeight() const { return fWeight*fBoostWeight; }
	Float_t GetOriginalWeight() const { return fWeight; }	Float_t GetOriginalWeight() const { return fWeight; }
	Float_t GetBoostWeight() const { return TMath::Max(Float_t(0.0001) ,fBoostWeight); }	Float_t GetBoostWeight() const { return TMath::Max(Float_t(0.0001) ,fBoostWeight); }

	UInt_t GetType() const { return GetClass(); } // better u se GetClass()
	UInt_t GetClass() const { return fClass; }	UInt_t GetClass() const { return fClass; }

	UInt_t Type() const { return fClass; } // backward com patible -> to be removed	Int_t GetSignalClass() const { return fSignalClass; } // interme diate solution to keep IsSignal() of Event working


	UInt_t GetNVariables() const { return fValues.size(); }	UInt_t GetNVariables() const;
	UInt_t GetNTargets() const { return fTargets.size(); }	UInt_t GetNTargets() const;
	UInt_t GetNSpectators() const { return fSpectators.size(); }	UInt_t GetNSpectators() const;
	UInt_t GetNVars() const { return fValues.size(); } // back
	ward compatible -> to be removed


	Float_t GetVal(UInt_t ivar) const;	const std::vector<UInt_t>* GetVariableArrangement() const { return fV
	Int_t GetSignalClass() const { return fSignalClass; } // interme	ariableArrangement; }
	diate solution to keep IsSignal() of Event working


		Float_t GetValue( UInt_t ivar) const;
	const std::vector<Float_t>& GetValues() const;	const std::vector<Float_t>& GetValues() const;


	Float_t GetValue ( UInt_t ivar) const { return GetVal( ivar	Float_t GetTarget( UInt_t itgt ) const { return fTargets.at(itgt); }
	); }	std::vector<Float_t>& GetTargets() const { return fTargets; }

		Float_t GetSpectator( UInt_t ivar) const;
		std::vector<Float_t>& GetSpectators() const { return fSpectators; }


	void ScaleWeight ( Float_t s ) { fWeight*=s; }	void ScaleWeight ( Float_t s ) { fWeight*=s; }
	void SetWeight ( Float_t w ) { fWeight=w; }	void SetWeight ( Float_t w ) { fWeight=w; }
	void SetBoostWeight ( Float_t w ) { fBoostWeight=w; }	void SetBoostWeight ( Float_t w ) { fBoostWeight=w; }
	void ScaleBoostWeight ( Float_t s ) { fBoostWeight *= s; }	void ScaleBoostWeight ( Float_t s ) { fBoostWeight *= s; }
	void SetType ( Int_t t ) { SetClass(t); }	void SetClass ( UInt_t t ) { fClass=t; }
	void SetClass ( UInt_t t ) { fClass=t; }	void SetVal ( UInt_t ivar, Float_t val );
	void SetType ( Types::ESBType t ) { fClass=(t==Types::kS	void SetTarget ( UInt_t itgt, Float_t value );
	ignal) ? 1 : 0; }	void SetSignalClass ( UInt_t cls ){ fSignalClass = cls; } /
	void SetVal ( UInt_t ivar, Float_t val );	/ intermediate solution to keep IsSignal() of Event working. TODO: remove I
	void SetValFloatNoCheck( UInt_t ivar, Float_t val ) { fValues[ivar	sSignal() from Event
	] = val; }	void SetSpectator ( UInt_t ivar, Float_t value );
		void SetVariableArrangement( std::vector<UInt_t>* const m ) const;
	void SetSignalClass ( UInt_t cls ){ fSignalClass = cls; } // in
	termediate solution to keep IsSignal() of Event working. TODO: remove IsSig
	nal() from Event

	void SetTarget( UInt_t itgt, Float_t value ) {
	if (fTargets.size() <= itgt) fTargets.resize( itgt+1 );
	fTargets.at(itgt) = value;
	}
	std::vector<Float_t>& GetTargets() const { return fTarget
	s; }
	Float_t GetTarget( UInt_t itgt ) const { return fTarget
	s.at(itgt); }

	void SetSpectator( UInt_t ivar, Float_t value ) {
	if (fSpectators.size() <= ivar) fSpectators.resize( ivar+1 );
	fSpectators.at(ivar) = value;
	}
	std::vector<Float_t>& GetSpectators() const { return fSpec
	tators; }
	Float_t GetSpectator( UInt_t ivar) const { return fSpec
	tators.at(ivar); }

	static void ClearDynamicVariables();	static void ClearDynamicVariables();

	void CopyVarValues( const Event& other );	void CopyVarValues( const Event& other );
	void Print ( std::ostream & o ) const;	void Print ( std::ostream & o ) const;

	private:	private:


	mutable std::vector<Float_t> fValues; // the event values	mutable std::vector<Float_t> fValues; // the event va
	static std::vector<Float_t> fgValuesDynamic; // the event values	lues
	mutable std::vector<Float_t> fTargets; // target values for	static std::vector<Float_t> fgValuesDynamic; // the event va
	regression	lues
		mutable std::vector<Float_t> fTargets; // target value
	mutable std::vector<Float_t> fSpectators; // "visisting" var	s for regression
	iables which are never used for any calculation	mutable std::vector<Float_t> fSpectators; // "visisting"
		variables which are never used for any calculation
		mutable std::vector<UInt_t>* fVariableArrangement; // needed for M
		ethodCategories, where we can train on other than the main variables

	UInt_t fClass; // signal or backgro und type: signal=1, background=0	UInt_t fClass; // signal or backgro und type: signal=1, background=0
	Float_t fWeight; // event weight (pro duct of global and individual weights)	Float_t fWeight; // event weight (pro duct of global and individual weights)
	Float_t fBoostWeight; // internal weight t o be set by boosting algorithm	Float_t fBoostWeight; // internal weight t o be set by boosting algorithm
	Bool_t fDynamic; // is set when the d ynamic values are taken	Bool_t fDynamic; // is set when the d ynamic values are taken


	UInt_t fSignalClass; // intermediate solu tion to keep IsSignal() of Event working. TODO: remove IsSignal() from Even t	UInt_t fSignalClass; // intermediate solu tion to keep IsSignal() of Event working. TODO: remove IsSignal() from Even t

	static Int_t fgCount; // count instances o f Event	static Int_t fgCount; // count instances o f Event
	};	};
	}	}

	#endif	#endif

End of changes. 17 change blocks.
	59 lines changed or deleted	41 lines changed or added

	FitMethodFunction.h	FitMethodFunction.h

	// @(#)root/mathcore:$Id: FitMethodFunction.h 26014 2008-10-29 16:37:28Z mo neta $	// @(#)root/mathcore:$Id: FitMethodFunction.h 31763 2009-12-10 10:40:21Z mo neta $
	// Author: L. Moneta Thu Aug 16 15:40:28 2007	// Author: L. Moneta Thu Aug 16 15:40:28 2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class FitMethodFunction	// Header file for class FitMethodFunction

	skipping to change at line 98	skipping to change at line 98
	reset number of function calls	reset number of function calls
	*/	*/
	virtual void ResetNCalls() { fNCalls = 0; }	virtual void ResetNCalls() { fNCalls = 0; }

	public:	public:

	protected:	protected:

	private:	private:


	unsigned int fNDim;	unsigned int fNDim; // function dimension
	unsigned int fNPoints; // size of the data	unsigned int fNPoints; // size of the data

	mutable unsigned int fNCalls;	mutable unsigned int fNCalls; // number of function calls

	};	};

	// define the normal and gradient function	// define the normal and gradient function
	typedef BasicFitMethodFunction<ROOT::Math::IMultiGenFunction> FitMet hodFunction;	typedef BasicFitMethodFunction<ROOT::Math::IMultiGenFunction> FitMet hodFunction;
	typedef BasicFitMethodFunction<ROOT::Math::IMultiGradFunction> FitMet hodGradFunction;	typedef BasicFitMethodFunction<ROOT::Math::IMultiGradFunction> FitMet hodGradFunction;

	} // end namespace Math	} // end namespace Math

	} // end namespace ROOT	} // end namespace ROOT

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	Fitter.h	Fitter.h

	// @(#)root/mathcore:$Id: Fitter.h 28946 2009-06-11 15:39:14Z moneta $	// @(#)root/mathcore:$Id: Fitter.h 31873 2009-12-14 10:05:39Z brun $
	// Author: L. Moneta Wed Aug 30 11:05:19 2006	// Author: L. Moneta Wed Aug 30 11:05:19 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Fitter	// Header file for class Fitter

	skipping to change at line 257	skipping to change at line 257
	or is not defined (like in case of fitting through a ::FitFCN)	or is not defined (like in case of fitting through a ::FitFCN)
	*/	*/
	bool IsBinFit() const { return fBinFit; }	bool IsBinFit() const { return fBinFit; }

	/**	/**
	return pointer to last used minimizer	return pointer to last used minimizer
	(is NULL in case fit is not yet done)	(is NULL in case fit is not yet done)
	This pointer will be valid as far as the data, the objective function	This pointer will be valid as far as the data, the objective function
	and the fitter class have not been deleted.	and the fitter class have not been deleted.
	To be used only after fitting.	To be used only after fitting.

		The pointer should not be stored and will be invalided after performi
		ng a new fitting.
		In this case a new instance of ROOT::Math::Minimizer will be re-creat
		ed and can be
		obtained calling again GetMinimizer()
	*/	*/
	ROOT::Math::Minimizer * GetMinimizer() { return fMinimizer.get(); }	ROOT::Math::Minimizer * GetMinimizer() { return fMinimizer.get(); }

	/**	/**
	return pointer to last used objective function	return pointer to last used objective function
	(is NULL in case fit is not yet done)	(is NULL in case fit is not yet done)
	This pointer will be valid as far as the data and the fitter class	This pointer will be valid as far as the data and the fitter class

	have not been deleted. To be used after the fitting	have not been deleted. To be used after the fitting.
		The pointer should not be stored and will be invalided after performi
		ng a new fitting.
		In this case a new instance of the function pointer will be re-create
		d and can be
		obtained calling again GetFCN()
	*/	*/
	ROOT::Math::IMultiGenFunction * GetFCN() { return fObjFunction.get(); }	ROOT::Math::IMultiGenFunction * GetFCN() { return fObjFunction.get(); }

	protected:	protected:

	/// least square fit	/// least square fit
	bool DoLeastSquareFit(const BinData & data);	bool DoLeastSquareFit(const BinData & data);
	/// binned likelihood fit	/// binned likelihood fit
	bool DoLikelihoodFit(const BinData & data);	bool DoLikelihoodFit(const BinData & data);
	/// un-binned likelihood fit	/// un-binned likelihood fit

End of changes. 3 change blocks.
	3 lines changed or deleted	12 lines changed or added

	GeneticGenes.h	GeneticGenes.h

	// @(#)root/tmva $Id: GeneticGenes.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: GeneticGenes.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Peter Speckmayer	// Author: Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : GeneticGenes *	* Class : GeneticGenes *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Genes definition for genetic algorithm *	* Genes definition for genetic algorithm *

	skipping to change at line 54	skipping to change at line 54

	public:	public:

	GeneticGenes():fFitness(0) {}	GeneticGenes():fFitness(0) {}
	GeneticGenes( std::vector<Double_t> & f );	GeneticGenes( std::vector<Double_t> & f );
	virtual ~GeneticGenes() {}	virtual ~GeneticGenes() {}

	std::vector<Double_t>& GetFactors() { return fFactors; }	std::vector<Double_t>& GetFactors() { return fFactors; }

	void SetFitness(Double_t fitness) { fFitness = fitness; }	void SetFitness(Double_t fitness) { fFitness = fitness; }

	Double_t GetFitness() { return fFitness; }	Double_t GetFitness() const { return fFitness; }

	friend Bool_t operator <(const GeneticGenes&, const GeneticGenes&);	friend Bool_t operator <(const GeneticGenes&, const GeneticGenes&);

	private:	private:

	std::vector<Double_t> fFactors; // stores the factors (coefficients) of one individual	std::vector<Double_t> fFactors; // stores the factors (coefficients) of one individual
	Double_t fFitness;	Double_t fFitness;

	ClassDef(GeneticGenes,0) // Genes definition for genetic algorithm	ClassDef(GeneticGenes,0) // Genes definition for genetic algorithm
	};	};

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	GeneticPopulation.h	GeneticPopulation.h

	// @(#)root/tmva $Id: GeneticPopulation.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: GeneticPopulation.h 31574 2009-12-05 18:23:21Z stelze r $
	// Author: Peter Speckmayer	// Author: Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : GeneticPopulation *	* Class : GeneticPopulation *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Population definition for genetic algorithm *	* Population definition for genetic algorithm *

	skipping to change at line 62	skipping to change at line 62
	class TH1F;	class TH1F;

	namespace TMVA {	namespace TMVA {

	class MsgLogger;	class MsgLogger;

	class GeneticPopulation {	class GeneticPopulation {

	public:	public:


	GeneticPopulation(const std::vector<Interval*>& ranges, Int_t size, U Int_t seed = 0);	GeneticPopulation(const std::vector<TMVA::Interval*>& ranges, Int_t s ize, UInt_t seed = 0);
	virtual ~GeneticPopulation();	virtual ~GeneticPopulation();

	void SetRandomSeed( UInt_t seed = 0);	void SetRandomSeed( UInt_t seed = 0);

	void MakeChildren();	void MakeChildren();
	void Mutate( Double_t probability = 20, Int_t startIndex = 0, Bool_t near = kFALSE,	void Mutate( Double_t probability = 20, Int_t startIndex = 0, Bool_t near = kFALSE,
	Double_t spread = 0.1, Bool_t mirror = kFALSE );	Double_t spread = 0.1, Bool_t mirror = kFALSE );

	GeneticGenes* GetGenes( Int_t index );	GeneticGenes* GetGenes( Int_t index );
	Int_t GetPopulationSize() const { return fGenePool.size(); }	Int_t GetPopulationSize() const { return fGenePool.size(); }

		Double_t GetFitness() const { return fGenePool.size()>0? fGenePo
		ol[0].GetFitness() : 0; }

		const std::vector<TMVA::GeneticGenes>& GetGenePool() const { return f
		GenePool; }
		const std::vector<TMVA::GeneticRange*>& GetRanges() const { return fR
		anges; }

	std::vector<TMVA::GeneticGenes>& GetGenePool() { return fGenePool; }	std::vector<TMVA::GeneticGenes>& GetGenePool() { return fGenePool; }
	std::vector<TMVA::GeneticRange*>& GetRanges() { return fRanges; }	std::vector<TMVA::GeneticRange*>& GetRanges() { return fRanges; }

	void Print( Int_t untilIndex = -1 );	void Print( Int_t untilIndex = -1 );
	void Print( ostream & out, Int_t utilIndex = -1 );	void Print( ostream & out, Int_t utilIndex = -1 );

	TH1F* VariableDistribution( Int_t varNumber, Int_t bins, Int_t min, I nt_t max );	TH1F* VariableDistribution( Int_t varNumber, Int_t bins, Int_t min, I nt_t max );
	std::vector< Double_t > VariableDistribution( Int_t varNumber );	std::vector< Double_t > VariableDistribution( Int_t varNumber );


End of changes. 3 change blocks.
	2 lines changed or deleted	9 lines changed or added

	HypoTestInverter.h	HypoTestInverter.h

	// @(#)root/roostats:$Id: HypoTestInverter.h 31322 2009-11-19 16:47:43Z mon eta $	// @(#)root/roostats:$Id: HypoTestInverter.h 31798 2009-12-10 14:57:15Z mon eta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_HypoTestInverter	#ifndef ROOSTATS_HypoTestInverter

	skipping to change at line 38	skipping to change at line 38
	namespace RooStats {	namespace RooStats {

	class HypoTestInverter : public IntervalCalculator, public TNamed {	class HypoTestInverter : public IntervalCalculator, public TNamed {

	public:	public:

	// default constructor (used only for I/O)	// default constructor (used only for I/O)
	HypoTestInverter();	HypoTestInverter();

	// constructor	// constructor

	HypoTestInverter( const char* name,	HypoTestInverter( HypoTestCalculator& myhc0,
	HypoTestCalculator* myhc0,	RooRealVar& scannedVariable,
	RooRealVar* scannedVariable,
	double size = 0.05) ;	double size = 0.05) ;

	virtual HypoTestInverterResult* GetInterval() const { return fResults; } ;	virtual HypoTestInverterResult* GetInterval() const { return fResults; } ;


	bool RunAutoScan( double xMin, double xMax, double target, double epsil on=0.005, int numAlgorithm=0 );	bool RunAutoScan( double xMin, double xMax, double target, double epsil on=0.005, unsigned int numAlgorithm=0 );

	bool RunFixedScan( int nBins, double xMin, double xMax );	bool RunFixedScan( int nBins, double xMin, double xMax );

	bool RunOnePoint( double thisX );	bool RunOnePoint( double thisX );

	void UseCLs( bool on = true) { fUseCLs = on; if (fResults) fResults->Us eCLs(on); }	void UseCLs( bool on = true) { fUseCLs = on; if (fResults) fResults->Us eCLs(on); }

	virtual void SetData(RooAbsData &) { } // not needed	virtual void SetData(RooAbsData &) { } // not needed

	virtual void SetModel(const ModelConfig &) { } // not needed	virtual void SetModel(const ModelConfig &) { } // not needed

End of changes. 3 change blocks.
	5 lines changed or deleted	4 lines changed or added

	HypoTestInverterResult.h	HypoTestInverterResult.h

	// @(#)root/roostats:$Id: HypoTestInverterResult.h 31322 2009-11-19 16:47:4 3Z moneta $	// @(#)root/roostats:$Id: HypoTestInverterResult.h 31798 2009-12-10 14:57:1 5Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_HypoTestInverterResult	#ifndef ROOSTATS_HypoTestInverterResult
	#define ROOSTATS_HypoTestInverterResult	#define ROOSTATS_HypoTestInverterResult

	#ifndef ROOSTATS_SimpleInterval	#ifndef ROOSTATS_SimpleInterval
	#include "RooStats/SimpleInterval.h"	#include "RooStats/SimpleInterval.h"
	#endif	#endif


		#include "RooStats/HypoTestResult.h"

	class RooRealVar;	class RooRealVar;

	namespace RooStats {	namespace RooStats {

	class HypoTestInverterResult : public SimpleInterval {	class HypoTestInverterResult : public SimpleInterval {

	public:	public:

	// default constructor	// default constructor
	explicit HypoTestInverterResult(const char* name = 0);	explicit HypoTestInverterResult(const char* name = 0);

	skipping to change at line 46	skipping to change at line 48

	// function to return the value of the parameter of interest for the i^ th entry in the results	// function to return the value of the parameter of interest for the i^ th entry in the results
	double GetXValue( int index ) const ;	double GetXValue( int index ) const ;

	// function to return the value of the confidence level for the i^th en try in the results	// function to return the value of the confidence level for the i^th en try in the results
	double GetYValue( int index ) const ;	double GetYValue( int index ) const ;

	// function to return the estimated error on the value of the confidenc e level for the i^th entry in the results	// function to return the estimated error on the value of the confidenc e level for the i^th entry in the results
	double GetYError( int index ) const ;	double GetYError( int index ) const ;


		// return a pointer to the i^th result object
		HypoTestResult* GetResult( int index ) const ;

	// number of entries in the results array	// number of entries in the results array
	int ArraySize() const { return fXValues.size(); };	int ArraySize() const { return fXValues.size(); };

	// set the size of the test (rate of Type I error) (eg. 0.05 for a 95% Confidence Interval)	// set the size of the test (rate of Type I error) (eg. 0.05 for a 95% Confidence Interval)
	virtual void SetTestSize( Double_t size ) { fConfidenceLevel = 1.-size; }	virtual void SetTestSize( Double_t size ) { fConfidenceLevel = 1.-size; }

	// set the confidence level for the interval (eg. 0.95 for a 95% Confid ence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Confid ence Interval)
	virtual void SetConfidenceLevel( Double_t cl ) { fConfidenceLevel = cl; }	virtual void SetConfidenceLevel( Double_t cl ) { fConfidenceLevel = cl; }

	// flag to switch between using CLsb (default) or CLs as confidence lev el	// flag to switch between using CLsb (default) or CLs as confidence lev el
	void UseCLs( bool on = true ) { fUseCLs = on; }	void UseCLs( bool on = true ) { fUseCLs = on; }

	// lower and upper bound of the confidence interval (to get upper/lower limits, multiply the size( = 1-confidence level ) by 2	// lower and upper bound of the confidence interval (to get upper/lower limits, multiply the size( = 1-confidence level ) by 2
	Double_t LowerLimit();	Double_t LowerLimit();
	Double_t UpperLimit();	Double_t UpperLimit();

	// rough estimation of the error on the computed bound of the confidenc e interval	// rough estimation of the error on the computed bound of the confidenc e interval

		// Estimate of lower limit error
		//function evaluates only a rought error on the lower limit. Be careful
		when using this estimation
	Double_t LowerLimitEstimatedError();	Double_t LowerLimitEstimatedError();


		// Estimate of lower limit error
		//function evaluates only a rought error on the lower limit. Be careful
		when using this estimation
	Double_t UpperLimitEstimatedError();	Double_t UpperLimitEstimatedError();

	private:	private:


		// merge with the content of another HypoTestInverterResult object
		bool Add( HypoTestInverterResult otherResult );

	double CalculateEstimatedError(double target);	double CalculateEstimatedError(double target);
	int FindClosestPointIndex(double target);	int FindClosestPointIndex(double target);
	double FindInterpolatedLimit(double target);	double FindInterpolatedLimit(double target);

	protected:	protected:

	bool fUseCLs;	bool fUseCLs;
	bool fInterpolateLowerLimit;	bool fInterpolateLowerLimit;
	bool fInterpolateUpperLimit;	bool fInterpolateUpperLimit;


End of changes. 6 change blocks.
	1 lines changed or deleted	16 lines changed or added

	IMethod.h	IMethod.h

	// @(#)root/tmva $Id: IMethod.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: IMethod.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : IMethod *	* Class : IMethod *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Interface for all concrete MVA method implementations *	* Interface for all concrete MVA method implementations *

	skipping to change at line 80	skipping to change at line 80
	// ------- virtual member functions to be implemented by each MVA met hod	// ------- virtual member functions to be implemented by each MVA met hod
	// the name of the method	// the name of the method
	virtual const char *GetName() const = 0;	virtual const char *GetName() const = 0;

	// calculate the MVA value - some methods may return a per-event erro r estimate (unless: *err = -1)	// calculate the MVA value - some methods may return a per-event erro r estimate (unless: *err = -1)
	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;

	// training method	// training method
	virtual void Train( void ) = 0;	virtual void Train( void ) = 0;


	// write weights to output stream
	virtual void WriteWeightsToStream( std::ostream& ) const = 0;

	// read weights from output stream	// read weights from output stream
	virtual void ReadWeightsFromStream( std::istream& ) = 0;	virtual void ReadWeightsFromStream( std::istream& ) = 0;

	// write method specific monitoring histograms to target file	// write method specific monitoring histograms to target file
	virtual void WriteMonitoringHistosToFile( void ) const = 0;	virtual void WriteMonitoringHistosToFile( void ) const = 0;

	// make ROOT-independent C++ class for classifier response	// make ROOT-independent C++ class for classifier response
	virtual void MakeClass( const TString& classFileName = TString("") ) const = 0;	virtual void MakeClass( const TString& classFileName = TString("") ) const = 0;

	// create ranking	// create ranking

End of changes. 2 change blocks.
	4 lines changed or deleted	1 lines changed or added

	LikelihoodIntervalPlot.h	LikelihoodIntervalPlot.h

	// @(#)root/roostats:$Id: LikelihoodIntervalPlot.h 31276 2009-11-18 15:06:4 2Z moneta $	// @(#)root/roostats:$Id: LikelihoodIntervalPlot.h 31793 2009-12-10 14:43:5 1Z moneta $

	/*************************************************************************	/*************************************************************************
	* Project: RooStats *	* Project: RooStats *
	* Package: RooFit/RooStats *	* Package: RooFit/RooStats *
	* Authors: *	* Authors: *
	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *
	*************************************************************************	*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *

	skipping to change at line 43	skipping to change at line 43
	LikelihoodIntervalPlot();	LikelihoodIntervalPlot();

	LikelihoodIntervalPlot(LikelihoodInterval* theInterval);	LikelihoodIntervalPlot(LikelihoodInterval* theInterval);

	// Destructor of SamplingDistribution	// Destructor of SamplingDistribution
	virtual ~LikelihoodIntervalPlot();	virtual ~LikelihoodIntervalPlot();

	void SetLikelihoodInterval(LikelihoodInterval* theInterval);	void SetLikelihoodInterval(LikelihoodInterval* theInterval);
	void SetPlotParameters(const RooArgSet *params) ;	void SetPlotParameters(const RooArgSet *params) ;


		// set plot range (for 1D plot)
		void SetRange(double x1, double x2) { fXmin = x1; fXmax = x2; }
		// set plot range (for 2D plot)
		void SetRange(double x1, double y1, double x2, double y2) {
		fXmin = x1; fXmax = x2;
		fYmin = y1; fYmax = y2;
		}

		//set plot precision (when drawing a RooPlot)
		void SetPrecision(double eps) { fPrecision = eps; }

	void SetContourColor(const Color_t color) {fColor = color;}	void SetContourColor(const Color_t color) {fColor = color;}
	void SetLineColor(const Color_t color) {fLineColor = color;}	void SetLineColor(const Color_t color) {fLineColor = color;}
	void SetMaximum(const Double_t theMaximum) {fMaximum = theMaximum;}	void SetMaximum(const Double_t theMaximum) {fMaximum = theMaximum;}
	void SetNPoints(Int_t np) { fNPoints = np; }	void SetNPoints(Int_t np) { fNPoints = np; }


		// draw the likelihood interval or contour
		// for the 1D case a RooPlot is drawn by default of the profiled Log-Li
		kelihood ratio
		// if option "TF1" is used the objects is drawn using a TF1 scanning th
		e LL function in a
		// grid of the setetd points (by default
		// the TF1 can be costumized by setting maximum and the number of point
		s to scan
	void Draw(const Option_t *options=0);	void Draw(const Option_t *options=0);

	private:	private:

	Int_t fColor;	Int_t fColor;
	Int_t fFillStyle;	Int_t fFillStyle;
	Int_t fLineColor;	Int_t fLineColor;
	Int_t fNdimPlot;	Int_t fNdimPlot;
	Int_t fNPoints; // number of points used to scan the PL	Int_t fNPoints; // number of points used to scan the PL


	Double_t fMaximum;	Double_t fMaximum; // function maximum
		// ranges for plots
		Double_t fXmin;
		Double_t fXmax;
		Double_t fYmin;
		Double_t fYmax;
		Double_t fPrecision; // RooCurve precision

	LikelihoodInterval *fInterval;	LikelihoodInterval *fInterval;

	RooArgSet *fParamsPlot;	RooArgSet *fParamsPlot;

	protected:	protected:

	ClassDef(LikelihoodIntervalPlot,1) // Class containing the results of the IntervalCalculator	ClassDef(LikelihoodIntervalPlot,1) // Class containing the results of the IntervalCalculator
	};	};
	}	}

End of changes. 4 change blocks.
	2 lines changed or deleted	27 lines changed or added

	MethodANNBase.h	MethodANNBase.h

	// @(#)root/tmva $Id: MethodANNBase.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodANNBase.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Matt Jachowski	// Author: Andreas Hoecker, Matt Jachowski

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodANNBase *	* Class : MethodANNBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Artificial neural network base class for the discrimination of sign al *	* Artificial neural network base class for the discrimination of sign al *

	skipping to change at line 70	skipping to change at line 70
	#ifndef ROOT_TMVA_TActivation	#ifndef ROOT_TMVA_TActivation
	#include "TMVA/TActivation.h"	#include "TMVA/TActivation.h"
	#endif	#endif
	#ifndef ROOT_TMVA_TNeuron	#ifndef ROOT_TMVA_TNeuron
	#include "TMVA/TNeuron.h"	#include "TMVA/TNeuron.h"
	#endif	#endif
	#ifndef ROOT_TMVA_TNeuronInput	#ifndef ROOT_TMVA_TNeuronInput
	#include "TMVA/TNeuronInput.h"	#include "TMVA/TNeuronInput.h"
	#endif	#endif


		class TH1;
		class TH1F;

	namespace TMVA {	namespace TMVA {

	class MethodANNBase : public MethodBase {	class MethodANNBase : public MethodBase {

	public:	public:

	// constructors dictated by subclassing off of MethodBase	// constructors dictated by subclassing off of MethodBase
	MethodANNBase( const TString& jobName,	MethodANNBase( const TString& jobName,
	Types::EMVA methodType,	Types::EMVA methodType,
	const TString& methodTitle,	const TString& methodTitle,

	skipping to change at line 109	skipping to change at line 112
	if (fInputCalculator != NULL) delete fInputCalculator;	if (fInputCalculator != NULL) delete fInputCalculator;
	fInputCalculator = inputCalculator;	fInputCalculator = inputCalculator;
	}	}

	// this will have to be overridden by every subclass	// this will have to be overridden by every subclass
	virtual void Train() = 0;	virtual void Train() = 0;

	// print network, for debugging	// print network, for debugging
	virtual void PrintNetwork() const;	virtual void PrintNetwork() const;


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	virtual void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// read weights from file	// read weights from file
	virtual void ReadWeightsFromStream( istream& istr );	virtual void ReadWeightsFromStream( istream& istr );

	// calculate the MVA value	// calculate the MVA value
	virtual Double_t GetMvaValue( Double_t* err = 0 );	virtual Double_t GetMvaValue( Double_t* err = 0 );

	virtual const std::vector<Float_t> &GetRegressionValues();	virtual const std::vector<Float_t> &GetRegressionValues();

	skipping to change at line 158	skipping to change at line 159
	void PrintMessage( TString message, Bool_t force = kFALSE ) const ;	void PrintMessage( TString message, Bool_t force = kFALSE ) const ;
	void ForceNetworkCalculations();	void ForceNetworkCalculations();
	void WaitForKeyboard();	void WaitForKeyboard();

	// accessors	// accessors
	Int_t NumCycles() { return fNcycles; }	Int_t NumCycles() { return fNcycles; }
	TNeuron* GetInputNeuron(Int_t index) { return (TNeuron*)fInputL ayer->At(index); }	TNeuron* GetInputNeuron(Int_t index) { return (TNeuron*)fInputL ayer->At(index); }
	TNeuron* GetOutputNeuron( Int_t index = 0) { return fOutputNeurons.at (index); }	TNeuron* GetOutputNeuron( Int_t index = 0) { return fOutputNeurons.at (index); }

	// protected variables	// protected variables

	TObjArray* fNetwork; // TObjArray of TObjArrays representing n	TObjArray* fNetwork; // TObjArray of TObjArrays representi
	etwork	ng network
	TObjArray* fSynapses; // array of pointers to synapses, no stru	TObjArray* fSynapses; // array of pointers to synapses, no
	ctural data	structural data
	TActivation* fActivation; // activation function to be used for hid	TActivation* fActivation; // activation function to be used for
	den layers	hidden layers
	TActivation* fIdentity; // activation for input and output layers	TActivation* fIdentity; // activation for input and output la
	TRandom3* frgen; // random number generator for various us	yers
	es	TRandom3* frgen; // random number generator for variou
		s uses
	TNeuronInput* fInputCalculator; // input calculator for all neurons	TNeuronInput* fInputCalculator; // input calculator for all neurons

	// monitoring histograms	// monitoring histograms
	TH1F* fEstimatorHistTrain; // monitors convergence of training sample	TH1F* fEstimatorHistTrain; // monitors convergence of training sample
	TH1F* fEstimatorHistTest; // monitors convergence of independent tes t sample	TH1F* fEstimatorHistTest; // monitors convergence of independent tes t sample


	// the neuronal network can be initialized after the analysis type ha	// monitoring histograms (not available for regression)
	s been set.	void CreateWeightMonitoringHists( const TString& bulkname, std::vecto
	void SetAnalysisType( Types::EAnalysisType type );	r<TH1> hv = 0 ) const;
		std::vector<TH1*> fEpochMonHistS; // epoch monitoring hitograms for s
		ignal
		std::vector<TH1*> fEpochMonHistB; // epoch monitoring hitograms for b
		ackground
		std::vector<TH1*> fEpochMonHistW; // epoch monitoring hitograms for w
		eights

	private:	private:

	// helper functions for building network	// helper functions for building network
	void BuildLayers(std::vector<Int_t>* layout, Bool_t from_file = false );	void BuildLayers(std::vector<Int_t>* layout, Bool_t from_file = false );
	void BuildLayer(Int_t numNeurons, TObjArray* curLayer, TObjArray* pre vLayer,	void BuildLayer(Int_t numNeurons, TObjArray* curLayer, TObjArray* pre vLayer,
	Int_t layerIndex, Int_t numLayers, Bool_t from_file = false);	Int_t layerIndex, Int_t numLayers, Bool_t from_file = false);
	void AddPreLinks(TNeuron* neuron, TObjArray* prevLayer);	void AddPreLinks(TNeuron* neuron, TObjArray* prevLayer);

	// helper functions for weight initialization	// helper functions for weight initialization

	skipping to change at line 193	skipping to change at line 197

	// helper functions for deleting network	// helper functions for deleting network
	void DeleteNetwork();	void DeleteNetwork();
	void DeleteNetworkLayer(TObjArray*& layer);	void DeleteNetworkLayer(TObjArray*& layer);

	// debugging utilities	// debugging utilities
	void PrintLayer(TObjArray* layer) const;	void PrintLayer(TObjArray* layer) const;
	void PrintNeuron(TNeuron* neuron) const;	void PrintNeuron(TNeuron* neuron) const;

	// private variables	// private variables

	Int_t fNcycles; // number of epochs to train	Int_t fNcycles; // number of epochs to trai
	TString fNeuronType; // name of neuron activation function cl	n
	ass	TString fNeuronType; // name of neuron activatio
	TString fNeuronInputType; // name of neuron input calculator class	n function class
	TObjArray* fInputLayer; // cache this for fast access	TString fNeuronInputType; // name of neuron input cal
	std::vector<TNeuron*> fOutputNeurons; // cache this for fast acc	culator class
	ess	TObjArray* fInputLayer; // cache this for fast acce
	TString fLayerSpec; // layout specification option	ss
		std::vector<TNeuron*> fOutputNeurons; // cache this for fast acce
		ss
		TString fLayerSpec; // layout specification opt
		ion

	// some static flags	// some static flags
	static const Bool_t fgDEBUG = kTRUE; // debug flag	static const Bool_t fgDEBUG = kTRUE; // debug flag
	static const Bool_t fgFIXED_SEED = kFALSE; // fix rand generator see d	static const Bool_t fgFIXED_SEED = kFALSE; // fix rand generator see d

	ClassDef(MethodANNBase,0) // Base class for TMVA ANNs	ClassDef(MethodANNBase,0) // Base class for TMVA ANNs
	};	};

	} // namespace TMVA	} // namespace TMVA


End of changes. 7 change blocks.
	23 lines changed or deleted	35 lines changed or added

	MethodBDT.h	MethodBDT.h

	// @(#)root/tmva $Id: MethodBDT.h 29226 2009-06-25 15:18:50Z brun $	// @(#)root/tmva $Id: MethodBDT.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBDT (Boosted Decision Trees) *	* Class : MethodBDT (Boosted Decision Trees) *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Boosted Decision Trees *	* Analysis of Boosted Decision Trees *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German y *	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German y *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
	* Doug Schouten <dschoute@sfu.ca> - Simon Fraser U., Canada *	* Doug Schouten <dschoute@sfu.ca> - Simon Fraser U., Canada *

		* Jan Therhaag <jan.therhaag@cern.ch> - U. of Bonn, Germany *
	* *	* *
	* Copyright (c) 2005: *	* Copyright (c) 2005: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	skipping to change at line 87	skipping to change at line 88

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// write all Events from the Tree into a vector of Events, that are	// write all Events from the Tree into a vector of Events, that are
	// more easily manipulated	// more easily manipulated
	void InitEventSample();	void InitEventSample();

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML(void* parent);	void ReadWeightsFromXML(void* parent);

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0);	Double_t GetMvaValue( Double_t* err = 0);
	Double_t GetMvaValue( Double_t* err , UInt_t useNTrees );	Double_t GetMvaValue( Double_t* err , UInt_t useNTrees );

	// regression response	// regression response
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();

	// apply the boost algorithm to a tree in the collection	// apply the boost algorithm to a tree in the collection

	Double_t Boost( std::vector<Event>, DecisionTree dt, Int_t iTree );	Double_t Boost( std::vector<TMVA::Event>, DecisionTree dt, Int_t iT ree );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

	// get the forest	// get the forest
	inline const std::vector<TMVA::DecisionTree*> & GetForest() const;	inline const std::vector<TMVA::DecisionTree*> & GetForest() const;

	// get the forest	// get the forest

	inline const std::vector<Event*> & GetTrainingEvents() const;	inline const std::vector<TMVA::Event*> & GetTrainingEvents() const;

	inline const std::vector<double> & GetBoostWeights() const;	inline const std::vector<double> & GetBoostWeights() const;

	//return the individual relative variable importance	//return the individual relative variable importance
	std::vector<Double_t> GetVariableImportance();	std::vector<Double_t> GetVariableImportance();
	Double_t GetVariableImportance(UInt_t ivar);	Double_t GetVariableImportance(UInt_t ivar);

	Double_t TestTreeQuality( DecisionTree *dt );	Double_t TestTreeQuality( DecisionTree *dt );

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// header and auxiliary classes	// header and auxiliary classes
	void MakeClassSpecificHeader( std::ostream&, const TString& ) const;	void MakeClassSpecificHeader( std::ostream&, const TString& ) const;

	void MakeClassInstantiateNode( DecisionTreeNode *n, std::ostream& fou t,	void MakeClassInstantiateNode( DecisionTreeNode *n, std::ostream& fou t,
	const TString& className ) const;	const TString& className ) const;

	void GetHelpMessage() const;	void GetHelpMessage() const;


		protected:
		void DeclareCompatibilityOptions();

	private:	private:
	// Init used in the various constructors	// Init used in the various constructors
	void Init( void );	void Init( void );

	// boosting algorithm (adaptive boosting)	// boosting algorithm (adaptive boosting)

	Double_t AdaBoost( std::vector<Event>, DecisionTree dt );	Double_t AdaBoost( std::vector<TMVA::Event>, DecisionTree dt );

	// boosting as a random re-weighting	// boosting as a random re-weighting

	Double_t Bagging( std::vector<Event*>, Int_t iTree );	Double_t Bagging( std::vector<TMVA::Event*>, Int_t iTree );

	// boosting special for regression	// boosting special for regression

	Double_t RegBoost( std::vector<Event>, DecisionTree dt );	Double_t RegBoost( std::vector<TMVA::Event>, DecisionTree dt );

	// adaboost adapted to regression	// adaboost adapted to regression

	Double_t AdaBoostR2( std::vector<Event>, DecisionTree dt );	Double_t AdaBoostR2( std::vector<TMVA::Event>, DecisionTree dt );

	// binomial likelihood gradient boost for classification	// binomial likelihood gradient boost for classification
	// (see Friedman: "Greedy Function Approximation: a Gradient Boosting Machine"	// (see Friedman: "Greedy Function Approximation: a Gradient Boosting Machine"
	// Technical report, Dept. of Statistics, Stanford University)	// Technical report, Dept. of Statistics, Stanford University)

	Double_t GradBoost( std::vector<Event>, DecisionTree dt );	Double_t GradBoost( std::vector<TMVA::Event>, DecisionTree dt );
	void InitGradBoost( std::vector<Event*>);	Double_t GradBoostRegression(std::vector<TMVA::Event*>, DecisionTree
	void UpdateTargets( std::vector<Event*>);	*dt );
		void InitGradBoost( std::vector<TMVA::Event*>);
		void UpdateTargets( std::vector<TMVA::Event*>);
		void UpdateTargetsRegression( std::vector<TMVA::Event*>,Bool_t first=
		kFALSE);
	Double_t GetGradBoostMVA(TMVA::Event& e, UInt_t nTrees);	Double_t GetGradBoostMVA(TMVA::Event& e, UInt_t nTrees);
	void GetRandomSubSample();	void GetRandomSubSample();

		Double_t GetWeightedQuantile(std::vector<std::vector<Double_t> > &vec , const Double_t quantile, const Double_t SumOfWeights = 0.0);


	std::vector<Event*> fEventSample; // the training eve	std::vector<TMVA::Event*> fEventSample; // the training eve
	nts	nts
	std::vector<Event*> fValidationSample;// the Validation e	std::vector<TMVA::Event*> fValidationSample;// the Validation e
	vents	vents
	std::vector<Event*> fSubSample; // subsample for ba	std::vector<TMVA::Event*> fSubSample; // subsample for ba
	gged grad boost	gged grad boost

	Int_t fNTrees; // number of decisi on trees requested	Int_t fNTrees; // number of decisi on trees requested
	std::vector<DecisionTree*> fForest; // the collection o f decision trees	std::vector<DecisionTree*> fForest; // the collection o f decision trees
	std::vector<double> fBoostWeights; // the weights appl ied in the individual boosts	std::vector<double> fBoostWeights; // the weights appl ied in the individual boosts

		std::vector<double> fInitialWeights; // the initial even
		t weights
		std::vector<double> fRegResiduals; // temporary storag
		e for regression residuals
	TString fBoostType; // string specifyin g the boost type	TString fBoostType; // string specifyin g the boost type

		Double_t fSumOfWeights; // total sum of all event weights
	Double_t fAdaBoostBeta; // beta parameter f or AdaBoost algorithm	Double_t fAdaBoostBeta; // beta parameter f or AdaBoost algorithm
	TString fAdaBoostR2Loss; // loss type used i n AdaBoostR2 (Linear,Quadratic or Exponential)	TString fAdaBoostR2Loss; // loss type used i n AdaBoostR2 (Linear,Quadratic or Exponential)

		Double_t fTransitionPoint; // break-down point for gradient regression
	Double_t fShrinkage; // learning rate fo r gradient boost;	Double_t fShrinkage; // learning rate fo r gradient boost;
	Bool_t fBaggedGradBoost; // turn bagging in combination with grad boost on/off	Bool_t fBaggedGradBoost; // turn bagging in combination with grad boost on/off
	Double_t fSampleFraction; // fraction of even ts used for bagged grad boost	Double_t fSampleFraction; // fraction of even ts used for bagged grad boost

	//options for the decision Tree	//options for the decision Tree
	SeparationBase *fSepType; // the separation u sed in node splitting	SeparationBase *fSepType; // the separation u sed in node splitting
	TString fSepTypeS; // the separation ( option string) used in node splitting	TString fSepTypeS; // the separation ( option string) used in node splitting
	Int_t fNodeMinEvents; // min number of ev ents in node	Int_t fNodeMinEvents; // min number of ev ents in node

	Int_t fNCuts; // grid used in cut applied in node splitting	Int_t fNCuts; // grid used in cut applied in node splitting

	skipping to change at line 209	skipping to change at line 218
	Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted	Double_t fPruneStrength; // a parameter to set the "amount" of pruning..needs to be adjusted
	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig	DecisionTree::EPruneMethod fPruneMethod; // method used for prunig
	TString fPruneMethodS; // prune method op tion String	TString fPruneMethodS; // prune method op tion String
	Bool_t fPruneBeforeBoost;// flag to prune b efore boosting	Bool_t fPruneBeforeBoost;// flag to prune b efore boosting
	Double_t fFValidationEvents; // fraction o f events to use for pruning	Double_t fFValidationEvents; // fraction o f events to use for pruning
	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample	Bool_t fAutomatic; // use user given prune strength or automatically determined one using a validation sample
	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training	Bool_t fRandomisedTrees; // choose a random subset of possible cut variables at each node during training
	UInt_t fUseNvars; // the number of v ariables used in the randomised tree splitting	UInt_t fUseNvars; // the number of v ariables used in the randomised tree splitting
	UInt_t fUseNTrainEvents; // number of rando mly picked training events used in randomised (and bagged) trees	UInt_t fUseNTrainEvents; // number of rando mly picked training events used in randomised (and bagged) trees


	std::vector<Double_t> fVariableImportance; // the relative importance of the different variables	std::vector<Double_t> fVariableImportance; // the relative importance of the different variables

	// debugging flags	// debugging flags

	static const Int_t fgDebugLevel = 0; // debug level determining	static const Int_t fgDebugLevel; // debug level det
	some printout/control plots etc.	ermining some printout/control plots etc.

		// for backward compatibility

		Double_t fSampleSizeFraction; // relative siz
		e of bagged event sample to original sample size
		Bool_t fNoNegWeightsInTraining; // ignore n
		egative event weights in the training

	ClassDef(MethodBDT,0) // Analysis of Boosted Decision Trees	ClassDef(MethodBDT,0) // Analysis of Boosted Decision Trees

	};	};

	} // namespace TMVA	} // namespace TMVA

	const std::vector<TMVA::DecisionTree*>& TMVA::MethodBDT::GetForest() const { return fForest; }	const std::vector<TMVA::DecisionTree*>& TMVA::MethodBDT::GetForest() const { return fForest; }
	const std::vector<TMVA::Event*>& TMVA::MethodBDT::GetTrainingEvents( ) const { return fEventSample; }	const std::vector<TMVA::Event*>& TMVA::MethodBDT::GetTrainingEvents( ) const { return fEventSample; }
	const std::vector<double>& TMVA::MethodBDT::GetBoostWeights() const { return fBoostWeights; }	const std::vector<double>& TMVA::MethodBDT::GetBoostWeights() const { return fBoostWeights; }

	#endif	#endif

End of changes. 20 change blocks.
	22 lines changed or deleted	42 lines changed or added

	MethodBase.h	MethodBase.h

	// @(#)root/tmva $Id: MethodBase.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodBase.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBase *	* Class : MethodBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 44	skipping to change at line 44
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// MethodBase //	// MethodBase //
	// //	// //
	// Virtual base class for all TMVA method //	// Virtual base class for all TMVA method //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <iosfwd>	#include <iosfwd>
	#include <vector>	#include <vector>

		#include "assert.h"

	#ifndef ROOT_TMVA_IMethod	#ifndef ROOT_TMVA_IMethod
	#include "TMVA/IMethod.h"	#include "TMVA/IMethod.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Configurable	#ifndef ROOT_TMVA_Configurable
	#include "TMVA/Configurable.h"	#include "TMVA/Configurable.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif

	skipping to change at line 110	skipping to change at line 111
	virtual ~MethodBase();	virtual ~MethodBase();

	// declaration, processing and checking of configuration options	// declaration, processing and checking of configuration options
	void SetupMethod();	void SetupMethod();
	void ProcessSetup();	void ProcessSetup();
	virtual void CheckSetup(); // may be overwritten by derived class es	virtual void CheckSetup(); // may be overwritten by derived class es

	// ---------- main training and testing methods --------------------- ---------	// ---------- main training and testing methods --------------------- ---------

	// prepare tree branch with the method's discriminating variable	// prepare tree branch with the method's discriminating variable

	void AddOutput( Types::ETreeType type, Types::EAnalysisTy	void AddOutput( Types::ETreeType type, Types::EAnalysisTy
	pe analysisType ) {	pe analysisType );
	if (analysisType == Types::kRegression) AddRegressionOutput( type
	);
	else { AddClassifierOutput( type ); if (HasMVAPdfs()) AddClassifie
	rOutputProb( type ); }
	}

	// performs classifier training	// performs classifier training
	// calls methods Train() implemented by derived classes	// calls methods Train() implemented by derived classes
	void TrainMethod();	void TrainMethod();
	virtual void Train() = 0;	virtual void Train() = 0;

	// store and retrieve time used for training	// store and retrieve time used for training
	void SetTrainTime( Double_t trainTime ) { fTrainTime = tr ainTime; }	void SetTrainTime( Double_t trainTime ) { fTrainTime = tr ainTime; }
	Double_t GetTrainTime() const { return fTrainTime; }	Double_t GetTrainTime() const { return fTrainTime; }


	skipping to change at line 142	skipping to change at line 140
	virtual void TestRegression( Double_t& bias, Double_t& biasT,	virtual void TestRegression( Double_t& bias, Double_t& biasT,
	Double_t& dev, Double_t& devT,	Double_t& dev, Double_t& devT,
	Double_t& rms, Double_t& rmsT,	Double_t& rms, Double_t& rmsT,
	Double_t& mInf, Double_t& mInfT, // mutual information	Double_t& mInf, Double_t& mInfT, // mutual information
	Double_t& corr,	Double_t& corr,
	Types::ETreeType type );	Types::ETreeType type );

	// classifier response - some methods may return a per-event error es timate (unless: *err = -1)	// classifier response - some methods may return a per-event error es timate (unless: *err = -1)
	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;	virtual Double_t GetMvaValue( Double_t* err = 0 ) = 0;


		Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0
		);

	// options treatment	// options treatment
	virtual void Init() = 0;	virtual void Init() = 0;
	virtual void DeclareOptions() = 0;	virtual void DeclareOptions() = 0;
	virtual void ProcessOptions() = 0;	virtual void ProcessOptions() = 0;

		virtual void DeclareCompatibilityOptions(); // declaration of pas t options

	// regression response	// regression response
	virtual const std::vector<Float_t>& GetRegressionValues() {	virtual const std::vector<Float_t>& GetRegressionValues() {
	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);	std::vector<Float_t>* ptr = new std::vector<Float_t>(0);
	return (*ptr);	return (*ptr);
	}	}

	// probability of classifier response (mvaval) to be signal (requires "CreateMvaPdf" option set)	// probability of classifier response (mvaval) to be signal (requires "CreateMvaPdf" option set)
	virtual Double_t GetProba( Double_t mvaVal, Double_t ap_sig );	virtual Double_t GetProba( Double_t mvaVal, Double_t ap_sig );


	skipping to change at line 171	skipping to change at line 172

	// perfrom extra actions during the boosting at different stages	// perfrom extra actions during the boosting at different stages
	virtual Bool_t MonitorBoost(MethodBoost* /booster/) {return kFALS E;};	virtual Bool_t MonitorBoost(MethodBoost* /booster/) {return kFALS E;};

	// make ROOT-independent C++ class	// make ROOT-independent C++ class
	virtual void MakeClass( const TString& classFileName = TString("" ) ) const;	virtual void MakeClass( const TString& classFileName = TString("" ) ) const;

	// print help message	// print help message
	void PrintHelpMessage() const;	void PrintHelpMessage() const;


		//
	// streamer methods for training information (creates "weight" files) --------	// streamer methods for training information (creates "weight" files) --------

	// meta data characterising the method	//
	void WriteStateToFile () const;	public:
	void WriteStateToStream ( std::ostream& tf, Bool_t isCl	void WriteStateToFile () const;
	ass = kFALSE ) const; // obsolete	void ReadStateFromFile ();
	void WriteStateToStream ( TFile& rf ) const;
	// obsolete
	void WriteStateToXML ( void* parent ) const;

	void ReadStateFromFile ();
	void ReadStateFromStream ( std::istream& tf );
	// obsolete
	void ReadStateFromStream ( TFile& rf );
	// obsolete
	void ReadStateFromXML ( void* parent );

	// the variable information
	void WriteVarsToStream ( std::ostream& o, const TStrin
	g& prefix = "" ) const; // obsolete
	void AddVarsXMLTo ( void* parent ) const;
	void AddTargetsXMLTo ( void* parent ) const;

	void ReadVarsFromStream ( std::istream& istr );
	// obsolete
	void ReadVariablesFromXML ( void* varnode );
	void ReadTargetsFromXML ( void* tarnode );


		protected:
	// the actual "weights"	// the actual "weights"

	virtual void WriteWeightsToStream ( std::ostream& ) const = 0;	virtual void AddWeightsXMLTo ( void* parent ) const = 0;
	// obsolete	virtual void ReadWeightsFromXML ( void* wghtnode ) = 0;
	virtual void WriteWeightsToStream ( TFile& ) const {}	virtual void ReadWeightsFromStream( std::istream& ) = 0; // bac
	// obsolete	kward compatibility
	virtual void AddWeightsXMLTo ( void* parent ) const = 0;	virtual void ReadWeightsFromStream( TFile& ) {} // bac
		kward compatibility
	virtual void ReadWeightsFromStream( std::istream& ) = 0;
	// obsolete
	virtual void ReadWeightsFromStream( TFile& ) {}
	// obsolete
	virtual void ReadWeightsFromXML ( void* wghtnode ) = 0;


		private:
		friend class MethodCategory;
		friend class MethodCommittee;
		friend class MethodCompositeBase;
		void WriteStateToXML ( void* parent ) const;
		void ReadStateFromXML ( void* parent );
		void WriteStateToStream ( std::ostream& tf ) const; // needed for
		MakeClass
		void WriteVarsToStream ( std::ostream& tf, const TString& prefix =
		"" ) const; // needed for MakeClass
		void ReadStateFromStream ( std::istream& tf ); // backward c
		ompatibility
		void ReadStateFromStream ( TFile& rf ); // backward c
		ompatibility

		// the variable information
		void AddVarsXMLTo ( void* parent ) const;
		void AddSpectatorsXMLTo ( void* parent ) const;
		void AddTargetsXMLTo ( void* parent ) const;
		void ReadVariablesFromXML ( void* varnode );
		void ReadSpectatorsFromXML( void* specnode);
		void ReadTargetsFromXML ( void* tarnode );
		void ReadVarsFromStream ( std::istream& istr ); // backward c
		ompatibility

		public:
	// ------------------------------------------------------------------ ---------	// ------------------------------------------------------------------ ---------

	// write evaluation histograms into target file	// write evaluation histograms into target file

	virtual void WriteEvaluationHistosToFile();	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetyp e);

	// write classifier-specific monitoring information to target file	// write classifier-specific monitoring information to target file
	virtual void WriteMonitoringHistosToFile() const;	virtual void WriteMonitoringHistosToFile() const;

	// ---------- public evaluation methods ----------------------------- ---------	// ---------- public evaluation methods ----------------------------- ---------

	// individual initialistion for testing of each method	// individual initialistion for testing of each method
	// overload this one for individual initialisation of the testing,	// overload this one for individual initialisation of the testing,
	// it is then called automatically within the global "TestInit"	// it is then called automatically within the global "TestInit"


	skipping to change at line 244	skipping to change at line 250
	Types::EMVA GetMethodType () const { return fMethodType; }	Types::EMVA GetMethodType () const { return fMethodType; }
	const char* GetName () const { return fMethodName.Data( ); }	const char* GetName () const { return fMethodName.Data( ); }
	const TString& GetTestvarName () const { return fTestvar; }	const TString& GetTestvarName () const { return fTestvar; }
	const TString GetProbaName () const { return fTestvar + "_Prob a"; }	const TString GetProbaName () const { return fTestvar + "_Prob a"; }
	TString GetWeightFileName() const;	TString GetWeightFileName() const;

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t n umberClasses, UInt_t numberTargets ) = 0;	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t n umberClasses, UInt_t numberTargets ) = 0;

	// build classifier name in Test tree	// build classifier name in Test tree
	// MVA prefix (e.g., "TMVA_")	// MVA prefix (e.g., "TMVA_")

	void SetTestvarPrefix( TString prefix ) { fTestvarP	void SetTestvarName ( const TString & v="" ) { fTestvar
	refix = prefix; }	= (v=="") ? ("MVA_" + GetMethodName()) : v; }
	void SetTestvarName ( const TString & v="" ) { fTestvar
	= (v=="") ? (fTestvarPrefix + GetMethodName()) : v; }

	// number of input variable used by classifier	// number of input variable used by classifier
	UInt_t GetNvar() const { return DataInfo().GetNVariab les(); }	UInt_t GetNvar() const { return DataInfo().GetNVariab les(); }
	UInt_t GetNVariables() const { return DataInfo().GetNVariab les(); }	UInt_t GetNVariables() const { return DataInfo().GetNVariab les(); }
	UInt_t GetNTargets() const { return DataInfo().GetNTarget s(); };	UInt_t GetNTargets() const { return DataInfo().GetNTarget s(); };

	// internal names and expressions of input variables	// internal names and expressions of input variables
	const TString& GetInputVar ( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetInternalName(); }	const TString& GetInputVar ( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetInternalName(); }
	const TString& GetInputLabel( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetLabel(); }	const TString& GetInputLabel( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetLabel(); }
	const TString& GetInputTitle( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetTitle(); }	const TString& GetInputTitle( Int_t i ) const { return DataInfo().G etVariableInfo(i).GetTitle(); }

	skipping to change at line 273	skipping to change at line 278
	// sets the minimum requirement on the MVA output to declare an event signal-like	// sets the minimum requirement on the MVA output to declare an event signal-like
	Double_t GetSignalReferenceCut() const { return fSignalRefere nceCut; }	Double_t GetSignalReferenceCut() const { return fSignalRefere nceCut; }

	// sets the minimum requirement on the MVA output to declare an event signal-like	// sets the minimum requirement on the MVA output to declare an event signal-like
	void SetSignalReferenceCut( Double_t cut ) { fSignalRefer enceCut = cut; }	void SetSignalReferenceCut( Double_t cut ) { fSignalRefer enceCut = cut; }

	// pointers to ROOT directories	// pointers to ROOT directories
	TDirectory* BaseDir() const;	TDirectory* BaseDir() const;
	TDirectory* MethodBaseDir() const;	TDirectory* MethodBaseDir() const;
	void SetMethodDir ( TDirectory* methodDir ) { fBaseDir = fMethodBaseDir = methodDir; }	void SetMethodDir ( TDirectory* methodDir ) { fBaseDir = fMethodBaseDir = methodDir; }

		void SetBaseDir( TDirectory* methodDir ){ fBaseDir = meth
		odDir; }
		void SetMethodBaseDir( TDirectory* methodDir ){ fMethodBa
		seDir = methodDir; }

	// the TMVA version can be obtained and checked using	// the TMVA version can be obtained and checked using
	// if (GetTrainingTMVAVersionCode()>TMVA_VERSION(3,7,2)) {...}	// if (GetTrainingTMVAVersionCode()>TMVA_VERSION(3,7,2)) {...}
	// or	// or
	// if (GetTrainingROOTVersionCode()>ROOT_VERSION(5,15,5)) {...}	// if (GetTrainingROOTVersionCode()>ROOT_VERSION(5,15,5)) {...}
	UInt_t GetTrainingTMVAVersionCode() const { return fTMVAT rainingVersion; }	UInt_t GetTrainingTMVAVersionCode() const { return fTMVAT rainingVersion; }
	UInt_t GetTrainingROOTVersionCode() const { return fROOTT rainingVersion; }	UInt_t GetTrainingROOTVersionCode() const { return fROOTT rainingVersion; }
	TString GetTrainingTMVAVersionString() const;	TString GetTrainingTMVAVersionString() const;
	TString GetTrainingROOTVersionString() const;	TString GetTrainingROOTVersionString() const;

	TransformationHandler& GetTransformationHandler() { return fTr ansformation; }	TransformationHandler& GetTransformationHandler() { return fTr ansformation; }
	const TransformationHandler& GetTransformationHandler() const { retu rn fTransformation; }	const TransformationHandler& GetTransformationHandler() const { retu rn fTransformation; }

	// ---------- event accessors --------------------------------------- ---------	// ---------- event accessors --------------------------------------- ---------

	// returns reference to data set	// returns reference to data set
	DataSetInfo& DataInfo() const { return fDataSetInfo; }	DataSetInfo& DataInfo() const { return fDataSetInfo; }


		mutable const Event* fTmpEvent; //! temporary event when testing on
		a different DataSet than the own one

	// event reference and update	// event reference and update
	UInt_t GetNEvents () const { return Data()->GetNEvents (); }	UInt_t GetNEvents () const { return Data()->GetNEvents (); }
	const Event* GetEvent () const;	const Event* GetEvent () const;
	const Event* GetEvent ( const TMVA::Event* ev ) const;	const Event* GetEvent ( const TMVA::Event* ev ) const;
	const Event* GetEvent ( Long64_t ievt ) const;	const Event* GetEvent ( Long64_t ievt ) const;
	const Event* GetEvent ( Long64_t ievt , Types::ETreeType t ype ) const;	const Event* GetEvent ( Long64_t ievt , Types::ETreeType t ype ) const;
	const Event* GetTrainingEvent( Long64_t ievt ) const;	const Event* GetTrainingEvent( Long64_t ievt ) const;
	const Event* GetTestingEvent ( Long64_t ievt ) const;	const Event* GetTestingEvent ( Long64_t ievt ) const;

	const std::vector<Event*>& GetEventCollection( Types::ETreeType type );	const std::vector<TMVA::Event*>& GetEventCollection( Types::ETreeType type );

	// ---------- public auxiliary methods ------------------------------ ---------	// ---------- public auxiliary methods ------------------------------ ---------

	// this method is used to decide whether an event is signal- or backg round-like	// this method is used to decide whether an event is signal- or backg round-like
	// the reference cut "xC" is taken to be where	// the reference cut "xC" is taken to be where
	// Int_[-oo,xC] { PDF_S(x) dx } = Int_[xC,+oo] { PDF_B(x) dx }	// Int_[-oo,xC] { PDF_S(x) dx } = Int_[xC,+oo] { PDF_B(x) dx }
	virtual Bool_t IsSignalLike() { return GetMvaValue() > GetSign alReferenceCut() ? kTRUE : kFALSE; }	virtual Bool_t IsSignalLike() { return GetMvaValue() > GetSign alReferenceCut() ? kTRUE : kFALSE; }

	DataSet* Data() const { return DataInfo().GetDataSet(); }	DataSet* Data() const { return DataInfo().GetDataSet(); }

	Bool_t HasMVAPdfs() const { return fHasMVAPdfs; }	Bool_t HasMVAPdfs() const { return fHasMVAPdfs; }
	virtual void SetAnalysisType( Types::EAnalysisType type ) { fAnalysisType = type; }	virtual void SetAnalysisType( Types::EAnalysisType type ) { fAnalysisType = type; }
	Types::EAnalysisType GetAnalysisType() const { return fAnalysisType; }	Types::EAnalysisType GetAnalysisType() const { return fAnalysisType; }
	Bool_t DoRegression() const { return fAnalysisType == Types::kRegression; }	Bool_t DoRegression() const { return fAnalysisType == Types::kRegression; }


		// setter method for suppressing writing to XML and writing of standa
		lone classes
		void DisableWriting(Bool_t setter){ fDisableWriting
		= setter; }

	protected:	protected:

	// ---------- protected acccessors ---------------------------------- ---------	// ---------- protected acccessors ---------------------------------- ---------

	//TDirectory* LocalTDir() const { return Data().LocalRootDir(); }	//TDirectory* LocalTDir() const { return Data().LocalRootDir(); }

	// weight file name and directory (given by global config variable)	// weight file name and directory (given by global config variable)
	void SetWeightFileName( TString );	void SetWeightFileName( TString );

	const TString& GetWeightFileDir() const { return fFileDir; }	const TString& GetWeightFileDir() const { return fFileDir; }

	skipping to change at line 366	skipping to change at line 378

	// static pointer to this object - required for ROOT finder (to be so lved differently)	// static pointer to this object - required for ROOT finder (to be so lved differently)
	static MethodBase* GetThisBase() { return fgThisBase; }	static MethodBase* GetThisBase() { return fgThisBase; }

	// some basic statistical analysis	// some basic statistical analysis
	void Statistics( Types::ETreeType treeType, const TString& theVarName ,	void Statistics( Types::ETreeType treeType, const TString& theVarName ,
	Double_t&, Double_t&, Double_t&,	Double_t&, Double_t&, Double_t&,
	Double_t&, Double_t&, Double_t& );	Double_t&, Double_t&, Double_t& );

	// if TRUE, write weights only to text files	// if TRUE, write weights only to text files

	Bool_t TxtWeightsOnly() const { return fTxtWeightsOnly; }	Bool_t TxtWeightsOnly() const { return kTRUE; }

	protected:	protected:

	// access to event information that needs method-specific information	// access to event information that needs method-specific information

	Float_t GetTWeight( const Event* ev ) const {	Float_t GetTWeight( const Event* ev ) const {
	return (fIgnoreNegWeightsInTraining && (ev->GetWeight() < 0)) ? 0. : ev->GetWeight();	return (fIgnoreNegWeightsInTraining && (ev->GetWeight() < 0)) ? 0. : ev->GetWeight();
	}	}


		Bool_t IsConstructedFromWeightFile() const { return fConstr
		uctedFromWeightFile; }

		public:
		virtual void SetCurrentEvent( Long64_t ievt ) const {
		Data()->SetCurrentEvent(ievt);
		}

	private:	private:

	// ---------- private definitions ----------------------------------- ---------	// ---------- private definitions ----------------------------------- ---------
	// Initialisation	// Initialisation
	void InitBase();	void InitBase();
	void DeclareBaseOptions();	void DeclareBaseOptions();
	void ProcessBaseOptions();	void ProcessBaseOptions();

	// used in efficiency computation	// used in efficiency computation
	enum ECutOrientation { kNegative = -1, kPositive = +1 };	enum ECutOrientation { kNegative = -1, kPositive = +1 };

	skipping to change at line 410	skipping to change at line 429
	Double_t GetEffForRoot ( Double_t ); // implementation	Double_t GetEffForRoot ( Double_t ); // implementation

	// used for file parsing	// used for file parsing
	Bool_t GetLine( std::istream& fin, char * buf );	Bool_t GetLine( std::istream& fin, char * buf );

	// fill test tree with classification or regression results	// fill test tree with classification or regression results
	virtual void AddClassifierOutput ( Types::ETreeType type );	virtual void AddClassifierOutput ( Types::ETreeType type );
	virtual void AddClassifierOutputProb( Types::ETreeType type );	virtual void AddClassifierOutputProb( Types::ETreeType type );
	virtual void AddRegressionOutput ( Types::ETreeType type );	virtual void AddRegressionOutput ( Types::ETreeType type );


	// ========== class members =========================================
	=========

	private:	private:

	void AddInfoItem( void* gi, const TString& name, const TS tring& value) const;	void AddInfoItem( void* gi, const TString& name, const TS tring& value) const;

		void CreateVariableTransforms(const TString& trafoDefinit
		ion );

		// ========== class members =========================================
		=========

	protected:	protected:

	// direct accessors	// direct accessors
	Ranking* fRanking; // pointer to ranking ob ject (created by derived classifiers)	Ranking* fRanking; // pointer to ranking ob ject (created by derived classifiers)
	std::vector<TString>* fInputVars; // vector of input varia bles used in MVA	std::vector<TString>* fInputVars; // vector of input varia bles used in MVA

	// histogram binning	// histogram binning
	Int_t fNbins; // number of bins in rep resentative histograms	Int_t fNbins; // number of bins in rep resentative histograms
	Int_t fNbinsH; // number of bins in eva luation histograms	Int_t fNbinsH; // number of bins in eva luation histograms

	Types::EAnalysisType fAnalysisType; // method-mode : true -- > regression, false --> classification	Types::EAnalysisType fAnalysisType; // method-mode : true -- > regression, false --> classification

	std::vector<Float_t>* fRegressionReturnVal; // holds the return-valu e for the regression	std::vector<Float_t>* fRegressionReturnVal; // holds the return-valu e for the regression


	Bool_t IsConstructedFromWeightFile() const { return fConstr
	uctedFromWeightFile; }

	private:	private:

	// MethodCuts redefines some of the evaluation variables and histogra ms -> must access private members	// MethodCuts redefines some of the evaluation variables and histogra ms -> must access private members
	friend class MethodCuts;	friend class MethodCuts;


		Bool_t fDisableWriting; //! set to true in order to s
		uppress writing to XML

	// data sets	// data sets
	DataSetInfo& fDataSetInfo; //! the data set information ( sometimes needed)	DataSetInfo& fDataSetInfo; //! the data set information ( sometimes needed)

	Double_t fSignalReferenceCut; // minimum requirement on the MVA output to declare an event signal-like	Double_t fSignalReferenceCut; // minimum requirement on the MVA output to declare an event signal-like
	Types::ESBType fVariableTransformType; // this is the event type ( sig or bgd) assumed for variable transform	Types::ESBType fVariableTransformType; // this is the event type ( sig or bgd) assumed for variable transform

	// naming and versioning	// naming and versioning
	TString fJobName; // name of job -> user defined , appears in weight files	TString fJobName; // name of job -> user defined , appears in weight files
	TString fMethodName; // name of the method (set in derived class)	TString fMethodName; // name of the method (set in derived class)
	Types::EMVA fMethodType; // type of method (set in deri ved class)	Types::EMVA fMethodType; // type of method (set in deri ved class)

	TString fTestvarPrefix; // 'MVA_' prefix of MVA variab le
	TString fTestvar; // variable used in evaluation , etc (mostly the MVA)	TString fTestvar; // variable used in evaluation , etc (mostly the MVA)
	UInt_t fTMVATrainingVersion; // TMVA version used for train ing	UInt_t fTMVATrainingVersion; // TMVA version used for train ing
	UInt_t fROOTTrainingVersion; // ROOT version used for train ing	UInt_t fROOTTrainingVersion; // ROOT version used for train ing

	Bool_t fNormalise; // normalise input variables
	Bool_t fConstructedFromWeightFile; // is it obtained from w eight file?	Bool_t fConstructedFromWeightFile; // is it obtained from w eight file?

	// Directory structure: fMethodBaseDir/fBaseDir	// Directory structure: fMethodBaseDir/fBaseDir
	// where the first directory name is defined by the method type	// where the first directory name is defined by the method type
	// and the second is user supplied (the title given in Factory::BookM ethod())	// and the second is user supplied (the title given in Factory::BookM ethod())
	TDirectory* fBaseDir; // base directory for the inst ance, needed to know where to jump back from localDir	TDirectory* fBaseDir; // base directory for the inst ance, needed to know where to jump back from localDir
	mutable TDirectory* fMethodBaseDir; // base directory for the meth od	mutable TDirectory* fMethodBaseDir; // base directory for the meth od

	TString fParentDir; // method parent name, like bo oster name	TString fParentDir; // method parent name, like bo oster name


	skipping to change at line 492	skipping to change at line 510

	// basic statistics quantities of MVA	// basic statistics quantities of MVA
	Double_t fMeanS; // mean (signal)	Double_t fMeanS; // mean (signal)
	Double_t fMeanB; // mean (background)	Double_t fMeanB; // mean (background)
	Double_t fRmsS; // RMS (signal)	Double_t fRmsS; // RMS (signal)
	Double_t fRmsB; // RMS (background)	Double_t fRmsB; // RMS (background)
	Double_t fXmin; // minimum (signal and backgro und)	Double_t fXmin; // minimum (signal and backgro und)
	Double_t fXmax; // maximum (signal and backgro und)	Double_t fXmax; // maximum (signal and backgro und)

	// variable preprocessing	// variable preprocessing

	Bool_t fUseDecorr; // kept for backward c ompatibility
	TString fVarTransformString; // labels variable tra nsform method	TString fVarTransformString; // labels variable tra nsform method

	TString fVariableTransformTypeString; // labels variable tra nsform type

	TransformationHandler fTransformation; // the list of transfo rmations	TransformationHandler fTransformation; // the list of transfo rmations

	// help and verbosity	// help and verbosity
	Bool_t fVerbose; // verbose flag	Bool_t fVerbose; // verbose flag
	TString fVerbosityLevelString; // verbosity level (user inp ut string)	TString fVerbosityLevelString; // verbosity level (user inp ut string)
	EMsgType fVerbosityLevel; // verbosity level	EMsgType fVerbosityLevel; // verbosity level
	Bool_t fHelp; // help flag	Bool_t fHelp; // help flag
	Bool_t fHasMVAPdfs; // MVA Pdfs are created for this classifier	Bool_t fHasMVAPdfs; // MVA Pdfs are created for this classifier

	Bool_t fIgnoreNegWeightsInTraining;// If true, events with negative weights are not used in training	Bool_t fIgnoreNegWeightsInTraining;// If true, events with negative weights are not used in training

	protected:	protected:

	Bool_t IgnoreEventsWithNegWeightsInTraining() const { retur n fIgnoreNegWeightsInTraining; }	Bool_t IgnoreEventsWithNegWeightsInTraining() const { retur n fIgnoreNegWeightsInTraining; }

	Bool_t fTxtWeightsOnly; // if TRUE, write weights on ly to text files

	// for signal/background	// for signal/background
	UInt_t fSignalClass; // index of the Signal-class	UInt_t fSignalClass; // index of the Signal-class
	UInt_t fBackgroundClass; // index of the Background-c lass	UInt_t fBackgroundClass; // index of the Background-c lass

	private:	private:

	// timing variables	// timing variables
	Double_t fTrainTime; // for timing measurements	Double_t fTrainTime; // for timing measurements
	Double_t fTestTime; // for timing measurements	Double_t fTestTime; // for timing measurements

	skipping to change at line 532	skipping to change at line 547
	// orientation of cut: depends on signal and background mean values	// orientation of cut: depends on signal and background mean values
	ECutOrientation fCutOrientation; // +1 if Sig>Bkg, -1 otherwise	ECutOrientation fCutOrientation; // +1 if Sig>Bkg, -1 otherwise

	// for root finder	// for root finder
	TSpline1* fSplRefS; // helper splines for RootFind er (signal)	TSpline1* fSplRefS; // helper splines for RootFind er (signal)
	TSpline1* fSplRefB; // helper splines for RootFind er (background)	TSpline1* fSplRefB; // helper splines for RootFind er (background)

	TSpline1* fSplTrainRefS; // helper splines for RootFind er (signal)	TSpline1* fSplTrainRefS; // helper splines for RootFind er (signal)
	TSpline1* fSplTrainRefB; // helper splines for RootFind er (background)	TSpline1* fSplTrainRefB; // helper splines for RootFind er (background)


	mutable std::vector<const std::vector<Event>> fEventCollections; // if the method needs the complete event-collection, the transformed event c oll. ist stored here.	mutable std::vector<const std::vector<TMVA::Event>> fEventCollectio ns; // if the method needs the complete event-collection, the transformed e vent coll. ist stored here.

	public:	public:
	Bool_t fSetupCompleted; // is method setup	Bool_t fSetupCompleted; // is method setup

	private:	private:

	// this carrier	// this carrier
	static MethodBase* fgThisBase; // this pointer	static MethodBase* fgThisBase; // this pointer


		// ===== depriciated options, kept for backward compatibility =====
		private:

		Bool_t fNormalise; // normalise input var
		iables
		Bool_t fUseDecorr; // synonymous for deco
		rrelation
		TString fVariableTransformTypeString; // labels variable tra
		nsform type
		Bool_t fTxtWeightsOnly; // if TRUE, write weig
		hts only to text files
		Int_t fNbinsMVAPdf; // number of bins used
		in histogram that creates PDF
		Int_t fNsmoothMVAPdf; // number of times a h
		istogram is smoothed before creating the PDF

	protected:	protected:

	ClassDef(MethodBase,0) // Virtual base class for all TMVA method	ClassDef(MethodBase,0) // Virtual base class for all TMVA method

	};	};
	} // namespace TMVA	} // namespace TMVA

	// ========== INLINE FUNCTIONS ============================================ =============	// ========== INLINE FUNCTIONS ============================================ =============

	//_______________________________________________________________________	//_______________________________________________________________________
	inline const TMVA::Event* TMVA::MethodBase::GetEvent( const TMVA::Event* ev ) const	inline const TMVA::Event* TMVA::MethodBase::GetEvent( const TMVA::Event* ev ) const
	{	{
	return GetTransformationHandler().Transform(ev);	return GetTransformationHandler().Transform(ev);
	}	}

	inline const TMVA::Event* TMVA::MethodBase::GetEvent() const	inline const TMVA::Event* TMVA::MethodBase::GetEvent() const
	{	{

	return GetTransformationHandler().Transform(Data()->GetEvent());	if(fTmpEvent)
		return GetTransformationHandler().Transform(fTmpEvent);
		else
		return GetTransformationHandler().Transform(Data()->GetEvent());
	}	}

	inline const TMVA::Event* TMVA::MethodBase::GetEvent( Long64_t ievt ) const	inline const TMVA::Event* TMVA::MethodBase::GetEvent( Long64_t ievt ) const
	{	{

		assert(fTmpEvent==0);
	return GetTransformationHandler().Transform(Data()->GetEvent(ievt));	return GetTransformationHandler().Transform(Data()->GetEvent(ievt));
	}	}

	inline const TMVA::Event* TMVA::MethodBase::GetEvent( Long64_t ievt, Types: :ETreeType type ) const	inline const TMVA::Event* TMVA::MethodBase::GetEvent( Long64_t ievt, Types: :ETreeType type ) const
	{	{

		assert(fTmpEvent==0);
	return GetTransformationHandler().Transform(Data()->GetEvent(ievt, type) );	return GetTransformationHandler().Transform(Data()->GetEvent(ievt, type) );
	}	}


	inline const std::vector<TMVA::Event*>& TMVA::MethodBase::GetEventCollectio
	n( Types::ETreeType type)
	{
	if (GetTransformationHandler().GetTransformationList().GetEntries() <= 0
	) {
	return (Data()->GetEventCollection(type));
	}
	Int_t idx = Data()->TreeIndex(type);
	if (fEventCollections.at(idx) == 0) {
	fEventCollections.at(idx) = &(Data()->GetEventCollection(type));
	fEventCollections.at(idx) = GetTransformationHandler().CalcTransforma
	tions(*(fEventCollections.at(idx)),kTRUE);
	}
	return *(fEventCollections.at(idx));
	}

	inline const TMVA::Event* TMVA::MethodBase::GetTrainingEvent( Long64_t ievt ) const	inline const TMVA::Event* TMVA::MethodBase::GetTrainingEvent( Long64_t ievt ) const
	{	{

		assert(fTmpEvent==0);
	return GetEvent(ievt, Types::kTraining);	return GetEvent(ievt, Types::kTraining);
	}	}

	inline const TMVA::Event* TMVA::MethodBase::GetTestingEvent( Long64_t ievt ) const	inline const TMVA::Event* TMVA::MethodBase::GetTestingEvent( Long64_t ievt ) const
	{	{

		assert(fTmpEvent==0);
	return GetEvent(ievt, Types::kTesting);	return GetEvent(ievt, Types::kTesting);
	}	}


	//_______________________________________________________________________
	inline 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));
	}

	//_______________________________________________________________________
	inline 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));
	}

	#endif	#endif

End of changes. 36 change blocks.
	104 lines changed or deleted	104 lines changed or added

	MethodBayesClassifier.h	MethodBayesClassifier.h

	// @(#)root/tmva $Id: MethodBayesClassifier.h 29122 2009-06-22 06:51:30Z br un $	// @(#)root/tmva $Id: MethodBayesClassifier.h 31458 2009-11-30 13:58:20Z st elzer $
	// Author: Abhishek Narain	// Author: Abhishek Narain

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodBayesClassifier *	* Class : MethodBayesClassifier *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Bayesian Classifier *	* Bayesian Classifier *

	skipping to change at line 69	skipping to change at line 69
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodBayesClassifier( void );	virtual ~MethodBayesClassifier( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	void Init( void );	void Init( void );

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodCFMlpANN.h	MethodCFMlpANN.h

	// @(#)root/tmva $Id: MethodCFMlpANN.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodCFMlpANN.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCFMlpANN *	* Class : MethodCFMlpANN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Interface for Clermond-Ferrand artificial neural network. *	* Interface for Clermond-Ferrand artificial neural network. *

	skipping to change at line 123	skipping to change at line 123
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodCFMlpANN( void );	virtual ~MethodCFMlpANN( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t /numberTargets/ );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t /numberTargets/ );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// data accessors for external functions	// data accessors for external functions
	Double_t GetData ( Int_t isel, Int_t ivar ) const { return (*fData)(i sel, ivar); }	Double_t GetData ( Int_t isel, Int_t ivar ) const { return (*fData)(i sel, ivar); }

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodCommittee.h	MethodCommittee.h

	// @(#)root/tmva $Id: MethodCommittee.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodCommittee.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCommittee *	* Class : MethodCommittee *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Boosting *	* Boosting *

	skipping to change at line 81	skipping to change at line 81
	virtual ~MethodCommittee( void );	virtual ~MethodCommittee( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// overloaded members from MethodBase	// overloaded members from MethodBase
	void WriteStateToFile() const;	void WriteStateToFile() const;

	// the training	// the training
	void Train();	void Train();


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// calculate the MVA value	// calculate the MVA value

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodCompositeBase.h	MethodCompositeBase.h

	// @(#)root/tmva $Id: MethodCompositeBase.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodCompositeBase.h 31458 2009-11-30 13:58:20Z stel zer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCompositeBase *	* Class : MethodCompositeBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 67	skipping to change at line 67
	const TString& methodTitle,	const TString& methodTitle,
	DataSetInfo& theData,	DataSetInfo& theData,
	const TString& theOption = "",	const TString& theOption = "",
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	MethodCompositeBase( Types::EMVA methodType,	MethodCompositeBase( Types::EMVA methodType,
	DataSetInfo& dsi,	DataSetInfo& dsi,
	const TString& weightFile,	const TString& weightFile,
	TDirectory* theBaseDir = 0 );	TDirectory* theBaseDir = 0 );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// calculate the MVA value combining all classifiers according to thi er fMethodWeight	// calculate the MVA value combining all classifiers according to thi er fMethodWeight
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );

	// performs classifier training	// performs classifier training

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodDT.h	MethodDT.h

	// @(#)root/tmva $Id: MethodDT.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodDT.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodDT (Boosted Decision Trees) *	* Class : MethodDT (Boosted Decision Trees) *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Boosted Decision Trees *	* Analysis of Boosted Decision Trees *

	skipping to change at line 79	skipping to change at line 79
	MethodDT( DataSetInfo& dsi,	MethodDT( DataSetInfo& dsi,
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodDT( void );	virtual ~MethodDT( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// the option handling methods	// the option handling methods

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodFDA.h	MethodFDA.h

	// @(#)root/tmva $Id: MethodFDA.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodFDA.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Peter Speckmayer	// Author: Andreas Hoecker, Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodFDA *	* Class : MethodFDA *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Function discriminant analysis (FDA). This simple classifier *	* Function discriminant analysis (FDA). This simple classifier *

	skipping to change at line 44	skipping to change at line 44
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// MethodFDA //	// MethodFDA //
	// //	// //
	// Function discriminant analysis (FDA). This simple classifier //	// Function discriminant analysis (FDA). This simple classifier //
	// fits any user-defined TFormula (via option configuration string) to //	// fits any user-defined TFormula (via option configuration string) to //
	// the training data by requiring a formula response of 1 (0) to signal //	// the training data by requiring a formula response of 1 (0) to signal //
	// (background) events. The parameter fitting is done via the abstract //	// (background) events. The parameter fitting is done via the abstract //
	// class FitterBase, featuring Monte Carlo sampling, Genetic //	// class FitterBase, featuring Monte Carlo sampling, Genetic //
	// Algorithm, Simulated Annealing, MINUIT and combinations of these. //	// Algorithm, Simulated Annealing, MINUIT and combinations of these. //

	//	// //
		// Can compute one-dimensional regression //
	//
	// Can compute one-dimensional regression
	//
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMVA_MethodBase	#ifndef ROOT_TMVA_MethodBase
	#include "TMVA/MethodBase.h"	#include "TMVA/MethodBase.h"
	#endif	#endif
	#ifndef ROOT_TMVA_IFitterTarget	#ifndef ROOT_TMVA_IFitterTarget
	#include "TMVA/IFitterTarget.h"	#include "TMVA/IFitterTarget.h"
	#endif	#endif


	skipping to change at line 85	skipping to change at line 85
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodFDA( void );	virtual ~MethodFDA( void );

	Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClass es, UInt_t numberTargets );	Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t numberClass es, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;


	void WriteWeightsToStream ( std::ostream & o ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );


	std::vector<Float_t>& GetRegressionValues();	std::vector<Float_t>& GetRegressionValues();

	void Init( void );	void Init( void );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

	Double_t EstimatorFunction( std::vector<Double_t>& );	Double_t EstimatorFunction( std::vector<Double_t>& );

	// no check of options at this place	// no check of options at this place
	void CheckSetup() {}	void CheckSetup() {}

	skipping to change at line 150	skipping to change at line 148
	std::vector<Interval*> fParRange; // ranges of parameters	std::vector<Interval*> fParRange; // ranges of parameters
	std::vector<Double_t> fBestPars; // the pars that optimise (minimise) the estimator	std::vector<Double_t> fBestPars; // the pars that optimise (minimise) the estimator
	TString fFitMethod; // estimator optimisation method	TString fFitMethod; // estimator optimisation method
	TString fConverger; // fitmethod uses fConver ger as intermediate step to converge into local minimas	TString fConverger; // fitmethod uses fConver ger as intermediate step to converge into local minimas
	FitterBase* fFitter; // the fitter used in the training	FitterBase* fFitter; // the fitter used in the training
	IFitterTarget* fConvergerFitter; // intermediate fitter	IFitterTarget* fConvergerFitter; // intermediate fitter

	// sum of weights (this should become centrally available through the dataset)	// sum of weights (this should become centrally available through the dataset)
	Double_t fSumOfWeightsSig; // sum of weights (signal )	Double_t fSumOfWeightsSig; // sum of weights (signal )
	Double_t fSumOfWeightsBkg; // sum of weights (backgr ound)	Double_t fSumOfWeightsBkg; // sum of weights (backgr ound)

	Double_t fSumOfWeights; // sum of weights	Double_t fSumOfWeights; // sum of weights

	ClassDef(MethodFDA,0) // Function Discriminant Analysis	ClassDef(MethodFDA,0) // Function Discriminant Analysis
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodFDA_H	#endif // MethodFDA_H

End of changes. 6 change blocks.
	10 lines changed or deleted	5 lines changed or added

	MethodFisher.h	MethodFisher.h

	// @(#)root/tmva $Id: MethodFisher.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodFisher.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Xavier Prudent, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Xavier Prudent, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodFisher *	* Class : MethodFisher *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of Fisher discriminant (Fisher or Mahalanobis approach) *	* Analysis of Fisher discriminant (Fisher or Mahalanobis approach) *

	skipping to change at line 79	skipping to change at line 79
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodFisher( void );	virtual ~MethodFisher( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to stream	// write weights to stream

	void WriteWeightsToStream( std::ostream & o) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from stream	// read weights from stream
	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	enum EFisherMethod { kFisher, kMahalanobis };	enum EFisherMethod { kFisher, kMahalanobis };

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodHMatrix.h	MethodHMatrix.h

	// @(#)root/tmva $Id: MethodHMatrix.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodHMatrix.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodHMatrix *	* Class : MethodHMatrix *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* H-Matrix method, which is implemented as a simple comparison of *	* H-Matrix method, which is implemented as a simple comparison of *

	skipping to change at line 83	skipping to change at line 83
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodHMatrix();	virtual ~MethodHMatrix();

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train();	void Train();


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodKNN.h	MethodKNN.h

	// @(#)root/tmva $Id: MethodKNN.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodKNN.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Rustem Ospanov	// Author: Rustem Ospanov

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodKNN *	* Class : MethodKNN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Analysis of k-nearest neighbor *	* Analysis of k-nearest neighbor *

	skipping to change at line 83	skipping to change at line 83

	virtual ~MethodKNN( void );	virtual ~MethodKNN( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	void Train( void );	void Train( void );

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );
	const std::vector<Float_t>& GetRegressionValues();	const std::vector<Float_t>& GetRegressionValues();


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;


	void WriteWeightsToStream(std::ostream& o) const;
	void WriteWeightsToStream(TFile& rf) const;	void WriteWeightsToStream(TFile& rf) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	void ReadWeightsFromStream(std::istream& istr);	void ReadWeightsFromStream(std::istream& istr);
	void ReadWeightsFromStream(TFile &rf);	void ReadWeightsFromStream(TFile &rf);

	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	protected:	protected:

	skipping to change at line 109	skipping to change at line 107
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	private:	private:

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

		void DeclareCompatibilityOptions();

	// default initialisation called by all constructors	// default initialisation called by all constructors
	void Init( void );	void Init( void );

	// create kd-tree (binary tree) structure	// create kd-tree (binary tree) structure
	void MakeKNN( void );	void MakeKNN( void );

	// polynomial and Gaussian kernel weight function	// polynomial and Gaussian kernel weight function
	Double_t PolnKernel(Double_t value) const;	Double_t PolnKernel(Double_t value) const;
	Double_t GausKernel(const kNN::Event &event_knn, const kNN::Event &ev ent, const std::vector<Double_t> &svec) const;	Double_t GausKernel(const kNN::Event &event_knn, const kNN::Event &ev ent, const std::vector<Double_t> &svec) const;

	skipping to change at line 150	skipping to change at line 149

	Bool_t fTrim; // set equal number of signal and background events	Bool_t fTrim; // set equal number of signal and background events
	Bool_t fUseKernel; // use polynomial kernel weight function	Bool_t fUseKernel; // use polynomial kernel weight function
	Bool_t fUseWeight; // use weights to count kNN	Bool_t fUseWeight; // use weights to count kNN
	Bool_t fUseLDA; // use local linear discriminat analysis to c ompute MVA	Bool_t fUseLDA; // use local linear discriminat analysis to c ompute MVA

	kNN::EventVec fEvent; //! (untouched) events used for learning	kNN::EventVec fEvent; //! (untouched) events used for learning

	LDA fLDA; //! Experimental feature for local knn analys is	LDA fLDA; //! Experimental feature for local knn analys is


		// for backward compatibility
		Int_t fTreeOptDepth; // number of binary tree levels used for opti
		mization

	ClassDef(MethodKNN,0) // k Nearest Neighbour classifier	ClassDef(MethodKNN,0) // k Nearest Neighbour classifier
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodKNN	#endif // MethodKNN

End of changes. 5 change blocks.
	3 lines changed or deleted	6 lines changed or added

	MethodLD.h	MethodLD.h

	skipping to change at line 13	skipping to change at line 13
	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodLD *	* Class : MethodLD *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Linear Discriminant (Simple Linear Regression) *	* Linear Discriminant (Simple Linear Regression) *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *

	* Krzysztof Danielowski <danielow@cern.ch> - IFJ PAN & AGH, Poland	* Krzysztof Danielowski <danielow@cern.ch> - IFJ PAN & AGH, Poland
	*	*
	* Kamil Kraszewski <kalq@cern.ch> - IFJ PAN & UJ, Poland	* Kamil Kraszewski <kalq@cern.ch> - IFJ PAN & UJ, Poland
	*	*
	* Maciej Kruk <mkruk@cern.ch> - IFJ PAN & AGH, Poland *	* Maciej Kruk <mkruk@cern.ch> - IFJ PAN & AGH, Poland *

	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerla nd *
	* Jan Therhaag <therhaag@physik.uni-bonn.de> - Uni Bonn, Ger many *	* Jan Therhaag <therhaag@physik.uni-bonn.de> - Uni Bonn, Ger many *
	* *	* *
	* Copyright (c) 2008: *	* Copyright (c) 2008: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* PAN, Poland *	* PAN, Poland *
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	* *	* *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_MethodLD	#ifndef ROOT_TMVA_MethodLD
	#define ROOT_TMVA_MethodLD	#define ROOT_TMVA_MethodLD

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //

	// MethodLD //	// MethodLD //
	// //	// //

	// Linear Discriminant	// Linear Discriminant //
	//	// Can compute multidimensional output for regression //
	// Can compute multidimensional output for regression	// (although it computes every dimension separately) //
	//
	// (although it computes every dimension separately)
	//
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <vector>	#include <vector>

	#ifndef ROOT_TMVA_MethodBase	#ifndef ROOT_TMVA_MethodBase
	#include "TMVA/MethodBase.h"	#include "TMVA/MethodBase.h"
	#endif	#endif
	#ifndef ROOT_TMatrixDfwd	#ifndef ROOT_TMatrixDfwd
	#include "TMatrixDfwd.h"	#include "TMatrixDfwd.h"

	skipping to change at line 83	skipping to change at line 83

	// training method	// training method
	void Train( void );	void Train( void );

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// calculate the Regression value	// calculate the Regression value
	virtual const std::vector<Float_t>& GetRegressionValues();	virtual const std::vector<Float_t>& GetRegressionValues();


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;


	void WriteWeightsToStream ( std::ostream & o ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	const Ranking* CreateRanking();	const Ranking* CreateRanking();
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

	protected:	protected:

	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;
	void GetHelpMessage() const;	void GetHelpMessage() const;

	private:	private:


	Int_t fNRegOut; // size of the output	Int_t fNRegOut; // size of the output

	TMatrixD *fSumMatx; // Sum of coordinates product matrix	TMatrixD *fSumMatx; // Sum of coordinates product matrix
	TMatrixD *fSumValMatx; // Sum of values multiplied by coord inates	TMatrixD *fSumValMatx; // Sum of values multiplied by coord inates
	TMatrixD *fCoeffMatx; // Matrix of coefficients	TMatrixD *fCoeffMatx; // Matrix of coefficients
	std::vector< std::vector<Double_t>* > *fLDCoeff; // LD coefficients	std::vector< std::vector<Double_t>* > *fLDCoeff; // LD coefficients

	// default initialisation called by all constructors	// default initialisation called by all constructors
	void Init( void );	void Init( void );

	// Initialization and allocation of matrices	// Initialization and allocation of matrices

End of changes. 7 change blocks.
	15 lines changed or deleted	10 lines changed or added

	MethodLikelihood.h	MethodLikelihood.h

	// @(#)root/tmva $Id: MethodLikelihood.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodLikelihood.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodLikelihood *	* Class : MethodLikelihood *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Likelihood analysis ("non-parametric approach") *	* Likelihood analysis ("non-parametric approach") *

	skipping to change at line 82	skipping to change at line 82

	virtual ~MethodLikelihood();	virtual ~MethodLikelihood();

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type,	virtual Bool_t HasAnalysisType( Types::EAnalysisType type,
	UInt_t numberClasses, UInt_t numberTa rgets );	UInt_t numberClasses, UInt_t numberTa rgets );

	// training method	// training method
	void Train();	void Train();

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void WriteWeightsToStream( TFile& rf ) const;	void WriteWeightsToStream( TFile& rf ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromStream( TFile& istr );	void ReadWeightsFromStream( TFile& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value
	// the argument is used for internal ranking tests	// the argument is used for internal ranking tests
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	skipping to change at line 104	skipping to change at line 103
	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile() const;	void WriteMonitoringHistosToFile() const;

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking();	const Ranking* CreateRanking();

	virtual void WriteOptionsToStream ( ostream& o, const TString& prefix ) const;	virtual void WriteOptionsToStream ( ostream& o, const TString& prefix ) const;

	protected:	protected:


		void DeclareCompatibilityOptions();

	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// header and auxiliary classes	// header and auxiliary classes
	void MakeClassSpecificHeader( std::ostream&, const TString& = "" ) co nst;	void MakeClassSpecificHeader( std::ostream&, const TString& = "" ) co nst;

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	private:	private:

	skipping to change at line 140	skipping to change at line 141
	std::vector<TH1> fHistBgd; // background PDFs ( histograms)	std::vector<TH1> fHistBgd; // background PDFs ( histograms)
	std::vector<TH1> fHistSig_smooth; // signal PDFs (smoo thed histograms)	std::vector<TH1> fHistSig_smooth; // signal PDFs (smoo thed histograms)
	std::vector<TH1> fHistBgd_smooth; // background PDFs ( smoothed histograms)	std::vector<TH1> fHistBgd_smooth; // background PDFs ( smoothed histograms)

	PDF* fDefaultPDFLik; // pdf that contains default definitions	PDF* fDefaultPDFLik; // pdf that contains default definitions
	std::vector<PDF> fPDFSig; // list of PDFs (sig nal)	std::vector<PDF> fPDFSig; // list of PDFs (sig nal)
	std::vector<PDF> fPDFBgd; // list of PDFs (bac kground)	std::vector<PDF> fPDFBgd; // list of PDFs (bac kground)

	// default initialisation called by all constructors	// default initialisation called by all constructors


		// obsolete variables kept for backward combatibility
		Int_t fNsmooth; // number of smooth
		passes
		Int_t* fNsmoothVarS; // number of smooth
		passes
		Int_t* fNsmoothVarB; // number of smooth
		passes
		Int_t fAverageEvtPerBin; // average events pe
		r bin; used to calculate fNbins
		Int_t* fAverageEvtPerBinVarS; // average events pe
		r bin; used to calculate fNbins
		Int_t* fAverageEvtPerBinVarB; // average events pe
		r bin; used to calculate fNbins
		TString fBorderMethodString; // the method to tak
		e care about "border" effects (string)
		Float_t fKDEfineFactor; // fine tuning facto
		r for Adaptive KDE
		TString fKDEiterString; // Number of iterati
		ons (string)
		TString fKDEtypeString; // Kernel type to us
		e for KDE (string)
		TString* fInterpolateString; // which interpolati
		on method used for reference histograms (individual for each variable)

	ClassDef(MethodLikelihood,0) // Likelihood analysis ("non-parametric approach")	ClassDef(MethodLikelihood,0) // Likelihood analysis ("non-parametric approach")
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodLikelihood_H	#endif // MethodLikelihood_H

End of changes. 4 change blocks.
	2 lines changed or deleted	27 lines changed or added

	MethodMLP.h	MethodMLP.h

	// @(#)root/tmva $Id: MethodMLP.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodMLP.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Matt Jachowski	// Author: Andreas Hoecker, Matt Jachowski

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodMLP *	* Class : MethodMLP *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* ANN Multilayer Perceptron class for the discrimination of signal *	* ANN Multilayer Perceptron class for the discrimination of signal *

	skipping to change at line 134	skipping to change at line 134
	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();
	void ProcessOptions();	void ProcessOptions();

	// general helper functions	// general helper functions
	void Train( Int_t nEpochs );	void Train( Int_t nEpochs );
	void Init();	void Init();
	void InitializeLearningRates(); // although this is only needed b y backprop	void InitializeLearningRates(); // although this is only needed b y backprop

	// used as a measure of success in all minimization techniques	// used as a measure of success in all minimization techniques

	Double_t CalculateEstimator( Types::ETreeType treeType = Types::kTrai ning );	Double_t CalculateEstimator( Types::ETreeType treeType = Types::kTrai ning, Int_t iEpoch = -1 );

	// BFGS functions	// BFGS functions
	void BFGSMinimize( Int_t nEpochs );	void BFGSMinimize( Int_t nEpochs );
	void SetGammaDelta( TMatrixD &Gamma, TMatrixD &Delta, std::vector <Double_t> &Buffer );	void SetGammaDelta( TMatrixD &Gamma, TMatrixD &Delta, std::vector <Double_t> &Buffer );
	void SteepestDir( TMatrixD &Dir );	void SteepestDir( TMatrixD &Dir );
	Bool_t GetHessian( TMatrixD &Hessian, TMatrixD &Gamma, TMatrixD &De lta );	Bool_t GetHessian( TMatrixD &Hessian, TMatrixD &Gamma, TMatrixD &De lta );
	void SetDir( TMatrixD &Hessian, TMatrixD &Dir );	void SetDir( TMatrixD &Hessian, TMatrixD &Dir );
	Double_t DerivDir( TMatrixD &Dir );	Double_t DerivDir( TMatrixD &Dir );
	Bool_t LineSearch( TMatrixD &Dir, std::vector<Double_t> &Buffer );	Bool_t LineSearch( TMatrixD &Dir, std::vector<Double_t> &Buffer );
	void ComputeDEDw();	void ComputeDEDw();

	skipping to change at line 169	skipping to change at line 169
	void CalculateNeuronDeltas();	void CalculateNeuronDeltas();
	void UpdateSynapses();	void UpdateSynapses();
	void AdjustSynapseWeights();	void AdjustSynapseWeights();

	// faster backpropagation	// faster backpropagation
	void TrainOneEventFast( Int_t ievt, Float_t*& branchVar, Int_t& t ype );	void TrainOneEventFast( Int_t ievt, Float_t*& branchVar, Int_t& t ype );

	// genetic algorithm functions	// genetic algorithm functions
	void GeneticMinimize();	void GeneticMinimize();


	// the neuronal network can be initialized after the analysis type ha
	s been set.
	void SetAnalysisType( Types::EAnalysisType type );

	#ifdef MethodMLP_UseMinuit__	#ifdef MethodMLP_UseMinuit__
	// minuit functions -- commented out because they rely on a static po inter	// minuit functions -- commented out because they rely on a static po inter
	void MinuitMinimize();	void MinuitMinimize();
	static MethodMLP* GetThisPtr() { return fgThis; }	static MethodMLP* GetThisPtr() { return fgThis; }
	static void IFCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t * fitPars, Int_t ifl );	static void IFCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t * fitPars, Int_t ifl );
	void FCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPar s, Int_t ifl );	void FCN( Int_t& npars, Double_t* grad, Double_t &f, Double_t* fitPar s, Int_t ifl );
	#endif	#endif

	// general	// general
	ETrainingMethod fTrainingMethod; // method of training, BP or GA	ETrainingMethod fTrainingMethod; // method of training, BP or GA

	skipping to change at line 202	skipping to change at line 199
	Double_t fTau; // line search variable	Double_t fTau; // line search variable
	Int_t fResetStep; // reset time (how often we clear he ssian matrix)	Int_t fResetStep; // reset time (how often we clear he ssian matrix)

	// backpropagation variable	// backpropagation variable
	Double_t fLearnRate; // learning rate for synapse weight adjustments	Double_t fLearnRate; // learning rate for synapse weight adjustments
	Double_t fDecayRate; // decay rate for above learning rat e	Double_t fDecayRate; // decay rate for above learning rat e
	EBPTrainingMode fBPMode; // backprop learning mode (sequentia l or batch)	EBPTrainingMode fBPMode; // backprop learning mode (sequentia l or batch)
	TString fBpModeS; // backprop learning mode option str ing (sequential or batch)	TString fBpModeS; // backprop learning mode option str ing (sequential or batch)
	Int_t fBatchSize; // batch size, only matters if in ba tch learning mode	Int_t fBatchSize; // batch size, only matters if in ba tch learning mode
	Int_t fTestRate; // test for overtraining performed a t each #th epochs	Int_t fTestRate; // test for overtraining performed a t each #th epochs

		Bool_t fEpochMon; // create and fill epoch-wise monito ring histograms (makes outputfile big!)

	// genetic algorithm variables	// genetic algorithm variables
	Int_t fGA_nsteps; // GA settings: number of steps	Int_t fGA_nsteps; // GA settings: number of steps
	Int_t fGA_preCalc; // GA settings: number of pre-calc s teps	Int_t fGA_preCalc; // GA settings: number of pre-calc s teps
	Int_t fGA_SC_steps; // GA settings: SC_steps	Int_t fGA_SC_steps; // GA settings: SC_steps
	Int_t fGA_SC_rate; // GA settings: SC_rate	Int_t fGA_SC_rate; // GA settings: SC_rate
	Double_t fGA_SC_factor; // GA settings: SC_factor	Double_t fGA_SC_factor; // GA settings: SC_factor

	#ifdef MethodMLP_UseMinuit__	#ifdef MethodMLP_UseMinuit__
	// minuit variables -- commented out because they rely on a static po inter	// minuit variables -- commented out because they rely on a static po inter

End of changes. 4 change blocks.
	6 lines changed or deleted	3 lines changed or added

	MethodPDEFoam.h	MethodPDEFoam.h

	// @(#)root/tmva $Id: MethodPDEFoam.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: MethodPDEFoam.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate Data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate Data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodPDEFoam *	* Class : MethodPDEFoam *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* The PDEFoam method is an extension of the PDERS method, which divid es *	* The PDEFoam method is an extension of the PDERS method, which divid es *

	skipping to change at line 103	skipping to change at line 103

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training methods	// training methods
	void Train( void );	void Train( void );
	void TrainMonoTargetRegression( void ); // Regression output: one value	void TrainMonoTargetRegression( void ); // Regression output: one value
	void TrainMultiTargetRegression( void ); // Regression output: any number of values	void TrainMultiTargetRegression( void ); // Regression output: any number of values
	void TrainSeparatedClassification( void ); // Classification: one foa m for Sig, one for Bg	void TrainSeparatedClassification( void ); // Classification: one foa m for Sig, one for Bg
	void TrainUnifiedClassification( void ); // Classification: one foa m for Signal and Bg	void TrainUnifiedClassification( void ); // Classification: one foa m for Signal and Bg


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to stream	// write weights to stream

	void WriteWeightsToStream( std::ostream & o) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from stream	// read weights from stream
	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );


	// write/read pure foams to/from xml file	// write/read pure foams to/from file
	void WriteFoamsToXMLFile() const;	void WriteFoamsToFile() const;
	void ReadFoamsFromXMLFile();	void ReadFoamsFromFile();

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// regression procedure	// regression procedure
	virtual const std::vector<Float_t>& GetRegressionValues();	virtual const std::vector<Float_t>& GetRegressionValues();

	// ranking of input variables	// ranking of input variables
	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking() { return 0; }


	skipping to change at line 213	skipping to change at line 211
	// options to be used	// options to be used
	Bool_t fSigBgSeparated; // Separate Sig and Bg, or not	Bool_t fSigBgSeparated; // Separate Sig and Bg, or not
	Double_t fFrac; // Fraction used for calc of Xmin, Xm ax	Double_t fFrac; // Fraction used for calc of Xmin, Xm ax
	Double_t fDiscrErrCut; // cut on discrimant error	Double_t fDiscrErrCut; // cut on discrimant error
	Int_t fVolFrac; // inverse volume fraction (used for density calculation during buildup)	Int_t fVolFrac; // inverse volume fraction (used for density calculation during buildup)
	Float_t fVolFracInv; // volume fraction (used for density calculation during buildup)	Float_t fVolFracInv; // volume fraction (used for density calculation during buildup)
	Int_t fnCells; // Number of Cells (1000)	Int_t fnCells; // Number of Cells (1000)
	Int_t fnActiveCells; // Number of active cells	Int_t fnActiveCells; // Number of active cells
	Int_t fnSampl; // Number of MC events per cell in bu ild-up (1000)	Int_t fnSampl; // Number of MC events per cell in bu ild-up (1000)
	Int_t fnBin; // Number of bins in build-up (100)	Int_t fnBin; // Number of bins in build-up (100)

	Int_t fOptRej; // Wted events for OptRej=0; wt=1 for
	OptRej=1 (default)
	Int_t fOptDrive; // (D=2) Option, type of Drive =1,2 f
	or Variance,WtMax driven reduction
	Int_t fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)	Int_t fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)

	Int_t fChat; // Chat level
	Float_t fNSigBgRatio; // ratio of number of signal events / bg events (training)	Float_t fNSigBgRatio; // ratio of number of signal events / bg events (training)


	Bool_t fCompress; // compress XML file	Bool_t fCompress; // compress foam output file
	Bool_t fMultiTargetRegression; // do regression on multible ta rgets	Bool_t fMultiTargetRegression; // do regression on multible ta rgets
	UInt_t fNmin; // minimal number of events in cell n ecessary to split cell"	UInt_t fNmin; // minimal number of events in cell n ecessary to split cell"
	Bool_t fCutNmin; // Grabbing cell with maximal RMS to split next (TFoam default)	Bool_t fCutNmin; // Grabbing cell with maximal RMS to split next (TFoam default)
	Double_t fRMSmin; // minimal number of events in cell n ecessary to split cell"	Double_t fRMSmin; // minimal number of events in cell n ecessary to split cell"
	Bool_t fCutRMSmin; // Grabbing cell with maximal RMS to split next (TFoam default)	Bool_t fCutRMSmin; // Grabbing cell with maximal RMS to split next (TFoam default)

	TString fKernelStr; // Kernel for GetMvaValue() (option s tring)	TString fKernelStr; // Kernel for GetMvaValue() (option s tring)
	EKernel fKernel; // Kernel for GetMvaValue()	EKernel fKernel; // Kernel for GetMvaValue()
	TString fTargetSelectionStr; // method of selecting the target (only mulit target regr.)	TString fTargetSelectionStr; // method of selecting the target (only mulit target regr.)
	ETargetSelection fTargetSelection; // method of selecting the target (only mulit target regr.)	ETargetSelection fTargetSelection; // method of selecting the target (only mulit target regr.)

	std::vector<Double_t> Xmin, Xmax; // range for histograms and foams	std::vector<Double_t> Xmin, Xmax; // range for histograms and foams

	// foams and densities	// foams and densities
	PDEFoam* foam[FOAM_NUMBER]; // foam[0]=signal, if Sig and BG are Sepe rated; else foam[0]=signal/bg	PDEFoam* foam[FOAM_NUMBER]; // foam[0]=signal, if Sig and BG are Sepe rated; else foam[0]=signal/bg
	// foam[1]=background, if Sig and BG are Seperated; else it is not used	// foam[1]=background, if Sig and BG are Seperated; else it is not used

	TRandom3 *PseRan; // random generator for PDEFoams

	// default initialisation called by all constructors	// default initialisation called by all constructors
	void Init( void );	void Init( void );

	ClassDef(MethodPDEFoam,0) // Analysis of PDEFoam discriminant (PDEFoa m or Mahalanobis approach)	ClassDef(MethodPDEFoam,0) // Analysis of PDEFoam discriminant (PDEFoa m or Mahalanobis approach)
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodPDEFoam_H	#endif // MethodPDEFoam_H

End of changes. 8 change blocks.
	13 lines changed or deleted	5 lines changed or added

	MethodPDERS.h	MethodPDERS.h

	// @(#)root/tmva $Id: MethodPDERS.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodPDERS.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Yair Mahalalel, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Yair Mahalalel, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodPDERS *	* Class : MethodPDERS *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Multidimensional Likelihood using the "Probability density estimato r *	* Multidimensional Likelihood using the "Probability density estimato r *

	skipping to change at line 89	skipping to change at line 89
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodPDERS( void );	virtual ~MethodPDERS( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void WriteWeightsToStream( TFile& rf ) const;	void WriteWeightsToStream( TFile& rf ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromStream( TFile& istr );	void ReadWeightsFromStream( TFile& istr );
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	MethodRuleFit.h	MethodRuleFit.h

	// @(#)root/tmva $Id: MethodRuleFit.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodRuleFit.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Fredrik Tegenfeldt	// Author: Fredrik Tegenfeldt

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodRuleFit *	* Class : MethodRuleFit *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Friedman's RuleFit method *	* Friedman's RuleFit method *

	skipping to change at line 78	skipping to change at line 78
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodRuleFit( void );	virtual ~MethodRuleFit( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t /numberTargets/ );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t /numberTargets/ );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value	// calculate the MVA value
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// write method specific histos to target file	// write method specific histos to target file

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MethodSVM.h	MethodSVM.h

	// @(#)root/tmva $Id: MethodSVM.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: MethodSVM.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Marcin Wolter, Andrzej Zemla	// Author: Marcin Wolter, Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodSVM *	* Class : MethodSVM *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Support Vector Machine *	* Support Vector Machine *

	skipping to change at line 80	skipping to change at line 80

	MethodSVM( DataSetInfo& theData, const TString& theWeightFile, TDirec tory* theTargetDir = NULL );	MethodSVM( DataSetInfo& theData, const TString& theWeightFile, TDirec tory* theTargetDir = NULL );

	virtual ~MethodSVM( void );	virtual ~MethodSVM( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( std::ostream& o ) const;
	void WriteWeightsToStream( TFile& fout ) const;	void WriteWeightsToStream( TFile& fout ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( std::istream& istr );	void ReadWeightsFromStream( std::istream& istr );
	void ReadWeightsFromStream( TFile& fFin );	void ReadWeightsFromStream( TFile& fFin );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );
	// calculate the MVA value	// calculate the MVA value

	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	skipping to change at line 114	skipping to change at line 112
	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)	// make ROOT-independent C++ class for classifier response (classifie r-specific implementation)
	void MakeClassSpecific( std::ostream&, const TString& ) const;	void MakeClassSpecific( std::ostream&, const TString& ) const;

	// get help message text	// get help message text
	void GetHelpMessage() const;	void GetHelpMessage() const;

	private:	private:

	// the option handling methods	// the option handling methods
	void DeclareOptions();	void DeclareOptions();

		void DeclareCompatibilityOptions();
	void ProcessOptions();	void ProcessOptions();


	Float_t fCost; // cost value	Float_t fCost; // cost value
	Float_t fTolerance; // tolerance parameter	Float_t fTolerance; // tolerance parameter
	UInt_t fMaxIter; // max number of iteration	UInt_t fMaxIter; // max number of iteration
	UShort_t fNSubSets; // nr of subsets, de	UShort_t fNSubSets; // nr of subsets, default 1
	fault 1
	Float_t fBparm; // free plane coefficient	Float_t fBparm; // free plane coefficient


	Float_t fGamma; // RBF Kernel parameter	Float_t fGamma; // RBF Kernel parameter

		SVWorkingSet* fWgSet; // svm working set
	SVWorkingSet* fWgSet; // svm working set	std::vector<TMVA::SVEvent> fInputData; // vector of training
	std::vector<TMVA::SVEvent> fInputData; // vector of trainin	data in SVM format
	g data in SVM format	std::vector<TMVA::SVEvent> fSupportVectors; // contains support ve
	std::vector<TMVA::SVEvent> fSupportVectors; // contains support	ctors
	vectors	SVKernelFunction* fSVKernelFunction; // kernel function
	SVKernelFunction* fSVKernelFunction; // kernel function
		TVectorD* fMinVars; // for normalization //is i
	TVectorD* fMinVars; // for normalization	t still needed??
	//is it still needed??	TVectorD* fMaxVars; // for normalization //is i
	TVectorD* fMaxVars; // for normalization	t still needed??
	//is it still needed??
		// for backward compatibility
		TString fTheKernel; // kernel name
		Float_t fDoubleSigmaSquared; // for RBF Kernel
		Int_t fOrder; // for Polynomial Kernel ( polynomi
		al order )
		Float_t fTheta; // for Sigmoidal Kernel
		Float_t fKappa; // for Sigmoidal Kernel

	ClassDef(MethodSVM,0) // Support Vector Machine	ClassDef(MethodSVM,0) // Support Vector Machine
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodSVM_H	#endif // MethodSVM_H

End of changes. 7 change blocks.
	21 lines changed or deleted	25 lines changed or added

	MethodSeedDistance.h	MethodSeedDistance.h

	// @(#)root/tmva $Id: MethodSeedDistance.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodSeedDistance.h 31574 2009-12-05 18:23:21Z stelz er $
	// Author: Andreas Hoecker, Peter Speckmayer	// Author: Andreas Hoecker, Peter Speckmayer

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodSeedDistance *	* Class : MethodSeedDistance *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* *	* *

	skipping to change at line 71	skipping to change at line 71
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodSeedDistance( void );	virtual ~MethodSeedDistance( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	virtual void Train( void );	virtual void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML ( void* /wghtnode/ ) {}	void ReadWeightsFromXML ( void* /wghtnode/ ) {}

	// calculate the MVA value	// calculate the MVA value
	virtual Double_t GetMvaValue( Double_t* err = 0 );	virtual Double_t GetMvaValue( Double_t* err = 0 );

	void Init( void );	void Init( void );

	skipping to change at line 140	skipping to change at line 138
	std::vector<Double_t> fMetricPars; //	std::vector<Double_t> fMetricPars; //
	std::vector<Double_t> fPars; // the pars that optimise (mi nimise) the estimator	std::vector<Double_t> fPars; // the pars that optimise (mi nimise) the estimator

	Int_t fDataSeeds;	Int_t fDataSeeds;
	Int_t fBackSeeds;	Int_t fBackSeeds;
	TString fMetricType;	TString fMetricType;

	Bool_t fPow2Estimator;	Bool_t fPow2Estimator;

	Int_t fNPars; // number of parameters	Int_t fNPars; // number of parameters

	std::vector<Interval*> fParRange; // ranges of parameters	std::vector<TMVA::Interval*> fParRange; // ranges of parame ters
	TString fFitMethod; // estimator optimisation method	TString fFitMethod; // estimator optimisation method
	TString fConverger; // fitmethod uses fConver ger as intermediate step to converge into local minimas	TString fConverger; // fitmethod uses fConver ger as intermediate step to converge into local minimas
	FitterBase* fFitter; // the fitter used in the training	FitterBase* fFitter; // the fitter used in the training
	IFitterTarget* fIntermediateFitter; // intermediate fitter	IFitterTarget* fIntermediateFitter; // intermediate fitter

	// speed up access to training events by caching	// speed up access to training events by caching
	std::vector<const Event*> fEventsSig; // event cache (sig nal)	std::vector<const Event*> fEventsSig; // event cache (sig nal)
	std::vector<const Event*> fEventsBkg; // event cache (bac kground)	std::vector<const Event*> fEventsBkg; // event cache (bac kground)

	// sum of weights (this should become centrally available through the dataset)	// sum of weights (this should become centrally available through the dataset)

End of changes. 4 change blocks.
	4 lines changed or deleted	2 lines changed or added

	MethodTMlpANN.h	MethodTMlpANN.h

	// @(#)root/tmva $Id: MethodTMlpANN.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodTMlpANN.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodTMlpANN *	* Class : MethodTMlpANN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Implementation of interface for Root-integrated artificial neural *	* Implementation of interface for Root-integrated artificial neural *

	skipping to change at line 72	skipping to change at line 72
	const TString& theWeightFile,	const TString& theWeightFile,
	TDirectory* theTargetDir = NULL );	TDirectory* theTargetDir = NULL );

	virtual ~MethodTMlpANN( void );	virtual ~MethodTMlpANN( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;

	// write weights to file	// write weights to file

	void WriteWeightsToStream( ostream& o ) const;
	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;

	// read weights from file	// read weights from file
	void ReadWeightsFromStream( istream& istr );	void ReadWeightsFromStream( istream& istr );
	void ReadWeightsFromXML(void* wghtnode);	void ReadWeightsFromXML(void* wghtnode);

	// calculate the MVA value ...	// calculate the MVA value ...
	// - here it is just a dummy, as it is done in the overwritten	// - here it is just a dummy, as it is done in the overwritten
	// - PrepareEvaluationtree... ugly but necessary due to the strucure	// - PrepareEvaluationtree... ugly but necessary due to the strucure
	// of TMultiLayerPercepton in ROOT grr... :-(	// of TMultiLayerPercepton in ROOT grr... :-(

End of changes. 3 change blocks.
	3 lines changed or deleted	1 lines changed or added

	MinimizerOptions.h	MinimizerOptions.h

	// @(#)root/mathcore:$Id: MinimizerOptions.h 29513 2009-07-17 15:30:07Z mon eta $	// @(#)root/mathcore:$Id: MinimizerOptions.h 31604 2009-12-07 19:04:33Z mon eta $
	// Author: L. Moneta Fri Aug 15 2008	// Author: L. Moneta Fri Aug 15 2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2008 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2008 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Math_MinimizerOptions	#ifndef ROOT_Math_MinimizerOptions

	skipping to change at line 35	skipping to change at line 35
	*/	*/
	class MinimizerOptions {	class MinimizerOptions {

	public:	public:

	// static methods for setting and retrieving the default options	// static methods for setting and retrieving the default options

	static void SetDefaultMinimizer(const char * type, const char * algo = 0 );	static void SetDefaultMinimizer(const char * type, const char * algo = 0 );
	static void SetDefaultErrorDef( double up);	static void SetDefaultErrorDef( double up);
	static void SetDefaultTolerance(double tol);	static void SetDefaultTolerance(double tol);

		static void SetDefaultPrecision(double prec);
	static void SetDefaultMaxFunctionCalls(int maxcall);	static void SetDefaultMaxFunctionCalls(int maxcall);
	static void SetDefaultMaxIterations(int maxiter);	static void SetDefaultMaxIterations(int maxiter);
	static void SetDefaultStrategy(int strat);	static void SetDefaultStrategy(int strat);
	static void SetDefaultPrintLevel(int level);	static void SetDefaultPrintLevel(int level);

	static const std::string & DefaultMinimizerType();	static const std::string & DefaultMinimizerType();
	static const std::string & DefaultMinimizerAlgo();	static const std::string & DefaultMinimizerAlgo();
	static double DefaultErrorDef();	static double DefaultErrorDef();
	static double DefaultTolerance();	static double DefaultTolerance();

		static double DefaultPrecision();
	static int DefaultMaxFunctionCalls();	static int DefaultMaxFunctionCalls();
	static int DefaultMaxIterations();	static int DefaultMaxIterations();
	static int DefaultStrategy();	static int DefaultStrategy();
	static int DefaultPrintLevel();	static int DefaultPrintLevel();


	// default options	// constructor using the default options
	MinimizerOptions() :	MinimizerOptions();
	fLevel( MinimizerOptions::DefaultPrintLevel()),
	fMaxCalls( MinimizerOptions::DefaultMaxFunctionCalls() ),
	fMaxIter( MinimizerOptions::DefaultMaxIterations() ),
	fStrategy( MinimizerOptions::DefaultStrategy() ),
	fErrorDef( MinimizerOptions::DefaultErrorDef() ),
	fTolerance( MinimizerOptions::DefaultTolerance() ),
	fMinimType( MinimizerOptions::DefaultMinimizerType() ),
	fAlgoType( MinimizerOptions::DefaultMinimizerAlgo() )
	{}

	/** non-static methods for retrivieng options */	/** non-static methods for retrivieng options */

	/// set print level	/// set print level
	int PrintLevel() const { return fLevel; }	int PrintLevel() const { return fLevel; }

	/// max number of function calls	/// max number of function calls
	unsigned int MaxFunctionCalls() const { return fMaxCalls; }	unsigned int MaxFunctionCalls() const { return fMaxCalls; }

	/// max iterations	/// max iterations
	unsigned int MaxIterations() const { return fMaxIter; }	unsigned int MaxIterations() const { return fMaxIter; }

	/// strategy	/// strategy
	int Strategy() const { return fStrategy; }	int Strategy() const { return fStrategy; }

	/// absolute tolerance	/// absolute tolerance
	double Tolerance() const { return fTolerance; }	double Tolerance() const { return fTolerance; }


		/// precision in the objective funciton calculation (value <=0 means lef
		t to default)
		double Precision() const { return fPrecision; }

	/// error definition	/// error definition
	double ErrorDef() const { return fErrorDef; }	double ErrorDef() const { return fErrorDef; }

	/// type of minimizer	/// type of minimizer
	const std::string & MinimizerType() const { return fMinimType; }	const std::string & MinimizerType() const { return fMinimType; }

	/// type of algorithm	/// type of algorithm
	const std::string & MinimizerAlgorithm() const { return fAlgoType; }	const std::string & MinimizerAlgorithm() const { return fAlgoType; }

	/** non-static methods for setting options */	/** non-static methods for setting options */

	skipping to change at line 101	skipping to change at line 97

	///set maximum of function calls	///set maximum of function calls
	void SetMaxFunctionCalls(unsigned int maxfcn) { fMaxCalls = maxfcn; }	void SetMaxFunctionCalls(unsigned int maxfcn) { fMaxCalls = maxfcn; }

	/// set maximum iterations (one iteration can have many function calls)	/// set maximum iterations (one iteration can have many function calls)
	void SetMaxIterations(unsigned int maxiter) { fMaxIter = maxiter; }	void SetMaxIterations(unsigned int maxiter) { fMaxIter = maxiter; }

	/// set the tolerance	/// set the tolerance
	void SetTolerance(double tol) { fTolerance = tol; }	void SetTolerance(double tol) { fTolerance = tol; }


		/// set the precision
		void SetPrecision(double prec) { fPrecision = prec; }

	/// set the strategy	/// set the strategy
	void SetStrategy(int stra) { fStrategy = stra; }	void SetStrategy(int stra) { fStrategy = stra; }

	/// set error def	/// set error def
	void SetErrorDef(double err) { fErrorDef = err; }	void SetErrorDef(double err) { fErrorDef = err; }

	/// set minimizer type	/// set minimizer type
	void SetMinimizerType(const char * type) { fMinimType = type; }	void SetMinimizerType(const char * type) { fMinimType = type; }

	/// set minimizer algorithm	/// set minimizer algorithm
	void SetMinimizerAlgorithm(const char *type) { fAlgoType = type; }	void SetMinimizerAlgorithm(const char *type) { fAlgoType = type; }

	private:	private:

	int fLevel; // debug print level	int fLevel; // debug print level
	int fMaxCalls; // maximum number of function calls	int fMaxCalls; // maximum number of function calls
	int fMaxIter; // maximum number of iterations	int fMaxIter; // maximum number of iterations
	int fStrategy; // minimizer strategy (used by Minuit)	int fStrategy; // minimizer strategy (used by Minuit)
	double fErrorDef; // error definition (=1. for getting 1 sigma e rror for chi2 fits)	double fErrorDef; // error definition (=1. for getting 1 sigma e rror for chi2 fits)
	double fTolerance; // minimize tolerance to reach solution	double fTolerance; // minimize tolerance to reach solution

		double fPrecision; // precision of the objective funciton evaluat ion (value <=0 means left to default)
	std::string fMinimType; // Minimizer type (Minuit, Minuit2, etc..	std::string fMinimType; // Minimizer type (Minuit, Minuit2, etc..
	std::string fAlgoType; // Minimizer algorithmic specification (Migrad , Minimize, ...)	std::string fAlgoType; // Minimizer algorithmic specification (Migrad , Minimize, ...)

	};	};

	} // end namespace Math	} // end namespace Math

	} // end namespace ROOT	} // end namespace ROOT

	#endif	#endif

End of changes. 7 change blocks.
	12 lines changed or deleted	13 lines changed or added

	ModulekNN.h	ModulekNN.h

	// @(#)root/tmva $Id: ModulekNN.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: ModulekNN.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Rustem Ospanov	// Author: Rustem Ospanov

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : ModulekNN *	* Class : ModulekNN *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Module for k-nearest neighbor algorithm *	* Module for k-nearest neighbor algorithm *

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	MsgLogger.h	MsgLogger.h

	// @(#)root/tmva $Id: MsgLogger.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: MsgLogger.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Attila Krasznahorkay	// Author: Attila Krasznahorkay

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MsgLogger *	* Class : MsgLogger *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* TMVA output logger class producing nicely formatted log messages *	* TMVA output logger class producing nicely formatted log messages *

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	Node.h	Node.h

	// @(#)root/tmva $Id: Node.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: Node.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Classes: Node *	* Classes: Node *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Node for the BinarySearch or Decision Trees *	* Node for the BinarySearch or Decision Trees *

	skipping to change at line 44	skipping to change at line 44
	// //	// //
	// Node base class for the BinarySearch or Decision Trees Nodes //	// Node base class for the BinarySearch or Decision Trees Nodes //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <iosfwd>	#include <iosfwd>
	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif


		#ifndef ROOT_TMVA_Version
		#include "TMVA/Version.h"
		#endif

	namespace TMVA {	namespace TMVA {

	class Node;	class Node;
	class Event;	class Event;
	class BinaryTree;	class BinaryTree;

	std::ostream& operator<<( std::ostream& os, const Node& node );	std::ostream& operator<<( std::ostream& os, const Node& node );
	std::ostream& operator<<( std::ostream& os, const Node* node );	std::ostream& operator<<( std::ostream& os, const Node* node );

	// a class used to identify a Node; (needed for recursive reading from t ext file)	// a class used to identify a Node; (needed for recursive reading from t ext file)

	skipping to change at line 110	skipping to change at line 114
	//recursively go through the part of the tree below this node and cou nt all daughters	//recursively go through the part of the tree below this node and cou nt all daughters
	Int_t CountMeAndAllDaughters() const;	Int_t CountMeAndAllDaughters() const;

	// printout of the node	// printout of the node
	virtual void Print( std::ostream& os ) const = 0;	virtual void Print( std::ostream& os ) const = 0;

	// recursive printout of the node and it daughters	// recursive printout of the node and it daughters
	virtual void PrintRec ( std::ostream& os ) const = 0;	virtual void PrintRec ( std::ostream& os ) const = 0;

	void* AddXMLTo(void* parent) const;	void* AddXMLTo(void* parent) const;

	void ReadXML(void* node);	void ReadXML(void* node, UInt_t tmva_Version_Code = TMVA_VERSION_COD E );
	virtual void AddAttributesToNode(void* node) const = 0;	virtual void AddAttributesToNode(void* node) const = 0;
	virtual void AddContentToNode(std::stringstream& s) const = 0;	virtual void AddContentToNode(std::stringstream& s) const = 0;

	// Set depth, layer of the where the node is within the tree, seen fr om the top (root)	// Set depth, layer of the where the node is within the tree, seen fr om the top (root)
	void SetDepth(UInt_t d){fDepth=d;}	void SetDepth(UInt_t d){fDepth=d;}

	// Return depth, layer of the where the node is within the tree, seen from the top (root)	// Return depth, layer of the where the node is within the tree, seen from the top (root)
	UInt_t GetDepth() const {return fDepth;}	UInt_t GetDepth() const {return fDepth;}

	// set node position, i.e, the node is a left (l) or right (r) daugth er	// set node position, i.e, the node is a left (l) or right (r) daugth er

	skipping to change at line 134	skipping to change at line 138
	char GetPos() const {return fPos;}	char GetPos() const {return fPos;}

	// Return the pointer to the Parent tree to which the Node belongs	// Return the pointer to the Parent tree to which the Node belongs
	TMVA::BinaryTree* GetParentTree() const {return fParentTree;}	TMVA::BinaryTree* GetParentTree() const {return fParentTree;}

	// set the pointer to the Parent Tree to which the Node belongs	// set the pointer to the Parent Tree to which the Node belongs
	void SetParentTree(TMVA::BinaryTree* t) {fParentTree = t;}	void SetParentTree(TMVA::BinaryTree* t) {fParentTree = t;}

	int GetCount(){return fgCount;}	int GetCount(){return fgCount;}


	virtual Bool_t ReadDataRecord( std::istream& ) = 0;	virtual Bool_t ReadDataRecord( std::istream&, UInt_t tmva_Version_Cod
	virtual void ReadAttributes(void* node) = 0;	e = TMVA_VERSION_CODE ) = 0;
		virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM
		VA_VERSION_CODE ) = 0;
	virtual void ReadContent(std::stringstream& s) =0;	virtual void ReadContent(std::stringstream& s) =0;

	private:	private:

	Node* fParent; // the previous (parent) node	Node* fParent; // the previous (parent) node
	Node* fLeft; // pointers to the two "daughter" nodes	Node* fLeft; // pointers to the two "daughter" nodes
	Node* fRight; // pointers to the two "daughter" nodes	Node* fRight; // pointers to the two "daughter" nodes

	char fPos; // position, i.e. it is a left (l) or r ight (r) daughter	char fPos; // position, i.e. it is a left (l) or r ight (r) daughter
	UInt_t fDepth; // depth of the node within the tree (s een from root node)	UInt_t fDepth; // depth of the node within the tree (s een from root node)

End of changes. 4 change blocks.
	4 lines changed or deleted	10 lines changed or added

	NodekNN.h	NodekNN.h

	// @(#)root/tmva $Id: NodekNN.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: NodekNN.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Rustem Ospanov	// Author: Rustem Ospanov

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Node *	* Class : Node *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* kd-tree (binary tree) template *	* kd-tree (binary tree) template *

	skipping to change at line 134	skipping to change at line 134

	// recursive search for k-nearest neighbor: k = nfind	// recursive search for k-nearest neighbor: k = nfind
	template<class T>	template<class T>
	UInt_t Find(std::list<std::pair<const Node<T> *, Float_t> > &nlist,	UInt_t Find(std::list<std::pair<const Node<T> *, Float_t> > &nlist,
	const Node<T> *node, const T &event, UInt_t nfind);	const Node<T> *node, const T &event, UInt_t nfind);

	// recursive search for k-nearest neighbor	// recursive search for k-nearest neighbor
	// find k events with sum of event weights >= nfind	// find k events with sum of event weights >= nfind
	template<class T>	template<class T>
	UInt_t Find(std::list<std::pair<const Node<T> *, Float_t> > &nlist,	UInt_t Find(std::list<std::pair<const Node<T> *, Float_t> > &nlist,

	const Node<T> *node, const T &event, Double_t nfind, Doubl e_t ncurr);	const Node<T> *node, const T &event, Double_t nfind, Doub le_t ncurr);

	// recursively travel upward until root node is reached	// recursively travel upward until root node is reached
	template <class T>	template <class T>
	UInt_t Depth(const Node<T> *node);	UInt_t Depth(const Node<T> *node);

	// prInt_t node content and content of its children	// prInt_t node content and content of its children
	//template <class T>	//template <class T>
	//std::ostream& operator<<(std::ostream& os, const Node<T> &node);	//std::ostream& operator<<(std::ostream& os, const Node<T> &node);

	//	//

	skipping to change at line 395	skipping to change at line 395
	// need typename keyword because qualified dependent names	// need typename keyword because qualified dependent names
	// are not valid types unless preceded by 'typename'.	// are not valid types unless preceded by 'typename'.
	typename std::list<std::pair<const Node<T> *, Float_t> >::iterator lit = nlist.begin();	typename std::list<std::pair<const Node<T> *, Float_t> >::iterator lit = nlist.begin();

	// find a place where current node should be inserted	// find a place where current node should be inserted
	for (; lit != nlist.end(); ++lit) {	for (; lit != nlist.end(); ++lit) {
	if (distance < lit->second) {	if (distance < lit->second) {
	break;	break;
	}	}
	else {	else {

	continue;	continue;
	}	}
	}	}

	nlist.insert(lit, std::pair<const Node<T> *, Float_t>(node, distan ce));	nlist.insert(lit, std::pair<const Node<T> *, Float_t>(node, distan ce));

	if (remove_back) {	if (remove_back) {
	nlist.pop_back();	nlist.pop_back();
	}	}
	}	}
	}	}


	skipping to change at line 492	skipping to change at line 492
	if (distance < max_dist) {	if (distance < max_dist) {
	insert_this = kTRUE;	insert_this = kTRUE;
	}	}
	}	}
	else {	else {
	std::cerr << "TMVA::kNN::Find() - logic error in recursive procedu re" << std::endl;	std::cerr << "TMVA::kNN::Find() - logic error in recursive procedu re" << std::endl;
	return 1;	return 1;
	}	}

	if (insert_this) {	if (insert_this) {

	// (re)compute total current weight when inserting a new node	// (re)compute total current weight when inserting a new node
	ncurr = 0;	ncurr = 0;

	// need typename keyword because qualified dependent names	// need typename keyword because qualified dependent names
	// are not valid types unless preceded by 'typename'.	// are not valid types unless preceded by 'typename'.
	typename std::list<std::pair<const Node<T> *, Float_t> >::iterator lit = nlist.begin();	typename std::list<std::pair<const Node<T> *, Float_t> >::iterator lit = nlist.begin();

	// find a place where current node should be inserted	// find a place where current node should be inserted
	for (; lit != nlist.end(); ++lit) {	for (; lit != nlist.end(); ++lit) {
	if (distance < lit->second) {	if (distance < lit->second) {
	break;	break;
	}	}


	ncurr += lit -> first -> GetWeight();	ncurr += lit -> first -> GetWeight();
	}	}

	lit = nlist.insert(lit, std::pair<const Node<T> *, Float_t>(node, distance));	lit = nlist.insert(lit, std::pair<const Node<T> *, Float_t>(node, distance));

	for (; lit != nlist.end(); ++lit) {	for (; lit != nlist.end(); ++lit) {

	ncurr += lit -> first -> GetWeight();	ncurr += lit -> first -> GetWeight();
	if (!(ncurr < nfind)) {	if (!(ncurr < nfind)) {
	++lit;	++lit;
	break;	break;
	}	}
	}	}

	if(lit != nlist.end())	if(lit != nlist.end())
	{	{
	nlist.erase(lit, nlist.end());	nlist.erase(lit, nlist.end());
	}	}
	}	}
	}	}

	UInt_t count = 1;	UInt_t count = 1;
	if (node->GetNodeL() && node->GetNodeR()) {	if (node->GetNodeL() && node->GetNodeR()) {
	if (value < node->GetVarDis()) {	if (value < node->GetVarDis()) {
	count += Find(nlist, node->GetNodeL(), event, nfind, ncurr);	count += Find(nlist, node->GetNodeL(), event, nfind, ncurr);
	count += Find(nlist, node->GetNodeR(), event, nfind, ncurr);	count += Find(nlist, node->GetNodeR(), event, nfind, ncurr);
	}	}
	else {	else {

End of changes. 6 change blocks.
	18 lines changed or deleted	18 lines changed or added

	PDEFoam.h	PDEFoam.h

	// @(#)root/foam:$Name: not supported by cvs2svn $:$Id: PDEFoam.h 29246 200
	9-06-26 16:50:00Z brun $
	// Author: S. Jadach <mailto:Stanislaw.jadach@ifj.edu.pl>, P.Sawicki <mailt
	o:Pawel.Sawicki@ifj.edu.pl>

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *

	* Classes: PDEFoam, PDEFoamCell, PDEFoamIntegrand, PDEFoamMaxwt, PDEFoamVe	* Classes: PDEFoam
	ct, *	*
	* TFDISTR
	*
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *

	* Collection of helper classes to be used with MethodPDEFoam *	* Class for PDEFoam object *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
	* Tancredi Carli - CERN, Switzerland *	* Tancredi Carli - CERN, Switzerland *
	* Dominik Dannheim - CERN, Switzerland *	* Dominik Dannheim - CERN, Switzerland *
	* Alexander Voigt - CERN, Switzerland *	* Alexander Voigt - CERN, Switzerland *
	* *	* *
	* Copyright (c) 2008: *	* Copyright (c) 2008: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

	skipping to change at line 34	skipping to change at line 31
	* Redistribution and use in source and binary forms, with or without *	* Redistribution and use in source and binary forms, with or without *
	* modification, are permitted according to the terms listed in LICENSE *	* modification, are permitted according to the terms listed in LICENSE *
	* (http://tmva.sourceforge.net/LICENSE) *	* (http://tmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_PDEFoam	#ifndef ROOT_TMVA_PDEFoam
	#define ROOT_TMVA_PDEFoam	#define ROOT_TMVA_PDEFoam

	#include <iosfwd>	#include <iosfwd>


	#ifndef ROOT_TMath
	#include "TMath.h"
	#endif
	#ifndef ROOT_TH2D	#ifndef ROOT_TH2D
	#include "TH2D.h"	#include "TH2D.h"
	#endif	#endif
	#ifndef ROOT_TObjArray	#ifndef ROOT_TObjArray
	#include "TObjArray.h"	#include "TObjArray.h"
	#endif	#endif
	#ifndef ROOT_TObjString	#ifndef ROOT_TObjString
	#include "TObjString.h"	#include "TObjString.h"
	#endif	#endif
	#ifndef ROOT_TVectorT	#ifndef ROOT_TVectorT
	#include "TVectorT.h"	#include "TVectorT.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif

	#ifndef ROOT_TRefArray
	#include "TRefArray.h"
	#endif
	#ifndef ROOT_TMethodCall
	#include "TMethodCall.h"
	#endif
	#ifndef ROOT_TMVA_BinarySearchTree
	#include "TMVA/BinarySearchTree.h"
	#endif
	#ifndef ROOT_TMVA_VariableInfo	#ifndef ROOT_TMVA_VariableInfo
	#include "TMVA/VariableInfo.h"	#include "TMVA/VariableInfo.h"
	#endif	#endif
	#ifndef ROOT_TMVA_Timer	#ifndef ROOT_TMVA_Timer
	#include "TMVA/Timer.h"	#include "TMVA/Timer.h"
	#endif	#endif

	#ifndef ROOT_TRef
	#include "TRef.h"
	#endif
	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif

		#ifndef ROOT_TRandom3
		#include "TRandom3.h"
		#endif


	class TRandom3;	#ifndef ROOT_TMVA_PDEFoamDistr
		#include "TMVA/PDEFoamDistr.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamVect
		#include "TMVA/PDEFoamVect.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamCell
		#include "TMVA/PDEFoamCell.h"
		#endif

	namespace TMVA {	namespace TMVA {
	class PDEFoam;	class PDEFoam;
	class PDEFoamCell;	class PDEFoamCell;

	class PDEFoamIntegrand;
	class PDEFoamVect;
	class PDEFoamMaxwt;
	class MsgLogger;

	enum EKernel { kNone, kGaus, kLinN };	enum EKernel { kNone, kGaus, kLinN };
	enum ETargetSelection { kMean, kMpv };	enum ETargetSelection { kMean, kMpv };
	enum ECellType { kAll, kActive, kInActive };	enum ECellType { kAll, kActive, kInActive };

	enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget };
	// possible values, saved in foam cells	// enum type for possible foam cell values
	// kNev : number of events (saved in cell element 0)	// kNev : number of events (saved in cell element 0)
	// kDiscriminator : discriminator (saved in cell element 0)	// kDiscriminator : discriminator (saved in cell element 0)

		// kDiscriminatorError : error on discriminator (saved in cell element 1 )
	// kTarget0 : target 0 (saved in cell element 0)	// kTarget0 : target 0 (saved in cell element 0)

		// kTargetError : error on target 0 (saved in cell element 1)
	// kMeanValue : mean sampling value (saved in fIntegral)	// kMeanValue : mean sampling value (saved in fIntegral)
	// kRms : rms of sampling distribution (saved in fDriver)	// kRms : rms of sampling distribution (saved in fDriver)

	// kRmsOvMean : rms/mean of sampling distribution (saved in fDriver	// kRmsOvMean : rms/mean of sampling distribution (saved in
	and fIntegral)	// fDriver and fIntegral)
	// kDensity : number of events/cell volume	// kDensity : number of events/cell volume

	enum ECellValue { kNev, kDiscriminator, kTarget0, kMeanValue, kRms, kRms	enum ECellValue { kNev, kDiscriminator, kDiscriminatorError, kTarget0,
	OvMean, kDensity };	kTarget0Error, kMeanValue, kRms, kRmsOvMean, kDensity
	// options for filling density (used in Density() to build up foam)	};
	// kEVENT_DENSITY : use event density for foam buildup
	// kDISCRIMINATOR : use N_sig/(N_sig + N_bg) for foam buildup
	// kTARGET : use GetTarget(0) for foam build up
	enum TDensityCalc { kEVENT_DENSITY, kDISCRIMINATOR, kTARGET };
	}	}


	//////////////////////////////////////////////////////////////
	// //
	// Class PDEFoamIntegrand is an Abstract class representing //
	// n-dimensional real positive integrand function //
	// //
	//////////////////////////////////////////////////////////////

	namespace TMVA {	namespace TMVA {


	class PDEFoamIntegrand : public ::TObject {

	public:
	PDEFoamIntegrand();
	virtual ~PDEFoamIntegrand() { }
	virtual Double_t Density(Int_t ndim, Double_t *) = 0;
	virtual Double_t Density(Int_t ndim, Double_t *, Double_t &) = 0;

	ClassDef(PDEFoamIntegrand,1); //n-dimensional real positive integrand
	of FOAM
	}; // end of PDEFoamIntegrand
	} // namespace TMVA

	///////////////////////////////////////////////////////////////////////////
	///
	//
	//
	// TFDISTR is a child class of PDEFoamIntegrand and contains Methods to
	//
	// create a probability density by filling in events.
	//
	// The main function is Density() which provides the event density at a
	//
	// given point during the foam build-up (sampling).
	//
	//
	//
	///////////////////////////////////////////////////////////////////////////
	///

	namespace TMVA {

	// class definition of underlying density
	class TFDISTR : public PDEFoamIntegrand
	{
	private:
	Int_t fDim; // number of dimensions
	Float_t *fXmin; //[fDim] minimal value of phase space in al
	l dimension
	Float_t *fXmax; //[fDim] maximal value of phase space in al
	l dimension
	Float_t fVolFrac; // volume fraction (with respect to total p
	hase space
	BinarySearchTree *fBst; // Binary tree to find events within a volu
	me
	TDensityCalc fDensityCalc;// method of density calculation

	protected:
	Int_t fSignalClass; // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event
	Int_t fBackgroundClass; // TODO: intermediate solution to keep IsSig
	nal() of Event working. TODO: remove IsSignal() from Event

	mutable MsgLogger* fLogger; //! message logger
	MsgLogger& Log() const { return *fLogger; }

	public:
	TFDISTR();
	virtual ~TFDISTR();

	// Getter and setter for VolFrac option
	void SetVolumeFraction(Float_t vfr){fVolFrac=vfr; return;}
	Float_t GetVolumeFraction(){return fVolFrac;}

	// set foam dimension (mandatory before foam build-up!)
	void SetDim(Int_t idim){
	fDim = idim;
	if (fXmin) delete [] fXmin;
	if (fXmax) delete [] fXmax;
	fXmin = new Float_t[fDim];
	fXmax = new Float_t[fDim];
	return;
	}

	// set foam boundaries
	void SetXmin(Int_t idim,Float_t wmin){fXmin[idim]=wmin; return;}
	void SetXmax(Int_t idim,Float_t wmax){fXmax[idim]=wmax; return;}

	// transformation functions for event variable into foam boundaries
	// reason: foam allways has boundaries [0, 1]
	Float_t VarTransform(Int_t idim, Float_t x){ // transform [xmi
	n, xmax] --> [0, 1]
	Float_t b=fXmax[idim]-fXmin[idim];
	return (x-fXmin[idim])/b;
	}
	Float_t VarTransformInvers(Int_t idim, Float_t x){ // transform [0,
	1] --> [xmin, xmax]
	Float_t b=fXmax[idim]-fXmin[idim];
	return x*b + fXmin[idim];
	}

	// debug function
	void PrintDensity();

	// density build-up functions
	void Initialize(Int_t ndim = 2);
	void FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNe
	gWeights=kFALSE );

	// Dominik Dannheim 10.Jan.2008
	// new method to fill edge histograms directly, without MC sampling
	void FillEdgeHist(Int_t nDim, TObjArray myfHistEdg , Double_t cellP
	osi, Double_t cellSize, Double_t ceSum, Double_t ceVol);

	// main function used by PDEFoam
	// returns density at a given point by range searching in BST
	Double_t Density(int nDim, Double_t *Xarg, Double_t &event_density);
	Double_t Density(int nDim, Double_t *Xarg){
	Double_t event_density = 0;
	return Density(nDim, Xarg, event_density);
	};

	// helper functions on BST
	UInt_t GetNEvents(PDEFoamCell* cell); // gets number of events in cel
	l (from fBst)
	Bool_t CellRMSCut(PDEFoamCell* cell, Float_t rms_cut, Int_t nbin); //
	calc cell rms and compare with rms_cut

	// Getters and setters for foam filling method
	void SetDensityCalc( TDensityCalc dc ){ fDensityCalc = dc; };
	Bool_t FillDiscriminator(){ return fDensityCalc == kDISCRIMINATOR; }
	Bool_t FillTarget0() { return fDensityCalc == kTARGET; }
	Bool_t FillEventDensity() { return fDensityCalc == kEVENT_DENSITY; }

	void SetSignalClass( Int_t cls ) { fSignalClass = cls; } // TODO
	: intermediate solution to keep IsSignal() of Event working. TODO: remove I
	sSignal() from Event
	void SetBackgroundClass( Int_t cls ) { fBackgroundClass = cls; } //
	TODO: intermediate solution to keep IsSignal() of Event working. TODO: remo
	ve IsSignal() from Event
	TH2D* MakeHistogram(Int_t nbinsx, Int_t nbinsy);

	ClassDef(TFDISTR,3) //Class for Event density
	}; //end of TFDISTR

	} // namespace TMVA

	///////////////////////////////////////////////////////////////////////////
	///
	//
	//
	// PDEFoam is the child class of the multi-dimensional general purpose
	//
	// Monte Carlo event generator (integrator) PDEFoam.
	//
	//
	//
	///////////////////////////////////////////////////////////////////////////
	///

	namespace TMVA {

	class PDEFoamCell;
	class PDEFoam;

	std::ostream& operator<< ( std::ostream& os, const PDEFoam& pdefoam );	std::ostream& operator<< ( std::ostream& os, const PDEFoam& pdefoam );
	std::istream& operator>> ( std::istream& istr, PDEFoam& pdefoam );	std::istream& operator>> ( std::istream& istr, PDEFoam& pdefoam );

	class PDEFoam : public TObject {	class PDEFoam : public TObject {
	protected:	protected:
	// COMPONENTS //	// COMPONENTS //
	//-------------- Input parameters	//-------------- Input parameters
	TString fName; // Name of a given instance of the FOAM cl ass	TString fName; // Name of a given instance of the FOAM cl ass

	TString fVersion; // Actual version of the FOAM like (1.01m)
	TString fDate; // Release date of FOAM
	Int_t fDim; // Dimension of the integration/simulation space	Int_t fDim; // Dimension of the integration/simulation space
	Int_t fNCells; // Maximum number of cells	Int_t fNCells; // Maximum number of cells

	Int_t fRNmax; // Maximum No. of the rand. numb. requeste
	d at once
	//-------------------
	Int_t fOptDrive; // Optimization switch =1,2 for variance o
	r maximum weight optimization
	Int_t fChat; // Chat=0,1,2 chat level in output, Chat=1
	normal level
	Int_t fOptRej; // Switch =0 for weighted events; =1 for u
	nweighted events in MC
	//-------------------	//-------------------
	Int_t fNBin; // No. of bins in the edge histogram for c ell MC exploration	Int_t fNBin; // No. of bins in the edge histogram for c ell MC exploration
	Int_t fNSampl; // No. of MC events, when dividing (explor ing) cell	Int_t fNSampl; // No. of MC events, when dividing (explor ing) cell
	Int_t fEvPerBin; // Maximum number of effective (wt=1) even ts per bin	Int_t fEvPerBin; // Maximum number of effective (wt=1) even ts per bin
	//------------------- MULTI-BRANCHING ---------------------	//------------------- MULTI-BRANCHING ---------------------

	Int_t *fMaskDiv; //! [fDim] Dynamic Mask for cell division	Int_t *fMaskDiv; //! [fDim] Dynamic Mask for cell division
	Int_t *fInhiDiv; //! [fDim] Flags for inhibiting cell divis ion	Int_t *fInhiDiv; //! [fDim] Flags for inhibiting cell divis ion

	Int_t fOptPRD; // Option switch for predefined division,
	for quick check
	PDEFoamVect **fXdivPRD; //! Lists of division values encoded in on
	e vector per direction
	//------------------- GEOMETRY ----------------------------	//------------------- GEOMETRY ----------------------------
	Int_t fNoAct; // Number of active cells	Int_t fNoAct; // Number of active cells
	Int_t fLastCe; // Index of the last cell	Int_t fLastCe; // Index of the last cell
	PDEFoamCell **fCells; // [fNCells] Array of ALL cells	PDEFoamCell **fCells; // [fNCells] Array of ALL cells
	//------------------ M.C. generation----------------------------	//------------------ M.C. generation----------------------------

	PDEFoamMaxwt *fMCMonit; // Monitor of the MC weight for measuring
	MC efficiency
	Double_t fMaxWtRej; // Maximum weight in rejection for getting
	wt=1 events
	TRefArray *fCellsAct; // Array of pointers to active cells, cons
	tructed at the end of foam build-up
	Double_t *fPrimAcu; // [fNoAct] Array of cumulative probabilit
	y of all active cells
	TObjArray *fHistEdg; // Histograms of wt, one for each cell edg e	TObjArray *fHistEdg; // Histograms of wt, one for each cell edg e

	TObjArray *fHistDbg; // Histograms of wt, for debug	Double_t *fRvec; // [fDim] random number vector from r.n. g
	TH1D *fHistWt; // Histogram of the MC wt	enerator fDim+1 maximum elements

	Double_t *fMCvect; // [fDim] Generated MC vector for the outs
	ide user
	Double_t fMCwt; // MC weight
	Double_t *fRvec; // [fRNmax] random number vector from r.n.
	generator fDim+1 maximum elements
	//----------- Procedures	//----------- Procedures

	PDEFoamIntegrand *fRho; //! Pointer to the user-defined integrand
	function/distribution
	TMethodCall *fMethodCall; //! ROOT's pointer to user-defined global
	distribution function
	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers

	//----------- Statistics and MC results
	Long_t fNCalls; // Total number of the function calls
	Long_t fNEffev; // Total number of effective events (wt=1)
	in the foam buildup
	Double_t fSumWt, fSumWt2; // Total sum of wt and wt^2
	Double_t fSumOve; // Total Sum of overveighted events
	Double_t fNevGen; // Total number of the generated MC events
	Double_t fWtMax, fWtMin; // Maximum/Minimum MC weight
	Double_t fPrime; // Primary integral R' (R=R'<wt>)
	Double_t fMCresult; // True Integral R from MC series
	Double_t fMCerror; // and its error
	//---------- working space for CELL exploration -------------	//---------- working space for CELL exploration -------------
	Double_t *fAlpha; // [fDim] Internal parameters of the hyper rectangle	Double_t *fAlpha; // [fDim] Internal parameters of the hyper rectangle
	// --------- PDE-Foam specific variables	// --------- PDE-Foam specific variables

		EFoamType fFoamType; // type of foam
	Double_t *fXmin; // [fDim] minimum for variable transform	Double_t *fXmin; // [fDim] minimum for variable transform
	Double_t *fXmax; // [fDim] maximum for variable transform	Double_t *fXmax; // [fDim] maximum for variable transform
	UInt_t fNElements; // number of variables in every cell	UInt_t fNElements; // number of variables in every cell
	Bool_t fCutNmin; // true: activate cut on minimal number of e vents in cell	Bool_t fCutNmin; // true: activate cut on minimal number of e vents in cell
	UInt_t fNmin; // minimal number of events in cell to split cell	UInt_t fNmin; // minimal number of events in cell to split cell

	Bool_t fCutRMSmin; // true: peek cell with max. RMS for next s plit	Bool_t fCutRMSmin; // true: peek cell with max. RMS for next sp lit
	Double_t fRMSmin; // activate cut: minimal RMS in cell to spli t cell	Double_t fRMSmin; // activate cut: minimal RMS in cell to spli t cell
	Float_t fVolFrac; // volume fraction (with respect to total ph ase space	Float_t fVolFrac; // volume fraction (with respect to total ph ase space

	TFDISTR *fDistr; //! density from extern	PDEFoamDistr *fDistr; //! distribution of training events
	Timer *fTimer; // timer for graphical output	Timer *fTimer; // timer for graphical output
	TObjArray *fVariableNames;// collection of all variable names	TObjArray *fVariableNames;// collection of all variable names
	Int_t fSignalClass; // TODO: intermediate solution to keep IsSig nal() of Event working. TODO: remove IsSignal() from Event	Int_t fSignalClass; // TODO: intermediate solution to keep IsSig nal() of Event working. TODO: remove IsSignal() from Event
	Int_t fBackgroundClass; // TODO: intermediate solution to keep IsSig nal() of Event working. TODO: remove IsSignal() from Event	Int_t fBackgroundClass; // TODO: intermediate solution to keep IsSig nal() of Event working. TODO: remove IsSignal() from Event
	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }


	/////////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////
	/////////////////////////	// METHODS //
	// METHODS	/////////////////////////////////////////////////////////////////
	//
	/////////////////////////////////////////////////////////////////////
	/////////////////////////
	private:	private:
	Double_t Sqr(Double_t x) const { return x*x;} // Square function	Double_t Sqr(Double_t x) const { return x*x;} // Square function

	protected:	protected:

	// override PDEFoam::OutputGrow(Bool_t) for nicer TMVA output	// ---------- TMVA console output
	virtual void OutputGrow(Bool_t finished = false );


	// weight result from function with kernel	void OutputGrow(Bool_t finished = false ); // nice TMVA console outpu
	Double_t WeightGaus(PDEFoamCell*, std::vector<Float_t>, UInt_t dim=0)	t
	;
	Double_t WeightLinNeighbors( std::vector<Float_t> txvec, ECellValue c
	v );


	public:	// ---------- Weighting functions for kernels
	PDEFoam(); // Default constructor (used only by ROOT
	streamer)
	PDEFoam(const TString&); // Principal user-defined constructor
	virtual ~PDEFoam(); // Default destructor
	PDEFoam(const PDEFoam&); // Copy Constructor NOT USED


	// Initialization	Float_t WeightGaus(PDEFoamCell*, std::vector<Float_t>, UInt_t dim=0);
	virtual void Initialize(Bool_t CreateCellElements); // Initialisa
	tion of foam
	virtual void Initialize(TRandom3, PDEFoamIntegrand ); // Alternativ
	e initialization method, backward compatibility
	virtual void InitCells(Bool_t CreateCellElements); // Initialisa
	tion of all foam cells
	virtual Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty ce
	ll and return its index
	virtual void Explore(PDEFoamCell *Cell); // Exploration of the new
	cell, determine <wt>, wtMax etc.
	virtual void Carver(Int_t&,Double_t&,Double_t&);// Determines the bes
	t edge, wt_max reduction
	virtual void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Det
	ermines the best edge, variace reduction
	virtual void MakeAlpha(); // Provides random point in
	side hyperrectangle
	virtual void Grow(); // build up foam
	virtual Long_t PeekMax(); // peek cell with max. driv
	er integral
	virtual Int_t Divide(PDEFoamCell *); // Divide iCell into two da
	ughters; iCell retained, taged as inactive
	virtual void MakeActiveList(); // Creates table of active
	cells
	virtual void GenerCel2(PDEFoamCell *&); // Chose an active cell the
	with probability ~ Primary integral
	// Generation
	virtual Double_t Eval(Double_t *xRand, Double_t &event_density); // e
	valuate distribution on point 'xRand'
	virtual Double_t Eval(Double_t *xRand){ // evaluate distribution on
	point 'xRand'
	Double_t event_density = 0;
	return Eval(xRand, event_density);
	};
	virtual void MakeEvent(); // Makes (generates) single
	MC event
	virtual void GetMCvect(Double_t *); // Provides generated rando
	mly MC vector
	virtual void GetMCwt(Double_t &); // Provides generated MC we
	ight
	virtual Double_t GetMCwt(); // Provides generates MC we
	ight
	virtual Double_t MCgenerate(Double_t *MCvect);// All three above func
	tion in one
	// Finalization
	virtual void GetIntegMC(Double_t&, Double_t&); // Provides Integrand
	and abs. error from MC run
	virtual void GetIntNorm(Double_t&, Double_t&); // Provides normaliza
	tion Inegrand
	virtual void GetWtParams(Double_t, Double_t&, Double_t&, Double_t&);/
	/ Provides MC weight parameters
	virtual void Finalize( Double_t&, Double_t&); // Prints summary o
	f MC integration
	virtual PDEFoamIntegrand *GetRho(){return fRho;} // Gets pointer of
	the distribut. (after restoring from disk)
	virtual TRandom3*GetPseRan() const {return fPseRan;} // Gets pointe
	r of r.n. generator (after restoring from disk)
	virtual void SetRhoInt(void *Rho); // Set new integrand
	distr. in interactive mode
	virtual void SetRho(PDEFoamIntegrand *Rho); // Set new integrand
	distr. in compiled mode
	virtual void ResetRho(PDEFoamIntegrand *Rho); // Set new
	distribution, delete old
	virtual void SetPseRan(TRandom3*PseRan){fPseRan=PseRan;} // Set new
	r.n. generator
	virtual void ResetPseRan(TRandom3*PseRan); // Set new
	r.n.g, delete old
	// Getters and Setters
	virtual void SetkDim(Int_t kDim){ // Sets dimension of cubical space
	fDim = kDim;
	if (fXmin) delete [] fXmin;
	if (fXmax) delete [] fXmax;
	fXmin = new Double_t[GetTotDim()];
	fXmax = new Double_t[GetTotDim()];
	}
	virtual void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maxi
	mum number of cells
	virtual void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no o
	f MC events in cell exploration
	virtual void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no o
	f bins in histogs in cell exploration
	virtual void SetChat(Int_t Chat){fChat = Chat;} // Sets opti
	on Chat, chat level
	virtual void SetOptRej(Int_t OptRej){fOptRej =OptRej;} // Sets opti
	on for MC rejection
	virtual void SetOptDrive(Int_t OptDrive){fOptDrive =OptDrive;} // S
	ets optimization switch
	virtual void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // S
	ets max. no. of effective events per bin
	virtual void SetMaxWtRej(Double_t MaxWtRej){fMaxWtRej=MaxWtRej;} // S
	ets max. weight for rejection
	virtual void SetInhiDiv(Int_t, Int_t ); // Set inhibition
	of cell division along certain edge
	virtual void SetXdivPRD(Int_t, Int_t, Double_t[]); // Set predefined
	division points
	// Getters and Setters
	virtual const char *GetVersion() const {return fVersion.Data();}// Ge
	t version of the FOAM
	virtual Int_t GetTotDim() const { return fDim;} // Ge
	t total dimension
	virtual Double_t GetPrimary() const {return fPrime;} // Ge
	t value of primary integral R'
	virtual void GetPrimary(Double_t &prime) {prime = fPrime;} // Ge
	t value of primary integral R'
	virtual Long_t GetnCalls() const {return fNCalls;} // Ge
	t total no. of the function calls
	virtual Long_t GetnEffev() const {return fNEffev;} // Ge
	t total no. of effective wt=1 events
	virtual TString GetFoamName() const {return fName;} // Ge
	t name of foam
	// Debug
	virtual void CheckAll(Int_t); // Checks correctness of the entire
	data structure in the FOAM object
	virtual void PrintCells(); // Prints content of all cells
	virtual void LinkCells(void); // Void function for backward compa
	tibility

	// getter and setter to activate cut options
	void CutNmin(Bool_t cut ) { fCutNmin = cut; }
	Bool_t CutNmin() { return fCutNmin; }
	void CutRMSmin(Bool_t cut ) { fCutRMSmin = cut; }
	Bool_t CutRMSmin() { return fCutRMSmin; }

	// getter and setter for cut values
	void SetNmin(UInt_t val) { fNmin=val; }
	UInt_t GetNmin() { return fNmin; }
	void SetRMSmin(Double_t val) { fRMSmin=val; }
	Double_t GetRMSmin() { return fRMSmin; }


	// foam output operators	Double_t WeightLinNeighbors( std::vector<Float_t> txvec, ECellValue c
	friend std::ostream& operator<< ( std::ostream& os, const PDEFoam& pd	v,
	efoam );	Int_t dim1=-1, Int_t dim2=-1,
	friend std::istream& operator>> ( std::istream& istr, PDEFoam& pd	Bool_t TreatEmptyCells=kFALSE );
	efoam );


	void ReadStream(istream &); // read foam from stream	// ---------- Foam build-up functions
	void PrintStream(ostream &) const; // write foam from stream
	void ReadXML( void* parent ); // read foam variables from xml
	void AddXMLTo( void* parent ); // write foam variables to xml


	// getters/ setters for foam boundaries	// Internal foam initialization functions
	void SetXmin(Int_t idim, Double_t wmin){	void InitCells(Bool_t CreateCellElements); // Initialisation of
	fXmin[idim]=wmin;	all foam cells
	fDistr->SetXmin(idim, wmin);	Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and r
	return;	eturn its index
	}	void Explore(PDEFoamCell *Cell); // Exploration of the new cell, d
	void SetXmax(Int_t idim, Double_t wmax){	etermine <wt>, wtMax etc.
	fXmax[idim]=wmax;	void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines
	fDistr->SetXmax(idim, wmax);	the best edge, variace reduction
	return;	void MakeAlpha(); // Provides random point inside hyperre
	}	ctangle
	Double_t GetXmin(Int_t idim){return fXmin[idim];}	void Grow(); // build up foam
	Double_t GetXmax(Int_t idim){return fXmax[idim];}	Long_t PeekMax(); // peek cell with max. driver integral
		Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCe
		ll retained, taged as inactive
		Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate
		distribution on point 'xRand'


	// getter/ setter for variable name	// ---------- Cell value access functions
	void AddVariableName(const char *s){
	TObjString *os = new TObjString(s);
	AddVariableName(os);
	};
	void AddVariableName(TObjString *s){
	fVariableNames->Add(s);
	};
	TObjString* GetVariableName(Int_t idx){
	return dynamic_cast<TObjString*>(fVariableNames->At(idx));
	};


	// transformation functions for event variable into foam boundaries	// low level functions to access a certain cell value
	// reason: foam allways has boundaries [0, 1]	TVectorD* GetCellElements(std::vector<Float_t>); // return cell
	Float_t VarTransform(Int_t idim, Float_t x){ // transform [xmi	elements of cell with given coordinates
	n, xmax] --> [0, 1]	Double_t GetCellElement(PDEFoamCell *cell, UInt_t i); // get Element
	Float_t b=fXmax[idim]-fXmin[idim];	'i' in cell 'cell'
	return (x-fXmin[idim])/b;	void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); //
	}	set Element 'i' in cell 'cell' to value 'value'
	std::vector<Float_t> VarTransform(std::vector<Float_t> invec){
	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransform(i, invec.at(i)));
	return outvec;
	}
	Float_t VarTransformInvers(Int_t idim, Float_t x){ // transform [0,
	1] --> [xmin, xmax]
	Float_t b=fXmax[idim]-fXmin[idim];
	return x*b + fXmin[idim];
	}
	std::vector<Float_t> VarTransformInvers(std::vector<Float_t> invec){
	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransformInvers(i, invec.at(i)));
	return outvec;
	}


	// projection method	// helper functions to access cell data
	virtual TH2D* Project2(Int_t idim1, Int_t idim2, const char *opt="nev	Double_t GetCellValue(PDEFoamCell*, ECellValue);
	", const char *ker="kNone", UInt_t maxbins=0);


	// Project foam by creating MC events	// specific function used during evaluation; determines, whether a ce
	virtual TH2D* ProjectMC(Int_t idim1, Int_t idim2, Int_t nevents, Int_	ll value is undefined
	t nbin);	Bool_t CellValueIsUndefined( PDEFoamCell* );


	// Draw a 1-dim histogram	// finds cell according to given event variables
	virtual TH1D* Draw1Dim(const char *opt, Int_t nbin);	PDEFoamCell* FindCell(std::vector<Float_t>); //!
		std::vector<TMVA::PDEFoamCell*> FindCells(std::vector<Float_t>); //!


	// Generates C++ code (root macro) for drawing foam with boxes (only	// find cells, which fit a given event vector
	2-dim!)	void FindCellsRecursive(std::vector<Float_t>, PDEFoamCell*,
	virtual void RootPlot2dim( const TString& filename, std::string what,	std::vector<PDEFoamCell*> &);
	Bool_t CreateCanvas = kTRUE, Bool_t colors
	= kTRUE, Bool_t log_colors = kFALSE );	// calculates the mean/ mpv target values for a given event 'tvals'
		std::vector<Float_t> GetCellTargets( std::vector<Float_t> tvals, ETar
		getSelection ts );
		// get number of events in cell during foam build-up
		Double_t GetBuildUpCellEvents(PDEFoamCell* cell);


	// init TObject pointer on cells	// ---------- Public functions ----------------------------------
	void ResetCellElements(Bool_t allcells = false);	public:
		PDEFoam(); // Default constructor (used only by ROOT
		streamer)
		PDEFoam(const TString&); // Principal user-defined constructor
		virtual ~PDEFoam(); // Default destructor
		PDEFoam(const PDEFoam&); // Copy Constructor NOT USED


	// low level functions to access a certain cell value	// ---------- Foam creation functions
	TVectorD* GetCellElements(std::vector<Float_t>); // return cell
	elements of cell with given coordinates
	Double_t GetCellElement(PDEFoamCell *cell, UInt_t i); // get Element
	'i' in cell 'cell'
	void SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); //
	set Element 'i' in cell 'cell' to value 'value'
	void SetNElements(UInt_t numb){ fNElements = numb; } // init every
	cell element (TVectorD*)
	UInt_t GetNElements(){ return fNElements; } // returns num
	ber of elements, saved on every cell


	void DisplayCellContent(void); // debug function	void Init(); // initialize PDEFoamDistr
		void FillBinarySearchTree( const Event* ev, Bool_t NoNegWeights=kFALS
		E );
		void Create(Bool_t CreateCellElements=false); // build-up foam


	// functions to fill created cells with certain values	// function to fill created cell with given value
	void FillFoamCells(const Event* ev, EFoamType ft, Bool_t NoNegWeights	void FillFoamCells(const Event* ev, Bool_t NoNegWeights=kFALSE);
	=kFALSE);

	// functions to calc discriminators/ mean targets for every cell	// functions to calc discriminators/ mean targets for every cell
	// using filled cell values	// using filled cell values
	void CalcCellDiscr();	void CalcCellDiscr();
	void CalcCellTarget();	void CalcCellTarget();


	// helper functions to access cell data	// init TObject pointer on cells
	Double_t GetCellMean(std::vector<Float_t> xvec);	void ResetCellElements(Bool_t allcells = false);
	Double_t GetCellRMS(std::vector<Float_t> xvec);
	Double_t GetCellEntries(std::vector<Float_t> xvec);
	Double_t GetCellDiscr(std::vector<Float_t> xvec, EKernel kernel=kNone
	);
	Double_t GetCellDiscrError(std::vector<Float_t> xvec);
	Double_t GetCellDensity(std::vector<Float_t> xvec, EKernel kernel=kNo
	ne);


	Double_t GetCellMean(PDEFoamCell* cell);	// ---------- Getters and Setters
	Double_t GetCellRMS(PDEFoamCell* cell);
	Double_t GetCellRMSovMean(PDEFoamCell* cell);
	Double_t GetCellEntries(PDEFoamCell* cell);
	Double_t GetCellEvents(PDEFoamCell* cell);
	Double_t GetCellDiscr(PDEFoamCell* cell);
	Double_t GetCellDiscrError(PDEFoamCell* cell);
	Double_t GetCellRegValue0(PDEFoamCell* cell); // returns regression v
	alue (regression method 1)
	Double_t GetCellDensity(PDEFoamCell*);


	// returns regression value (mono target regression)	void SetkDim(Int_t kDim); // Sets dimension of cubical space
	Double_t GetCellRegValue0(std::vector<Float_t>, EKernel kernel=kNone)	void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum numb
	;	er of cells
	// returns regression value i, given all variables (multi target regr	void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC eve
	ession)	nts in cell exploration
	Double_t GetProjectedRegValue(UInt_t i, std::vector<Float_t> vals, EK	void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins i
	ernel kernel=kNone, ETargetSelection ts=kMean);	n histogs in cell exploration
	Double_t GetCellTarget(UInt_t target_number, std::vector<Float_t> tva	void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. n
	ls, ETargetSelection ts);	o. of effective events per bin
		void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division al
		ong certain edge
		void SetNElements(UInt_t numb){fNElements = numb;} // init every cell
		element (TVectorD*)
		void SetPDEFoamVolumeFraction(Double_t vfr){fVolFrac = vfr;} // set V
		olFrac to PDEFoam
		void SetVolumeFraction(Double_t); // set VolFrac to PDEFoamDistr
		void SetFoamType(EFoamType ft); // set foam type


	// helper/ debug functions	void SetSignalClass( Int_t cls ) { fSignalClass = cls; fDistr->Se
	Double_t GetSumCellIntg(); // test function. calculates sum	tSignalClass( cls ); } // TODO: intermediate solution to keep IsSignal() of
	over all cell->GetIntg()	Event working. TODO: remove IsSignal() from Event
	Double_t GetSumCellElements(UInt_t); // test function. calculates sum	void SetBackgroundClass( Int_t cls ) { fBackgroundClass = cls; fDistr
	over all cell->GetCellElement()	->SetBackgroundClass( cls ); } // TODO: intermediate solution to keep IsSig
	UInt_t GetNActiveCells(); // returns number of active cell	nal() of Event working. TODO: remove IsSignal() from Event
	s
	UInt_t GetNInActiveCells(); // returns number of not active
	cells
	UInt_t GetNCells(); // returns number of cells
	PDEFoamCell* GetRootCell(); // get pointer to root cell
	Int_t GetSumCellMemory(ECellType ct = kAll); // return memory cons
	umtion of all cells
	void CheckCells(Bool_t remove_empty_cells=false); // check all ce
	lls with respect to critical values
	void RemoveEmptyCell(Int_t iCell); // removes iCell if its volume
	is zero
	void PrintCellElements(); // print all cells with its el
	ements


	// find cell according to given event variables	Int_t GetTotDim() const {return fDim; } // Get total dimension
	PDEFoamCell* FindCell(std::vector<Float_t>); //!	TString GetFoamName() const {return fName; } // Get name of foam
		UInt_t GetNElements() const {return fNElements; } // returns number
		of elements, saved on every cell
		Double_t GetPDEFoamVolumeFraction() const {return fVolFrac;} // get V
		olFrac from PDEFoam
		EFoamType GetFoamType() const {return fFoamType;}; // get foam t
		ype
		UInt_t GetNActiveCells() const {return fNoAct;}; // returns numbe
		r of active cells
		UInt_t GetNInActiveCells() const {return GetNCells()-GetNActiveCell
		s();}; // returns number of not active cells
		UInt_t GetNCells() const {return fNCells;}; // returns nu
		mber of cells
		PDEFoamCell* GetRootCell() const {return fCells[0];}; // get pointe
		r to root cell

		// Getters and Setters for user cut options
		void CutNmin(Bool_t cut ) { fCutNmin = cut; }
		Bool_t CutNmin() { return fCutNmin; }
		void CutRMSmin(Bool_t cut ) { fCutRMSmin = cut; }
		Bool_t CutRMSmin() { return fCutRMSmin; }
		void SetNmin(UInt_t val) { fNmin=val; }
		UInt_t GetNmin() { return fNmin; }
		void SetRMSmin(Double_t val) { fRMSmin=val; }
		Double_t GetRMSmin() { return fRMSmin; }


	// helper functions to include TFDISTR into the PDEFoam class	// Getters and Setters for foam boundaries
	// set VolFrac to PDEFoam	void SetXmin(Int_t idim, Double_t wmin);
	void SetPDEFoamVolumeFraction( Double_t vfr) { fVolFrac = vfr; }	void SetXmax(Int_t idim, Double_t wmax);
	// get VolFrac from PDEFoam	Double_t GetXmin(Int_t idim){return fXmin[idim];}
	Double_t GetPDEFoamVolumeFraction() const { return fVolFrac; }	Double_t GetXmax(Int_t idim){return fXmax[idim];}
	void SetVolumeFraction(Double_t); // set VolFrac to TFDISTR
	void FillBinarySearchTree( const Event* ev, EFoamType ft, Bool_t NoNe
	gWeights=kFALSE );
	void Create(Bool_t CreateCellElements=false); // create PDEFoam
	void Init(); // initialize TFDISTR
	void PrintDensity(); // debug output
	void SetFoamType(EFoamType ft);


	void SetSignalClass( Int_t cls ) { fSignalClass = cls; fDistr->Se	// Getters and Setters for variable names
	tSignalClass( cls ); } // TODO: intermediate solution to keep IsSignal() of	void AddVariableName(const char *s) { AddVariableName(new TObjString(
	Event working. TODO: remove IsSignal() from Event	s)); };
	void SetBackgroundClass( Int_t cls ) { fBackgroundClass = cls; fDistr	void AddVariableName(TObjString *s) { fVariableNames->Add(s); };
	->SetBackgroundClass( cls ); } // TODO: intermediate solution to keep IsSig	TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjStrin
	nal() of Event working. TODO: remove IsSignal() from Event	g*>(fVariableNames->At(idx));};


	/////////////////////////////////////////////////////////////////////	// ---------- Transformation functions for event variables into foam
	/////////////////////////	boundaries
	ClassDef(PDEFoam,3) // General purpose self-adapting binning	// reason: foam allways has boundaries [0, 1]
	}; // end of PDEFoam


	} // namespace TMVA	Float_t VarTransform(Int_t idim, Float_t x); // transform [xmin
		, xmax] --> [0, 1]
		std::vector<Float_t> VarTransform(std::vector<Float_t> invec);
		Float_t VarTransformInvers(Int_t idim, Float_t x); // transform [0, 1
		] --> [xmin, xmax]
		std::vector<Float_t> VarTransformInvers(std::vector<Float_t> invec);

		// ---------- Debug functions

		void CheckAll(Int_t); // Checks correctness of the entire data s
		tructure in the FOAM object
		void PrintCells(); // Prints content of all cells
		void CheckCells(Bool_t remove_empty_cells=false); // check all
		cells with respect to critical values
		void RemoveEmptyCell(Int_t iCell); // removes iCell if its volume
		is zero
		void PrintCellElements(); // print all cells with its el
		ements


	///////////////////////////////////////////////////////////////////////////	// ---------- Foam output
	/////////
	//
	//
	// Class PDEFoamCell used in PDEFoam
	//
	//
	//
	// Objects of this class are hyperrectangular cells organized in the binary
	tree. //
	// Special algoritm for encoding relalive positioning of the cells
	//
	// saves total memory allocation needed for the system of cells.
	//
	//
	//
	///////////////////////////////////////////////////////////////////////////
	/////////


	namespace TMVA {	friend std::ostream& operator<< ( std::ostream& os, const PDEFoam& pd
		efoam );
		friend std::istream& operator>> ( std::istream& istr, PDEFoam& pd
		efoam );


	class PDEFoamVect;	void ReadStream(istream &); // read foam from stream
		void PrintStream(ostream &) const; // write foam from stream
		void ReadXML( void* parent ); // read foam variables from xml
		void AddXMLTo( void* parent ); // write foam variables to xml


	class PDEFoamCell : public TObject {	// ---------- Foam projection methods


	// static, the same for all cells!	// project foam to two-dimensional histogram
	private:	TH2D* Project2(Int_t idim1, Int_t idim2, const char *opt="nev",
	Short_t fDim; // Dimension of the vector space	const char *ker="kNone", UInt_t maxbins=0);
	// MEMBERS
		// helper function for Project2()
		Double_t GetProjectionCellValue( PDEFoamCell* cell,
		Int_t idim1, Int_t idim2, ECellValue
		cv );


	private:	// Project one-dimensional foam to a 1-dim histogram
	//--- linked tree organization ---	TH1D* Draw1Dim(const char *opt, Int_t nbin);
	Int_t fSerial; // Serial number
	Int_t fStatus; // Status (active, inactive)
	TRef fParent; // Pointer to parent cell
	TRef fDaught0; // Pointer to daughter 1
	TRef fDaught1; // Pointer to daughter 2
	//--- M.C. sampling and choice of the best edge ---


	private:	// Generates C++ code (root macro) for drawing foam with boxes (only
	Double_t fXdiv; // Factor for division	2-dim!)
	Int_t fBest; // Best Edge for division	void RootPlot2dim( const TString& filename, std::string what,
	//--- Integrals of all kinds ---	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE
	Double_t fVolume; // Cartesian Volume of cell	,
	Double_t fIntegral; // Integral over cell (estimate from	Bool_t log_colors = kFALSE );
	exploration)
	Double_t fDrive; // Driver integral, only for cell b
	uild-up
	Double_t fPrimary; // Primary integral, only for MC gen
	eration
	//---------- working space for the user --------------
	TObject *fElement; // may set by the user to save some
	data in this cell

	/////////////////////////////////////////////////////////////////////
	/////////////////
	// METHODS
	//
	/////////////////////////////////////////////////////////////////////
	/////////////////
	public:
	PDEFoamCell(); // Default Constructor for RO
	OT streamers
	PDEFoamCell(Int_t); // User Constructor
	PDEFoamCell(PDEFoamCell &); // Copy Constructor
	virtual ~PDEFoamCell(); // Destructor
	void Fill(Int_t, PDEFoamCell, PDEFoamCell, PDEFoamCell*); // As
	signs values of attributes
	PDEFoamCell& operator=(const PDEFoamCell&); // Substitution op
	erator (never used)
	//--------------- Geometry ----------------------------------
	Double_t GetXdiv() const { return fXdiv;} // Pointer to Xdi
	v
	Int_t GetBest() const { return fBest;} // Pointer to Bes
	t
	void SetBest(Int_t Best){ fBest =Best;} // Set Best edge
	candidate
	void SetXdiv(Double_t Xdiv){ fXdiv =Xdiv;} // Set x-division
	for best edge cand.
	void GetHcub( PDEFoamVect&, PDEFoamVect&) const; // Get positi
	on and size vectors (h-cubical subspace)
	void GetHSize( PDEFoamVect& ) const; // Get size onl
	y of cell vector (h-cubical subspace)
	//--------------- Integrals/Volumes -------------------------
	void CalcVolume(); // Calculates vol
	ume of cell
	Double_t GetVolume() const { return fVolume;} // Volume of cell
	Double_t GetIntg() const { return fIntegral;} // Get Integral
	Double_t GetDriv() const { return fDrive;} // Get Drive
	Double_t GetPrim() const { return fPrimary;} // Get Primary
	void SetIntg(Double_t Intg){ fIntegral=Intg;} // Set true integ
	ral
	void SetDriv(Double_t Driv){ fDrive =Driv;} // Set driver int
	egral
	void SetPrim(Double_t Prim){ fPrimary =Prim;} // Set primary in
	tegral
	//--------------- linked tree organization ------------------
	Int_t GetStat() const { return fStatus;} // Get Status
	void SetStat(Int_t Stat){ fStatus=Stat;} // Set Status
	PDEFoamCell* GetPare() const { return (PDEFoamCell*) fParent.GetObjec
	t(); } // Get Pointer to parent cell
	PDEFoamCell* GetDau0() const { return (PDEFoamCell*) fDaught0.GetObje
	ct(); } // Get Pointer to 1-st daughter vertex
	PDEFoamCell* GetDau1() const { return (PDEFoamCell*) fDaught1.GetObje
	ct(); } // Get Pointer to 2-nd daughter vertex
	void SetDau0(PDEFoamCell* Daug){ fDaught0 = Daug;} // Set point
	er to 1-st daughter
	void SetDau1(PDEFoamCell* Daug){ fDaught1 = Daug;} // Set point
	er to 2-nd daughter
	void SetPare(PDEFoamCell* Pare){ fParent = Pare;} // Set point
	er to parent
	void SetSerial(Int_t Serial){ fSerial=Serial;} // Set serial
	number
	Int_t GetSerial() const { return fSerial;} // Get serial
	number
	//--- other ---
	void Print(Option_t *option) const ; // Prints cell
	content
	//--- getter and setter for user variable ---
	void SetElement(TObject* fobj){ fElement = fobj; } // Set user va
	riable
	TObject* GetElement(){ return fElement; } // Get pointer
	to user varibale
	/////////////////////////////////////////////////////////////////////
	///////
	ClassDef(PDEFoamCell,1) //Single cell of FOAM
	}; // end of PDEFoamCell
	} // namespace TMVA

	//////////////////////////////////////////////////////////////////
	// //
	// Small auxiliary class for controlling MC weight. //
	// //
	//////////////////////////////////////////////////////////////////


	namespace TMVA {	// ---------- Foam evaluation functions


	class PDEFoamMaxwt : public TObject {	// get cell value for a given event
		Double_t GetCellValue(std::vector<Float_t>, ECellValue);


	private:	// helper functions to access cell data with kernel
	Double_t fNent; // No. of MC events	Double_t GetCellDiscr(std::vector<Float_t> xvec, EKernel kernel=kNone
	Int_t fnBin; // No. of bins on the weight distribution	);
	Double_t fwmax; // Maximum analyzed weight	Double_t GetCellDensity(std::vector<Float_t> xvec, EKernel kernel=kNo
		ne);


	protected:	// calc mean cell value of neighbor cells
	mutable MsgLogger* fLogger; //! message logger	Double_t GetAverageNeighborsValue(std::vector<Float_t> txvec, ECellVa
	MsgLogger& Log() const { return *fLogger; }	lue cv);


	public:	// returns regression value (mono target regression)
		Double_t GetCellRegValue0(std::vector<Float_t>, EKernel kernel=kNone)
		;


	TH1D *fWtHst1; // Histogram of the weight wt	// returns regression value i, given all variables (multi target regr
	TH1D *fWtHst2; // Histogram of wt filled with wt	ession)
		std::vector<Float_t> GetProjectedRegValue(std::vector<Float_t> vals,
		EKernel kernel=kNone, ETargetSelection ts=kMean);


	public:	// ---------- ROOT class definition
	// constructor	ClassDef(PDEFoam,3)
	PDEFoamMaxwt(); // NOT IMPLEMENTED (NEVER US	}; // end of PDEFoam
	ED)
	PDEFoamMaxwt(Double_t, Int_t); // Principal Constructor
	PDEFoamMaxwt(PDEFoamMaxwt &From); // Copy constructor
	virtual ~PDEFoamMaxwt(); // Destructor
	void Reset(); // Reset
	PDEFoamMaxwt& operator=(const PDEFoamMaxwt &); // operator =
	void Fill(Double_t);
	void Make(Double_t, Double_t&);
	void GetMCeff(Double_t, Double_t&, Double_t&); // get MC efficiency=
	<w>/wmax

	ClassDef(PDEFoamMaxwt,1); //Controlling of the MC weight (maximum wei
	ght)
	}; // end of PDEFoamMaxwt
	} // namespace TMVA

	///////////////////////////////////////////////////////////////////////////
	/////
	//
	//
	// Auxiliary class PDEFoamVect of n-dimensional vector, with dynamic alloca
	tion //
	// used for the cartesian geometry of the PDEFoam cells
	//
	//
	//
	///////////////////////////////////////////////////////////////////////////
	/////


	namespace TMVA {	} // namespace TMVA
	////////////////////////////////////////////////////////////////////////
	///////
	class PDEFoamVect : public TObject {


	private:	// ---------- Inline functions
	Int_t fDim; // Dimension
	Double_t *fCoords; // [fDim] Coordinates
	PDEFoamVect *fNext; // pointer for tree constructio
	n
	PDEFoamVect *fPrev; // pointer for tree constructio
	n


	protected:	//_____________________________________________________________________
	mutable MsgLogger* fLogger; //! message logger	inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x)
	MsgLogger& Log() const { return *fLogger; }	{
		// transform variable x from [xmin, xmax] --> [0, 1]
		return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
		}


	public:	//_____________________________________________________________________
	// constructor	inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(std::vector<Float_t
	PDEFoamVect(); // Constructor	> invec)
	PDEFoamVect(Int_t); // USER Constructor	{
	PDEFoamVect(const PDEFoamVect &); // Copy constructor	// transform vector invec from [xmin, xmax] --> [0, 1]
	virtual ~PDEFoamVect(); // Destructor	std::vector<Float_t> outvec;
		for(UInt_t i=0; i<invec.size(); i++)
	/////////////////////////////////////////////////////////////////////	outvec.push_back(VarTransform(i, invec.at(i)));
	/////////	return outvec;
	// Overloading operators	}
	//
	/////////////////////////////////////////////////////////////////////
	/////////
	PDEFoamVect& operator =( const PDEFoamVect& ); // = operator; Substit
	ution
	Double_t & operator[]( Int_t ); // [] provides POINTER
	to coordinate
	PDEFoamVect& operator =( Double_t [] ); // LOAD IN entire doub
	le vector
	PDEFoamVect& operator =( Double_t ); // LOAD IN double numb
	er
	////////////////////////// OTHER METHODS ///////////////////////
	///////////
	PDEFoamVect& operator+=( const PDEFoamVect& ); // +=; add vector u+
	=v (FAST)
	PDEFoamVect& operator-=( const PDEFoamVect& ); // +=; add vector u+
	=v (FAST)
	PDEFoamVect& operator=( const Double_t& ); // =; mult. by scal
	ar v*=x (FAST)
	PDEFoamVect operator+ ( const PDEFoamVect& ); // +; u=v+s, NEVER
	USE IT, SLOW!!!
	PDEFoamVect operator- ( const PDEFoamVect& ); // -; u=v-s, NEVER
	USE IT, SLOW!!!
	void Print(Option_t *option) const; // Prints vector
	void PrintList(); // Prints vector and the
	following linked list
	Int_t GetDim() const { return fDim; } // Returns dimension
	Double_t GetCoord(Int_t i) const { return fCoords[i]; } // Return
	s coordinate


	ClassDef(PDEFoamVect,1) //n-dimensional vector with dynamical allocat	//_____________________________________________________________________
	ion	inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x)
	}; // end of PDEFoamVect	{
	} // namespace TMVA	// transform variable x from [0, 1] --> [xmin, xmax]
		return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];
		}

		//_____________________________________________________________________
		inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(std::vector<F
		loat_t> invec)
		{
		// transform vector invec from [0, 1] --> [xmin, xmax]
		std::vector<Float_t> outvec;
		for(UInt_t i=0; i<invec.size(); i++)
		outvec.push_back(VarTransformInvers(i, invec.at(i)));
		return outvec;
		}

	#endif	#endif

End of changes. 73 change blocks.
	785 lines changed or deleted	265 lines changed or added

	PoissonLikelihoodFCN.h	PoissonLikelihoodFCN.h

	// @(#)root/mathcore:$Id: PoissonLikelihoodFCN.h 30539 2009-10-01 13:13:09Z moneta $	// @(#)root/mathcore:$Id: PoissonLikelihoodFCN.h 31763 2009-12-10 10:40:21Z moneta $
	// Author: L. Moneta Fri Aug 17 14:29:24 2007	// Author: L. Moneta Fri Aug 17 14:29:24 2007

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2007 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class PoissonLikelihoodFCN	// Header file for class PoissonLikelihoodFCN

	skipping to change at line 141	skipping to change at line 141
	virtual double DoDerivative(const double * x, unsigned int icoord ) con st {	virtual double DoDerivative(const double * x, unsigned int icoord ) con st {
	Gradient(x, &fGrad[0]);	Gradient(x, &fGrad[0]);
	return fGrad[icoord];	return fGrad[icoord];
	}	}

	//data member	//data member

	const BinData & fData;	const BinData & fData;
	const IModelFunction & fFunc;	const IModelFunction & fFunc;


	unsigned int fNDim;
	unsigned int fNPoints; // size of the data
	mutable unsigned int fNEffPoints; // number of effective points used in the fit	mutable unsigned int fNEffPoints; // number of effective points used in the fit

	mutable unsigned int fNCalls;

	mutable std::vector<double> fGrad; // for derivatives	mutable std::vector<double> fGrad; // for derivatives

	};	};

	// define useful typedef's	// define useful typedef's
	typedef PoissonLikelihoodFCN<ROOT::Math::IMultiGenFunction> PoissonLL Function;	typedef PoissonLikelihoodFCN<ROOT::Math::IMultiGenFunction> PoissonLL Function;
	typedef PoissonLikelihoodFCN<ROOT::Math::IMultiGradFunction> PoissonL LGradFunction;	typedef PoissonLikelihoodFCN<ROOT::Math::IMultiGradFunction> PoissonL LGradFunction;

	} // end namespace Fit	} // end namespace Fit

End of changes. 3 change blocks.
	4 lines changed or deleted	1 lines changed or added

	ProfileLikelihoodTestStat.h	ProfileLikelihoodTestStat.h

	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 31276 2009-11-18 15:0 6:42Z moneta $	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 31529 2009-12-03 14:5 7:25Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_ProfileLikelihoodTestStat	#ifndef ROOSTATS_ProfileLikelihoodTestStat

	skipping to change at line 138	skipping to change at line 138
	// store best fit parameters	// store best fit parameters
	// RooProfileLL::bestFitParams returns best fit of nuisance param eters only	// RooProfileLL::bestFitParams returns best fit of nuisance param eters only
	// fCachedBestFitParams = (RooArgSet*) (fProfile->bestFitPar ams().clone("lastBestFit"));	// fCachedBestFitParams = (RooArgSet*) (fProfile->bestFitPar ams().clone("lastBestFit"));
	// ProfileLL::getParameters returns current value of the paramete rs	// ProfileLL::getParameters returns current value of the paramete rs
	// fCachedBestFitParams = (RooArgSet*) (fProfile->getParamet ers(data)->clone("lastBestFit"));	// fCachedBestFitParams = (RooArgSet*) (fProfile->getParamet ers(data)->clone("lastBestFit"));
	//cout << "making fCachedBestFitParams: " << fCachedBestFitParams << fCachedBestFitParams->getSize() << endl;	//cout << "making fCachedBestFitParams: " << fCachedBestFitParams << fCachedBestFitParams->getSize() << endl;

	// store original values, since minimization will change them.	// store original values, since minimization will change them.
	RooArgSet* origParamVals = (RooArgSet*) paramsOfInterest.snapshot ();	RooArgSet* origParamVals = (RooArgSet*) paramsOfInterest.snapshot ();


	// find minimum	// find minimum - add these extra lines to avoid calling first SE
		T WARN in RooMinuit constructor
		Bool_t smode = RooMsgService::instance().silentMode() ;
		RooMsgService::instance().setSilentMode(kTRUE) ;
	RooMinuit minuit(*nll);	RooMinuit minuit(*nll);

		if (!smode) RooMsgService::instance().setSilentMode(kFALSE) ;
	minuit.setPrintLevel(-999);	minuit.setPrintLevel(-999);
	minuit.setNoWarn();	minuit.setNoWarn();
	minuit.migrad();	minuit.migrad();

	// store the best fit values for future use	// store the best fit values for future use
	fCachedBestFitParams = (RooArgSet*) (nll->getParameters(data)->sn apshot());	fCachedBestFitParams = (RooArgSet*) (nll->getParameters(data)->sn apshot());

	// restore parameters	// restore parameters
	SetParameters(origParamVals, &paramsOfInterest );	SetParameters(origParamVals, &paramsOfInterest );


End of changes. 3 change blocks.
	2 lines changed or deleted	6 lines changed or added

	RConfigOptions.h	RConfigOptions.h
	#ifndef ROOT_RConfigOptions	#ifndef ROOT_RConfigOptions
	#define ROOT_RConfigOptions	#define ROOT_RConfigOptions

	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.4.2/ i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.5.4p2/i 686-slc5-gcc43-opt --fail-on-missing --enable-cintex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5 --enable-mathmore --enable-m inuit2 --enable-mysql --enable-oracle --enable-python --enable-qt --enable- qtgsi --enable-reflex --enable-roofit --enable-table --enable-unuran --with -castor-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43 -opt/usr/include/shift --with-castor-libdir=/afs/cern.ch/sw/lcg/external/ca stor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-cern-libdir=/afs/cern.ch/s w/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/lib --with-dcap-libdir=/af s/cern.ch/sw/lcg/external/dcache_client/1.9.3/i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3/i686-sl c5-gcc43-opt/dcap/include --with-fftw3-incdir=/afs/cern.ch/sw/lcg/external/ fftw3/3.1.2/i686-slc5-gcc43-opt/include --with-fftw3-libdir=/afs/cern.ch/sw /lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/lib --with-gccxml=/afs/cern.c h/sw/lcg/external/gccxml/0.9.0_20090601/i686-slc5-gcc43-opt/bin --with-gfal -libdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-3/i686-slc5-gcc43-opt /lib --with-gfal-incdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-3/i68 6-slc5-gcc43-opt/include --with-globus-incdir=/afs/cern.ch/sw/lcg/external/ Grid/globus/4.0.3-VDT-1.6.0/i686-slc5-gcc43-opt/globus/include --with-globu s-libdir=/afs/cern.ch/sw/lcg/external/Grid/globus/4.0.3-VDT-1.6.0/i686-slc5 -gcc43-opt/globus/lib --with-gsl-incdir=/afs/cern.ch/sw/lcg/external/GSL/1. 10/i686-slc5-gcc43-opt/include --with-gsl-libdir=/afs/cern.ch/sw/lcg/extern al/GSL/1.10/i686-slc5-gcc43-opt/lib --with-mysql-incdir=/afs/cern.ch/sw/lcg /external/mysql/5.0.18/i686-slc5-gcc43-opt/include --with-mysql-libdir=/afs /cern.ch/sw/lcg/external/mysql/5.0.18/i686-slc5-gcc43-opt/lib --with-oracle -incdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0/i686-slc5-gcc43-opt/ include --with-oracle-libdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0 /i686-slc5-gcc43-opt/lib --with-shift-incdir=/afs/cern.ch/sw/lcg/external/c astor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/shift --with-shift-libdir=/a fs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --wi th-pythia6-libdir=/afs/cern.ch/user/b/bellenot/scratch0/dist/pythia6/i686-s lc5-gcc43-opt --with-pythia8-incdir=/afs/cern.ch/user/b/bellenot/scratch0/d ist/pythia8/i686-slc5-gcc43-opt/include --with-pythia8-libdir=/afs/cern.ch/ user/b/bellenot/scratch0/dist/pythia8/i686-slc5-gcc43-opt/lib --with-gviz-i ncdir=/build/bellenot/libraries/i686-slc5-gcc43-opt/graphviz-2.24.0/include /graphviz --with-gviz-libdir=/build/bellenot/libraries/i686-slc5-gcc43-opt/ graphviz-2.24.0/lib"	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.4.2/ i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.5.4p2/i 686-slc5-gcc43-opt --fail-on-missing --enable-cintex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5 --enable-mathmore --enable-m inuit2 --enable-mysql --enable-oracle --enable-python --enable-qt --enable- qtgsi --enable-reflex --enable-roofit --enable-table --enable-unuran --with -castor-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43 -opt/usr/include/shift --with-castor-libdir=/afs/cern.ch/sw/lcg/external/ca stor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-cern-libdir=/afs/cern.ch/s w/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/lib --with-dcap-libdir=/af s/cern.ch/sw/lcg/external/dcache_client/1.9.3/i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3/i686-sl c5-gcc43-opt/dcap/include --with-fftw3-incdir=/afs/cern.ch/sw/lcg/external/ fftw3/3.1.2/i686-slc5-gcc43-opt/include --with-fftw3-libdir=/afs/cern.ch/sw /lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/lib --with-gccxml=/afs/cern.c h/sw/lcg/external/gccxml/0.9.0_20090601/i686-slc5-gcc43-opt/bin --with-gfal -libdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-3/i686-slc5-gcc43-opt /lib --with-gfal-incdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-3/i68 6-slc5-gcc43-opt/include --with-globus-incdir=/afs/cern.ch/sw/lcg/external/ Grid/globus/4.0.3-VDT-1.6.0/i686-slc5-gcc43-opt/globus/include --with-globu s-libdir=/afs/cern.ch/sw/lcg/external/Grid/globus/4.0.3-VDT-1.6.0/i686-slc5 -gcc43-opt/globus/lib --with-gsl-incdir=/afs/cern.ch/sw/lcg/external/GSL/1. 10/i686-slc5-gcc43-opt/include --with-gsl-libdir=/afs/cern.ch/sw/lcg/extern al/GSL/1.10/i686-slc5-gcc43-opt/lib --with-mysql-incdir=/afs/cern.ch/sw/lcg /external/mysql/5.0.18/i686-slc5-gcc43-opt/include --with-mysql-libdir=/afs /cern.ch/sw/lcg/external/mysql/5.0.18/i686-slc5-gcc43-opt/lib --with-oracle -incdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0/i686-slc5-gcc43-opt/ include --with-oracle-libdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0 /i686-slc5-gcc43-opt/lib --with-shift-incdir=/afs/cern.ch/sw/lcg/external/c astor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/shift --with-shift-libdir=/a fs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --wi th-pythia6-libdir=/afs/cern.ch/user/b/bellenot/scratch0/dist/pythia6/i686-s lc5-gcc43-opt --with-pythia8-incdir=/afs/cern.ch/user/b/bellenot/scratch0/d ist/pythia8/i686-slc5-gcc43-opt/include --with-pythia8-libdir=/afs/cern.ch/ user/b/bellenot/scratch0/dist/pythia8/i686-slc5-gcc43-opt/lib --with-gviz-i ncdir=/build/bellenot/libraries/i686-slc5-gcc43-opt/graphviz-2.24.0/include /graphviz --with-gviz-libdir=/build/bellenot/libraries/i686-slc5-gcc43-opt/ graphviz-2.24.0/lib"

	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft gl builtin_freetype builtin_glew builtin_pcre builtin_zlib castor cint5 cin tex editline dcache exceptions explicitlink fftw3 gviz gdml genvector gfal krb5 ldap mathmore memstat minuit2 mysql opengl oracle pythia6 pythia8 pyth on qt qtgsi reflex roofit rfio shadowpw shared ssl table tmva unuran xft xm l xrootd thread"	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft gl builtin_freetype builtin_glew builtin_pcre builtin_zlib castor cint5 cin tex editline dcache exceptions explicitlink fftw3 gviz gdml genvector gfal globus krb5 ldap mathmore memstat minuit2 mysql opengl oracle pythia6 pythi a8 python qt qtgsi reflex roofit rfio shadowpw shared ssl table tmva unuran xft xml xrootd thread"

	#endif	#endif

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	RVersion.h	RVersion.h

	skipping to change at line 17	skipping to change at line 17
	* These macros can be used in the following way:	* These macros can be used in the following way:
	*	*
	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)
	* #include <newheader.h>	* #include <newheader.h>
	* #else	* #else
	* #include <oldheader.h>	* #include <oldheader.h>
	* #endif	* #endif
	*	*
	*/	*/


	#define ROOT_RELEASE "5.25/04"	#define ROOT_RELEASE "5.26/00"
	#define ROOT_RELEASE_DATE "Nov 23 2009"	#define ROOT_RELEASE_DATE "Dec 14 2009"
	#define ROOT_RELEASE_TIME "22:31:15"	#define ROOT_RELEASE_TIME "15:43:39"
	#define ROOT_SVN_REVISION 31399	#define ROOT_SVN_REVISION 31878
	#define ROOT_SVN_BRANCH "trunk"	#define ROOT_SVN_BRANCH "trunk"

	#define ROOT_VERSION_CODE 334084	#define ROOT_VERSION_CODE 334336
	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

End of changes. 2 change blocks.
	5 lines changed or deleted	5 lines changed or added

	Reader.h	Reader.h

	// @(#)root/tmva $Id: Reader.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: Reader.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Reader *	* Class : Reader *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Reader class to be used in the user application to interpret the tr ained *	* Reader class to be used in the user application to interpret the tr ained *

	skipping to change at line 123	skipping to change at line 123
	virtual const char* GetName() const { return "Reader"; }	virtual const char* GetName() const { return "Reader"; }
	Bool_t Verbose( void ) const { return fVerbose; }	Bool_t Verbose( void ) const { return fVerbose; }
	void SetVerbose( Bool_t v ) { fVerbose = v; }	void SetVerbose( Bool_t v ) { fVerbose = v; }

	const DataSetInfo& DataInfo() const { return fDataSetInfo; }	const DataSetInfo& DataInfo() const { return fDataSetInfo; }
	DataSetInfo& DataInfo() { return fDataSetInfo; }	DataSetInfo& DataInfo() { return fDataSetInfo; }

	void AddVariable( const TString& expression, Float_t* );	void AddVariable( const TString& expression, Float_t* );
	void AddVariable( const TString& expression, Int_t* );	void AddVariable( const TString& expression, Int_t* );


		void AddSpectator( const TString& expression, Float_t* );
		void AddSpectator( const TString& expression, Int_t* );

	private:	private:


		TString GetMethodTypeFromFile( const TString& filename );

	// this booking method is internal	// this booking method is internal
	IMethod* BookMVA( Types::EMVA method, const TString& weightfile );	IMethod* BookMVA( Types::EMVA method, const TString& weightfile );

	DataSetInfo fDataSetInfo; // the data set	DataSetInfo fDataSetInfo; // the data set

	DataInputHandler fDataInputHandler;	DataInputHandler fDataInputHandler;

	// Init Reader class	// Init Reader class
	void Init( void );	void Init( void );


End of changes. 3 change blocks.
	1 lines changed or deleted	6 lines changed or added

	RooConstraintSum.h	RooConstraintSum.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooConstraintSum.h 24269 2008-06-13 15:37:03Z wouter $	* File: $Id: RooConstraintSum.h 31654 2009-12-08 13:38:37Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_CONSTRAINT_SUM	#ifndef ROO_CONSTRAINT_SUM
	#define ROO_CONSTRAINT_SUM	#define ROO_CONSTRAINT_SUM

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"

		#include "RooSetProxy.h"

	class RooRealVar;	class RooRealVar;
	class RooArgList ;	class RooArgList ;

	class RooConstraintSum : public RooAbsReal {	class RooConstraintSum : public RooAbsReal {
	public:	public:

	RooConstraintSum() ;	RooConstraintSum() ;

	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet) ;	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet, const RooArgSet& paramSet) ;
	virtual ~RooConstraintSum() ;	virtual ~RooConstraintSum() ;

	RooConstraintSum(const RooConstraintSum& other, const char* name = 0);	RooConstraintSum(const RooConstraintSum& other, const char* name = 0);
	virtual TObject* clone(const char* newname) const { return new RooConstra intSum(*this, newname); }	virtual TObject* clone(const char* newname) const { return new RooConstra intSum(*this, newname); }

	protected:	protected:

	RooListProxy _set1 ; // Set of constraint terms	RooListProxy _set1 ; // Set of constraint terms

		RooSetProxy _paramSet ; // Set of parameters to which constraints apply
	TIterator* _setIter1 ; //! do not persist	TIterator* _setIter1 ; //! do not persist

	Double_t evaluate() const;	Double_t evaluate() const;


	ClassDef(RooConstraintSum,1) // sum of -log of set of RooAbsPdf represent ing parameter constraints	ClassDef(RooConstraintSum,2) // sum of -log of set of RooAbsPdf represent ing parameter constraints
	};	};

	#endif	#endif

End of changes. 5 change blocks.
	3 lines changed or deleted	5 lines changed or added

	RootFinder.h	RootFinder.h

	// @(#)root/mathmore:$Id: RootFinder.h 25486 2008-09-22 12:43:03Z moneta $	// @(#)root/tmva $Id: RootFinder.h 29195 2009-06-24 10:39:49Z brun $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss


	/**********************************************************************	/**************************************************************************
	* *	********
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis
	* *	*
	* This library is free software; you can redistribute it and/or *	* Package: TMVA
	* modify it under the terms of the GNU General Public License *	*
	* as published by the Free Software Foundation; either version 2 *	* Class : RootFinder
	* of the License, or (at your option) any later version. *	*
	* *	* Web : http://tmva.sourceforge.net
	* This library is distributed in the hope that it will be useful, *	*
	* but WITHOUT ANY WARRANTY; without even the implied warranty of *	*
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *	*
	* General Public License for more details. *	* Description:
	* *	*
	* You should have received a copy of the GNU General Public License *	* Root finding using Brents algorithm
	* along with this library (see file COPYING); if not, write *	*
	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *	* (translated from CERNLIB function RZERO)
	* 330, Boston, MA 02111-1307 USA, or contact the author. *	*
	* *	*
	**********************************************************************/	*
		* Authors (alphabetical):
	// Header file for class RootFinder	*
	//	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland
	// Created by: moneta at Sun Nov 14 16:59:55 2004	*
	//	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German
	// Last update: Sun Nov 14 16:59:55 2004	y *
	//	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada
	#ifndef ROOT_Math_RootFinder	*
	#define ROOT_Math_RootFinder	*
		*
		* Copyright (c) 2005:
		*
		* CERN, Switzerland
		*
		* U. of Victoria, Canada
		*
		* MPI-K Heidelberg, Germany
		*
		*
		*
		* Redistribution and use in source and binary forms, with or without
		*
		* modification, are permitted according to the terms listed in LICENSE
		*
		* (http://tmva.sourceforge.net/LICENSE)
		*
		**************************************************************************
		********/

		#ifndef ROOT_TMVA_RootFinder
		#define ROOT_TMVA_RootFinder

		//////////////////////////////////////////////////////////////////////////
		// //
		// RootFinder //
		// //
		// Root finding using Brents algorithm //
		// (translated from CERNLIB function RZERO) //
		// //
		//////////////////////////////////////////////////////////////////////////


	#ifndef ROOT_Math_IFunctionfwd	#ifndef ROOT_TObject
	#include "Math/IFunctionfwd.h"	#include "TObject.h"
	#endif	#endif


	#ifndef ROOT_Math_IRootFinderMethod	namespace TMVA {
	#include "Math/IRootFinderMethod.h"
	#endif


	/**	class MsgLogger;
	@defgroup RootFinders One-dimensional Root-Finding algorithms
	@ingroup NumAlgo	class RootFinder : public TObject {
	*/
		public:
	namespace ROOT {
	namespace Math {

	//_________________________________________________________________________
	____________
	/**
	Class to find the Root of one dimensional functions.
	The class is templated on the type of Root solver algorithms.
	The possible types of Root-finding algorithms are:
	<ul>
	<li>Root Bracketing Algorithms which they do not require function
	derivatives
	<ol>
	<li>Roots::Bisection
	<li>Roots::FalsePos
	<li>Roots::Brent
	</ol>
	<li>Root Finding Algorithms using Derivatives
	<ol>
	<li>Roots::Newton
	<li>Roots::Secant
	<li>Roots::Steffenson
	</ol>
	</ul>

	This class does not cupport copying

	@ingroup RootFinders

	*/

	class RootFinder {

	public:

	enum EType { kBRENT, // Methods
	from MathCore
	kGSL_BISECTION, kGSL_FALSE_POS, kGSL_BRENT, // GSL Nor
	mal
	kGSL_NEWTON, kGSL_SECANT, kGSL_STEFFENSON // GSL Der
	ivatives
	};

	/**
	Construct a Root-Finder algorithm
	*/
	RootFinder(RootFinder::EType type = RootFinder::kBRENT);
	virtual ~RootFinder();

	private:
	// usually copying is non trivial, so we make this unaccessible
	RootFinder(const RootFinder & ) {}
	RootFinder & operator = (const RootFinder & rhs)
	{
	if (this == &rhs) return *this; // time saving self-test
	return *this;
	}

	public:

	int SetMethod(RootFinder::EType type = RootFinder::kBRENT);

	/**
	Provide to the solver the function and the initial search inter
	val [xlow, xup]
	for algorithms not using derivatives (bracketing algorithms)
	The templated function f must be of a type implementing the \a
	operator() method,
	<em> double operator() ( double x ) </em>
	Returns non zero if interval is not valid (i.e. does not contai
	ns a root)
	*/

	int SetFunction( const IGenFunction & f, double xlow, double xup)
	{
	return fSolver->SetFunction( f, xlow, xup);
	}

	/**
	Provide to the solver the function and an initial estimate of t
	he root,
	for algorithms using derivatives.
	The templated function f must be of a type implementing the \a
	operator()
	and the \a Gradient() methods.
	<em> double operator() ( double x ) </em>
	Returns non zero if starting point is not valid
	*/

	int SetFunction( const IGradFunction & f, double xstart) {
	return fSolver->SetFunction( f, xstart);
	}

	template<class Function, class Derivative>
	int Solve(Function f, Derivative d, double start,
	int maxIter = 100, double absTol = 1E-3, double relTol =
	1E-6);

	template<class Function>
	int Solve(Function f, double min, double max,
	int maxIter = 100, double absTol = 1E-3, double relTol =
	1E-6);

	/**
	Compute the roots iterating until the estimate of the Root is
	within the required tolerance returning
	the iteration Status
	*/
	int Solve( int maxIter = 100, double absTol = 1E-3, double relTol
	= 1E-6) {
	return fSolver->Solve( maxIter, absTol, relTol );
	}

	/**
	Return the number of iteration performed to find the Root.
	*/
	int Iterations() const {
	return fSolver->Iterations();
	}

	/**
	Perform a single iteration and return the Status
	*/
	int Iterate() {
	return fSolver->Iterate();
	}

	/**
	Return the current and latest estimate of the Root
	*/
	double Root() const {
	return fSolver->Root();
	}

	/**
	Return the current and latest estimate of the lower value of th
	e Root-finding interval (for bracketing algorithms)
	*/
	/* double XLower() const { */
	/* return fSolver->XLower(); */
	/* } */

	/**
	Return the current and latest estimate of the upper value of th
	e Root-finding interval (for bracketing algorithms)
	*/
	/* double XUpper() const { */
	/* return fSolver->XUpper(); */
	/* } */

	/**
	Get Name of the Root-finding solver algorithm
	*/
	const char * Name() const {
	return fSolver->Name();
	}

	#ifdef LATER
	/**
	Test convertgence Status of current iteration using interval va
	lues (for bracketing algorithms)
	*/
	static int TestInterval( double xlow, double xup, double epsAbs, d
	ouble epsRel) {
	return GSLRootHelper::TestInterval(xlow, xup, epsAbs, epsRel);
	}

	/**
	Test convergence Status of current iteration using last Root es
	timates (for algorithms using function derivatives)
	*/
	static int TestDelta( double r1, double r0, double epsAbs, double
	epsRel) {
	return GSLRootHelper::TestDelta(r1, r0, epsAbs, epsRel);
	}

	/**
	Test function residual
	*/
	static int TestResidual(double f, double epsAbs) {
	return GSLRootHelper::TestResidual(f, epsAbs);
	}
	#endif


	protected:	RootFinder( Double_t (*rootVal)( Double_t ),
		Double_t rootMin, Double_t rootMax,
		Int_t maxIterations = 100,
		Double_t absTolerance = 0.0 );
		virtual ~RootFinder( void );


	private:	// returns the root of the function
		Double_t Root( Double_t refValue );


	IRootFinderMethod* fSolver; // type of algorithm to be used	private:


	};	Double_t fRootMin; // minimum root value
		Double_t fRootMax; // maximum root value
		Int_t fMaxIter; // maximum number of iterations
		Double_t fAbsTol; // absolute tolerance deviation


	} // namespace Math	// function pointer
	} // namespace ROOT	Double_t (*fGetRootVal)( Double_t );

	#include "Math/WrappedFunction.h"
	#include "Math/Functor.h"

	template<class Function, class Derivative>
	int ROOT::Math::RootFinder::Solve(Function f, Derivative d, double start,
	int maxIter, double absTol, double relTol
	)
	{
	ROOT::Math::GradFunctor1D wf(f, d);
	if (fSolver) fSolver->SetFunction(wf, start);
	return Solve(maxIter, absTol, relTol);
	}

	template<class Function>
	int ROOT::Math::RootFinder::Solve(Function f, double min, double max,
	int maxIter, double absTol, double relTol
	)
	{
	ROOT::Math::WrappedFunction<Function> wf(f);
	if (fSolver) fSolver->SetFunction(wf, min, max);
	return Solve(maxIter, absTol, relTol);
	}


	#endif /* ROOT_Math_RootFinder */	mutable MsgLogger* fLogger; //! message logger
		MsgLogger& Log() const { return *fLogger; }

		ClassDef(RootFinder,0) // Root finding using Brents algorithm
		};

		} // namespace TMVA

		#endif

End of changes. 11 change blocks.
	253 lines changed or deleted	84 lines changed or added

	RuleCut.h	RuleCut.h

	// @(#)root/tmva $Id: RuleCut.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: RuleCut.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Rule *	* Class : Rule *
	* *	* *
	* Description: *	* Description: *
	* A class describing a 'rule cut' *	* A class describing a 'rule cut' *
	* *	* *

	skipping to change at line 131	skipping to change at line 131
	// evaluate event using the cut	// evaluate event using the cut

	// Loop over all cuts	// Loop over all cuts
	Int_t sel;	Int_t sel;
	Double_t val;	Double_t val;
	Bool_t done=kFALSE;	Bool_t done=kFALSE;
	Bool_t minOK, cutOK;	Bool_t minOK, cutOK;
	UInt_t nc=0;	UInt_t nc=0;
	while (!done) {	while (!done) {
	sel = fSelector[nc];	sel = fSelector[nc];

	val = eve.GetVal(sel);	val = eve.GetValue(sel);
	minOK = (fCutDoMin[nc] ? (val>fCutMin[nc]):kTRUE); // min cut ok	minOK = (fCutDoMin[nc] ? (val>fCutMin[nc]):kTRUE); // min cut ok
	cutOK = (minOK ? ((fCutDoMax[nc] ? (val<fCutMax[nc]):kTRUE)) : kFALSE ); // cut ok	cutOK = (minOK ? ((fCutDoMax[nc] ? (val<fCutMax[nc]):kTRUE)) : kFALSE ); // cut ok
	nc++;	nc++;
	done = ((!cutOK) \|\| (nc==fSelector.size())); // done if	done = ((!cutOK) \|\| (nc==fSelector.size())); // done if
	}	}
	// return ( cutOK ? 1.0: 0.0 );	// return ( cutOK ? 1.0: 0.0 );
	return cutOK;	return cutOK;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	RuleFitAPI.h	RuleFitAPI.h

	// @(#)root/tmva $Id: RuleFitAPI.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/tmva $Id: RuleFitAPI.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : RuleFitAPI *	* Class : RuleFitAPI *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Interface to Friedman's RuleFit method *	* Interface to Friedman's RuleFit method *

	skipping to change at line 43	skipping to change at line 43
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// RuleFitAPI //	// RuleFitAPI //
	// //	// //
	// J Friedman's RuleFit method //	// J Friedman's RuleFit method //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <fstream>	#include <fstream>


		#include "TMVA/MsgLogger.h"

	namespace TMVA {	namespace TMVA {


	class MsgLogger;
	class MethodRuleFit;	class MethodRuleFit;

	class RuleFitAPI {	class RuleFitAPI {

	public:	public:

	RuleFitAPI( const TMVA::MethodRuleFit rfbase, TMVA::RuleFit rulefit , EMsgType minType );	RuleFitAPI( const TMVA::MethodRuleFit rfbase, TMVA::RuleFit rulefit , EMsgType minType );

	virtual ~RuleFitAPI();	virtual ~RuleFitAPI();


	skipping to change at line 190	skipping to change at line 191
	std::vector<Float_t> fRFYhat; // score results from test sample	std::vector<Float_t> fRFYhat; // score results from test sample
	std::vector<Float_t> fRFVarImp; // variable importances	std::vector<Float_t> fRFVarImp; // variable importances
	std::vector<Int_t> fRFVarImpInd; // variable index	std::vector<Int_t> fRFVarImpInd; // variable index
	TString fRFWorkDir; // working directory	TString fRFWorkDir; // working directory
	IntParms fRFIntParms; // integer parameters	IntParms fRFIntParms; // integer parameters
	RealParms fRFRealParms; // real parameters	RealParms fRFRealParms; // real parameters
	std::vector<int> fRFLx; // variable selector	std::vector<int> fRFLx; // variable selector
	ERFProgram fRFProgram; // what to run	ERFProgram fRFProgram; // what to run
	TString fModelType; // model type string	TString fModelType; // model type string


	mutable MsgLogger fLogger; // message logger	mutable MsgLogger fLogger; // message logger

	ClassDef(RuleFitAPI,0) // Friedman's RuleFit method	ClassDef(RuleFitAPI,0) // Friedman's RuleFit method

	};	};

	} // namespace TMVA	} // namespace TMVA

	//_______________________________________________________________________	//_______________________________________________________________________
	void TMVA::RuleFitAPI::TrainRuleFit()	void TMVA::RuleFitAPI::TrainRuleFit()
	{	{

End of changes. 4 change blocks.
	3 lines changed or deleted	4 lines changed or added

	SVEvent.h	SVEvent.h

	// @(#)root/tmva $Id: SVEvent.h 29205 2009-06-24 19:33:19Z brun $	// @(#)root/tmva $Id: SVEvent.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andrzej Zemla	// Author: Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SVEvent *	* Class : SVEvent *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Event class for Support Vector Machine *	* Event class for Support Vector Machine *

	skipping to change at line 54	skipping to change at line 54
	public:	public:

	SVEvent();	SVEvent();
	SVEvent( const Event*, const Float_t );	SVEvent( const Event*, const Float_t );
	SVEvent( const std::vector<Float_t>*, Float_t alpha, const Int_t type Flag, const UInt_t ns );	SVEvent( const std::vector<Float_t>*, Float_t alpha, const Int_t type Flag, const UInt_t ns );
	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t alpha_p,const Int_t typeFlag);	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t alpha_p,const Int_t typeFlag);

	virtual ~SVEvent();	virtual ~SVEvent();

	void SetAlpha ( Float_t alpha ) { fAlpha = alpha; }	void SetAlpha ( Float_t alpha ) { fAlpha = alpha; }

	void SetAlpha_p ( Float_t alpha ) { fAlpha_p = alpha; }	void SetAlpha_p ( Float_t alpha ) { fAlpha_p = alpha; }
	void SetErrorCache ( Float_t err_cache ) { fErrorCache = err_cach e; }	void SetErrorCache ( Float_t err_cache ) { fErrorCache = err_cach e; }
	void SetIsShrinked ( Int_t isshrinked ) { fIsShrinked = isshrink ed; }	void SetIsShrinked ( Int_t isshrinked ) { fIsShrinked = isshrink ed; }
	void SetLine ( Float_t* line ) { fLine = line; }	void SetLine ( Float_t* line ) { fLine = line; }
	void SetIdx ( Int_t idx ) { fIdx = idx; }	void SetIdx ( Int_t idx ) { fIdx = idx; }
	void SetNs ( UInt_t ns ) { fNs = ns; }	void SetNs ( UInt_t ns ) { fNs = ns; }

	void UpdateErrorCache(Float_t upercache ) { fErrorCache += upercache; }	void UpdateErrorCache(Float_t upercache ) { fErrorCache += upercac he; }


	std::vector<Float_t>* GetDataVector() { return &fDataVector; }	std::vector<Float_t>* GetDataVector() { return &fDataVector; }
	Float_t GetAlpha() const { return fAlpha; }	Float_t GetAlpha() const { return fAlpha; }
	Float_t GetAlpha_p() const { return fAlpha_p; }	Float_t GetAlpha_p() const { return fAlpha_p; }
	Float_t GetDeltaAlpha() const { return fAlpha - fAlpha_p;	Float_t GetDeltaAlpha() const { return fAlpha - fAlpha_p; }
	}


	Float_t GetErrorCache() const { return fErrorCache; }	Float_t GetErrorCache() const { return fErrorCache; }
	Int_t GetTypeFlag() const { return fTypeFlag; }	Int_t GetTypeFlag() const { return fTypeFlag; }
	Int_t GetNVar() const { return fNVar; }	Int_t GetNVar() const { return fNVar; }
	Int_t GetIdx() const { return fIdx;}	Int_t GetIdx() const { return fIdx;}
	Float_t* GetLine() const { return fLine;}	Float_t* GetLine() const { return fLine;}
	UInt_t GetNs() const { return fNs;}	UInt_t GetNs() const { return fNs;}
	Float_t GetCweight() const { return fCweight;}	Float_t GetCweight() const { return fCweight;}

	Float_t GetTarget() const { return fTarget;}	Float_t GetTarget() const { return fTarget;}

	Bool_t IsInI0a() const { return (0.< fAlpha) && (fAlpha<fCweight); }	Bool_t IsInI0a() const { return (0.< fAlpha) && (fAlpha<fCweight); }
	Bool_t IsInI0b() const { return (0.< fAlpha) && (fAlpha_p<fCweight); }	Bool_t IsInI0b() const { return (0.< fAlpha) && (fAlpha_p<fCweight); }

	Bool_t IsInI0() const { return (IsInI0a() \|\| IsInI0b()); }	Bool_t IsInI0() const { return (IsInI0a() \|\| IsInI0b()); }
	Bool_t IsInI1() const { return (fAlpha == 0. && fAlpha_p ==	Bool_t IsInI1() const { return (fAlpha == 0. && fAlpha_p == 0.); }
	0.); }	Bool_t IsInI2() const { return (fAlpha == 0. && fAlpha_p == fCweigh
	Bool_t IsInI2() const { return (fAlpha == 0. && fAlpha_p == fCweight	t); }
	); }	Bool_t IsInI3() const { return (fAlpha == fCweight && fAlpha_p == 0
	Bool_t IsInI3() const { return (fAlpha == fCweight && fAlpha_p == 0.	.); }
	); }

	void Print( std::ostream& os ) const;	void Print( std::ostream& os ) const;
	void PrintData();	void PrintData();

	private:	private:

	std::vector<Float_t> fDataVector;	std::vector<Float_t> fDataVector;

	const Float_t fCweight; // svm cost weight	const Float_t fCweight; // svm cost weight
	Float_t fAlpha; // lagrange multiplier	Float_t fAlpha; // lagrange multiplier
	Float_t fAlpha_p; // lagrange multiplier	Float_t fAlpha_p; // lagrange multiplier
	Float_t fErrorCache; // optimization parameter	Float_t fErrorCache; // optimization parameter
		UInt_t fNVar; // number of variables
	UInt_t fNVar; // number of variables	const Int_t fTypeFlag; // is sig or bkg - svm requieres 1
	const Int_t fTypeFlag; // is sig or bkg - svm requieres 1 for	for sig and -1 for bkg
	sig and -1 for bkg	Int_t fIdx; // index flag
	Int_t fIdx; // index flag	UInt_t fNs; // documentation
	UInt_t fNs; // documentation	Int_t fIsShrinked; // shrinking flag, see documentati
	Int_t fIsShrinked; // shrinking flag, see documentation	on
	Float_t* fLine; // pointer to column of kerenl matrix	Float_t* fLine; // pointer to column of kerenl mat
	const Float_t fTarget; // regression target	rix
		const Float_t fTarget; // regression target

	ClassDef(SVEvent,0) // Event for SVM	ClassDef(SVEvent,0) // Event for SVM
	};	};
	}	}

	#endif //ROOT_TMVA_SVEvent	#endif //ROOT_TMVA_SVEvent

End of changes. 8 change blocks.
	30 lines changed or deleted	29 lines changed or added

	SVKernelFunction.h	SVKernelFunction.h

	// @(#)root/tmva $Id: SVKernelFunction.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: SVKernelFunction.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andrzej Zemla	// Author: Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SVKernelFunction *	* Class : SVKernelFunction *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Kernel for Support Vector Machine *	* Kernel for Support Vector Machine *

	skipping to change at line 37	skipping to change at line 37

	#ifndef ROOT_TMVA_SVKernelFunction	#ifndef ROOT_TMVA_SVKernelFunction
	#define ROOT_TMVA_SVKernelFunction	#define ROOT_TMVA_SVKernelFunction

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {


	class SVEvent;	class SVEvent;
	class SVKernelFunction {	class SVKernelFunction {

	public:	public:

	SVKernelFunction();	SVKernelFunction();
	SVKernelFunction( Float_t );	SVKernelFunction( Float_t );
	~SVKernelFunction();	~SVKernelFunction();

	Float_t Evaluate( SVEvent* ev1, SVEvent* ev2 );	Float_t Evaluate( SVEvent* ev1, SVEvent* ev2 );


		enum EKernelType { kLinear , kRBF, kPolynomial, kSigmoidal };

		void setCompatibilityParams(EKernelType k, UInt_t order, Float_t thet
		a, Float_t kappa);

	private:	private:

	Float_t fGamma; // documentation	Float_t fGamma; // documentation

	};
		// kernel, order, theta, and kappa are for backward compatibility
		EKernelType fKernel;
		UInt_t fOrder;
		Float_t fTheta;
		Float_t fKappa;
		};
	}	}

	#endif	#endif

End of changes. 4 change blocks.
	4 lines changed or deleted	15 lines changed or added

	SVKernelMatrix.h	SVKernelMatrix.h

	// @(#)root/tmva $Id: SVKernelMatrix.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: SVKernelMatrix.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andrzej Zemla	// Author: Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SVKernelMatrix *	* Class : SVKernelMatrix *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Kernel matrix for Support Vector Machine *	* Kernel matrix for Support Vector Machine *

	skipping to change at line 61	skipping to change at line 61
	//destructor	//destructor
	~SVKernelMatrix();	~SVKernelMatrix();

	//functions	//functions
	Float_t* GetLine ( UInt_t );	Float_t* GetLine ( UInt_t );
	Float_t* GetColumn ( UInt_t col ) { return this->GetLine(col);}	Float_t* GetColumn ( UInt_t col ) { return this->GetLine(col);}
	Float_t GetElement( UInt_t i, UInt_t j );	Float_t GetElement( UInt_t i, UInt_t j );

	private:	private:


	UInt_t fSize; // matrix size	UInt_t fSize; // matrix size
	SVKernelFunction* fKernelFunction; // kernel function	SVKernelFunction* fKernelFunction; // kernel function
	Float_t** fSVKernelMatrix; // kernel matrix	Float_t** fSVKernelMatrix; // kernel matrix

	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }

	};	};
	}	}
	#endif	#endif

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	SVWorkingSet.h	SVWorkingSet.h

	// @(#)root/tmva $Id: SVWorkingSet.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: SVWorkingSet.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andrzej Zemla	// Author: Andrzej Zemla

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SVWorkingSet *	* Class : SVWorkingSet *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Working class for Support Vector Machine *	* Working class for Support Vector Machine *

	skipping to change at line 55	skipping to change at line 55

	public:	public:

	SVWorkingSet();	SVWorkingSet();
	SVWorkingSet( std::vector<TMVA::SVEvent>, SVKernelFunction*, Float_ t , Bool_t);	SVWorkingSet( std::vector<TMVA::SVEvent>, SVKernelFunction*, Float_ t , Bool_t);
	~SVWorkingSet();	~SVWorkingSet();

	Bool_t ExamineExample( SVEvent*);	Bool_t ExamineExample( SVEvent*);
	Bool_t TakeStep ( SVEvent, SVEvent);	Bool_t TakeStep ( SVEvent, SVEvent);
	Bool_t Terminated();	Bool_t Terminated();

	void Train();	void Train(UInt_t nIter=1000);
	void PrintStat();	void PrintStat();
	std::vector<TMVA::SVEvent> GetSupportVectors();	std::vector<TMVA::SVEvent> GetSupportVectors();
	Float_t GetBpar() {return 0.5*(fB_low + fB_up);}	Float_t GetBpar() {return 0.5*(fB_low + fB_up);}

	//for regression	//for regression
	Bool_t ExamineExampleReg(SVEvent*);	Bool_t ExamineExampleReg(SVEvent*);
	Bool_t TakeStepReg(SVEvent, SVEvent);	Bool_t TakeStepReg(SVEvent, SVEvent);
	Bool_t IsDiffSignificant(Float_t, Float_t, Float_t);	Bool_t IsDiffSignificant(Float_t, Float_t, Float_t);
	void TrainReg();	void TrainReg();


End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TBackCompFitter.h	TBackCompFitter.h

	// @(#)root/minuit2:$Id: TBackCompFitter.h 28022 2009-04-01 14:41:58Z monet a $	// @(#)root/minuit2:$Id: TBackCompFitter.h 31873 2009-12-14 10:05:39Z brun $
	// Author: L. Moneta 08/2008	// Author: L. Moneta 08/2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2008 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2008 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_TBackCompFitter_H_	#ifndef ROOT_TBackCompFitter_H_
	#define ROOT_TBackCompFitter_H_	#define ROOT_TBackCompFitter_H_

	skipping to change at line 41	skipping to change at line 41
	/**	/**
	TVirtualFitter backward compatibility implementation using new ROOT::Fi t::Fitter	TVirtualFitter backward compatibility implementation using new ROOT::Fi t::Fitter
	*/	*/

	class TGraph;	class TGraph;

	namespace ROOT {	namespace ROOT {
	namespace Fit {	namespace Fit {
	class FitData;	class FitData;
	}	}

		namespace Math {
		class Minimizer;
		}
	}	}

	class TBackCompFitter : public TVirtualFitter {	class TBackCompFitter : public TVirtualFitter {

	public:	public:

	TBackCompFitter();	TBackCompFitter();

	//TBackCompFitter(ROOT::Fit::Fitter & fitter, ROOT::Fit::FitData * );	//TBackCompFitter(ROOT::Fit::Fitter & fitter, ROOT::Fit::FitData * );
	TBackCompFitter( std::auto_ptr<ROOT::Fit::Fitter> fitter, std::auto_ptr <ROOT::Fit::FitData> data );	TBackCompFitter( std::auto_ptr<ROOT::Fit::Fitter> fitter, std::auto_ptr <ROOT::Fit::FitData> data );

	skipping to change at line 104	skipping to change at line 107

	// get reference to Fit configuration (NOTE: it will be invalid when cla ss is deleted)	// get reference to Fit configuration (NOTE: it will be invalid when cla ss is deleted)
	ROOT::Fit::FitConfig & GetFitConfig() { return fFitter->Config(); }	ROOT::Fit::FitConfig & GetFitConfig() { return fFitter->Config(); }

	// get reference to Fit Result object (NOTE: it will be invalid when cla ss is deleted)	// get reference to Fit Result object (NOTE: it will be invalid when cla ss is deleted)
	const ROOT::Fit::FitResult & GetFitResult() const { return fFitter->Resu lt(); }	const ROOT::Fit::FitResult & GetFitResult() const { return fFitter->Resu lt(); }

	// get reference to Fit Data object (NOTE: it will be invalid when class is deleted)	// get reference to Fit Data object (NOTE: it will be invalid when class is deleted)
	const ROOT::Fit::FitData & GetFitData() const { return *fFitData; }	const ROOT::Fit::FitData & GetFitData() const { return *fFitData; }


		// return pointer to last used minimizer
		ROOT::Math::Minimizer * GetMinimizer();

		// return pointer to last used objective function
		ROOT::Math::IMultiGenFunction * GetObjFunction();

	// scan likelihood value of parameter and fill the given graph.	// scan likelihood value of parameter and fill the given graph.
	bool Scan(unsigned int ipar, TGraph * gr, double xmin = 0, double xmax = 0);	bool Scan(unsigned int ipar, TGraph * gr, double xmin = 0, double xmax = 0);

	// // scan likelihood value for two parameters and fill the given graph .	// // scan likelihood value for two parameters and fill the given graph .
	// bool Scan2D(unsigned int ipar, unsigned int jpar, TGraph2D * gr,	// bool Scan2D(unsigned int ipar, unsigned int jpar, TGraph2D * gr,
	// double xmin = 0, double xmax = 0, double ymin = 0, double ymax = 0);	// double xmin = 0, double xmax = 0, double ymin = 0, double ymax = 0);

	// create contour of two parameters around the minimum	// create contour of two parameters around the minimum
	// pass as option confidence level: default is a value of 0.683	// pass as option confidence level: default is a value of 0.683
	bool Contour(unsigned int ipar, unsigned int jpar, TGraph * gr , double confLevel = 0.683);	bool Contour(unsigned int ipar, unsigned int jpar, TGraph * gr , double confLevel = 0.683);

End of changes. 3 change blocks.
	1 lines changed or deleted	10 lines changed or added

	TCollectionProxyInfo.h	TCollectionProxyInfo.h

	// @(#)root/cont:$Id: TCollectionProxyInfo.h 28776 2009-06-02 15:16:39Z pca nal $	// @(#)root/cont:$Id: TCollectionProxyInfo.h 31743 2009-12-09 19:08:37Z pca nal $
	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 58	skipping to change at line 58
	*	*
	* Small helper to save proxy environment in the event of	* Small helper to save proxy environment in the event of
	* recursive calls.	* recursive calls.
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	#ifndef __CINT__	#ifndef __CINT__
	struct EnvironBase {	struct EnvironBase {

		private:
		EnvironBase(const EnvironBase&); // Intentionally not implement, copy
		is not supported
		EnvironBase &operator=(const EnvironBase&); // Intentionally not impl
		ement, copy is not supported
		public:
	EnvironBase() : fIdx(0), fSize(0), fObject(0), fStart(0), fTemp(0), f UseTemp(kFALSE), fRefCount(1), fSpace(0)	EnvironBase() : fIdx(0), fSize(0), fObject(0), fStart(0), fTemp(0), f UseTemp(kFALSE), fRefCount(1), fSpace(0)
	{	{

	// fprintf("Running default constructor on %p\n",this);
	}	}
	virtual ~EnvironBase() {}	virtual ~EnvironBase() {}
	size_t fIdx;	size_t fIdx;
	size_t fSize;	size_t fSize;
	void* fObject;	void* fObject;
	void* fStart;	void* fStart;
	void* fTemp;	void* fTemp;
	Bool_t fUseTemp;	Bool_t fUseTemp;
	int fRefCount;	int fRefCount;
	size_t fSpace;	size_t fSpace;

End of changes. 3 change blocks.
	2 lines changed or deleted	7 lines changed or added

	TEveArrow.h	TEveArrow.h

	// @(#)root/eve:$Id: TEveArrow.h 31016 2009-11-06 17:39:41Z matevz $	// @(#)root/eve:$Id: TEveArrow.h 31517 2009-12-03 11:56:23Z matevz $
	// Author: Matevz Tadel 2007	// Author: Matevz Tadel 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveArrow	#ifndef ROOT_TEveArrow
	#define ROOT_TEveArrow	#define ROOT_TEveArrow

	#include "TEveElement.h"	#include "TEveElement.h"

		#include "TEveVector.h"
	#include "TNamed.h"	#include "TNamed.h"
	#include "TAtt3D.h"	#include "TAtt3D.h"
	#include "TAttBBox.h"	#include "TAttBBox.h"

	#include "TEveVSDStructs.h"

	class TEveArrow : public TEveElement,	class TEveArrow : public TEveElement,
	public TNamed,	public TNamed,
	public TAtt3D,	public TAtt3D,
	public TAttBBox	public TAttBBox
	{	{
	friend class TEveArrowGL;	friend class TEveArrowGL;
	friend class TEveArrowEditor;	friend class TEveArrowEditor;

	private:	private:

End of changes. 3 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TEveBoxSet.h	TEveBoxSet.h

	// @(#)root/eve:$Id: TEveBoxSet.h 27157 2009-01-15 14:05:12Z brun $	// @(#)root/eve:$Id: TEveBoxSet.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveBoxSet	#ifndef ROOT_TEveBoxSet
	#define ROOT_TEveBoxSet	#define ROOT_TEveBoxSet

	#include "TEveDigitSet.h"	#include "TEveDigitSet.h"

	#include "TEveVSDStructs.h"	#include "TEveVector.h"

	class TGeoMatrix;	class TGeoMatrix;
	class TRandom;	class TRandom;

	class TEveBoxSet: public TEveDigitSet	class TEveBoxSet: public TEveDigitSet
	{	{
	friend class TEveBoxSetGL;	friend class TEveBoxSetGL;

	TEveBoxSet(const TEveBoxSet&); // Not implemented	TEveBoxSet(const TEveBoxSet&); // Not implemented
	TEveBoxSet& operator=(const TEveBoxSet&); // Not implemented	TEveBoxSet& operator=(const TEveBoxSet&); // Not implemented

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TEveBoxSetGL.h	TEveBoxSetGL.h

	// @(#)root/eve:$Id: TEveBoxSetGL.h 26250 2008-11-17 20:56:44Z matevz $	// @(#)root/eve:$Id: TEveBoxSetGL.h 31450 2009-11-27 14:25:37Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 34	skipping to change at line 34
	TEveBoxSet *fM; // Model object.	TEveBoxSet *fM; // Model object.

	mutable UInt_t fBoxDL; // Display-list id for a box atom.	mutable UInt_t fBoxDL; // Display-list id for a box atom.

	Int_t PrimitiveType() const;	Int_t PrimitiveType() const;
	Bool_t SetupColor(const TEveDigitSet::DigitBase_t& q) const;	Bool_t SetupColor(const TEveDigitSet::DigitBase_t& q) const;
	void MakeOriginBox(Float_t p[24], Float_t dx, Float_t dy, Float_t dz) const;	void MakeOriginBox(Float_t p[24], Float_t dx, Float_t dy, Float_t dz) const;
	void RenderBox(const Float_t p[24]) const;	void RenderBox(const Float_t p[24]) const;
	void MakeDisplayList() const;	void MakeDisplayList() const;


		void RenderBoxes(TGLRnrCtx & rnrCtx) const;

	public:	public:
	TEveBoxSetGL();	TEveBoxSetGL();
	virtual ~TEveBoxSetGL();	virtual ~TEveBoxSetGL();

	virtual Bool_t ShouldDLCache(const TGLRnrCtx & rnrCtx) const;	virtual Bool_t ShouldDLCache(const TGLRnrCtx & rnrCtx) const;
	virtual void DLCacheDrop();	virtual void DLCacheDrop();
	virtual void DLCachePurge();	virtual void DLCachePurge();

	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);	virtual Bool_t SetModel(TObject* obj, const Option_t* opt=0);
	virtual void SetBBox();	virtual void SetBBox();

End of changes. 2 change blocks.
	1 lines changed or deleted	3 lines changed or added

	TEveCaloLegoGL.h	TEveCaloLegoGL.h

	// @(#)root/eve:$Id: TEveCaloLegoGL.h 30929 2009-10-30 15:18:51Z matevz $	// @(#)root/eve:$Id: TEveCaloLegoGL.h 31517 2009-12-03 11:56:23Z matevz $
	// Author: Alja Mrak-Tadel 2007	// Author: Alja Mrak-Tadel 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveCaloLegoGL	#ifndef ROOT_TEveCaloLegoGL
	#define ROOT_TEveCaloLegoGL	#define ROOT_TEveCaloLegoGL

	#include "TGLObject.h"	#include "TGLObject.h"
	#include "TGLAxisPainter.h"	#include "TGLAxisPainter.h"

	#include "TEveCaloData.h"	#include "TEveCaloData.h"

	#include "TEveVSDStructs.h"	#include "TEveVector.h"
	#include "TEveCalo.h"	#include "TEveCalo.h"

	#include <map>	#include <map>

	class TEveCaloLego;	class TEveCaloLego;

	class TEveCaloLegoGL : public TGLObject	class TEveCaloLegoGL : public TGLObject
	{	{
	private:	private:
	struct Cell2D_t	struct Cell2D_t

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TEveGedEditor.h	TEveGedEditor.h

	// @(#)root/eve:$Id: TEveGedEditor.h 31326 2009-11-19 17:04:40Z matevz $	// @(#)root/eve:$Id: TEveGedEditor.h 31428 2009-11-25 17:03:52Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveGedEditor	#ifndef ROOT_TEveGedEditor
	#define ROOT_TEveGedEditor	#define ROOT_TEveGedEditor

	#include "TGedEditor.h"	#include "TGedEditor.h"
	#include "TGedFrame.h"	#include "TGedFrame.h"

		#include "TGButton.h"

	class TEveElement;	class TEveElement;

		class TContextMenu;

	//========================================================================= =====	//========================================================================= =====
	// TEveGedEditor	// TEveGedEditor
	//========================================================================= =====	//========================================================================= =====

	class TEveGedEditor : public TGedEditor	class TEveGedEditor : public TGedEditor
	{	{
	TEveGedEditor(const TEveGedEditor&); // Not implemented	TEveGedEditor(const TEveGedEditor&); // Not implemented
	TEveGedEditor& operator=(const TEveGedEditor&); // Not implemented	TEveGedEditor& operator=(const TEveGedEditor&); // Not implemented


	skipping to change at line 41	skipping to change at line 43

	protected:	protected:
	TEveElement *fElement; // Cached eve-element pointer.	TEveElement *fElement; // Cached eve-element pointer.
	TObject *fObject; // Cached tobj pointer.	TObject *fObject; // Cached tobj pointer.

	virtual TGedFrame* CreateNameFrame(const TGWindow* parent, const char* t ab_name);	virtual TGedFrame* CreateNameFrame(const TGWindow* parent, const char* t ab_name);

	static Int_t fgMaxExtraEditors;	static Int_t fgMaxExtraEditors;
	static TList *fgExtraEditors;	static TList *fgExtraEditors;


		static TContextMenu *fgContextMenu;

	public:	public:
	TEveGedEditor(TCanvas* canvas=0, UInt_t width=250, UInt_t height=400);	TEveGedEditor(TCanvas* canvas=0, UInt_t width=250, UInt_t height=400);
	virtual ~TEveGedEditor();	virtual ~TEveGedEditor();

	virtual void CloseWindow();	virtual void CloseWindow();
	virtual void DeleteWindow();	virtual void DeleteWindow();

	TEveElement* GetEveElement() const;	TEveElement* GetEveElement() const;

	void DisplayElement(TEveElement* re);	void DisplayElement(TEveElement* re);

	skipping to change at line 64	skipping to change at line 68
	virtual void Update(TGedFrame* gframe=0);	virtual void Update(TGedFrame* gframe=0);

	// --- Statics for extra editors. ---	// --- Statics for extra editors. ---

	static void SpawnNewEditor(TObject* obj);	static void SpawnNewEditor(TObject* obj);
	static void ElementChanged(TEveElement* el);	static void ElementChanged(TEveElement* el);
	static void ElementDeleted(TEveElement* el);	static void ElementDeleted(TEveElement* el);

	static void DestroyEditors();	static void DestroyEditors();


		static TContextMenu* GetContextMenu();

	ClassDef(TEveGedEditor, 0); // Specialization of TGedEditor for proper u pdate propagation to TEveManager.	ClassDef(TEveGedEditor, 0); // Specialization of TGedEditor for proper u pdate propagation to TEveManager.
	};	};

	//========================================================================= =====	//========================================================================= =====
	// TEveGedNameFrame	// TEveGedNameFrame
	//========================================================================= =====	//========================================================================= =====


	class TEveGedNameFrame : public TGedFrame	class TEveGedNameFrame : public TGedFrame
	{	{
	private:	private:
	TEveGedNameFrame(const TEveGedNameFrame&); // Not implemented	TEveGedNameFrame(const TEveGedNameFrame&); // Not implemented
	TEveGedNameFrame& operator=(const TEveGedNameFrame&); // Not implemented	TEveGedNameFrame& operator=(const TEveGedNameFrame&); // Not implemented

	protected:	protected:
	TGTextButton *fNCButton; // Name/Class button.	TGTextButton *fNCButton; // Name/Class button.

	public:	public:
	TEveGedNameFrame(const TGWindow *p=0, Int_t width=140, Int_t height=30,	TEveGedNameFrame(const TGWindow *p=0, Int_t width=140, Int_t height=30,
	UInt_t options=kChildFrame \| kHorizontalFrame);	UInt_t options=kChildFrame \| kHorizontalFrame);
	virtual ~TEveGedNameFrame();	virtual ~TEveGedNameFrame();

	virtual void SetModel(TObject* obj);	virtual void SetModel(TObject* obj);

	void SpawnEditorClone();	void SpawnEditorClone();

	ClassDef(TEveGedNameFrame, 0); // Top name-frame used in EVE.	ClassDef(TEveGedNameFrame, 0); // Top name-frame used in EVE.
	};	};


		//=========================================================================
		=====
		// TEveGedNameTextButton
		//=========================================================================
		=====

		class TEveGedNameTextButton : public TGTextButton
		{
		TEveGedNameFrame *fFrame;

		public:
		TEveGedNameTextButton(TEveGedNameFrame* p);
		virtual ~TEveGedNameTextButton();

		virtual Bool_t HandleButton(Event_t* event);

		ClassDef(TEveGedNameTextButton, 0); // Button for GED name-frame.
		};

	#endif	#endif

End of changes. 7 change blocks.
	2 lines changed or deleted	27 lines changed or added

	TEveJetCone.h	TEveJetCone.h

	// @(#)root/eve:$Id: TEveJetCone.h 28214 2009-04-15 11:32:25Z matevz $	// @(#)root/eve:$Id: TEveJetCone.h 31517 2009-12-03 11:56:23Z matevz $
	// Author: Matevz Tadel, Jochen Thaeder 2009	// Author: Matevz Tadel, Jochen Thaeder 2009

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveJetCone	#ifndef ROOT_TEveJetCone
	#define ROOT_TEveJetCone	#define ROOT_TEveJetCone

	#include "TEveElement.h"	#include "TEveElement.h"

	#include "TEveVSDStructs.h"	#include "TEveVector.h"
	#include "TAttBBox.h"	#include "TAttBBox.h"

	class TEveJetCone : public TEveElementList,	class TEveJetCone : public TEveElementList,
	public TAttBBox	public TAttBBox
	{	{
	friend class TEveJetConeGL;	friend class TEveJetConeGL;

	private:	private:
	TEveJetCone(const TEveJetCone&); // Not implemented	TEveJetCone(const TEveJetCone&); // Not implemented
	TEveJetCone& operator=(const TEveJetCone&); // Not implemented	TEveJetCone& operator=(const TEveJetCone&); // Not implemented

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TEveLine.h	TEveLine.h

	// @(#)root/eve:$Id: TEveLine.h 30840 2009-10-23 09:03:14Z matevz $	// @(#)root/eve:$Id: TEveLine.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveLine	#ifndef ROOT_TEveLine
	#define ROOT_TEveLine	#define ROOT_TEveLine


	#include "TEveUtil.h"
	#include "TEvePointSet.h"	#include "TEvePointSet.h"

		#include "TEveVector.h"

	#include "TAttLine.h"	#include "TAttLine.h"

	//------------------------------------------------------------------------- -----	//------------------------------------------------------------------------- -----
	// TEveLine	// TEveLine
	//------------------------------------------------------------------------- -----	//------------------------------------------------------------------------- -----

	class TEveLine : public TEvePointSet,	class TEveLine : public TEvePointSet,
	public TAttLine	public TAttLine
	{	{

	skipping to change at line 46	skipping to change at line 46
	Bool_t fRnrPoints;	Bool_t fRnrPoints;
	Bool_t fSmooth;	Bool_t fSmooth;

	static Bool_t fgDefaultSmooth;	static Bool_t fgDefaultSmooth;

	public:	public:
	TEveLine(Int_t n_points=0, ETreeVarType_e tv_type=kTVT_XYZ);	TEveLine(Int_t n_points=0, ETreeVarType_e tv_type=kTVT_XYZ);
	TEveLine(const char* name, Int_t n_points=0, ETreeVarType_e tv_type=kTVT _XYZ);	TEveLine(const char* name, Int_t n_points=0, ETreeVarType_e tv_type=kTVT _XYZ);
	virtual ~TEveLine() {}	virtual ~TEveLine() {}


	virtual void SetLineColor(Color_t col) { SetMainColor(col); }
	virtual void SetMarkerColor(Color_t col);	virtual void SetMarkerColor(Color_t col);


		virtual void SetLineColor(Color_t col) { SetMainColor(col); }
		virtual void SetLineStyle(Style_t lstyle);
		virtual void SetLineWidth(Width_t lwidth);

	Bool_t GetRnrLine() const { return fRnrLine; }	Bool_t GetRnrLine() const { return fRnrLine; }
	Bool_t GetRnrPoints() const { return fRnrPoints; }	Bool_t GetRnrPoints() const { return fRnrPoints; }
	Bool_t GetSmooth() const { return fSmooth; }	Bool_t GetSmooth() const { return fSmooth; }
	void SetRnrLine(Bool_t r);	void SetRnrLine(Bool_t r);
	void SetRnrPoints(Bool_t r);	void SetRnrPoints(Bool_t r);
	void SetSmooth(Bool_t r);	void SetSmooth(Bool_t r);

	void ReduceSegmentLengths(Float_t max);	void ReduceSegmentLengths(Float_t max);

	TEveVector GetLineStart() const;	TEveVector GetLineStart() const;

End of changes. 5 change blocks.
	3 lines changed or deleted	6 lines changed or added

	TEvePointSet.h	TEvePointSet.h

	// @(#)root/eve:$Id: TEvePointSet.h 31327 2009-11-19 17:13:58Z matevz $	// @(#)root/eve:$Id: TEvePointSet.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEvePointSet	#ifndef ROOT_TEvePointSet
	#define ROOT_TEvePointSet	#define ROOT_TEvePointSet


	#include "TEveVSDStructs.h"
	#include "TEveElement.h"	#include "TEveElement.h"
	#include "TEveProjectionBases.h"	#include "TEveProjectionBases.h"
	#include "TEveTreeTools.h"	#include "TEveTreeTools.h"

	#include "TArrayI.h"	#include "TArrayI.h"
	#include "TPointSet3D.h"	#include "TPointSet3D.h"
	#include "TQObject.h"	#include "TQObject.h"

	class TTree;	class TTree;
	class TF3;	class TF3;

	skipping to change at line 82	skipping to change at line 81
	{ fName = n; fTitle = t; NameTitleChanged(); }	{ fName = n; fTitle = t; NameTitleChanged(); }

	Int_t GetIntIdsPerPoint() const { return fIntIdsPerPoint; }	Int_t GetIntIdsPerPoint() const { return fIntIdsPerPoint; }
	Int_t* GetPointIntIds(Int_t p) const;	Int_t* GetPointIntIds(Int_t p) const;
	Int_t GetPointIntId(Int_t p, Int_t i) const;	Int_t GetPointIntId(Int_t p, Int_t i) const;

	void SetPointIntIds(Int_t* ids);	void SetPointIntIds(Int_t* ids);
	void SetPointIntIds(Int_t n, Int_t* ids);	void SetPointIntIds(Int_t n, Int_t* ids);

	virtual void SetMarkerColor(Color_t col) { SetMainColor(col); }	virtual void SetMarkerColor(Color_t col) { SetMainColor(col); }

		virtual void SetMarkerStyle(Style_t mstyle=1);
		virtual void SetMarkerSize(Size_t msize=1);

	virtual void Paint(Option_t* option="");	virtual void Paint(Option_t* option="");

	virtual void InitFill(Int_t subIdNum);	virtual void InitFill(Int_t subIdNum);
	virtual void TakeAction(TEvePointSelector*);	virtual void TakeAction(TEvePointSelector*);

	virtual void PointSelected(Int_t id); // SIGNAL	virtual void PointSelected(Int_t id); // SIGNAL

	virtual const TGPicture* GetListTreeIcon(Bool_t open=kFALSE);	virtual const TGPicture* GetListTreeIcon(Bool_t open=kFALSE);


End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	TEvePolygonSetProjected.h	TEvePolygonSetProjected.h

	// @(#)root/eve:$Id: TEvePolygonSetProjected.h 30840 2009-10-23 09:03:14Z m atevz $	// @(#)root/eve:$Id: TEvePolygonSetProjected.h 31517 2009-12-03 11:56:23Z m atevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEvePolygonSetProjected	#ifndef ROOT_TEvePolygonSetProjected
	#define ROOT_TEvePolygonSetProjected	#define ROOT_TEvePolygonSetProjected

	#include "TEveElement.h"	#include "TEveElement.h"
	#include "TEveProjectionBases.h"	#include "TEveProjectionBases.h"

	#include "TNamed.h"	#include "TNamed.h"
	#include "TAtt3D.h"	#include "TAtt3D.h"
	#include "TAttBBox.h"	#include "TAttBBox.h"
	#include "TColor.h"	#include "TColor.h"

	#include "TEveVSDStructs.h"

	class TBuffer3D;	class TBuffer3D;

	class TEveVector;	class TEveVector;

	class TEvePolygonSetProjected : public TEveElementList,	class TEvePolygonSetProjected : public TEveElementList,
	public TEveProjected,	public TEveProjected,
	public TAtt3D,	public TAtt3D,
	public TAttBBox	public TAttBBox
	{	{

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	TEveProjectionManager.h	TEveProjectionManager.h

	// @(#)root/eve:$Id: TEveProjectionManager.h 30840 2009-10-23 09:03:14Z mat evz $	// @(#)root/eve:$Id: TEveProjectionManager.h 31517 2009-12-03 11:56:23Z mat evz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveProjectionManager	#ifndef ROOT_TEveProjectionManager
	#define ROOT_TEveProjectionManager	#define ROOT_TEveProjectionManager

	#include "TEveElement.h"	#include "TEveElement.h"
	#include "TAttBBox.h"	#include "TAttBBox.h"
	#include "TEveProjections.h"	#include "TEveProjections.h"

	#include "TEveVSDStructs.h"

	class TEveProjectionManager : public TEveElementList,	class TEveProjectionManager : public TEveElementList,
	public TAttBBox	public TAttBBox
	{	{
	private:	private:
	TEveProjectionManager(const TEveProjectionManager&); // Not i mplemented	TEveProjectionManager(const TEveProjectionManager&); // Not i mplemented
	TEveProjectionManager& operator=(const TEveProjectionManager&); // Not i mplemented	TEveProjectionManager& operator=(const TEveProjectionManager&); // Not i mplemented

	protected:	protected:
	TEveProjection* fProjections[TEveProjection::kPT_End];	TEveProjection* fProjections[TEveProjection::kPT_End];

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	TEveProjections.h	TEveProjections.h

	// @(#)root/eve:$Id: TEveProjections.h 30840 2009-10-23 09:03:14Z matevz $	// @(#)root/eve:$Id: TEveProjections.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveProjections	#ifndef ROOT_TEveProjections
	#define ROOT_TEveProjections	#define ROOT_TEveProjections


	#include "TEveVSDStructs.h"	#include "TEveVector.h"
		#include "TString.h"

	#include <vector>	#include <vector>

	//========================================================================= =====	//========================================================================= =====
	// TEveProjection	// TEveProjection
	//========================================================================= =====	//========================================================================= =====

	class TEveProjection	class TEveProjection
	{	{
	public:	public:

End of changes. 2 change blocks.
	2 lines changed or deleted	3 lines changed or added

	TEveTrack.h	TEveTrack.h

	// @(#)root/eve:$Id: TEveTrack.h 30840 2009-10-23 09:03:14Z matevz $	// @(#)root/eve:$Id: TEveTrack.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveTrack	#ifndef ROOT_TEveTrack
	#define ROOT_TEveTrack	#define ROOT_TEveTrack

	#include <vector>	#include <vector>


	#include "TEveVSDStructs.h"	#include "TEveVector.h"
	#include "TEveElement.h"	#include "TEveElement.h"
	#include "TEveLine.h"	#include "TEveLine.h"

	#include "TPolyMarker3D.h"	#include "TPolyMarker3D.h"
	#include "TMarker.h"	#include "TMarker.h"

	class TEveTrackPropagator;	class TEveTrackPropagator;
	class TEveTrackList;	class TEveTrackList;


		class TEveRecTrack;
		class TEveMCTrack;
		class TParticle;

	class TEveTrack : public TEveLine	class TEveTrack : public TEveLine
	{	{
	friend class TEveTrackPropagator;	friend class TEveTrackPropagator;
	friend class TEveTrackList;	friend class TEveTrackList;
	friend class TEveTrackGL;	friend class TEveTrackGL;

	private:	private:
	TEveTrack& operator=(const TEveTrack&); // Not implemented	TEveTrack& operator=(const TEveTrack&); // Not implemented

	public:	public:

	skipping to change at line 109	skipping to change at line 113
	const vPathMark_t& RefPathMarks() const { return fPathMarks; }	const vPathMark_t& RefPathMarks() const { return fPathMarks; }

	void PrintPathMarks(); // MENU	void PrintPathMarks(); // MENU

	void SetLockPoints(Bool_t l) { fLockPoints = l; }	void SetLockPoints(Bool_t l) { fLockPoints = l; }
	Bool_t GetLockPoints() const { return fLockPoints; }	Bool_t GetLockPoints() const { return fLockPoints; }

	//-------------------------------------------------------------------	//-------------------------------------------------------------------

	virtual void SecSelected(TEveTrack); // SIGNAL*	virtual void SecSelected(TEveTrack); // SIGNAL*

	virtual void SetLineStyle(Style_t lstyle);

	virtual const TGPicture* GetListTreeIcon(Bool_t open=kFALSE);	virtual const TGPicture* GetListTreeIcon(Bool_t open=kFALSE);

	virtual void CopyVizParams(const TEveElement* el);	virtual void CopyVizParams(const TEveElement* el);
	virtual void WriteVizParams(ostream& out, const TString& var);	virtual void WriteVizParams(ostream& out, const TString& var);

	virtual TClass* ProjectedClass(const TEveProjection* p) const;	virtual TClass* ProjectedClass(const TEveProjection* p) const;

	Bool_t ShouldBreakTrack() const;	Bool_t ShouldBreakTrack() const;


End of changes. 4 change blocks.
	3 lines changed or deleted	6 lines changed or added

	TEveTrackPropagator.h	TEveTrackPropagator.h

	// @(#)root/eve:$Id: TEveTrackPropagator.h 29919 2009-08-26 20:43:36Z matev z $	// @(#)root/eve:$Id: TEveTrackPropagator.h 31540 2009-12-03 17:02:17Z matev z $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveTrackPropagator	#ifndef ROOT_TEveTrackPropagator
	#define ROOT_TEveTrackPropagator	#define ROOT_TEveTrackPropagator


	#include "TEveVSDStructs.h"	#include "TEveVector.h"
	#include "TEveUtil.h"	#include "TEveUtil.h"
	#include "TEveElement.h"	#include "TEveElement.h"
	#include "TMarker.h"	#include "TMarker.h"

	#include <vector>	#include <vector>

	class TEvePointSet;	class TEvePointSet;

	//========================================================================= =====	//========================================================================= =====
	// TEveMagField	// TEveMagField

	skipping to change at line 283	skipping to change at line 283

	TMarker& RefPMAtt() { return fPMAtt; }	TMarker& RefPMAtt() { return fPMAtt; }
	TMarker& RefFVAtt() { return fFVAtt; }	TMarker& RefFVAtt() { return fFVAtt; }

	static Bool_t IsOutsideBounds(const TEveVector& point, Float_t maxRsqr, Float_t maxZ);	static Bool_t IsOutsideBounds(const TEveVector& point, Float_t maxRsqr, Float_t maxZ);

	static Float_t fgDefMagField; // Default value for constant solenoid magnetic field.	static Float_t fgDefMagField; // Default value for constant solenoid magnetic field.
	static const Float_t fgkB2C; // Constant for conversion of momentum to curvature.	static const Float_t fgkB2C; // Constant for conversion of momentum to curvature.
	static TEveTrackPropagator fgDefault; // Default track propagator.	static TEveTrackPropagator fgDefault; // Default track propagator.


		static Float_t fgEditorMaxR; // Max R that can be set in GU
		I editor.
		static Float_t fgEditorMaxZ; // Max Z that can be set in GU
		I editor.

	ClassDef(TEveTrackPropagator, 0); // Calculates path of a particle takin g into account special path-marks and imposed boundaries.	ClassDef(TEveTrackPropagator, 0); // Calculates path of a particle takin g into account special path-marks and imposed boundaries.
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	inline Bool_t TEveTrackPropagator::IsOutsideBounds(const TEveVector& point,	inline Bool_t TEveTrackPropagator::IsOutsideBounds(const TEveVector& point,
	Float_t maxRsq r,	Float_t maxRsq r,
	Float_t maxZ)	Float_t maxZ)
	{	{
	// Return true if point% is outside of cylindrical bounds detrmined by	// Return true if point% is outside of cylindrical bounds detrmined by
	// square radius and z.	// square radius and z.

End of changes. 3 change blocks.
	2 lines changed or deleted	7 lines changed or added

	TEveVSDStructs.h	TEveVSDStructs.h

	// @(#)root/eve:$Id: TEveVSDStructs.h 29908 2009-08-25 18:09:53Z matevz $	// @(#)root/eve:$Id: TEveVSDStructs.h 31517 2009-12-03 11:56:23Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveVSDStructs	#ifndef ROOT_TEveVSDStructs
	#define ROOT_TEveVSDStructs	#define ROOT_TEveVSDStructs

	#include "TObject.h"	#include "TObject.h"

	#include "TMath.h"

	#include "TParticle.h"	#include "TParticle.h"

		#include "TEveVector.h"

	/************************************************************************ **/	/************************************************************************ **/
	// VSD Structures	// VSD Structures
	/************************************************************************ **/	/************************************************************************ **/

	// Basic structures for Reve VSD concept. Design criteria:	// Basic structures for Reve VSD concept. Design criteria:
	//	//
	// * provide basic cross-referencing functionality;	// * provide basic cross-referencing functionality;
	//	//
	// * small memory/disk footprint (floats / count on compression in	// * small memory/disk footprint (floats / count on compression in
	// split mode);	// split mode);
	//	//
	// * simple usage from tree selections;	// * simple usage from tree selections;
	//	//
	// * placement in TClonesArray (composites are TObject derived);	// * placement in TClonesArray (composites are TObject derived);
	//	//
	// * minimal member-naming (impossible to make everybody happy).	// * minimal member-naming (impossible to make everybody happy).
	//	//

	/************************************************************************ **/	/************************************************************************ **/

	// TEveVector
	/**************************************************************************
	****/

	class TEveVector
	{
	public:
	Float_t fX, fY, fZ; // Components of the vector.

	TEveVector() : fX(0), fY(0), fZ(0) {}
	TEveVector(const Float_t* v) : fX(v[0]), fY(v[1]), fZ(v[2]) {}
	TEveVector(const Double_t* v) : fX(v[0]), fY(v[1]), fZ(v[2]) {}
	TEveVector(Float_t x, Float_t y, Float_t z) : fX(x), fY(y), fZ(z) {}
	virtual ~TEveVector() {}

	void Dump() const;

	operator const Float_t*() const { return &fX; }
	operator Float_t*() { return &fX; }

	TEveVector& operator =(Float_t s) { fX = s; fY *= s; f
	Z = s; return this; }
	TEveVector& operator +=(const TEveVector& v) { fX += v.fX; fY += v.fY; f
	Z += v.fZ; return *this; }
	TEveVector& operator -=(const TEveVector& v) { fX -= v.fX; fY -= v.fY; f
	Z -= v.fZ; return *this; }

	TEveVector operator + (const TEveVector &) const;
	TEveVector operator - (const TEveVector &) const;
	TEveVector operator * (Float_t a) const;

	Float_t& operator [] (Int_t indx);
	Float_t operator [] (Int_t indx) const;

	const Float_t* Arr() const { return &fX; }
	Float_t* Arr() { return &fX; }

	void Set(const Float_t* v) { fX = v[0]; fY = v[1]; fZ = v[2]; }
	void Set(const Double_t* v) { fX = v[0]; fY = v[1]; fZ = v[2]; }
	void Set(Float_t x, Float_t y, Float_t z) { fX = x; fY = y; fZ = z; }
	void Set(Double_t x, Double_t y, Double_t z) { fX = x; fY = y; fZ = z; }
	void Set(const TVector3& v) { fX = v.x(); fY = v.y(); fZ = v.z(); }
	void Set(const TEveVector& v) { fX = v.fX; fY = v.fY; fZ = v.fZ; }

	void NegateXYZ() { fX = - fX; fY = -fY; fZ = -fZ; }
	void Normalize(Float_t length=1);

	Float_t Phi() const;
	Float_t Theta() const;
	Float_t CosTheta() const;
	Float_t Eta() const;

	Float_t Mag() const { return TMath::Sqrt(fXfX + fYfY + fZ*fZ);}
	Float_t Mag2() const { return fXfX + fYfY + fZ*fZ;}

	Float_t Perp() const { return TMath::Sqrt(fXfX + fYfY);}
	Float_t Perp2() const { return fXfX + fYfY;}
	Float_t R() const { return Perp(); }

	Float_t Distance(const TEveVector& v) const;
	Float_t SquareDistance(const TEveVector& v) const;

	Float_t Dot(const TEveVector& a) const;
	TEveVector Cross(const TEveVector& a) const;

	TEveVector& Sub(const TEveVector& p, const TEveVector& q);

	TEveVector& Mult(const TEveVector& a, Float_t af);

	TEveVector Orthogonal() const;
	void OrthoNormBase(TEveVector& a, TEveVector& b) const;

	ClassDef(TEveVector, 1); // Float three-vector; a minimal Float_t copy o
	f TVector3 used to represent points and momenta (also used in VSD).
	};

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::Phi() const
	{
	return fX == 0.0 && fY == 0.0 ? 0.0 : TMath::ATan2(fY, fX);
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::Theta() const
	{
	return fX == 0.0 && fY == 0.0 && fZ == 0.0 ? 0.0 : TMath::ATan2(Perp(),
	fZ);
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::CosTheta() const
	{
	Float_t ptot = Mag(); return ptot == 0.0 ? 1.0 : fZ/ptot;
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::Distance( const TEveVector& b) const
	{
	return TMath::Sqrt((fX - b.fX)*(fX - b.fX) +
	(fY - b.fY)*(fY - b.fY) +
	(fZ - b.fZ)*(fZ - b.fZ));
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::SquareDistance(const TEveVector& b) const
	{
	return ((fX - b.fX) * (fX - b.fX) +
	(fY - b.fY) * (fY - b.fY) +
	(fZ - b.fZ) * (fZ - b.fZ));
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::Dot(const TEveVector& a) const
	{
	return a.fXfX + a.fYfY + a.fZ*fZ;
	}

	//_________________________________________________________________________
	_____
	inline TEveVector TEveVector::Cross(const TEveVector& a) const
	{
	TEveVector r;
	r.fX = fY * a.fZ - fZ * a.fY;
	r.fY = fZ * a.fX - fX * a.fZ;
	r.fZ = fX * a.fY - fY * a.fX;
	return r;
	}

	//_________________________________________________________________________
	_____
	inline TEveVector& TEveVector::Sub(const TEveVector& p, const TEveVector& q
	)
	{
	fX = p.fX - q.fX;
	fY = p.fY - q.fY;
	fZ = p.fZ - q.fZ;
	return *this;
	}

	//_________________________________________________________________________
	_____
	inline TEveVector& TEveVector::Mult(const TEveVector& a, Float_t af)
	{
	fX = a.fX * af;
	fY = a.fY * af;
	fZ = a.fZ * af;
	return *this;
	}

	//_________________________________________________________________________
	_____
	inline Float_t& TEveVector::operator [] (Int_t idx)
	{
	return (&fX)[idx];
	}

	//_________________________________________________________________________
	_____
	inline Float_t TEveVector::operator [] (Int_t idx) const
	{
	return (&fX)[idx];
	}

	/**************************************************************************
	****/
	// TEveVector4
	/**************************************************************************
	****/

	class TEveVector4 : public TEveVector
	{
	public:
	Float_t fT;

	TEveVector4() : TEveVector(), fT(0) {}
	TEveVector4(const TEveVector& v) : TEveVector(v), fT(0) {}
	TEveVector4(Float_t x, Float_t y, Float_t z, Float_t t=0) :
	TEveVector(x, y, z), fT(t) {}
	virtual ~TEveVector4() {}

	void Dump() const;

	TEveVector4 operator + (const TEveVector4 & b) const
	{ return TEveVector4(fX + b.fX, fY + b.fY, fZ + b.fZ, fT + b.fT); }

	TEveVector4 operator - (const TEveVector4 & b) const
	{ return TEveVector4(fX - b.fX, fY - b.fY, fZ - b.fZ, fT - b.fT); }

	TEveVector4 operator * (Float_t a) const
	{ return TEveVector4(afX, afY, afZ, afT); }

	TEveVector4& operator += (const TEveVector4 & b)
	{ fX += b.fX; fY += b.fY; fZ += b.fZ; fT += b.fT; return *this; }

	ClassDef(TEveVector4, 1); // Float four-vector.
	};

	/**************************************************************************
	****/
	// TEvePathMark
	/**************************************************************************
	****/

	class TEvePathMark
	{
	public:
	enum EType_e { kReference, kDaughter, kDecay, kCluster2D };

	EType_e fType; // Mark-type.
	TEveVector fV; // Vertex.
	TEveVector fP; // Momentum.
	TEveVector fE; // Extra, meaning depends on fType.
	Float_t fTime; // Time.

	TEvePathMark(EType_e type=kReference) :
	fType(type), fV(), fP(), fE(), fTime(0) {}

	TEvePathMark(EType_e type, const TEveVector& v, Float_t time=0) :
	fType(type), fV(v), fP(), fE(), fTime(time) {}

	TEvePathMark(EType_e type, const TEveVector& v, const TEveVector& p, Flo
	at_t time=0) :
	fType(type), fV(v), fP(p), fE(), fTime(time) {}

	TEvePathMark(EType_e type, const TEveVector& v, const TEveVector& p, con
	st TEveVector& e, Float_t time=0) :
	fType(type), fV(v), fP(p), fE(e), fTime(time) {}

	virtual ~TEvePathMark() {}

	const char* TypeName();

	ClassDef(TEvePathMark, 1); // Special-point on track: position/momentum
	reference, daughter creation or decay (also used in VSD).
	};

	/**************************************************************************
	****/
	// TEveMCTrack	// TEveMCTrack
	/************************************************************************ **/	/************************************************************************ **/

	class TEveMCTrack : public TParticle // ?? Copy stuff over ??	class TEveMCTrack : public TParticle // ?? Copy stuff over ??
	{	{
	public:	public:
	Int_t fLabel; // Label of the track	Int_t fLabel; // Label of the track
	Int_t fIndex; // Index of the track (in some source array)	Int_t fIndex; // Index of the track (in some source array)
	Int_t fEvaLabel; // Label of primary particle	Int_t fEvaLabel; // Label of primary particle


End of changes. 4 change blocks.
	247 lines changed or deleted	2 lines changed or added

	TEveViewer.h	TEveViewer.h

	// @(#)root/eve:$Id: TEveViewer.h 31299 2009-11-18 21:06:28Z matevz $	// @(#)root/eve:$Id: TEveViewer.h 31821 2009-12-10 18:22:44Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 55	skipping to change at line 55
	public:	public:
	TEveViewer(const char* n="TEveViewer", const char* t="");	TEveViewer(const char* n="TEveViewer", const char* t="");
	virtual ~TEveViewer();	virtual ~TEveViewer();

	virtual void PreUndock();	virtual void PreUndock();
	virtual void PostDock();	virtual void PostDock();

	TGLViewer* GetGLViewer() const { return fGLViewer; }	TGLViewer* GetGLViewer() const { return fGLViewer; }
	void SetGLViewer(TGLViewer* viewer, TGFrame* frame);	void SetGLViewer(TGLViewer* viewer, TGFrame* frame);


	TGLSAViewer* SpawnGLViewer(TGedEditor* ged);	TGLSAViewer* SpawnGLViewer(TGedEditor* ged=0, Bool_t stereo=kFALSE
	TGLEmbeddedViewer* SpawnGLEmbeddedViewer(TGedEditor* ged, Int_t border=0	);
	);	TGLEmbeddedViewer* SpawnGLEmbeddedViewer(TGedEditor* ged=0, Int_t border
		=0);

	void Redraw(Bool_t resetCameras=kFALSE);	void Redraw(Bool_t resetCameras=kFALSE);

		void SwitchStereo();

	virtual void AddScene(TEveScene* scene);	virtual void AddScene(TEveScene* scene);

	virtual void RemoveElementLocal(TEveElement* el);	virtual void RemoveElementLocal(TEveElement* el);
	virtual void RemoveElementsLocal();	virtual void RemoveElementsLocal();

	virtual TObject* GetEditorObject(const TEveException& eh="TEveViewer::Ge tEditorObject ") const;	virtual TObject* GetEditorObject(const TEveException& eh="TEveViewer::Ge tEditorObject ") const;

	virtual Bool_t HandleElementPaste(TEveElement* el);	virtual Bool_t HandleElementPaste(TEveElement* el);


End of changes. 3 change blocks.
	4 lines changed or deleted	6 lines changed or added

	TGL5DPainter.h	TGL5DPainter.h

	skipping to change at line 42	skipping to change at line 42
	enum EDefaults {	enum EDefaults {
	kNContours = 4,	kNContours = 4,
	kNLowPts = 50	kNLowPts = 50
	};	};

	typedef Rgl::Mc::TIsoMesh<Float_t> Mesh_t;	typedef Rgl::Mc::TIsoMesh<Float_t> Mesh_t;

	//Iso surface.	//Iso surface.
	struct Surf_t {	struct Surf_t {
	Surf_t()	Surf_t()

	: f4D(0.), fShowCloud(kFALSE), fHide(kFALSE),	: f4D(0.), fRange(0.), fShowCloud(kFALSE), fHide(kFALSE),
	fColor(0), fHighlight(kFALSE), fAlpha(100)	fColor(0), fHighlight(kFALSE), fAlpha(100)
	{	{
	}	}

	Mesh_t fMesh; //Mesh.	Mesh_t fMesh; //Mesh.
	Double_t f4D; //Iso-level.	Double_t f4D; //Iso-level.
	Double_t fRange; //Selection critera (f4D +- fRange).	Double_t fRange; //Selection critera (f4D +- fRange).
	Bool_t fShowCloud;//Show/Hide original cloud.	Bool_t fShowCloud;//Show/Hide original cloud.
	Bool_t fHide; //Show/Hide surface.	Bool_t fHide; //Show/Hide surface.
	Color_t fColor; //Color.	Color_t fColor; //Color.

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TGLAxisPainter.h	TGLAxisPainter.h

	// @(#)root/eve:$Id: TGLAxisPainter.h 30425 2009-09-24 19:45:11Z matevz $	// @(#)root/eve:$Id: TGLAxisPainter.h 31671 2009-12-08 15:22:31Z matevz $
	// Author: Alja Mrak-Tadel 2009	// Author: Alja Mrak-Tadel 2009

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 43	skipping to change at line 43
	typedef std::vector<TM_t> TMVec_t; // vector od tick line s	typedef std::vector<TM_t> TMVec_t; // vector od tick line s

	private:	private:
	TGLAxisPainter(const TGLAxisPainter&); // Not implemented	TGLAxisPainter(const TGLAxisPainter&); // Not implemented
	TGLAxisPainter& operator=(const TGLAxisPainter&); // Not implemented	TGLAxisPainter& operator=(const TGLAxisPainter&); // Not implemented

	// Print format derived from attributers.	// Print format derived from attributers.
	Int_t fExp;	Int_t fExp;
	Int_t fMaxDigits;	Int_t fMaxDigits;
	Int_t fDecimals;	Int_t fDecimals;

	char fFormat[8];	TString fFormat;

	// Font derived from axis attributes.	// Font derived from axis attributes.
	TGLFont fLabelFont;	TGLFont fLabelFont;
	TGLFont fTitleFont;	TGLFont fTitleFont;

	// Print format.	// Print format.
	void LabelsLimits(const char *label, Int_t &first, Int_t &last) const;	void LabelsLimits(const char *label, Int_t &first, Int_t &last) const;
	void FormAxisValue(Double_t x, TString &s) const;	void FormAxisValue(Double_t x, TString &s) const;

	protected:	protected:

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TGLClip.h	TGLClip.h

	// @(#)root/gl:$Id: TGLClip.h 28607 2009-05-13 15:11:33Z matevz $	// @(#)root/gl:$Id: TGLClip.h 31541 2009-12-03 20:00:32Z matevz $
	// Author: Richard Maunder 16/09/2005	// Author: Richard Maunder 16/09/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 50	skipping to change at line 50
	UInt_t fTimeStamp;	UInt_t fTimeStamp;
	Bool_t fValid;	Bool_t fValid;

	public:	public:
	TGLClip(const TGLLogicalShape & logical, const TGLMatrix & transform, co nst float color[4]);	TGLClip(const TGLLogicalShape & logical, const TGLMatrix & transform, co nst float color[4]);
	virtual ~TGLClip();	virtual ~TGLClip();

	virtual void Modified() { TGLPhysicalShape::Modified(); IncTimeStamp(); }	virtual void Modified() { TGLPhysicalShape::Modified(); IncTimeStamp(); }

	virtual void Setup(const TGLBoundingBox & bbox) = 0;	virtual void Setup(const TGLBoundingBox & bbox) = 0;

		virtual void Setup(const TGLVector3&, const TGLVector3&);

	EMode GetMode() const { return fMode; }	EMode GetMode() const { return fMode; }
	void SetMode(EMode mode) { if (mode != fMode) { fMode = mode; ++fTimeS tamp; } }	void SetMode(EMode mode) { if (mode != fMode) { fMode = mode; ++fTimeS tamp; } }

	UInt_t TimeStamp() const { return fTimeStamp; }	UInt_t TimeStamp() const { return fTimeStamp; }
	void IncTimeStamp() { ++fTimeStamp; }	void IncTimeStamp() { ++fTimeStamp; }

	Bool_t IsValid() const { return fValid; }	Bool_t IsValid() const { return fValid; }
	void Invalidate() { fValid = kFALSE; }	void Invalidate() { fValid = kFALSE; }


	skipping to change at line 86	skipping to change at line 87
	class TGLClipPlane : public TGLClip	class TGLClipPlane : public TGLClip
	{	{
	private:	private:
	static const float fgColor[4]; //! Fixed color of clip plane	static const float fgColor[4]; //! Fixed color of clip plane

	public:	public:
	TGLClipPlane();	TGLClipPlane();
	virtual ~TGLClipPlane();	virtual ~TGLClipPlane();

	virtual void Setup(const TGLBoundingBox & bbox);	virtual void Setup(const TGLBoundingBox & bbox);

		virtual void Setup(const TGLVector3& point, const TGLVector3& normal);

	void Set(const TGLPlane & plane);	void Set(const TGLPlane & plane);

	virtual void PlaneSet(TGLPlaneSet_t & set) const;	virtual void PlaneSet(TGLPlaneSet_t & set) const;

	ClassDef(TGLClipPlane, 0); // clipping plane	ClassDef(TGLClipPlane, 0); // clipping plane
	};	};

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //

	skipping to change at line 113	skipping to change at line 115
	class TGLClipBox : public TGLClip	class TGLClipBox : public TGLClip
	{	{
	private:	private:
	static const float fgColor[4]; //! Fixed color of clip box	static const float fgColor[4]; //! Fixed color of clip box

	public:	public:
	TGLClipBox();	TGLClipBox();
	virtual ~TGLClipBox();	virtual ~TGLClipBox();

	virtual void Setup(const TGLBoundingBox & bbox);	virtual void Setup(const TGLBoundingBox & bbox);

		virtual void Setup(const TGLVector3& min_point, const TGLVector3& max_po int);

	virtual void PlaneSet(TGLPlaneSet_t & set) const;	virtual void PlaneSet(TGLPlaneSet_t & set) const;

	ClassDef(TGLClipBox, 0); // clipping box	ClassDef(TGLClipBox, 0); // clipping box
	};	};

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	//	//
	// TGLClipSet	// TGLClipSet
	//	//

End of changes. 4 change blocks.
	1 lines changed or deleted	4 lines changed or added

	TGLFormat.h	TGLFormat.h

	// @(#)root/gl:$Id: TGLFormat.h 21453 2007-12-18 15:18:30Z matevz $	// @(#)root/gl:$Id: TGLFormat.h 31821 2009-12-10 18:22:44Z matevz $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLFormat	#ifndef ROOT_TGLFormat
	#define ROOT_TGLFormat	#define ROOT_TGLFormat

	skipping to change at line 38	skipping to change at line 38
	-with/without accum buffer	-with/without accum buffer
	-double/single buffered	-double/single buffered
	*/	*/

	class TGLFormat {	class TGLFormat {
	public:	public:
	enum EFormatOptions {	enum EFormatOptions {
	kDoubleBuffer = 1,	kDoubleBuffer = 1,
	kDepth = 2,	kDepth = 2,
	kAccum = 4,	kAccum = 4,

	kStencil = 8	kStencil = 8,
		kStereo = 16
	};	};

	private:	private:
	Bool_t fDoubleBuffered;	Bool_t fDoubleBuffered;

		Bool_t fStereo;
	UInt_t fDepthSize;	UInt_t fDepthSize;
	UInt_t fAccumSize;	UInt_t fAccumSize;
	UInt_t fStencilSize;	UInt_t fStencilSize;

	public:	public:
	TGLFormat();	TGLFormat();
	TGLFormat(EFormatOptions options);	TGLFormat(EFormatOptions options);

	//Virtual dtor only to supress warnings from g++ -	//Virtual dtor only to supress warnings from g++ -
	//ClassDef adds virtual functions, so g++ wants virtual dtor.	//ClassDef adds virtual functions, so g++ wants virtual dtor.

	skipping to change at line 73	skipping to change at line 75
	void SetStencilSize(UInt_t stencil);	void SetStencilSize(UInt_t stencil);
	Bool_t HasStencil()const;	Bool_t HasStencil()const;

	UInt_t GetAccumSize()const;	UInt_t GetAccumSize()const;
	void SetAccumSize(UInt_t accum);	void SetAccumSize(UInt_t accum);
	Bool_t HasAccumBuffer()const;	Bool_t HasAccumBuffer()const;

	Bool_t IsDoubleBuffered()const;	Bool_t IsDoubleBuffered()const;
	void SetDoubleBuffered(Bool_t db);	void SetDoubleBuffered(Bool_t db);


		Bool_t IsStereo()const;
		void SetStereo(Bool_t db);

	ClassDef(TGLFormat, 0) // Describes GL buffer format.	ClassDef(TGLFormat, 0) // Describes GL buffer format.
	};	};

	#endif	#endif

End of changes. 4 change blocks.
	2 lines changed or deleted	7 lines changed or added

	TGLIsoMesh.h	TGLIsoMesh.h

	skipping to change at line 93	skipping to change at line 93
	template<class V>	template<class V>
	class TGridGeometry {	class TGridGeometry {
	public:	public:
	enum EVertexPosition{	enum EVertexPosition{
	kBinCenter,	kBinCenter,
	kBinEdge	kBinEdge
	};	};

	TGridGeometry() : fMinX(0), fStepX(0),	TGridGeometry() : fMinX(0), fStepX(0),
	fMinY(0), fStepY(0),	fMinY(0), fStepY(0),

	fMinZ(0), fStepZ(0)	fMinZ(0), fStepZ(0),
		fXScaleInverted(1.),
		fYScaleInverted(1.),
		fZScaleInverted(1.)
	{	{
	//Default constructor.	//Default constructor.
	}	}

	TGridGeometry(const TAxis x, const TAxis y, const TAxis *z,	TGridGeometry(const TAxis x, const TAxis y, const TAxis *z,
	Double_t xs = 1., Double_t ys = 1., Double_t zs = 1.,	Double_t xs = 1., Double_t ys = 1., Double_t zs = 1.,
	EVertexPosition pos = kBinCenter)	EVertexPosition pos = kBinCenter)
	: fMinX(0), fStepX(0),	: fMinX(0), fStepX(0),
	fMinY(0), fStepY(0),	fMinY(0), fStepY(0),
	fMinZ(0), fStepZ(0),	fMinZ(0), fStepZ(0),

End of changes. 1 change blocks.
	1 lines changed or deleted	4 lines changed or added

	TGLSAViewer.h	TGLSAViewer.h

	// @(#)root/gl:$Id: TGLSAViewer.h 31299 2009-11-18 21:06:28Z matevz $	// @(#)root/gl:$Id: TGLSAViewer.h 31821 2009-12-10 18:22:44Z matevz $
	// Author: Richard Maunder / Timur Pocheptsov	// Author: Richard Maunder / Timur Pocheptsov

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TGLSAViewer	#ifndef ROOT_TGLSAViewer
	#define ROOT_TGLSAViewer	#define ROOT_TGLSAViewer

	#include "TGLViewer.h"	#include "TGLViewer.h"
	#include "TString.h"	#include "TString.h"

	class TGLSAFrame;	class TGLSAFrame;

		class TGLFormat;
	class TGWindow;	class TGWindow;
	class TGFrame;	class TGFrame;
	class TGCompositeFrame;	class TGCompositeFrame;
	class TGPopupMenu;	class TGPopupMenu;
	class TGButton;	class TGButton;

	class TGedEditor;	class TGedEditor;
	class TGLEventHandler;	class TGLEventHandler;
	class TGMenuBar;	class TGMenuBar;


	skipping to change at line 51	skipping to change at line 52
	kGLXOY, kGLXOZ, kGLZOY,	kGLXOY, kGLXOZ, kGLZOY,
	kGLXnOY, kGLXnOZ, kGLZnOY,	kGLXnOY, kGLXnOZ, kGLZnOY,
	kGLOrthoRotate, kGLOrthoDolly,	kGLOrthoRotate, kGLOrthoDolly,
	kGLSaveEPS, kGLSavePDF, kGLSavePNG, kGLSaveGIF, kGLSaveAnimGIF,	kGLSaveEPS, kGLSavePDF, kGLSavePNG, kGLSaveGIF, kGLSaveAnimGIF,
	kGLSaveJPG, kGLSaveAS, kGLCloseViewer, kGLQuitROOT,	kGLSaveJPG, kGLSaveAS, kGLCloseViewer, kGLQuitROOT,
	kGLEditObject };	kGLEditObject };

	private:	private:
	// GUI components	// GUI components
	TGLSAFrame *fFrame;	TGLSAFrame *fFrame;

		TGLFormat *fFormat;
	TGPopupMenu *fFileMenu;	TGPopupMenu *fFileMenu;
	TGPopupMenu *fFileSaveMenu;	TGPopupMenu *fFileSaveMenu;
	TGPopupMenu *fCameraMenu;	TGPopupMenu *fCameraMenu;
	TGPopupMenu *fHelpMenu;	TGPopupMenu *fHelpMenu;

	// Ged	// Ged
	TGCompositeFrame *fLeftVerticalFrame;	TGCompositeFrame *fLeftVerticalFrame;

	TGCompositeFrame *fRightVerticalFrame;	TGCompositeFrame *fRightVerticalFrame;


	skipping to change at line 86	skipping to change at line 88
	static const char *fgHelpText2;	static const char *fgHelpText2;

	void CreateMenus();	void CreateMenus();
	void CreateFrames();	void CreateFrames();

	// non-copyable class	// non-copyable class
	TGLSAViewer(const TGLSAViewer &);	TGLSAViewer(const TGLSAViewer &);
	TGLSAViewer & operator = (const TGLSAViewer &);	TGLSAViewer & operator = (const TGLSAViewer &);

	public:	public:

	TGLSAViewer(TVirtualPad *pad);	TGLSAViewer(TVirtualPad* pad, TGLFormat* format=0);
	TGLSAViewer(const TGWindow parent, TVirtualPad pad, TGedEditor *ged=0)	TGLSAViewer(const TGWindow* parent, TVirtualPad pad, TGedEditor ged=0,
	;	TGLFormat* format=0);
	~TGLSAViewer();	~TGLSAViewer();

	virtual void CreateGLWidget();	virtual void CreateGLWidget();
	virtual void DestroyGLWidget();	virtual void DestroyGLWidget();

	virtual const char* GetName() const { return "GLViewer"; }	virtual const char* GetName() const { return "GLViewer"; }

	virtual void SelectionChanged();	virtual void SelectionChanged();

	void Show();	void Show();

	skipping to change at line 111	skipping to change at line 114
	void EnableMenuBarHiding();	void EnableMenuBarHiding();

	void HandleMenuBarHiding(Event_t* ev);	void HandleMenuBarHiding(Event_t* ev);

	// GUI events - editors, frame etc	// GUI events - editors, frame etc
	Bool_t ProcessFrameMessage(Long_t msg, Long_t parm1, Long_t);	Bool_t ProcessFrameMessage(Long_t msg, Long_t parm1, Long_t);

	TGCompositeFrame* GetFrame() const;	TGCompositeFrame* GetFrame() const;
	TGCompositeFrame* GetLeftVerticalFrame() const { return fLeftVerticalFra me; }	TGCompositeFrame* GetLeftVerticalFrame() const { return fLeftVerticalFra me; }


		TGLFormat* GetFormat() const { return fFormat; }

	void ToggleEditObject();	void ToggleEditObject();
	void ToggleOrthoRotate();	void ToggleOrthoRotate();
	void ToggleOrthoDolly();	void ToggleOrthoDolly();

	ClassDef(TGLSAViewer, 0); // Standalone GL viewer.	ClassDef(TGLSAViewer, 0); // Standalone GL viewer.
	};	};

	#endif	#endif

End of changes. 5 change blocks.
	4 lines changed or deleted	8 lines changed or added

	TGLSurfacePainter.h	TGLSurfacePainter.h

	skipping to change at line 17	skipping to change at line 17
	#ifndef ROOT_TGLPlotPainter	#ifndef ROOT_TGLPlotPainter
	#include "TGLPlotPainter.h"	#include "TGLPlotPainter.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif
	#ifndef ROOT_TGLUtil	#ifndef ROOT_TGLUtil
	#include "TGLUtil.h"	#include "TGLUtil.h"
	#endif	#endif


		class TRandom;

	class TGLSurfacePainter : public TGLPlotPainter {	class TGLSurfacePainter : public TGLPlotPainter {
	private:	private:
	enum ESurfaceType {	enum ESurfaceType {
	kSurf,	kSurf,
	kSurf1,	kSurf1,
	kSurf2,	kSurf2,
	kSurf3,	kSurf3,
	kSurf4,	kSurf4,
	kSurf5	kSurf5
	};	};

	skipping to change at line 101	skipping to change at line 103
	void GenTexMap()const;	void GenTexMap()const;
	void DrawContoursProjection()const;	void DrawContoursProjection()const;

	Bool_t Textured()const;	Bool_t Textured()const;
	Bool_t HasSections()const;	Bool_t HasSections()const;
	Bool_t HasProjections()const;	Bool_t HasProjections()const;

	void DrawPalette()const;	void DrawPalette()const;
	void DrawPaletteAxis()const;	void DrawPaletteAxis()const;


		static TRandom *fgRandom;

	ClassDef(TGLSurfacePainter, 0)//Surface painter.	ClassDef(TGLSurfacePainter, 0)//Surface painter.
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	4 lines changed or added

	TGLViewer.h	TGLViewer.h

	// @(#)root/gl:$Id: TGLViewer.h 31299 2009-11-18 21:06:28Z matevz $	// @(#)root/gl:$Id: TGLViewer.h 31821 2009-12-10 18:22:44Z matevz $
	// Author: Richard Maunder 25/05/2005	// Author: Richard Maunder 25/05/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 86	skipping to change at line 86
	TContextMenu *fContextMenu; //!	TContextMenu *fContextMenu; //!

	// Cameras	// Cameras
	// TODO: Put in vector and allow external creation	// TODO: Put in vector and allow external creation
	TGLPerspectiveCamera fPerspectiveCameraXOZ; //!	TGLPerspectiveCamera fPerspectiveCameraXOZ; //!
	TGLPerspectiveCamera fPerspectiveCameraYOZ; //!	TGLPerspectiveCamera fPerspectiveCameraYOZ; //!
	TGLPerspectiveCamera fPerspectiveCameraXOY; //!	TGLPerspectiveCamera fPerspectiveCameraXOY; //!
	TGLOrthoCamera fOrthoXOYCamera; //!	TGLOrthoCamera fOrthoXOYCamera; //!
	TGLOrthoCamera fOrthoXOZCamera; //!	TGLOrthoCamera fOrthoXOZCamera; //!
	TGLOrthoCamera fOrthoZOYCamera; //!	TGLOrthoCamera fOrthoZOYCamera; //!

	TGLOrthoCamera fOrthoXnOYCamera; //!	TGLOrthoCamera fOrthoXnOYCamera; //!
	TGLOrthoCamera fOrthoXnOZCamera; //!	TGLOrthoCamera fOrthoXnOZCamera; //!
	TGLOrthoCamera fOrthoZnOYCamera; //!	TGLOrthoCamera fOrthoZnOYCamera; //!
	TGLCamera *fCurrentCamera; //!	TGLCamera *fCurrentCamera; //!


		// Stereo
		Bool_t fStereo; //! use stereo rendering
		Float_t fStereoZeroParallax; //! position of zero-paralla
		x plane: 0 - near clipping plane, 1 - far clipping plane
		Float_t fStereoEyeOffsetFac; //!
		Float_t fStereoFrustumAsymFac; //!

	// Lights	// Lights
	TGLLightSet *fLightSet; //!	TGLLightSet *fLightSet; //!
	// Clipping	// Clipping
	TGLClipSet *fClipSet; //!	TGLClipSet *fClipSet; //!
	Bool_t fClipAutoUpdate; //!	Bool_t fClipAutoUpdate; //!
	// Selected physical	// Selected physical
	TGLSelectRecord fCurrentSelRec; //! select record in use as selected	TGLSelectRecord fCurrentSelRec; //! select record in use as selected
	TGLSelectRecord fSelRec; //! select record from last select (should go to context)	TGLSelectRecord fSelRec; //! select record from last select (should go to context)
	TGLSelectRecord fSecSelRec; //! select record from last secondary select (should go to context)	TGLSelectRecord fSecSelRec; //! select record from last secondary select (should go to context)
	TGLManipSet *fSelectedPShapeRef; //!	TGLManipSet *fSelectedPShapeRef; //!

	skipping to change at line 265	skipping to change at line 271
	Double_t center[3], Double_t hRotate, Double_t vRotate);	Double_t center[3], Double_t hRotate, Double_t vRotate);
	void GetGuideState(Int_t & axesType, Bool_t & axesDepthTest, Bool_t & re ferenceOn, Double_t* referencePos) const;	void GetGuideState(Int_t & axesType, Bool_t & axesDepthTest, Bool_t & re ferenceOn, Double_t* referencePos) const;
	void SetGuideState(Int_t axesType, Bool_t axesDepthTest, Bool_t referenc eOn, const Double_t* referencePos);	void SetGuideState(Int_t axesType, Bool_t axesDepthTest, Bool_t referenc eOn, const Double_t* referencePos);
	void SetDrawCameraCenter(Bool_t x);	void SetDrawCameraCenter(Bool_t x);
	Bool_t GetDrawCameraCenter() { return fDrawCameraCenter; }	Bool_t GetDrawCameraCenter() { return fDrawCameraCenter; }
	void PickCameraCenter() { fPushAction = kPushCamCenter; RefreshPadE ditor(this); }	void PickCameraCenter() { fPushAction = kPushCamCenter; RefreshPadE ditor(this); }
	void PickAnnotate() { fPushAction = kPushAnnotate; RefreshPadE ditor(this); }	void PickAnnotate() { fPushAction = kPushAnnotate; RefreshPadE ditor(this); }
	TGLCameraOverlay* GetCameraOverlay() const { return fCameraOverlay; }	TGLCameraOverlay* GetCameraOverlay() const { return fCameraOverlay; }
	void SetCameraOverlay(TGLCameraOverlay* m) { fCameraOverlay = m; }	void SetCameraOverlay(TGLCameraOverlay* m) { fCameraOverlay = m; }


		// Stereo
		Bool_t GetStereo() const { return fStereo; }
		Float_t GetStereoZeroParallax() const { return fStereoZeroParallax;
		}
		Float_t GetStereoEyeOffsetFac() const { return fStereoEyeOffsetFac;
		}
		Float_t GetStereoFrustumAsymFac() const { return fStereoFrustumAsymFac;
		}

		void SetStereo(Bool_t s) { fStereo = s; }
		void SetStereoZeroParallax(Float_t f) { fStereoZeroParallax = f; }
		void SetStereoEyeOffsetFac(Float_t f) { fStereoEyeOffsetFac = f; }
		void SetStereoFrustumAsymFac(Float_t f) { fStereoFrustumAsymFac = f; }

		// Push / drag action
	EPushAction GetPushAction() const { return fPushAction; }	EPushAction GetPushAction() const { return fPushAction; }
	EDragAction GetDragAction() const { return fDragAction; }	EDragAction GetDragAction() const { return fDragAction; }

	const TGLPhysicalShape * GetSelected() const;	const TGLPhysicalShape * GetSelected() const;

	// Draw and selection	// Draw and selection

	// Scene rendering timeouts	// Scene rendering timeouts
	Float_t GetMaxSceneDrawTimeHQ() const { return fMaxSceneDrawTimeHQ; }	Float_t GetMaxSceneDrawTimeHQ() const { return fMaxSceneDrawTimeHQ; }
	Float_t GetMaxSceneDrawTimeLQ() const { return fMaxSceneDrawTimeLQ; }	Float_t GetMaxSceneDrawTimeLQ() const { return fMaxSceneDrawTimeLQ; }
	void SetMaxSceneDrawTimeHQ(Float_t t) { fMaxSceneDrawTimeHQ = t; }	void SetMaxSceneDrawTimeHQ(Float_t t) { fMaxSceneDrawTimeHQ = t; }
	void SetMaxSceneDrawTimeLQ(Float_t t) { fMaxSceneDrawTimeLQ = t; }	void SetMaxSceneDrawTimeLQ(Float_t t) { fMaxSceneDrawTimeLQ = t; }

	// Request methods post cross thread request via TROOT::ProcessLineFast( ).	// Request methods post cross thread request via TROOT::ProcessLineFast( ).
	void RequestDraw(Short_t LOD = TGLRnrCtx::kLODMed); // Cross thread draw request	void RequestDraw(Short_t LOD = TGLRnrCtx::kLODMed); // Cross thread draw request
	virtual void PreRender();	virtual void PreRender();
	virtual void PostRender();	virtual void PostRender();
	void DoDraw();	void DoDraw();

		void DoDrawMono();
		void DoDrawStereo();

	void DrawGuides();	void DrawGuides();
	void DrawDebugInfo();	void DrawDebugInfo();

	Bool_t RequestSelect(Int_t x, Int_t y); // Cross thread select request	Bool_t RequestSelect(Int_t x, Int_t y); // Cross thread select request
	Bool_t DoSelect(Int_t x, Int_t y); // First level selecton (shapes/objects).	Bool_t DoSelect(Int_t x, Int_t y); // First level selecton (shapes/objects).
	Bool_t RequestSecondarySelect(Int_t x, Int_t y); // Cross thread seconda ry select request	Bool_t RequestSecondarySelect(Int_t x, Int_t y); // Cross thread seconda ry select request
	Bool_t DoSecondarySelect(Int_t x, Int_t y); // Second level selecto n (inner structure).	Bool_t DoSecondarySelect(Int_t x, Int_t y); // Second level selecto n (inner structure).
	void ApplySelection();	void ApplySelection();


End of changes. 5 change blocks.
	4 lines changed or deleted	28 lines changed or added

	TGLViewerEditor.h	TGLViewerEditor.h

	skipping to change at line 34	skipping to change at line 34

	class TGLLightSetSubEditor;	class TGLLightSetSubEditor;
	class TGLClipSetSubEditor;	class TGLClipSetSubEditor;

	class TGLViewerEditor : public TGedFrame	class TGLViewerEditor : public TGedFrame
	{	{
	private:	private:
	//Pointers to manipulate with tabs	//Pointers to manipulate with tabs
	TGCompositeFrame *fGuidesFrame;	TGCompositeFrame *fGuidesFrame;
	TGCompositeFrame *fClipFrame;	TGCompositeFrame *fClipFrame;

		TGCompositeFrame *fStereoFrame;

	TGLLightSetSubEditor *fLightSet;	TGLLightSetSubEditor *fLightSet;

	TGColorSelect *fClearColor;	TGColorSelect *fClearColor;
	TGCheckButton *fIgnoreSizesOnUpdate;	TGCheckButton *fIgnoreSizesOnUpdate;
	TGCheckButton *fResetCamerasOnUpdate;	TGCheckButton *fResetCamerasOnUpdate;
	TGTextButton *fUpdateScene;	TGTextButton *fUpdateScene;
	TGTextButton *fCameraHome;	TGTextButton *fCameraHome;

	TGNumberEntry *fMaxSceneDrawTimeHQ;	TGNumberEntry *fMaxSceneDrawTimeHQ;

	skipping to change at line 82	skipping to change at line 83
	TGNumberEntry *fReferencePosX;	TGNumberEntry *fReferencePosX;
	TGNumberEntry *fReferencePosY;	TGNumberEntry *fReferencePosY;
	TGNumberEntry *fReferencePosZ;	TGNumberEntry *fReferencePosZ;

	TGGroupFrame *fCamContainer;	TGGroupFrame *fCamContainer;
	TGComboBox* fCamMode;	TGComboBox* fCamMode;
	TGCheckButton* fCamOverlayOn;	TGCheckButton* fCamOverlayOn;

	TGLClipSetSubEditor *fClipSet;	TGLClipSetSubEditor *fClipSet;


		TGNumberEntry *fStereoZeroParallax;
		TGNumberEntry *fStereoEyeOffsetFac;
		TGNumberEntry *fStereoFrustumAsymFac;

	//Model	//Model
	TGLViewer *fViewer;	TGLViewer *fViewer;
	Bool_t fIsInPad;	Bool_t fIsInPad;

	void ConnectSignals2Slots();	void ConnectSignals2Slots();

	TGLViewerEditor(const TGLViewerEditor &);	TGLViewerEditor(const TGLViewerEditor &);
	TGLViewerEditor &operator = (const TGLViewerEditor &);	TGLViewerEditor &operator = (const TGLViewerEditor &);

	void CreateStyleTab();	void CreateStyleTab();
	void CreateGuidesTab();	void CreateGuidesTab();
	void CreateClippingTab();	void CreateClippingTab();

		void CreateStereoTab();

	void UpdateReferencePosState();	void UpdateReferencePosState();

	public:	public:
	TGLViewerEditor(const TGWindow *p=0, Int_t width=140, Int_t height=30,	TGLViewerEditor(const TGWindow *p=0, Int_t width=140, Int_t height=30,
	UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrame Background());	UInt_t options=kChildFrame, Pixel_t back=GetDefaultFrame Background());
	~TGLViewerEditor();	~TGLViewerEditor();

	virtual void ViewerRedraw();	virtual void ViewerRedraw();


	skipping to change at line 123	skipping to change at line 129
	void UpdatePointLineStuff();	void UpdatePointLineStuff();
	void DoCameraCenterExt();	void DoCameraCenterExt();
	void DoCaptureCenter();	void DoCaptureCenter();
	void DoAnnotation();	void DoAnnotation();
	void DoDrawCameraCenter();	void DoDrawCameraCenter();
	void UpdateCameraCenter();	void UpdateCameraCenter();
	//Axis manipulation	//Axis manipulation
	void UpdateViewerAxes(Int_t id);	void UpdateViewerAxes(Int_t id);
	void UpdateViewerReference();	void UpdateViewerReference();
	void DoCameraOverlay();	void DoCameraOverlay();

		// Stereo
		void UpdateStereo();

	void DetachFromPad(){fIsInPad = kFALSE;}	void DetachFromPad(){fIsInPad = kFALSE;}

	static TGNumberEntry* MakeLabeledNEntry(TGCompositeFrame* p, const char* name,	static TGNumberEntry* MakeLabeledNEntry(TGCompositeFrame* p, const char* name,
	Int_t labelw, Int_t nd=7, Int_t s=5);	Int_t labelw, Int_t nd=7, Int_t s=5);

	ClassDef(TGLViewerEditor, 0); //GUI for editing TGLViewer attributes	ClassDef(TGLViewerEditor, 0); //GUI for editing TGLViewer attributes
	};	};

	#endif	#endif

End of changes. 4 change blocks.
	0 lines changed or deleted	8 lines changed or added

	TGeoNode.h	TGeoNode.h

	// @(#)root/geom:$Id: TGeoNode.h 27731 2009-03-09 17:40:56Z brun $	// @(#)root/geom:$Id: TGeoNode.h 31454 2009-11-30 07:39:14Z brun $
	// Author: Andrei Gheata 24/10/01	// Author: Andrei Gheata 24/10/01

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 212	skipping to change at line 212
	virtual TGeoPatternFinder *GetFinder() const {return fFinder;}	virtual TGeoPatternFinder *GetFinder() const {return fFinder;}
	virtual TGeoMatrix *GetMatrix() const {cd(); return fFinder->GetMatrix() ;}	virtual TGeoMatrix *GetMatrix() const {cd(); return fFinder->GetMatrix() ;}
	virtual TGeoNode *MakeCopyNode() const;	virtual TGeoNode *MakeCopyNode() const;
	void SetFinder(const TGeoPatternFinder finder) {fFinder = (TGeoPatternFinder)finder;}	void SetFinder(const TGeoPatternFinder finder) {fFinder = (TGeoPatternFinder)finder;}

	ClassDef(TGeoNodeOffset, 1) // a geometry node with just an offset	ClassDef(TGeoNodeOffset, 1) // a geometry node with just an offset
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /

		// TGeoIteratorPlugin - Plugin for a TGeoIterator providing the method /
		/
		// ProcessNode each time Next is called. /
		/
		// /
		/
		///////////////////////////////////////////////////////////////////////////
		/

		class TGeoIterator;

		class TGeoIteratorPlugin : public TObject
		{
		private:
		const TGeoIterator *fIterator; // Caller iterator
		// No copy
		TGeoIteratorPlugin(const TGeoIteratorPlugin &);
		TGeoIteratorPlugin &operator=(const TGeoIteratorPlugin &);
		public:
		TGeoIteratorPlugin() : TObject(),fIterator(0) {}
		virtual ~TGeoIteratorPlugin() {}

		virtual void ProcessNode() = 0;
		void SetIterator(const TGeoIterator *iter) {fIterator = ite
		r;}

		ClassDef(TGeoIteratorPlugin, 0) // ABC for user plugins connecter to a
		geometry iterator.
		};

		///////////////////////////////////////////////////////////////////////////
		/
		// /
		/
	// TGeoIterator - iterator for the node tree / /	// TGeoIterator - iterator for the node tree / /
	// / /	// / /
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoIterator	class TGeoIterator
	{	{
	private:	private:
	TGeoVolume *fTop; // Top volume of the iterated b ranch	TGeoVolume *fTop; // Top volume of the iterated b ranch
	Bool_t fMustResume; // Private flag to resume from current node.	Bool_t fMustResume; // Private flag to resume from current node.
	Bool_t fMustStop; // Private flag to signal that the iterator has finished.	Bool_t fMustStop; // Private flag to signal that the iterator has finished.
	Int_t fLevel; // Current level in the tree	Int_t fLevel; // Current level in the tree
	Int_t fType; // Type of iteration	Int_t fType; // Type of iteration
	Int_t *fArray; // Array of node indices for th e current path	Int_t *fArray; // Array of node indices for th e current path
	TGeoHMatrix *fMatrix; // Current global matrix	TGeoHMatrix *fMatrix; // Current global matrix
	TString fTopName; // User name for top	TString fTopName; // User name for top

		TGeoIteratorPlugin
		*fPlugin; // User iterator plugin
		Bool_t fPluginAutoexec; // Plugin automatically execute
		d during next()

	void IncreaseArray();	void IncreaseArray();
	protected:	protected:

	TGeoIterator() : fTop(0), fMustResume(0), fMustStop(0),	TGeoIterator() : fTop(0), fMustResume(0), fMustStop(0), fLevel(0), fType
	fLevel(0), fType(0), fArray(0), fMatrix(0), fTopName()	(0),
	{ }	fArray(0), fMatrix(0), fTopName(), fPlugin(0), fPluginA
		utoexec(kFALSE) { }

	public:	public:
	TGeoIterator(TGeoVolume *top);	TGeoIterator(TGeoVolume *top);
	TGeoIterator(const TGeoIterator &iter);	TGeoIterator(const TGeoIterator &iter);
	virtual ~TGeoIterator();	virtual ~TGeoIterator();

	TGeoIterator &operator=(const TGeoIterator &iter);	TGeoIterator &operator=(const TGeoIterator &iter);
	TGeoNode *operator()();	TGeoNode *operator()();
	TGeoNode *Next();	TGeoNode *Next();

	const TGeoMatrix *GetCurrentMatrix() const;	const TGeoMatrix *GetCurrentMatrix() const;
	Int_t GetIndex(Int_t i) const {return ((i<=fLevel)?fArray[i]:- 1);}	Int_t GetIndex(Int_t i) const {return ((i<=fLevel)?fArray[i]:- 1);}
	Int_t GetLevel() const {return fLevel;}	Int_t GetLevel() const {return fLevel;}
	TGeoNode *GetNode(Int_t level) const;	TGeoNode *GetNode(Int_t level) const;
	void GetPath(TString &path) const;	void GetPath(TString &path) const;

		TGeoIteratorPlugin
		*GetUserPlugin() const {return fPlugin;}

	TGeoVolume *GetTopVolume() const {return fTop;}	TGeoVolume *GetTopVolume() const {return fTop;}
	Int_t GetType() const {return fType;}	Int_t GetType() const {return fType;}
	void Reset(TGeoVolume *top=0);	void Reset(TGeoVolume *top=0);

		void SetUserPlugin(TGeoIteratorPlugin *plugin);
		void SetPluginAutoexec(Bool_t mode) {fPluginAutoexec = mode;}
	void SetType(Int_t type) {fType = type;}	void SetType(Int_t type) {fType = type;}
	void SetTopName(const char* name);	void SetTopName(const char* name);
	void Skip();	void Skip();

	ClassDef(TGeoIterator,0) //Iterator for geometry.	ClassDef(TGeoIterator,0) //Iterator for geometry.
	};	};

	#endif	#endif

End of changes. 6 change blocks.
	4 lines changed or deleted	48 lines changed or added

	TGraphTime.h	TGraphTime.h

	// @(#)root/hist:$Id: TGraphTime.h 29482 2009-07-16 07:42:31Z brun $	// @(#)root/hist:$Id: TGraphTime.h 31667 2009-12-08 15:11:34Z brun $
	// Author: Rene Brun 13/07/2009	// Author: Rene Brun 13/07/2009

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 50	skipping to change at line 50
	TObjArray *fSteps; //array of TLists for each time step	TObjArray *fSteps; //array of TLists for each time step
	TH1 *fFrame; //TH1 object used for the pad range	TH1 *fFrame; //TH1 object used for the pad range

	public:	public:

	TGraphTime();	TGraphTime();
	TGraphTime(Int_t nsteps, Double_t xmin, Double_t ymin, Double_t xmax, Do uble_t ymax);	TGraphTime(Int_t nsteps, Double_t xmin, Double_t ymin, Double_t xmax, Do uble_t ymax);
	TGraphTime(const TGraphTime &gr);	TGraphTime(const TGraphTime &gr);
	virtual ~TGraphTime();	virtual ~TGraphTime();


	virtual Int_t Add(const TObject obj, Int_t slot, Option_t opti	virtual Int_t Add(const TObject obj, Int_t slot, Option_t option="")
	on="");	;
	virtual void Draw(Option_t *chopt="");	virtual void Draw(Option_t *chopt="");
	TObjArray *GetSteps() const {return fSteps;}	TObjArray *GetSteps() const {return fSteps;}
	virtual void Paint(Option_t *chopt="");	virtual void Paint(Option_t *chopt="");
	virtual void SetSleepTime(Int_t stime=0) {fSleepTime = stime;}	virtual void SaveAnimatedGif(const char *filename="") const;
		virtual void SetSleepTime(Int_t stime=0) {fSleepTime = stime;}

	ClassDef(TGraphTime,1) //An array of objects evolving with time	ClassDef(TGraphTime,1) //An array of objects evolving with time
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	7 lines changed or deleted	8 lines changed or added

	THnSparse.h	THnSparse.h

	// @(#)root/hist:$Id: THnSparse.h 31207 2009-11-16 16:52:00Z moneta $	// @(#)root/hist:$Id: THnSparse.h 31491 2009-12-01 18:11:55Z moneta $
	// Author: Axel Naumann (2007-09-11)	// Author: Axel Naumann (2007-09-11)

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 61	skipping to change at line 61

	class TAxis;	class TAxis;
	class TCollection;	class TCollection;
	class TFitResultPtr;	class TFitResultPtr;
	class TH1;	class TH1;
	class TH1D;	class TH1D;
	class TH2D;	class TH2D;
	class TH3D;	class TH3D;
	class TF1;	class TF1;


		#include "TFitResultPtr.h"

	class THnSparseArrayChunk: public TObject {	class THnSparseArrayChunk: public TObject {
	private:	private:

	THnSparseArrayChunk(const THnSparseArrayChunk&); // Not implemented	THnSparseArrayChunk(const THnSparseArrayChunk&); // Not implemented
	THnSparseArrayChunk& operator=(const THnSparseArrayChunk&); // Not imple mented	THnSparseArrayChunk& operator=(const THnSparseArrayChunk&); // Not imple mented

	public:	public:
	THnSparseArrayChunk():	THnSparseArrayChunk():
	fCoordinateAllocationSize(-1), fSingleCoordinateSize(0), fCoordinates Size(0), fCoordinates(0),	fCoordinateAllocationSize(-1), fSingleCoordinateSize(0), fCoordinates Size(0), fCoordinates(0),
	fContent(0), fSumw2(0) {}	fContent(0), fSumw2(0) {}

End of changes. 2 change blocks.
	1 lines changed or deleted	3 lines changed or added

	TLinearMinimizer.h	TLinearMinimizer.h

	// @(#)root/minuit:$Id: TLinearMinimizer.h 25486 2008-09-22 12:43:03Z monet a $	// @(#)root/minuit:$Id: TLinearMinimizer.h 31604 2009-12-07 19:04:33Z monet a $
	// Author: L. Moneta Wed Oct 25 16:28:55 2006	// Author: L. Moneta Wed Oct 25 16:28:55 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class TLinearMinimizer	// Header file for class TLinearMinimizer

	skipping to change at line 117	skipping to change at line 117
	virtual const double * Errors() const { return &fErrors.front(); }	virtual const double * Errors() const { return &fErrors.front(); }

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int i, unsigned int j) const {	virtual double CovMatrix(unsigned int i, unsigned int j) const {
	return fCovar[i + fDim* j];	return fCovar[i + fDim* j];
	}	}


		/// return covariance matrix status
		virtual int CovMatrixStatus() const {
		if (fCovar.size() == 0) return 0;
		return (fStatus ==0) ? 3 : 1;
		}

	/// return reference to the objective function	/// return reference to the objective function
	///virtual const ROOT::Math::IGenFunction & Function() const;	///virtual const ROOT::Math::IGenFunction & Function() const;

	protected:	protected:

	private:	private:

	bool fRobust;	bool fRobust;
	unsigned int fDim;	unsigned int fDim;
	unsigned int fNFree;	unsigned int fNFree;

End of changes. 2 change blocks.
	1 lines changed or deleted	7 lines changed or added

	TMonitor.h	TMonitor.h

	// @(#)root/net:$Id: TMonitor.h 28779 2009-06-02 16:17:10Z rdm $	// @(#)root/net:$Id: TMonitor.h 31598 2009-12-07 15:21:47Z rdm $
	// Author: Fons Rademakers 09/01/97	// Author: Fons Rademakers 09/01/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 74	skipping to change at line 74
	virtual void Remove(TSocket *sock);	virtual void Remove(TSocket *sock);
	virtual void RemoveAll();	virtual void RemoveAll();

	virtual void Activate(TSocket *sock);	virtual void Activate(TSocket *sock);
	virtual void ActivateAll();	virtual void ActivateAll();
	virtual void DeActivate(TSocket *sock);	virtual void DeActivate(TSocket *sock);
	virtual void DeActivateAll();	virtual void DeActivateAll();
	virtual void Ready(TSocket sock); // SIGNAL*	virtual void Ready(TSocket sock); // SIGNAL*

	void Interrupt() { fInterrupt = kTRUE; }	void Interrupt() { fInterrupt = kTRUE; }

		void ResetInterrupt() { fInterrupt = kFALSE; }

	TSocket *Select();	TSocket *Select();
	TSocket *Select(Long_t timeout);	TSocket *Select(Long_t timeout);
	Int_t Select(TList rdready, TList wrready, Long_t timeout);	Int_t Select(TList rdready, TList wrready, Long_t timeout);

	Int_t GetActive(Long_t timeout = -1) const;	Int_t GetActive(Long_t timeout = -1) const;
	Int_t GetDeActive() const;	Int_t GetDeActive() const;
	TList *GetListOfActives() const;	TList *GetListOfActives() const;
	TList *GetListOfDeActives() const;	TList *GetListOfDeActives() const;


End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	TNeuronInputSum.h	TNeuronInputSum.h

	// @(#)root/tmva $Id: TNeuronInputSum.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: TNeuronInputSum.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Matt Jachowski	// Author: Matt Jachowski

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : TMVA::TNeuronInputSum *	* Class : TMVA::TNeuronInputSum *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* TNeuron input calculator -- calculates the weighted sum of inputs. *	* TNeuron input calculator -- calculates the weighted sum of inputs. *

	skipping to change at line 62	skipping to change at line 62

	public:	public:

	TNeuronInputSum() {}	TNeuronInputSum() {}
	virtual ~TNeuronInputSum() {}	virtual ~TNeuronInputSum() {}

	// calculate input value for neuron	// calculate input value for neuron
	Double_t GetInput( const TNeuron* neuron ) const {	Double_t GetInput( const TNeuron* neuron ) const {
	if (neuron->IsInputNeuron()) return 0;	if (neuron->IsInputNeuron()) return 0;
	Double_t result = 0;	Double_t result = 0;

	Int_t npl = neuron->NumPreLinks();	Int_t npl = neuron->NumPreLinks();
	for (Int_t i=0; i < npl; i++) {	for (Int_t i=0; i < npl; i++) {
	result += neuron->PreLinkAt(i)->GetWeightedValue();	result += neuron->PreLinkAt(i)->GetWeightedValue();
	}	}
	return result;	return result;
	}	}

	// name of class	// name of class
	TString GetName() { return "Sum of weighted activations"; }	TString GetName() { return "Sum of weighted activations"; }

	ClassDef(TNeuronInputSum,0) // Calculates weighted sum of neuron inpu ts	ClassDef(TNeuronInputSum,0) // Calculates weighted sum of neuron inpu ts

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TPacketizerUnit.h	TPacketizerUnit.h

	// @(#)root/proofplayer:$Id: TPacketizerUnit.h 30870 2009-10-26 15:16:00Z g anis $	// @(#)root/proofplayer:$Id: TPacketizerUnit.h 31840 2009-12-11 10:01:17Z g anis $
	// Author: Long Tran-Thanh 22/07/07	// Author: Long Tran-Thanh 22/07/07

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 48	skipping to change at line 48
	class TStopwatch;	class TStopwatch;

	class TPacketizerUnit : public TVirtualPacketizer {	class TPacketizerUnit : public TVirtualPacketizer {

	public: // public because of Sun CC bug	public: // public because of Sun CC bug
	class TSlaveStat;	class TSlaveStat;

	private:	private:
	TList *fPackets; // all processed packets	TList *fPackets; // all processed packets
	TMap *fSlaveStats; // Slave status, keyed by correspondig TSl ave	TMap *fSlaveStats; // Slave status, keyed by correspondig TSl ave

	Long64_t fPacketSize; // Global base packet size
	// It can be set with PROOF_PacketSize
	// parameter, in the input list.
	Int_t fPacketAsAFraction; // Used to calculate the packet size
	// fPacketSize = fTotalEntries / (fPacketA
	sAFraction * nslaves)
	// fPacketAsAFraction can be interpreted a
	s follows:
	// assuming all slaves have equal processi
	ng rate, packet size
	// is (#events processed by 1 slave) / fPa
	cketSizeAsAFraction.
	// It can be set with PROOF_PacketAsAFract
	ion in input list.
	TStopwatch *fStopwatch; // For measuring the start time of each pa cket	TStopwatch *fStopwatch; // For measuring the start time of each pa cket
	Long64_t fProcessing; // Event being processed	Long64_t fProcessing; // Event being processed
	Long64_t fAssigned; // no. entries processed or being processe d.	Long64_t fAssigned; // no. entries processed or being processe d.
	Double_t fTimeLimit; // Packet time limit	Double_t fTimeLimit; // Packet time limit

	TPacketizerUnit();	TPacketizerUnit();
	TPacketizerUnit(const TPacketizerUnit&); // no implementation, will generate	TPacketizerUnit(const TPacketizerUnit&); // no implementation, will generate
	void operator=(const TPacketizerUnit&); // error on accidental usage	void operator=(const TPacketizerUnit&); // error on accidental usage

	public:	public:

End of changes. 2 change blocks.
	15 lines changed or deleted	1 lines changed or added

	TProof.h	TProof.h

	// @(#)root/proof:$Id: TProof.h 30995 2009-11-05 17:41:03Z ganis $	// @(#)root/proof:$Id: TProof.h 31520 2009-12-03 12:58:41Z brun $
	// Author: Fons Rademakers 13/02/97	// Author: Fons Rademakers 13/02/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 121	skipping to change at line 121
	// 17 -> 18: support for reconnection on daemon restarts	// 17 -> 18: support for reconnection on daemon restarts
	// 18 -> 19: TProofProgressStatus used in kPROOF_PROGRESS, kPROOF_STOPPROCE SS	// 18 -> 19: TProofProgressStatus used in kPROOF_PROGRESS, kPROOF_STOPPROCE SS
	// and kPROOF_GETNEXTPACKET messages in Master - worker communica tion	// and kPROOF_GETNEXTPACKET messages in Master - worker communica tion
	// 19 -> 20: Fix the asynchronous mode (required changes in some messages)	// 19 -> 20: Fix the asynchronous mode (required changes in some messages)
	// 20 -> 21: Add support for session queuing	// 20 -> 21: Add support for session queuing
	// 21 -> 22: Add support for switching from sync to async while running ('C trl-Z' functionality)	// 21 -> 22: Add support for switching from sync to async while running ('C trl-Z' functionality)
	// 22 -> 23: New dataset features (default tree name; classification per fi leserver)	// 22 -> 23: New dataset features (default tree name; classification per fi leserver)
	// 23 -> 24: Merging optimization	// 23 -> 24: Merging optimization
	// 24 -> 25: Handling of 'data' dir; group information	// 24 -> 25: Handling of 'data' dir; group information
	// 25 -> 26: Use new TProofProgressInfo class	// 25 -> 26: Use new TProofProgressInfo class

		// 26 -> 27: Use new file for updating the session status

	// PROOF magic constants	// PROOF magic constants

	const Int_t kPROOF_Protocol = 26; // protocol versi on number	const Int_t kPROOF_Protocol = 27; // protocol versi on number
	const Int_t kPROOF_Port = 1093; // IANA registere d PROOF port	const Int_t kPROOF_Port = 1093; // IANA registere d PROOF port
	const char* const kPROOF_ConfFile = "proof.conf"; // default config file	const char* const kPROOF_ConfFile = "proof.conf"; // default config file
	const char* const kPROOF_ConfDir = "/usr/local/root"; // default c onfig dir	const char* const kPROOF_ConfDir = "/usr/local/root"; // default c onfig dir
	const char* const kPROOF_WorkDir = ".proof"; // default workin g directory	const char* const kPROOF_WorkDir = ".proof"; // default workin g directory
	const char* const kPROOF_CacheDir = "cache"; // file cache dir , under WorkDir	const char* const kPROOF_CacheDir = "cache"; // file cache dir , under WorkDir
	const char* const kPROOF_PackDir = "packages"; // package dir, u nder WorkDir	const char* const kPROOF_PackDir = "packages"; // package dir, u nder WorkDir
	const char* const kPROOF_QueryDir = "queries"; // query dir, und er WorkDir	const char* const kPROOF_QueryDir = "queries"; // query dir, und er WorkDir
	const char* const kPROOF_DataSetDir = "datasets"; // dataset dir, u nder WorkDir	const char* const kPROOF_DataSetDir = "datasets"; // dataset dir, u nder WorkDir
	const char* const kPROOF_DataDir = "data"; // dir for produc ed data, under WorkDir	const char* const kPROOF_DataDir = "data"; // dir for produc ed data, under WorkDir
	const char* const kPROOF_CacheLockFile = "proof-cache-lock-"; // cache lock file	const char* const kPROOF_CacheLockFile = "proof-cache-lock-"; // cache lock file

	skipping to change at line 243	skipping to change at line 244
	void SetStatus(ESlaveStatus stat) { fStatus = stat; }	void SetStatus(ESlaveStatus stat) { fStatus = stat; }
	void SetSysInfo(SysInfo_t si);	void SetSysInfo(SysInfo_t si);

	Int_t Compare(const TObject *obj) const;	Int_t Compare(const TObject *obj) const;
	Bool_t IsSortable() const { return kTRUE; }	Bool_t IsSortable() const { return kTRUE; }
	void Print(Option_t *option="") const;	void Print(Option_t *option="") const;

	ClassDef(TSlaveInfo,3) //basic info on slave	ClassDef(TSlaveInfo,3) //basic info on slave
	};	};


		// Merger info class
		class TMergerInfo : public TObject {
		private:

		TSlave *fMerger; // Slave that acts as merger
		Int_t fPort; // Port number, on which it accepts output
		s from other workers
		Int_t fMergedObjects; // Total number of objects it must accept
		from other workers
		// (-1 == not set yet)
		Int_t fWorkersToMerge; // Number of workers that are merged on th
		is merger
		// (does not change during time)
		Int_t fMergedWorkers; // Current number of already merged worker
		s
		// (does change during time as workers are
		being merged)

		TList *fWorkers; // List of already assigned workers
		Bool_t fIsActive; // Merger state

		public:

		TMergerInfo(TSlave *t, Int_t port, Int_t forHowManyWorkers) :
		fMerger(t), fPort(port), fMergedObjects(0), fWorkersToMerge(
		forHowManyWorkers),
		fMergedWorkers(0), fWorkers(0), fIsActive(kTRUE) { }
		virtual ~TMergerInfo();

		void AddWorker(TSlave *sl);
		TList *GetWorkers() { return fWorkers; }

		TSlave *GetMerger() { return fMerger; }
		Int_t GetPort() { return fPort; }

		Int_t GetWorkersToMerge() { return fWorkersToMerge; }
		Int_t GetMergedWorkers() { return fMergedWorkers; }
		Int_t GetMergedObjects() { return fMergedObjects; }

		void SetMergedWorker();
		void AddMergedObjects(Int_t objects) { fMergedObjects += objects;
		}

		Bool_t AreAllWorkersAssigned();
		Bool_t AreAllWorkersMerged();

		void Deactivate() { fIsActive = kFALSE; }
		Bool_t IsActive() { return fIsActive; }

		ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker se
		rving as merger
		};

	// Small auxilliary class for merging progress notification	// Small auxilliary class for merging progress notification
	class TProofMergePrg {	class TProofMergePrg {
	private:	private:
	TString fExp;	TString fExp;
	Int_t fIdx;	Int_t fIdx;
	Int_t fNWrks;	Int_t fNWrks;
	static char fgCr[4];	static char fgCr[4];
	public:	public:
	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1) { }	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1) { }


	skipping to change at line 313	skipping to change at line 359
	kAskUser = 0x0	kAskUser = 0x0
	};	};
	enum ERegisterOpt {	enum ERegisterOpt {
	kFailIfExists = 0,	kFailIfExists = 0,
	kOverwriteIfExists = 1,	kOverwriteIfExists = 1,
	kMergeIfExists = 2	kMergeIfExists = 2
	};	};
	enum EUploadDataSetAnswer {	enum EUploadDataSetAnswer {
	kError = -1,	kError = -1,
	kDataSetExists = -2,	kDataSetExists = -2,

	kFail = -3	kFail = -3
	};	};
	enum EUploadPackageOpt {	enum EUploadPackageOpt {
	kUntar = 0x0, //Untar over existing dir [default]	kUntar = 0x0, //Untar over existing dir [default]
	kRemoveOld = 0x1 //Remove existing dir with same name	kRemoveOld = 0x1 //Remove existing dir with same name
	};	};
	enum ERunStatus {	enum ERunStatus {
	kRunning = 0, // Normal status	kRunning = 0, // Normal status
	kStopped = 1, // After the stop button has been presse d	kStopped = 1, // After the stop button has been presse d
	kAborted = 2 // After the abort button has been press ed	kAborted = 2 // After the abort button has been press ed
	};	};


		enum ESubMerger {
		kOutputSize = 1, //Number of objects in worker's output l
		ist
		kSendOutput = 2, //Naster asks worker for its output list
		kBeMerger = 3, //Master tells worker to be a merger
		kMergerDown = 4, //Merger cannot serve
		kStopMerging = 5, //Master tells worker to stop merging (a
		nd return output)
		kOutputSent = 6 //Worker reports sending its output to g
		iven worker
		};

	private:	private:
	enum EUrgent {	enum EUrgent {
	kLocalInterrupt = -1,	kLocalInterrupt = -1,
	kPing = 0,	kPing = 0,
	kHardInterrupt = 1,	kHardInterrupt = 1,
	kSoftInterrupt,	kSoftInterrupt,
	kShutdownInterrupt	kShutdownInterrupt
	};	};
	enum EProofCacheCommands {	enum EProofCacheCommands {
	kShowCache = 1,	kShowCache = 1,

	skipping to change at line 474	skipping to change at line 529
	TList *fInputData; //Input data objects sent over via fil e	TList *fInputData; //Input data objects sent over via fil e
	TString fInputDataFile; //File with input data objects	TString fInputDataFile; //File with input data objects

	PrintProgress_t fPrintProgress; //Function function to display progres s info in batch mode	PrintProgress_t fPrintProgress; //Function function to display progres s info in batch mode

	TVirtualMutex *fCloseMutex; // Avoid crashes in MarkBad or alike w hile closing	TVirtualMutex *fCloseMutex; // Avoid crashes in MarkBad or alike w hile closing

	TList *fLoadedMacros; // List of loaded macros (just file na mes)	TList *fLoadedMacros; // List of loaded macros (just file na mes)
	static TList *fgProofEnvList; // List of TNameds defining environmen t	static TList *fgProofEnvList; // List of TNameds defining environmen t
	// variables to pass to proofserv	// variables to pass to proofserv


		Bool_t fMergersSet; // Indicates, if the following variabl
		es have been initialized properly
		Int_t fMergersCount;
		Int_t fWorkersToMerge; // Current total number of workers, wh
		ich have not been yet assigned to any merger
		Int_t fLastAssignedMerger;
		TList *fMergers;
		Bool_t fFinalizationRunning;
		Int_t fRedirectNext;

	static TPluginHandler *fgLogViewer; // Log dialog box plugin	static TPluginHandler *fgLogViewer; // Log dialog box plugin

	protected:	protected:
	enum ESlaves { kAll, kActive, kUnique, kAllUnique };	enum ESlaves { kAll, kActive, kUnique, kAllUnique };

	Bool_t fMasterServ; //true if we are a master server	Bool_t fMasterServ; //true if we are a master server
	TUrl fUrl; //Url of the master	TUrl fUrl; //Url of the master
	TString fConfFile; //file containing config information	TString fConfFile; //file containing config information
	TString fConfDir; //directory containing cluster config i nformation	TString fConfDir; //directory containing cluster config i nformation
	TString fImage; //master's image name	TString fImage; //master's image name

	skipping to change at line 560	skipping to change at line 624
	Int_t BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list = kAllUnique);	Int_t BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list = kAllUnique);
	Int_t BroadcastGroupPriority(const char grp, Int_t priority, TList workers);	Int_t BroadcastGroupPriority(const char grp, Int_t priority, TList workers);
	Int_t BroadcastObject(const TObject obj, Int_t kind, TList slaves);	Int_t BroadcastObject(const TObject obj, Int_t kind, TList slaves);
	Int_t BroadcastObject(const TObject *obj, Int_t kind = kMESS_OBJECT, ESlaves list = kActive);	Int_t BroadcastObject(const TObject *obj, Int_t kind = kMESS_OBJECT, ESlaves list = kActive);
	Int_t BroadcastRaw(const void buffer, Int_t length, TList slaves);	Int_t BroadcastRaw(const void buffer, Int_t length, TList slaves);
	Int_t BroadcastRaw(const void *buffer, Int_t length, ESlaves list = k Active);	Int_t BroadcastRaw(const void *buffer, Int_t length, ESlaves list = k Active);
	Int_t Collect(const TSlave *sl, Long_t timeout = -1, Int_t endtype = -1);	Int_t Collect(const TSlave *sl, Long_t timeout = -1, Int_t endtype = -1);
	Int_t Collect(TMonitor *mon, Long_t timeout = -1, Int_t endtype = -1) ;	Int_t Collect(TMonitor *mon, Long_t timeout = -1, Int_t endtype = -1) ;
	Int_t CollectInputFrom(TSocket *s, Int_t endtype = -1);	Int_t CollectInputFrom(TSocket *s, Int_t endtype = -1);
	Int_t HandleInputMessage(TSlave wrk, TMessage m);	Int_t HandleInputMessage(TSlave wrk, TMessage m);

		void HandleSubmerger(TMessage mess, TSlave sl);
	void SetMonitor(TMonitor *mon = 0, Bool_t on = kTRUE);	void SetMonitor(TMonitor *mon = 0, Bool_t on = kTRUE);

	void ReleaseMonitor(TMonitor *mon);	void ReleaseMonitor(TMonitor *mon);

	void FindUniqueSlaves();	void FindUniqueSlaves();
	TSlave FindSlave(TSocket s) const;	TSlave FindSlave(TSocket s) const;
	TList *GetListOfSlaves() const { return fSlaves; }	TList *GetListOfSlaves() const { return fSlaves; }
	TList *GetListOfInactiveSlaves() const { return fInactiveSlaves; }	TList *GetListOfInactiveSlaves() const { return fInactiveSlaves; }
	TList *GetListOfUniqueSlaves() const { return fUniqueSlaves; }	TList *GetListOfUniqueSlaves() const { return fUniqueSlaves; }
	TList *GetListOfBadSlaves() const { return fBadSlaves; }	TList *GetListOfBadSlaves() const { return fBadSlaves; }

	skipping to change at line 593	skipping to change at line 658

	void MarkBad(TSlave wrk, const char reason = 0);	void MarkBad(TSlave wrk, const char reason = 0);
	void MarkBad(TSocket s, const char reason = 0);	void MarkBad(TSocket s, const char reason = 0);
	void TerminateWorker(TSlave *wrk);	void TerminateWorker(TSlave *wrk);
	void TerminateWorker(const char *ord);	void TerminateWorker(const char *ord);

	void ActivateAsyncInput();	void ActivateAsyncInput();
	void DeActivateAsyncInput();	void DeActivateAsyncInput();

	Int_t GetQueryReference(Int_t qry, TString &ref);	Int_t GetQueryReference(Int_t qry, TString &ref);


	void PrintProgress(Long64_t total, Long64_t processed, Float_t procT ime = -1.);	void PrintProgress(Long64_t total, Long64_t processed, Float_t procT ime = -1.);


	void ResetMergePrg();	// Managing mergers
		Bool_t CreateMerger(TSlave *sl, Int_t port);
		void RedirectWorker(TSocket s, TSlave sl, Int_t output_size);
		Int_t GetActiveMergersCount();
		Int_t FindNextFreeMerger();
		void ResetMergers() { fMergersSet = kFALSE; }
		void AskForOutput(TSlave *sl);


		void FinalizationDone() { fFinalizationRunning = kFALSE; }

		void ResetMergePrg();
	void ParseConfigField(const char *config);	void ParseConfigField(const char *config);

	Bool_t Prompt(const char *p);	Bool_t Prompt(const char *p);
	void ClearDataProgress(Int_t r, Int_t t);	void ClearDataProgress(Int_t r, Int_t t);

	protected:	protected:
	TProof(); // For derived classes to use	TProof(); // For derived classes to use
	Int_t Init(const char masterurl, const char conffile,	Int_t Init(const char masterurl, const char conffile,
	const char *confdir, Int_t loglevel,	const char *confdir, Int_t loglevel,
	const char *alias = 0);	const char *alias = 0);

End of changes. 11 change blocks.
	5 lines changed or deleted	91 lines changed or added

	TProofDebug.h	TProofDebug.h

	// @(#)root/proof:$Id: TProofDebug.h 30174 2009-09-15 14:24:56Z ganis $	// @(#)root/proof:$Id: TProofDebug.h 31505 2009-12-02 13:20:06Z brun $
	// Author: Maarten Ballintijn 19/6/2002	// Author: Maarten Ballintijn 19/6/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 45	skipping to change at line 45
	kInput = 16,	kInput = 16,
	kGlobal = 32,	kGlobal = 32,
	kPackage = 64,	kPackage = 64,
	kFeedback = 128,	kFeedback = 128,
	kCondor = 256,	kCondor = 256,
	kDraw = 512,	kDraw = 512,
	kAsyn = 1024,	kAsyn = 1024,
	kCache = 2048,	kCache = 2048,
	kCollect = 4096,	kCollect = 4096,
	kDataset = 8192,	kDataset = 8192,

		kSubmerger = 16384,

	kAll = 0xFFFFFFFF	kAll = 0xFFFFFFFF
	};	};
	};	};

	R__EXTERN TProofDebug::EProofDebugMask gProofDebugMask;	R__EXTERN TProofDebug::EProofDebugMask gProofDebugMask;
	R__EXTERN Int_t gProofDebugLevel;	R__EXTERN Int_t gProofDebugLevel;

	#define PDB(mask,level) \	#define PDB(mask,level) \
	if ((TProofDebug::mask & gProofDebugMask) && gProofDebugLevel >= (level) )	if ((TProofDebug::mask & gProofDebugMask) && gProofDebugLevel >= (level) )

End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	TProofLite.h	TProofLite.h

	// @(#)root/proof:$Id: TProofLite.h 29133 2009-06-22 12:28:50Z brun $	// @(#)root/proof:$Id: TProofLite.h 31719 2009-12-09 10:31:17Z ganis $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TProofLite	#ifndef ROOT_TProofLite
	#define ROOT_TProofLite	#define ROOT_TProofLite

	skipping to change at line 56	skipping to change at line 56
	TString fSockPath; // UNIX socket path for communication with worker s	TString fSockPath; // UNIX socket path for communication with worker s
	TServerSocket *fServSock; // Server socket to accept call backs	TServerSocket *fServSock; // Server socket to accept call backs
	Bool_t fForkStartup; // Startup N-1 workers forking the first worker	Bool_t fForkStartup; // Startup N-1 workers forking the first worker

	TProofLockPath *fCacheLock; //cache dir locker	TProofLockPath *fCacheLock; //cache dir locker
	TProofLockPath *fQueryLock; // Query dir locker	TProofLockPath *fQueryLock; // Query dir locker
	TQueryResultManager *fQMgr; // Query-result manager	TQueryResultManager *fQMgr; // Query-result manager

	TDataSetManager* fDataSetManager; // dataset manager	TDataSetManager* fDataSetManager; // dataset manager


		static Int_t fgWrksMax; // Max number of workers

	TProofLite(const TProofLite &); // not implemented	TProofLite(const TProofLite &); // not implemented
	void operator=(const TProofLite &); // idem	void operator=(const TProofLite &); // idem

	Int_t CleanupSandbox();	Int_t CleanupSandbox();
	Int_t CreateSandbox();	Int_t CreateSandbox();
	void NotifyStartUp(const char *action, Int_t done, Int_t tot);	void NotifyStartUp(const char *action, Int_t done, Int_t tot);
	Int_t SetProofServEnv(const char *ord);	Int_t SetProofServEnv(const char *ord);
	Int_t InitDataSetManager();	Int_t InitDataSetManager();

		void ResolveKeywords(TString &s, const char *logfile);

	void SendInputDataFile();	void SendInputDataFile();

	protected:	protected:
	TProofLite() : TProof() { } // For derived classes to use	TProofLite() : TProof() { } // For derived classes to use

	Int_t CreateSymLinks(TList *files);	Int_t CreateSymLinks(TList *files);

	TList GetDataSet(const char name);
	Int_t Init(const char masterurl, const char conffile,	Int_t Init(const char masterurl, const char conffile,
	const char *confdir, Int_t loglevel,	const char *confdir, Int_t loglevel,
	const char *alias = 0);	const char *alias = 0);
	TProofQueryResult MakeQueryResult(Long64_t nent, const char opt,	TProofQueryResult MakeQueryResult(Long64_t nent, const char opt,
	Long64_t fst, TDSet *dset,	Long64_t fst, TDSet *dset,
	const char *selec);	const char *selec);
	void SetQueryRunning(TProofQueryResult *pq);	void SetQueryRunning(TProofQueryResult *pq);
	Int_t SetupWorkers(Int_t opt = 0, TList *wrks = 0);	Int_t SetupWorkers(Int_t opt = 0, TList *wrks = 0);

	public:	public:

End of changes. 4 change blocks.
	2 lines changed or deleted	4 lines changed or added

	TProofServ.h	TProofServ.h

	// @(#)root/proof:$Id: TProofServ.h 31012 2009-11-06 16:08:19Z ganis $	// @(#)root/proof:$Id: TProofServ.h 31683 2009-12-08 16:12:08Z ganis $
	// Author: Fons Rademakers 16/02/97	// Author: Fons Rademakers 16/02/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 61	skipping to change at line 61
	class THashList;	class THashList;
	class TList;	class TList;
	class TDSetElement;	class TDSetElement;
	class TMessage;	class TMessage;
	class TShutdownTimer;	class TShutdownTimer;
	class TReaperTimer;	class TReaperTimer;
	class TMutex;	class TMutex;
	class TFileCollection;	class TFileCollection;
	class TDataSetManager;	class TDataSetManager;
	class TFileHandler;	class TFileHandler;

		class TMonitor;
		class TServerSocket;

	// Hook to external function setting up authentication related stuff	// Hook to external function setting up authentication related stuff
	// for old versions.	// for old versions.
	// For backward compatibility	// For backward compatibility
	typedef Int_t (OldProofServAuthSetup_t)(TSocket , Bool_t, Int_t,	typedef Int_t (OldProofServAuthSetup_t)(TSocket , Bool_t, Int_t,
	TString &, TString &, TString &);	TString &, TString &, TString &);

	class TProofServ : public TApplication {	class TProofServ : public TApplication {

	friend class TProofServLite;	friend class TProofServLite;

	skipping to change at line 150	skipping to change at line 152

	Int_t fInflateFactor; // Factor in 1/1000 to inflate the CPU time	Int_t fInflateFactor; // Factor in 1/1000 to inflate the CPU time

	Int_t fCompressMsg; // Compression level for messages	Int_t fCompressMsg; // Compression level for messages

	TDataSetManager* fDataSetManager; // dataset manager	TDataSetManager* fDataSetManager; // dataset manager

	Bool_t fLogToSysLog; //true if logs should be sent to syslog too	Bool_t fLogToSysLog; //true if logs should be sent to syslog too
	Bool_t fSendLogToMaster; // On workers, controls logs sending to master	Bool_t fSendLogToMaster; // On workers, controls logs sending to master


		TServerSocket *fMergingSocket; // Socket used for merging outputs if su
		bmerger
		TMonitor *fMergingMonitor; // Monitor for merging sockets
		Int_t fMergedWorkers; // Number of workers merged

	// Quotas (-1 to disable)	// Quotas (-1 to disable)
	Int_t fMaxQueries; //Max number of queries fully kept	Int_t fMaxQueries; //Max number of queries fully kept
	Long64_t fMaxBoxSize; //Max size of the sandbox	Long64_t fMaxBoxSize; //Max size of the sandbox
	Long64_t fHWMBoxSize; //High-Water-Mark on the sandbox size	Long64_t fHWMBoxSize; //High-Water-Mark on the sandbox size

	// Memory limits (-1 to disable) set by envs ROOTPROOFASSOFT and RPPTPRO FOASHARD	// Memory limits (-1 to disable) set by envs ROOTPROOFASSOFT and RPPTPRO FOASHARD
	Long_t fVirtMemHWM; //Above this we terminate gently (in kB )	Long_t fVirtMemHWM; //Above this we terminate gently (in kB )
	Long_t fVirtMemMax; //Hard limit enforced by the system (in kB)	Long_t fVirtMemMax; //Hard limit enforced by the system (in kB)

	// In bytes; default is 1MB	// In bytes; default is 1MB

	skipping to change at line 179	skipping to change at line 185
	Int_t OldAuthSetup(TString &wconf);	Int_t OldAuthSetup(TString &wconf);
	Int_t GetPriority();	Int_t GetPriority();

	// Query handlers	// Query handlers
	TProofQueryResult MakeQueryResult(Long64_t nentries, const char opt,	TProofQueryResult MakeQueryResult(Long64_t nentries, const char opt,
	TList inl, Long64_t first, TDSet ds et,	TList inl, Long64_t first, TDSet ds et,
	const char selec, TObject elist);	const char selec, TObject elist);
	void SetQueryRunning(TProofQueryResult *pq);	void SetQueryRunning(TProofQueryResult *pq);

	// Results handling	// Results handling

	void SendResults(TSocket sock, TList outlist = 0, TQueryResul	Int_t SendResults(TSocket sock, TList outlist = 0, TQueryResul
	t *pq = 0);	t *pq = 0);
		Bool_t AcceptResults(Int_t connections, TVirtualProofPlayer *merg
		erPlayer);

	Int_t RegisterDataSets(TList in, TList out);	Int_t RegisterDataSets(TList in, TList out);

	// Waiting queries handlers	// Waiting queries handlers
	void SetIdle(Bool_t st = kTRUE);	void SetIdle(Bool_t st = kTRUE);
	Bool_t IsWaiting();	Bool_t IsWaiting();
	Int_t WaitingQueries();	Int_t WaitingQueries();
	Int_t QueueQuery(TProofQueryResult *pq);	Int_t QueueQuery(TProofQueryResult *pq);
	TProofQueryResult *NextQuery();	TProofQueryResult *NextQuery();
	Int_t CleanupWaitingQueries(Bool_t del = kTRUE, TList *qls = 0);	Int_t CleanupWaitingQueries(Bool_t del = kTRUE, TList *qls = 0);

	protected:	protected:
	virtual void HandleArchive(TMessage *mess);	virtual void HandleArchive(TMessage *mess);
	virtual Int_t HandleCache(TMessage *mess);	virtual Int_t HandleCache(TMessage *mess);
	virtual void HandleCheckFile(TMessage *mess);	virtual void HandleCheckFile(TMessage *mess);
	virtual Int_t HandleDataSets(TMessage *mess);	virtual Int_t HandleDataSets(TMessage *mess);

		virtual void HandleSubmerger(TMessage *mess);
	virtual void HandleFork(TMessage *mess);	virtual void HandleFork(TMessage *mess);
	virtual void HandleLibIncPath(TMessage *mess);	virtual void HandleLibIncPath(TMessage *mess);
	virtual void HandleProcess(TMessage *mess);	virtual void HandleProcess(TMessage *mess);
	virtual void HandleQueryList(TMessage *mess);	virtual void HandleQueryList(TMessage *mess);
	virtual void HandleRemove(TMessage *mess);	virtual void HandleRemove(TMessage *mess);
	virtual void HandleRetrieve(TMessage *mess);	virtual void HandleRetrieve(TMessage *mess);
	virtual void HandleWorkerLists(TMessage *mess);	virtual void HandleWorkerLists(TMessage *mess);

	virtual void ProcessNext();	virtual void ProcessNext();
	virtual Int_t Setup();	virtual Int_t Setup();

	skipping to change at line 258	skipping to change at line 267
	Int_t GetInflateFactor() const { return fInflateFactor; }	Int_t GetInflateFactor() const { return fInflateFactor; }

	Long_t GetVirtMemHWM() const { return fVirtMemHWM; }	Long_t GetVirtMemHWM() const { return fVirtMemHWM; }

	Long64_t GetMsgSizeHWM() const { return fMsgSizeHWM; }	Long64_t GetMsgSizeHWM() const { return fMsgSizeHWM; }

	const char *GetPrefix() const { return fPrefix; }	const char *GetPrefix() const { return fPrefix; }

	void FlushLogFile();	void FlushLogFile();


		TProofLockPath *GetCacheLock() { return fCacheLock; } //cache dir l ocker; used by TProofPlayer
	Int_t CopyFromCache(const char *name, Bool_t cpbin);	Int_t CopyFromCache(const char *name, Bool_t cpbin);
	Int_t CopyToCache(const char *name, Int_t opt = 0);	Int_t CopyToCache(const char *name, Int_t opt = 0);

	virtual EQueryAction GetWorkers(TList *workers, Int_t &prioritychange,	virtual EQueryAction GetWorkers(TList *workers, Int_t &prioritychange,
	Bool_t resume = kFALSE);	Bool_t resume = kFALSE);
	virtual void HandleException(Int_t sig);	virtual void HandleException(Int_t sig);
	virtual Int_t HandleSocketInput(TMessage *mess, Bool_t all);	virtual Int_t HandleSocketInput(TMessage *mess, Bool_t all);
	virtual void HandleSocketInput();	virtual void HandleSocketInput();
	virtual void HandleUrgentData();	virtual void HandleUrgentData();
	virtual void HandleSigPipe();	virtual void HandleSigPipe();

End of changes. 6 change blocks.
	3 lines changed or deleted	15 lines changed or added

	TPyException.h	TPyException.h

	// @(#)root/pyroot:$Name: $:$Id: TPyException.h 21958 2008-02-02 10:39:18Z rdm $	// @(#)root/pyroot:$Name: $:$Id: TPyException.h 31630 2009-12-08 10:21:36Z rdm $
	#ifndef ROOT_TPyException	#ifndef ROOT_TPyException
	#define ROOT_TPyException	#define ROOT_TPyException

	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///
	// //	// //
	// TPyException //	// TPyException //
	// //	// //
	// Purpose: A C++ exception class for throwing python exceptions //	// Purpose: A C++ exception class for throwing python exceptions //
	// through C++ code. //	// through C++ code. //
	// Created: Apr, 2004, sss, from the version in D0's python_util. //	// Created: Apr, 2004, sss, from the version in D0's python_util. //

	skipping to change at line 66	skipping to change at line 66
	ClassDef(TPyException,0) //C++ exception for throwing python exception s	ClassDef(TPyException,0) //C++ exception for throwing python exception s
	};	};

	} // namespace PyROOT	} // namespace PyROOT

	#if defined(G__DICTIONARY) && defined(R__SOLARIS)	#if defined(G__DICTIONARY) && defined(R__SOLARIS)
	// Force the inclusion of rw/math.h	// Force the inclusion of rw/math.h
	#include <limits>	#include <limits>
	// Work around interaction between a struct named exception in math.h,	// Work around interaction between a struct named exception in math.h,
	// std::exception and the use of using namespace std;	// std::exception and the use of using namespace std;

		#if (__SUNPRO_CC < 0x5050)
	#define exception std::exception	#define exception std::exception
	#endif	#endif
	#endif	#endif

		#endif

End of changes. 3 change blocks.
	1 lines changed or deleted	2 lines changed or added

	TStreamerElement.h	TStreamerElement.h

	// @(#)root/meta:$Id: TStreamerElement.h 28776 2009-06-02 15:16:39Z pcanal $	// @(#)root/meta:$Id: TStreamerElement.h 31565 2009-12-04 18:44:27Z pcanal $
	// Author: Rene Brun 12/10/2000	// Author: Rene Brun 12/10/2000

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 338	skipping to change at line 338

	private:	private:
	TStreamerString(const TStreamerString&); // Not implemented	TStreamerString(const TStreamerString&); // Not implemented
	TStreamerString&operator=(const TStreamerString&); // Not implemented	TStreamerString&operator=(const TStreamerString&); // Not implemented

	public:	public:

	TStreamerString();	TStreamerString();
	TStreamerString(const char name, const char title, Int_t offset);	TStreamerString(const char name, const char title, Int_t offset);
	virtual ~TStreamerString();	virtual ~TStreamerString();

		const char *GetInclude() const;
	Int_t GetSize() const;	Int_t GetSize() const;

	ClassDef(TStreamerString,2) //Streamer element of type TString	ClassDef(TStreamerString,2) //Streamer element of type TString
	};	};

	//________________________________________________________________________	//________________________________________________________________________
	class TStreamerSTL : public TStreamerElement {	class TStreamerSTL : public TStreamerElement {


		enum {
		kWarned = BIT(21)
		};

	private:	private:
	TStreamerSTL(const TStreamerSTL&); // Not implemented	TStreamerSTL(const TStreamerSTL&); // Not implemented
	TStreamerSTL&operator=(const TStreamerSTL&); // Not implemented	TStreamerSTL&operator=(const TStreamerSTL&); // Not implemented

	protected:	protected:
	Int_t fSTLtype; //type of STL vector	Int_t fSTLtype; //type of STL vector
	Int_t fCtype; //STL contained type	Int_t fCtype; //STL contained type

	public:	public:


End of changes. 3 change blocks.
	1 lines changed or deleted	6 lines changed or added

	TTreeCache.h	TTreeCache.h

	// @(#)root/tree:$Id: TTreeCache.h 31077 2009-11-11 08:51:57Z brun $	// @(#)root/tree:$Id: TTreeCache.h 31457 2009-11-30 13:36:37Z brun $
	// Author: Rene Brun 04/06/2006	// Author: Rene Brun 04/06/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 66	skipping to change at line 66

	public:	public:
	TTreeCache();	TTreeCache();
	TTreeCache(TTree *tree, Int_t buffersize=0);	TTreeCache(TTree *tree, Int_t buffersize=0);
	virtual ~TTreeCache();	virtual ~TTreeCache();
	virtual void AddBranch(TBranch *b, Bool_t subbranches = kFALSE);	virtual void AddBranch(TBranch *b, Bool_t subbranches = kFALSE);
	virtual void AddBranch(const char *branch, Bool_t subbranches = k FALSE);	virtual void AddBranch(const char *branch, Bool_t subbranches = k FALSE);
	Double_t GetEfficiency();	Double_t GetEfficiency();
	Double_t GetEfficiencyRel();	Double_t GetEfficiencyRel();
	static Int_t GetLearnEntries();	static Int_t GetLearnEntries();

	virtual Bool_t GetSkipZip() { return kFALSE; } // This function is only used by TTreeCacheUnzip (ignore it)
	virtual Bool_t FillBuffer();	virtual Bool_t FillBuffer();
	TTree *GetOwner() const;	TTree *GetOwner() const;
	TTree *GetTree() const;	TTree *GetTree() const;
	virtual Bool_t IsLearning() const {return fIsLearning;}	virtual Bool_t IsLearning() const {return fIsLearning;}
	virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len);	virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len);
	virtual void ResetCache();	virtual void ResetCache();
	virtual void SetEntryRange(Long64_t emin, Long64_t emax);	virtual void SetEntryRange(Long64_t emin, Long64_t emax);
	static void SetLearnEntries(Int_t n = 10);	static void SetLearnEntries(Int_t n = 10);
	void StartLearningPhase();	void StartLearningPhase();
	virtual void StopLearningPhase();	virtual void StopLearningPhase();

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TTreeCacheUnzip.h	TTreeCacheUnzip.h

	// @(#)root/tree:$Id: TTreeCacheUnzip.h 31112 2009-11-12 10:03:32Z brun $	// @(#)root/tree:$Id: TTreeCacheUnzip.h 31469 2009-11-30 17:25:19Z brun $
	// Author: Rene Brun 04/06/2006	// Author: Rene Brun 04/06/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 56	skipping to change at line 56
	protected:	protected:

	// Members for paral. managing	// Members for paral. managing
	TThread *fUnzipThread[10];	TThread *fUnzipThread[10];
	Bool_t fActiveThread; // Used to terminate gracefully the unzippers	Bool_t fActiveThread; // Used to terminate gracefully the unzippers
	TCondition *fUnzipStartCondition; // Used to signal the threads to sta rt.	TCondition *fUnzipStartCondition; // Used to signal the threads to sta rt.
	TCondition *fUnzipDoneCondition; // Used to wait for an unzip tour to finish. Gives the Async feel.	TCondition *fUnzipDoneCondition; // Used to wait for an unzip tour to finish. Gives the Async feel.
	Bool_t fParallel; // Indicate if we want to activate t he parallelism (for this instance)	Bool_t fParallel; // Indicate if we want to activate t he parallelism (for this instance)
	Bool_t fAsyncReading;	Bool_t fAsyncReading;
	TMutex *fMutexList; // Mutex to protect the various list s. Used by the condvars.	TMutex *fMutexList; // Mutex to protect the various list s. Used by the condvars.

		TMutex *fIOMutex;

	Int_t fCycle;	Int_t fCycle;
	static TTreeCacheUnzip::EParUnzipMode fgParallel; // Indicate if we wan t to activate the parallelism	static TTreeCacheUnzip::EParUnzipMode fgParallel; // Indicate if we wan t to activate the parallelism

	Int_t fLastReadPos;	Int_t fLastReadPos;

		Int_t fBlocksToGo;
	// Members to keep track of the unzipping buffer
	Long64_t fPosWrite;

	// Unzipping related members	// Unzipping related members
	Int_t *fUnzipLen; //! [fNseek] Length of the unzipped buffe rs	Int_t *fUnzipLen; //! [fNseek] Length of the unzipped buffe rs
	char **fUnzipChunks; //! [fNseek] Individual unzipped chunks. Their summed size is kept under control.	char **fUnzipChunks; //! [fNseek] Individual unzipped chunks. Their summed size is kept under control.
	Byte_t *fUnzipStatus; //! [fNSeek] For each blk, tells us if it 's unzipped or pending	Byte_t *fUnzipStatus; //! [fNSeek] For each blk, tells us if it 's unzipped or pending
	Long64_t fTotalUnzipBytes; //! The total sum of the currently unzipp ed blks	Long64_t fTotalUnzipBytes; //! The total sum of the currently unzipp ed blks

	Int_t fNseekMax; //! fNseek can change so we need to know its max size	Int_t fNseekMax; //! fNseek can change so we need to know its max size
	Long64_t fUnzipBufferSize; //! Max Size for the ready unzipped bloc ks (default is 2*fBufferSize)	Long64_t fUnzipBufferSize; //! Max Size for the ready unzipped bloc ks (default is 2*fBufferSize)


	Bool_t fSkipZip; // say if we should skip the uncompressi on of all buffers
	static Double_t fgRelBuffSize; // This is the percentage of the TTreeCac heUnzip that will be used	static Double_t fgRelBuffSize; // This is the percentage of the TTreeCac heUnzip that will be used


	//! keep track of the buffer set we are currently unzipping
	Int_t fUnzipStart; //! This will give uf the start index (fS
	eekSort)
	Int_t fUnzipEnd; //! Unzipped buffers go from fUnzipStart
	to fUnzipEnd

	// Members use to keep statistics	// Members use to keep statistics
	Int_t fNUnzip; //! number of blocks that were unzipped	Int_t fNUnzip; //! number of blocks that were unzipped
	Int_t fNFound; //! number of blocks that were found in t he cache	Int_t fNFound; //! number of blocks that were found in t he cache

		Int_t fNStalls; //! number of hits which caused a stall
	Int_t fNMissed; //! number of blocks that were not found in the cache and were unzipped	Int_t fNMissed; //! number of blocks that were not found in the cache and were unzipped

	std::queue<Int_t> fActiveBlks; // The blocks which are active now	std::queue<Int_t> fActiveBlks; // The blocks which are active now

	private:	private:
	TTreeCacheUnzip(const TTreeCacheUnzip &); //this class cannot be copied	TTreeCacheUnzip(const TTreeCacheUnzip &); //this class cannot be copied
	TTreeCacheUnzip& operator=(const TTreeCacheUnzip &);	TTreeCacheUnzip& operator=(const TTreeCacheUnzip &);


		char *fCompBuffer;
		Int_t fCompBufferSize;

	// Private methods	// Private methods
	void Init();	void Init();
	Int_t StartThreadUnzip(Int_t nthreads);	Int_t StartThreadUnzip(Int_t nthreads);
	Int_t StopThreadUnzip();	Int_t StopThreadUnzip();

	public:	public:
	TTreeCacheUnzip();	TTreeCacheUnzip();
	TTreeCacheUnzip(TTree *tree, Int_t buffersize=0);	TTreeCacheUnzip(TTree *tree, Int_t buffersize=0);
	virtual ~TTreeCacheUnzip();	virtual ~TTreeCacheUnzip();
	virtual void AddBranch(TBranch *b, Bool_t subbranches = kFALSE);	virtual void AddBranch(TBranch *b, Bool_t subbranches = kFALSE);
	virtual void AddBranch(const char *branch, Bool_t subbranches = k FALSE);	virtual void AddBranch(const char *branch, Bool_t subbranches = k FALSE);
	Bool_t FillBuffer();	Bool_t FillBuffer();

		virtual Int_t ReadBufferExt(char *buf, Long64_t pos, Int_t len, In t_t &loc);
	void SetEntryRange(Long64_t emin, Long64_t emax);	void SetEntryRange(Long64_t emin, Long64_t emax);
	virtual void StopLearningPhase();	virtual void StopLearningPhase();
	void UpdateBranches(TTree *tree, Bool_t owner = kFALSE);	void UpdateBranches(TTree *tree, Bool_t owner = kFALSE);

	// Methods related to the thread	// Methods related to the thread
	static EParUnzipMode GetParallelUnzip();	static EParUnzipMode GetParallelUnzip();
	static Bool_t IsParallelUnzip();	static Bool_t IsParallelUnzip();
	static Int_t SetParallelUnzip(TTreeCacheUnzip::EParUnzipMode opt ion = TTreeCacheUnzip::kEnable);	static Int_t SetParallelUnzip(TTreeCacheUnzip::EParUnzipMode opt ion = TTreeCacheUnzip::kEnable);

	Bool_t IsActiveThread();	Bool_t IsActiveThread();
	Bool_t IsQueueEmpty();	Bool_t IsQueueEmpty();

	void WaitUnzipStartSignal();	void WaitUnzipStartSignal();
	void SendUnzipStartSignal(Bool_t broadcast);	void SendUnzipStartSignal(Bool_t broadcast);

	// Unzipping related methods	// Unzipping related methods
	Int_t GetRecordHeader(char *buf, Int_t maxbytes, Int_t &nbytes, Int_t &objlen, Int_t &keylen);	Int_t GetRecordHeader(char *buf, Int_t maxbytes, Int_t &nbytes, Int_t &objlen, Int_t &keylen);

	virtual Bool_t GetSkipZip() { return fSkipZip; }
	virtual void ResetCache();	virtual void ResetCache();

	Int_t GetUnzipBuffer(char *buf, Long64_t pos, Int_t len, Bool_ t free);	virtual Int_t GetUnzipBuffer(char *buf, Long64_t pos, Int_t len, Bool_ t free);
	void SetUnzipBufferSize(Long64_t bufferSize);	void SetUnzipBufferSize(Long64_t bufferSize);

	virtual void SetSkipZip(Bool_t skip = kTRUE) { fSkipZip = skip; }	static void SetUnzipRelBufferSize(Float_t relbufferSize);
	Int_t UnzipBuffer(char *dest, char src);	Int_t UnzipBuffer(char *dest, char src);
	Int_t UnzipCache(Int_t &startindex, Int_t &locbuffsz, char *&lo cbuff);	Int_t UnzipCache(Int_t &startindex, Int_t &locbuffsz, char *&lo cbuff);

	// Methods to get stats	// Methods to get stats
	Int_t GetNUnzip() { return fNUnzip; }	Int_t GetNUnzip() { return fNUnzip; }
	Int_t GetNFound() { return fNFound; }	Int_t GetNFound() { return fNFound; }
	Int_t GetNMissed(){ return fNMissed; }	Int_t GetNMissed(){ return fNMissed; }

	void Print(Option_t* option = "") const;	void Print(Option_t* option = "") const;


End of changes. 11 change blocks.
	14 lines changed or deleted	10 lines changed or added

	TTreePerfStats.h	TTreePerfStats.h

	// @(#)root/treeplayer:$Id: TTreePerfStats.h 31024 2009-11-08 16:33:36Z bru n $	// @(#)root/treeplayer:$Id: TTreePerfStats.h 31417 2009-11-25 14:07:51Z bru n $
	// Author: Rene Brun 29/10/09	// Author: Rene Brun 29/10/09

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 30	skipping to change at line 30
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TVirtualPerfStats	#ifndef ROOT_TVirtualPerfStats
	#include "TVirtualPerfStats.h"	#include "TVirtualPerfStats.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif


		class TBrowser;
	class TFile;	class TFile;
	class TTree;	class TTree;
	class TStopwatch;	class TStopwatch;
	class TPaveText;	class TPaveText;
	class TGraphErrors;	class TGraphErrors;
	class TGaxis;	class TGaxis;
	class TText;	class TText;
	class TTreePerfStats : public TVirtualPerfStats {	class TTreePerfStats : public TVirtualPerfStats {

	protected:	protected:

	skipping to change at line 66	skipping to change at line 67
	TGraphErrors *fGraphTime ; //pointer to the graph with timestamp info	TGraphErrors *fGraphTime ; //pointer to the graph with timestamp info
	TPaveText *fPave; //pointer to annotation pavetext	TPaveText *fPave; //pointer to annotation pavetext
	TStopwatch *fWatch; //TStopwatch pointer	TStopwatch *fWatch; //TStopwatch pointer
	TGaxis *fRealTimeAxis; //pointer to TGaxis object showing real-ti me	TGaxis *fRealTimeAxis; //pointer to TGaxis object showing real-ti me
	TText *fHostInfoText; //Graphics Text object with the fHostInfo data	TText *fHostInfoText; //Graphics Text object with the fHostInfo data

	public:	public:
	TTreePerfStats();	TTreePerfStats();
	TTreePerfStats(const char name, TTree T);	TTreePerfStats(const char name, TTree T);
	virtual ~TTreePerfStats();	virtual ~TTreePerfStats();

		virtual void Browse(TBrowser *b);
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void Draw(Option_t *option="");	virtual void Draw(Option_t *option="");
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	virtual void Finish();	virtual void Finish();
	virtual Long64_t GetBytesRead() const {return fBytesRead;}	virtual Long64_t GetBytesRead() const {return fBytesRead;}
	virtual Long64_t GetBytesReadExtra() const {return fBytesReadExtra;}	virtual Long64_t GetBytesReadExtra() const {return fBytesReadExtra;}
	virtual Double_t GetCpuTime() const {return fCpuTime;}	virtual Double_t GetCpuTime() const {return fCpuTime;}
	virtual Double_t GetDiskTime() const {return fDiskTime;}	virtual Double_t GetDiskTime() const {return fDiskTime;}
	TGraphErrors *GetGraphIO() {return fGraphIO;}	TGraphErrors *GetGraphIO() {return fGraphIO;}
	TGraphErrors *GetGraphTime() {return fGraphTime;}	TGraphErrors *GetGraphTime() {return fGraphTime;}

End of changes. 3 change blocks.
	1 lines changed or deleted	3 lines changed or added

	TTreePlayer.h	TTreePlayer.h

	// @(#)root/treeplayer:$Id: TTreePlayer.h 28514 2009-05-11 10:44:08Z brun $	// @(#)root/treeplayer:$Id: TTreePlayer.h 31561 2009-12-04 16:31:47Z brun $
	// Author: Rene Brun 12/01/96	// Author: Rene Brun 12/01/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TUrl.h	TUrl.h

	// @(#)root/base:$Id: TUrl.h 22301 2008-02-24 15:04:36Z rdm $	// @(#)root/base:$Id: TUrl.h 31537 2009-12-03 16:45:40Z rdm $
	// Author: Fons Rademakers 17/01/97	// Author: Fons Rademakers 17/01/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 32	skipping to change at line 32
	// [proto://][user[:passwd]@]host[:port]/file.ext[#anchor][?options] //	// [proto://][user[:passwd]@]host[:port]/file.ext[#anchor][?options] //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif

		#ifndef ROOT_TMap
		#include "TMap.h"
		#endif

	class THashList;	class THashList;

		class TMap;

	class TUrl : public TObject {	class TUrl : public TObject {

	private:	private:
	TString fUrl; // full URL	TString fUrl; // full URL
	TString fProtocol; // protocol: http, ftp, news, root, proof, ...	TString fProtocol; // protocol: http, ftp, news, root, proof, ...
	TString fUser; // user name	TString fUser; // user name
	TString fPasswd; // password	TString fPasswd; // password
	TString fHost; // remote host	TString fHost; // remote host
	TString fFile; // remote object	TString fFile; // remote object
	TString fAnchor; // anchor in object (after #)	TString fAnchor; // anchor in object (after #)
	TString fOptions; // options/search (after ?)	TString fOptions; // options/search (after ?)
	mutable TString fFileOA; //!file with option and anchor	mutable TString fFileOA; //!file with option and anchor
	mutable TString fHostFQ; //!fully qualified host name	mutable TString fHostFQ; //!fully qualified host name
	Int_t fPort; // port through which to contact remote server	Int_t fPort; // port through which to contact remote server

		mutable TMap *fOptionsMap; //!map containing options key/value pairs

	static TObjArray *fgSpecialProtocols; // list of special protocols	static TObjArray *fgSpecialProtocols; // list of special protocols
	static THashList *fgHostFQDNs; // list of resolved host FQDNs	static THashList *fgHostFQDNs; // list of resolved host FQDNs

	void FindFile(char *u, Bool_t stripDoubleSlash = kTRUE);	void FindFile(char *u, Bool_t stripDoubleSlash = kTRUE);

	public:	public:
	TUrl() : fUrl(), fProtocol(), fUser(), fPasswd(), fHost(), fFile(),	TUrl() : fUrl(), fProtocol(), fUser(), fPasswd(), fHost(), fFile(),

	fAnchor(), fOptions(), fFileOA(), fHostFQ(), fPort(-1) { }	fAnchor(), fOptions(), fFileOA(), fHostFQ(), fPort(-1), fOption sMap(0) { }
	TUrl(const char *url, Bool_t defaultIsFile = kFALSE);	TUrl(const char *url, Bool_t defaultIsFile = kFALSE);
	TUrl(const TUrl &url);	TUrl(const TUrl &url);
	TUrl &operator=(const TUrl &rhs);	TUrl &operator=(const TUrl &rhs);

	virtual ~TUrl() { }	virtual ~TUrl();

	const char *GetUrl(Bool_t withDeflt = kFALSE);	const char *GetUrl(Bool_t withDeflt = kFALSE);
	const char *GetProtocol() const { return fProtocol; }	const char *GetProtocol() const { return fProtocol; }
	const char *GetUser() const { return fUser; }	const char *GetUser() const { return fUser; }
	const char *GetPasswd() const { return fPasswd; }	const char *GetPasswd() const { return fPasswd; }
	const char *GetHost() const { return fHost; }	const char *GetHost() const { return fHost; }
	const char *GetHostFQDN() const;	const char *GetHostFQDN() const;
	const char *GetFile() const { return fFile; }	const char *GetFile() const { return fFile; }
	const char *GetAnchor() const { return fAnchor; }	const char *GetAnchor() const { return fAnchor; }
	const char *GetOptions() const { return fOptions; }	const char *GetOptions() const { return fOptions; }

		const char GetValueFromOptions(const char key) const;
		Int_t GetIntValueFromOptions(const char *key) const;
		void ParseOptions() const;
		void CleanRelativePath();
	const char *GetFileAndOptions() const;	const char *GetFileAndOptions() const;
	Int_t GetPort() const { return fPort; }	Int_t GetPort() const { return fPort; }
	Bool_t IsValid() const { return fPort == -1 ? kFALSE : kTRUE; }	Bool_t IsValid() const { return fPort == -1 ? kFALSE : kTRUE; }

	void SetProtocol(const char *proto, Bool_t setDefaultPort = kFALS E);	void SetProtocol(const char *proto, Bool_t setDefaultPort = kFALS E);
	void SetUser(const char *user) { fUser = user; fUrl = ""; }	void SetUser(const char *user) { fUser = user; fUrl = ""; }
	void SetPasswd(const char *pw) { fPasswd = pw; fUrl = ""; }	void SetPasswd(const char *pw) { fPasswd = pw; fUrl = ""; }
	void SetHost(const char *host) { fHost = host; fUrl = ""; }	void SetHost(const char *host) { fHost = host; fUrl = ""; }
	void SetFile(const char *file) { fFile = file; fUrl = ""; fFileOA = "";}	void SetFile(const char *file) { fFile = file; fUrl = ""; fFileOA = "";}
	void SetAnchor(const char *anchor) { fAnchor = anchor; fUrl = ""; fFileOA = ""; }	void SetAnchor(const char *anchor) { fAnchor = anchor; fUrl = ""; fFileOA = ""; }

End of changes. 7 change blocks.
	3 lines changed or deleted	12 lines changed or added

	TVirtualGeoPainter.h	TVirtualGeoPainter.h

	// @(#)root/geom:$Id: TVirtualGeoPainter.h 27749 2009-03-10 15:23:52Z brun $	// @(#)root/geom:$Id: TVirtualGeoPainter.h 31454 2009-11-30 07:39:14Z brun $
	// Author: Andrei Gheata 11/01/02	// Author: Andrei Gheata 11/01/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TVirtualGeoPainter	#ifndef ROOT_TVirtualGeoPainter

	skipping to change at line 38	skipping to change at line 38
	class TGeoShape;	class TGeoShape;
	class TGeoMatrix;	class TGeoMatrix;
	class TGeoHMatrix;	class TGeoHMatrix;
	class TGeoManager;	class TGeoManager;
	class TVirtualGeoTrack;	class TVirtualGeoTrack;
	class TParticle;	class TParticle;
	class TObjArray;	class TObjArray;
	class TH2F;	class TH2F;
	class TStopwatch;	class TStopwatch;
	class TGeoBatemanSol;	class TGeoBatemanSol;

		class TGeoIteratorPlugin;

	class TVirtualGeoPainter : public TObject {	class TVirtualGeoPainter : public TObject {

	protected:	protected:
	static TVirtualGeoPainter *fgGeoPainter; //Pointer to class painter	static TVirtualGeoPainter *fgGeoPainter; //Pointer to class painter

	public:	public:
	enum EGeoVisLevel {	enum EGeoVisLevel {
	kGeoVisLevel = 0	kGeoVisLevel = 0
	};	};

	skipping to change at line 130	skipping to change at line 131
	virtual void PaintVolume(TGeoVolume vol, Option_t option="", TGe oMatrix* global=0) = 0;	virtual void PaintVolume(TGeoVolume vol, Option_t option="", TGe oMatrix* global=0) = 0;
	virtual void RandomPoints(const TGeoVolume vol, Int_t npoints, Op tion_t option="") = 0;	virtual void RandomPoints(const TGeoVolume vol, Int_t npoints, Op tion_t option="") = 0;
	virtual void RandomRays(Int_t nrays, Double_t startx, Double_t sta rty, Double_t startz) = 0;	virtual void RandomRays(Int_t nrays, Double_t startx, Double_t sta rty, Double_t startz) = 0;
	virtual void Raytrace(Option_t *option="") = 0;	virtual void Raytrace(Option_t *option="") = 0;
	virtual TGeoNode SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char g3path) = 0;	virtual TGeoNode SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char g3path) = 0;
	virtual void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3 , Double_t bombz=1.3,	virtual void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3 , Double_t bombz=1.3,
	Double_t bombr=1.3) = 0;	Double_t bombr=1.3) = 0;
	virtual void SetClippingShape(TGeoShape *shape) = 0;	virtual void SetClippingShape(TGeoShape *shape) = 0;
	virtual void SetExplodedView(Int_t iopt=0) = 0;	virtual void SetExplodedView(Int_t iopt=0) = 0;
	virtual void SetGeoManager(TGeoManager *geom) = 0;	virtual void SetGeoManager(TGeoManager *geom) = 0;

		virtual void SetIteratorPlugin(TGeoIteratorPlugin *plugin) = 0;
	virtual void SetCheckedNode(TGeoNode *node) = 0;	virtual void SetCheckedNode(TGeoNode *node) = 0;
	virtual void SetNsegments(Int_t nseg=20) = 0;	virtual void SetNsegments(Int_t nseg=20) = 0;
	virtual void SetNmeshPoints(Int_t npoints) = 0;	virtual void SetNmeshPoints(Int_t npoints) = 0;
	virtual void SetRaytracing(Bool_t flag=kTRUE) = 0;	virtual void SetRaytracing(Bool_t flag=kTRUE) = 0;
	static TVirtualGeoPainter *GeoPainter();	static TVirtualGeoPainter *GeoPainter();
	static void SetPainter(const TVirtualGeoPainter *painter);	static void SetPainter(const TVirtualGeoPainter *painter);
	virtual void SetTopVisible(Bool_t vis=kTRUE) = 0;	virtual void SetTopVisible(Bool_t vis=kTRUE) = 0;
	virtual void SetTopVolume(TGeoVolume *vol) = 0;	virtual void SetTopVolume(TGeoVolume *vol) = 0;
	virtual void SetVisLevel(Int_t level=3) = 0;	virtual void SetVisLevel(Int_t level=3) = 0;
	virtual void SetVisOption(Int_t option=0) = 0;	virtual void SetVisOption(Int_t option=0) = 0;

End of changes. 3 change blocks.
	1 lines changed or deleted	3 lines changed or added

	TVirtualTreePlayer.h	TVirtualTreePlayer.h

	// @(#)root/tree:$Id: TVirtualTreePlayer.h 28514 2009-05-11 10:44:08Z brun $	// @(#)root/tree:$Id: TVirtualTreePlayer.h 31561 2009-12-04 16:31:47Z brun $
	// Author: Rene Brun 30/08/99	// Author: Rene Brun 30/08/99

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	TXMLEngine.h	TXMLEngine.h

	// @(#)root/xml:$Id: TXMLEngine.h 24369 2008-06-19 11:27:50Z rdm $	// @(#)root/xml:$Id: TXMLEngine.h 31815 2009-12-10 16:27:22Z brun $
	// Author: Sergey Linev 10.05.2004	// Author: Sergey Linev 10.05.2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 33	skipping to change at line 33

	class TXMLInputStream;	class TXMLInputStream;
	class TXMLOutputStream;	class TXMLOutputStream;
	class TString;	class TString;

	class TXMLEngine : public TObject {	class TXMLEngine : public TObject {

	protected:	protected:
	char* Makestr(const char* str);	char* Makestr(const char* str);
	char* Makenstr(const char* start, int len);	char* Makenstr(const char* start, int len);

	XMLNodePointer_t AllocateNode(int namelen, XMLNodePointer_t parent);	XMLNodePointer_t AllocateNode(const char *name, XMLNodePointer_t parent
	XMLAttrPointer_t AllocateAttr(int namelen, int valuelen, XMLNodePointer	);
	_t xmlnode);	XMLAttrPointer_t AllocateAttr(const char name, const char value, XMLN
		odePointer_t xmlnode);
		XMLAttrPointer_t AllocateAttr(Ssiz_t namelen, Ssiz_t valuelen, XMLNodeP
		ointer_t xmlnode);
	XMLNsPointer_t FindNs(XMLNodePointer_t xmlnode, const char* nsname);	XMLNsPointer_t FindNs(XMLNodePointer_t xmlnode, const char* nsname);
	void TruncateNsExtension(XMLNodePointer_t xmlnode);	void TruncateNsExtension(XMLNodePointer_t xmlnode);
	void UnpackSpecialCharacters(char* target, const char* sour ce, int srclen);	void UnpackSpecialCharacters(char* target, const char* sour ce, int srclen);
	void OutputValue(char* value, TXMLOutputStream* out);	void OutputValue(char* value, TXMLOutputStream* out);
	void SaveNode(XMLNodePointer_t xmlnode, TXMLOutputStream* o ut, Int_t layout, Int_t level);	void SaveNode(XMLNodePointer_t xmlnode, TXMLOutputStream* o ut, Int_t layout, Int_t level);
	XMLNodePointer_t ReadNode(XMLNodePointer_t xmlparent, TXMLInputStream* inp, Int_t& resvalue);	XMLNodePointer_t ReadNode(XMLNodePointer_t xmlparent, TXMLInputStream* inp, Int_t& resvalue);
	void DisplayError(Int_t error, Int_t linenumber);	void DisplayError(Int_t error, Int_t linenumber);


		Bool_t fSkipComments; //! if true, do not create comments
		nodes in document during parsing

	public:	public:
	TXMLEngine();	TXMLEngine();
	virtual ~TXMLEngine();	virtual ~TXMLEngine();


		void SetSkipComments(bool on = kTRUE) { fSkipComments = on;
		}
		Bool_t GetSkipComments() const { return fSkipComments; }

	Bool_t HasAttr(XMLNodePointer_t xmlnode, const char* name);	Bool_t HasAttr(XMLNodePointer_t xmlnode, const char* name);
	const char* GetAttr(XMLNodePointer_t xmlnode, const char* name);	const char* GetAttr(XMLNodePointer_t xmlnode, const char* name);
	Int_t GetIntAttr(XMLNodePointer_t node, const char* name);	Int_t GetIntAttr(XMLNodePointer_t node, const char* name);
	XMLAttrPointer_t NewAttr(XMLNodePointer_t xmlnode, XMLNsPointer_t,	XMLAttrPointer_t NewAttr(XMLNodePointer_t xmlnode, XMLNsPointer_t,
	const char* name, const char* value);	const char* name, const char* value);
	XMLAttrPointer_t NewIntAttr(XMLNodePointer_t xmlnode, const char* name, Int_t value);	XMLAttrPointer_t NewIntAttr(XMLNodePointer_t xmlnode, const char* name, Int_t value);
	void FreeAttr(XMLNodePointer_t xmlnode, const char* name);	void FreeAttr(XMLNodePointer_t xmlnode, const char* name);
	void FreeAllAttr(XMLNodePointer_t xmlnode);	void FreeAllAttr(XMLNodePointer_t xmlnode);
	XMLAttrPointer_t GetFirstAttr(XMLNodePointer_t xmlnode);	XMLAttrPointer_t GetFirstAttr(XMLNodePointer_t xmlnode);
	XMLAttrPointer_t GetNextAttr(XMLAttrPointer_t xmlattr);	XMLAttrPointer_t GetNextAttr(XMLAttrPointer_t xmlattr);

End of changes. 4 change blocks.
	4 lines changed or deleted	14 lines changed or added

	Timer.h	Timer.h

	// @(#)root/tmva $Id: Timer.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: Timer.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Timer *	* Class : Timer *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Timing information for methods training *	* Timing information for methods training *

	skipping to change at line 78	skipping to change at line 78
	virtual ~Timer( void );	virtual ~Timer( void );

	void Init ( Int_t ncounts );	void Init ( Int_t ncounts );
	void Reset( void );	void Reset( void );

	// when the "Scientific" flag set, time is returned with subdecimals	// when the "Scientific" flag set, time is returned with subdecimals
	// for algorithm timing measurement	// for algorithm timing measurement
	TString GetElapsedTime ( Bool_t Scientific = kTRUE );	TString GetElapsedTime ( Bool_t Scientific = kTRUE );
	Double_t ElapsedSeconds ( void );	Double_t ElapsedSeconds ( void );
	TString GetLeftTime ( Int_t icounts );	TString GetLeftTime ( Int_t icounts );

	void DrawProgressBar( Int_t );	void DrawProgressBar( Int_t, const TString& comment = "" );
	void DrawProgressBar( TString );	void DrawProgressBar( TString );
	void DrawProgressBar( void );	void DrawProgressBar( void );

	private:	private:

	TString SecToText ( Double_t, Bool_t ) const;	TString SecToText ( Double_t, Bool_t ) const;

	Int_t fNcounts; // reference number of "counts"	Int_t fNcounts; // reference number of "counts"
	TString fPrefix; // prefix for outputs	TString fPrefix; // prefix for outputs
	Bool_t fColourfulOutput; // flag for use of colors	Bool_t fColourfulOutput; // flag for use of colors

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	Tools.h	Tools.h

	// @(#)root/tmva $Id: Tools.h 29229 2009-06-25 16:11:59Z brun $	// @(#)root/tmva $Id: Tools.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Tools *	* Class : Tools *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Global auxiliary applications and data treatment routines *	* Global auxiliary applications and data treatment routines *

	skipping to change at line 44	skipping to change at line 44
	// //	// //
	// Global auxiliary applications and data treatment routines //	// Global auxiliary applications and data treatment routines //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#include <vector>	#include <vector>
	#include <sstream>	#include <sstream>
	#include <iostream>	#include <iostream>
	#include <iomanip>	#include <iomanip>


	#ifndef ROOT_TMVA_TXMLEngine
	#ifndef ROOT_TXMLEngine	#ifndef ROOT_TXMLEngine
	#include "TXMLEngine.h"	#include "TXMLEngine.h"
	#endif	#endif


		#ifndef ROOT_TMatrixDSymfwd
		#include "TMatrixDSymfwd.h"
	#endif	#endif

	#ifndef ROOT_TMVA_TMatrixDSymEigen
	#ifndef ROOT_TMatrixDSymEigen	#ifndef ROOT_TMatrixDfwd
	#include "TMatrixDSymEigen.h"	#include "TMatrixDfwd.h"
	#endif	#endif


		#ifndef ROOT_TVectorDfwd
		#include "TVectorDfwd.h"
	#endif	#endif


	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif

	class TList;	class TList;
	class TTree;	class TTree;
	class TString;	class TString;
	class TH1;	class TH1;
	class TH2;	class TH2;
	class TH2F;	class TH2F;

	skipping to change at line 214	skipping to change at line 220

	TString StringFromInt ( Long_t i );	TString StringFromInt ( Long_t i );
	TString StringFromDouble ( Double_t d );	TString StringFromDouble ( Double_t d );
	void WriteTMatrixDToXML ( void* node, const char* name, TMatri xD* mat );	void WriteTMatrixDToXML ( void* node, const char* name, TMatri xD* mat );
	void WriteTVectorDToXML ( void* node, const char* name, TVecto rD* vec );	void WriteTVectorDToXML ( void* node, const char* name, TVecto rD* vec );
	void ReadTMatrixDFromXML( void* node, const char* name, TMatri xD* mat );	void ReadTMatrixDFromXML( void* node, const char* name, TMatri xD* mat );
	void ReadTVectorDFromXML( void* node, const char* name, TVecto rD* vec );	void ReadTVectorDFromXML( void* node, const char* name, TVecto rD* vec );
	Bool_t HistoHasEquidistantBins(const TH1& h);	Bool_t HistoHasEquidistantBins(const TH1& h);

	template<typename T>	template<typename T>

	void ReadAttr ( void* node, const char* , T& value );	inline void ReadAttr( void* node, const char* , T& value );

		inline void ReadAttr( void* node, const char* attrname, TString& valu
		e );

	template<typename T>	template<typename T>
	void AddAttr ( void* node, const char* , const T& value, I nt_t precision = 16 );	void AddAttr ( void* node, const char* , const T& value, I nt_t precision = 16 );
	void* AddChild ( void* parent, const char* childname, const char* content = 0 );	void* AddChild ( void* parent, const char* childname, const char* content = 0 );
	void* GetChild ( void* parent, const char* childname=0 );	void* GetChild ( void* parent, const char* childname=0 );
	void* GetNextChild( void* prevchild, const char* childname=0 );	void* GetNextChild( void* prevchild, const char* childname=0 );
	const char* GetContent ( void* node );	const char* GetContent ( void* node );

	TXMLEngine& xmlengine() { return *fXMLEngine; }	TXMLEngine& xmlengine() { return *fXMLEngine; }
	TXMLEngine* fXMLEngine;	TXMLEngine* fXMLEngine;


	skipping to change at line 247	skipping to change at line 256
	template<typename T>	template<typename T>
	void TMVA::Tools::ReadAttr( void* node, const char* attrname, T& value )	void TMVA::Tools::ReadAttr( void* node, const char* attrname, T& value )
	{	{
	// add attribute from xml	// add attribute from xml
	const char* val = xmlengine().GetAttr(node, attrname);	const char* val = xmlengine().GetAttr(node, attrname);
	std::stringstream s(val);	std::stringstream s(val);
	s >> value;	s >> value;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________

		void TMVA::Tools::ReadAttr( void* node, const char* attrname, TString& valu
		e )
		{
		// add attribute from xml
		const char* val = xmlengine().GetAttr(node, attrname);
		value = TString(val);
		}

		//_______________________________________________________________________
	template<typename T>	template<typename T>
	void TMVA::Tools::AddAttr( void* node, const char* attrname, const T& value , Int_t precision )	void TMVA::Tools::AddAttr( void* node, const char* attrname, const T& value , Int_t precision )
	{	{
	// add attribute to xml	// add attribute to xml
	std::stringstream s;	std::stringstream s;
	s.precision( precision );	s.precision( precision );
	s << std::scientific << value;	s << std::scientific << value;
	gTools().xmlengine().NewAttr(node, 0, attrname, s.str().c_str());	gTools().xmlengine().NewAttr(node, 0, attrname, s.str().c_str());
	}	}


End of changes. 8 change blocks.
	6 lines changed or deleted	25 lines changed or added

	Types.h	Types.h

	// @(#)root/tmva $Id: Types.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: Types.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Types *	* Class : Types *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* GLobal types (singleton class) *	* GLobal types (singleton class) *

	skipping to change at line 51	skipping to change at line 51
	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {


		typedef UInt_t TMVAVersion_t;

	class MsgLogger;	class MsgLogger;

	// message types for MsgLogger	// message types for MsgLogger
	// define outside of Types class to facilite access	// define outside of Types class to facilite access
	enum EMsgType {	enum EMsgType {
	kDEBUG = 1,	kDEBUG = 1,
	kVERBOSE = 2,	kVERBOSE = 2,
	kINFO = 3,	kINFO = 3,
	kWARNING = 4,	kWARNING = 4,
	kERROR = 5,	kERROR = 5,

	skipping to change at line 93	skipping to change at line 95
	kRuleFit ,	kRuleFit ,
	kSVM ,	kSVM ,
	kMLP ,	kMLP ,
	kBayesClassifier,	kBayesClassifier,
	kFDA ,	kFDA ,
	kCommittee ,	kCommittee ,
	kBoost ,	kBoost ,
	kPDEFoam ,	kPDEFoam ,
	kLD ,	kLD ,
	kPlugins ,	kPlugins ,

		kCategory ,
	kMaxMethod	kMaxMethod
	};	};

	// available variable transformations	// available variable transformations
	enum EVariableTransform {	enum EVariableTransform {
	kIdentity = 0,	kIdentity = 0,
	kDecorrelated,	kDecorrelated,
	kNormalized,	kNormalized,
	kPCA,	kPCA,
	kGaussDecorr,	kGaussDecorr,
	kMaxVariableTransform	kMaxVariableTransform
	};	};

	// type of analysis	// type of analysis
	enum EAnalysisType {	enum EAnalysisType {
	kClassification = 0,	kClassification = 0,
	kRegression,	kRegression,

		kMulticlass,
	kNoAnalysisType,	kNoAnalysisType,
	kMaxAnalysisType	kMaxAnalysisType
	};	};

	enum ESBType {	enum ESBType {
	kSignal = 0, // Never change this number - it is elsewhere assume d to be zero !	kSignal = 0, // Never change this number - it is elsewhere assume d to be zero !
	kBackground,	kBackground,
	kSBBoth,	kSBBoth,
	kMaxSBType,	kMaxSBType,
	kTrueType	kTrueType

End of changes. 4 change blocks.
	1 lines changed or deleted	5 lines changed or added

	VariableDecorrTransform.h	VariableDecorrTransform.h

	// @(#)root/tmva $Id: VariableDecorrTransform.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: VariableDecorrTransform.h 31574 2009-12-05 18:23:21Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : VariableDecorrTransform *	* Class : VariableDecorrTransform *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Decorrelation of input variables *	* Decorrelation of input variables *

	skipping to change at line 43	skipping to change at line 43
	// VariableDecorrTransform //	// VariableDecorrTransform //
	// //	// //
	// Linear interpolation class //	// Linear interpolation class //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMatrixDfwd	#ifndef ROOT_TMatrixDfwd
	#include "TMatrixDfwd.h"	#include "TMatrixDfwd.h"
	#endif	#endif


		#ifndef ROOT_TMatrixDSymfwd
		#include "TMatrixDSymfwd.h"
		#endif

	#ifndef ROOT_TMVA_VariableTransformBase	#ifndef ROOT_TMVA_VariableTransformBase
	#include "TMVA/VariableTransformBase.h"	#include "TMVA/VariableTransformBase.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class VariableDecorrTransform : public VariableTransformBase {	class VariableDecorrTransform : public VariableTransformBase {

	public:	public:


	skipping to change at line 64	skipping to change at line 68
	virtual ~VariableDecorrTransform( void );	virtual ~VariableDecorrTransform( void );

	void Initialize();	void Initialize();
	Bool_t PrepareTransformation( const std::vector<Event*>& );	Bool_t PrepareTransformation( const std::vector<Event*>& );

	// virtual const Event* Transform(const Event* const, Types::ESB Type type = Types::kMaxSBType) const;	// virtual const Event* Transform(const Event* const, Types::ESB Type type = Types::kMaxSBType) const;
	virtual const Event* Transform(const Event* const, Int_t cls ) const;	virtual const Event* Transform(const Event* const, Int_t cls ) const;
	virtual const Event* InverseTransform(const Event* const, Int_t cls ) const;	virtual const Event* InverseTransform(const Event* const, Int_t cls ) const;

	void WriteTransformationToStream ( std::ostream& ) const;	void WriteTransformationToStream ( std::ostream& ) const;

	void ReadTransformationFromStream( std::istream& );	void ReadTransformationFromStream( std::istream&, const TString& );

	virtual void AttachXMLTo(void* parent);	virtual void AttachXMLTo(void* parent);
	virtual void ReadFromXML( void* trfnode );	virtual void ReadFromXML( void* trfnode );

	virtual void PrintTransformation( ostream & o );	virtual void PrintTransformation( ostream & o );

	// writer of function code	// writer of function code
	virtual void MakeFunction( std::ostream& fout, const TString& fncName , Int_t part, UInt_t trCounter, Int_t cls );	virtual void MakeFunction( std::ostream& fout, const TString& fncName , Int_t part, UInt_t trCounter, Int_t cls );

	// provides string vector giving explicit transformation	// provides string vector giving explicit transformation

End of changes. 3 change blocks.
	2 lines changed or deleted	6 lines changed or added

	Version.h	Version.h

	// @(#)root/tmva $Id: Version.h 29211 2009-06-25 10:47:22Z brun $	// @(#)root/tmva $Id: Version.h 31839 2009-12-11 09:40:12Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Version *	* Class : Version *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Current TMVA Version - filled automatically during cvs tagging *	* Current TMVA Version - filled automatically during cvs tagging *

	skipping to change at line 41	skipping to change at line 41
	#define ROOT_TMVA_Version	#define ROOT_TMVA_Version

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// Version //	// Version //
	// //	// //
	// Automatically filled by cvs tagger: development/tmvaTag.py //	// Automatically filled by cvs tagger: development/tmvaTag.py //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


	#define TMVA_RELEASE "4.0.1"	#define TMVA_RELEASE "4.0.4"
	#define TMVA_RELEASE_DATE "Jun 25, 2009"	#define TMVA_RELEASE_DATE "Dec 11, 2009"
	#define TMVA_RELEASE_TIME "12:27:36"	#define TMVA_RELEASE_TIME "10:19:58"
	#define TMVA_VERSION_CODE 262145	#define TMVA_VERSION_CODE 262148
	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

End of changes. 2 change blocks.
	5 lines changed or deleted	5 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	BDTEventWrapper.h	BDTEventWrapper.h

	skipping to change at line 65	skipping to change at line 65
	// Set the index of the variable to compare on	// Set the index of the variable to compare on
	/**	/**
	* @param iVar - index of the variable in fEvent to use	* @param iVar - index of the variable in fEvent to use
	*/	*/
	inline static void SetVarIndex( Int_t iVar ) { if (iVar >= 0) fVarInd ex = iVar; }	inline static void SetVarIndex( Int_t iVar ) { if (iVar >= 0) fVarInd ex = iVar; }

	// Return the value of variable fVarIndex for this event	// Return the value of variable fVarIndex for this event
	/**	/**
	* @return value of variable fVarIndex for this event	* @return value of variable fVarIndex for this event
	*/	*/

	inline Double_t GetVal() const { return fEvent->GetVal(fVarIndex); }	inline Double_t GetVal() const { return fEvent->GetValue(fVarIndex); }
	const Event* operator*() const { return fEvent; }	const Event* operator*() const { return fEvent; }

	private:	private:

	static Int_t fVarIndex; // index of the variable to sort on	static Int_t fVarIndex; // index of the variable to sort on
	const Event* fEvent; // pointer to the event	const Event* fEvent; // pointer to the event

	Double_t fBkgWeight; // cumulative background weight for splittin g	Double_t fBkgWeight; // cumulative background weight for splittin g
	Double_t fSigWeight; // same for the signal weights	Double_t fSigWeight; // same for the signal weights
	};	};

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	BinarySearchTree.h	BinarySearchTree.h

	// @(#)root/tmva $Id: BinarySearchTree.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: BinarySearchTree.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : BinarySearchTree *	* Class : BinarySearchTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* BinarySearchTree incl. volume Search method *	* BinarySearchTree incl. volume Search method *

	skipping to change at line 96	skipping to change at line 96
	virtual BinaryTree* CreateTree() const { return new BinarySearchTree( ); }	virtual BinaryTree* CreateTree() const { return new BinarySearchTree( ); }
	virtual const char* ClassName() const { return "BinarySearchTree"; }	virtual const char* ClassName() const { return "BinarySearchTree"; }

	// Searches for a node with the specified data	// Searches for a node with the specified data
	// by calling the private, recursive, function for searching	// by calling the private, recursive, function for searching
	BinarySearchTreeNode* Search( Event * event ) const;	BinarySearchTreeNode* Search( Event * event ) const;

	// Adds an item to the tree,	// Adds an item to the tree,
	void Insert( const Event * );	void Insert( const Event * );


	//get sum of weights of the nodes;	// get sum of weights of the nodes;
	Double_t GetSumOfWeights( void ) const;	Double_t GetSumOfWeights( void ) const;

	//get sum of weights of the nodes of given type;	//get sum of weights of the nodes of given type;
	Double_t GetSumOfWeights( Int_t theType ) const;	Double_t GetSumOfWeights( Int_t theType ) const;

	//set the periode (number of variables)	//set the periode (number of variables)
	void SetPeriode( Int_t p ) { fPeriod = p; }	void SetPeriode( Int_t p ) { fPeriod = p; }


	// return periode (number of variables)	// return periode (number of variables)
	UInt_t GetPeriode( void ) const { return fPeriod; }	UInt_t GetPeriode( void ) const { return fPeriod; }

	// counts events (weights) within a given volume	// counts events (weights) within a given volume
	Double_t SearchVolume( Volume, std::vector<const TMVA::BinarySearchT reeNode>* events = 0 );	Double_t SearchVolume( Volume, std::vector<const TMVA::BinarySearchT reeNode>* events = 0 );

	// Create the search tree from the event collection	// Create the search tree from the event collection
	// using ONLY the variables specified in "theVars"	// using ONLY the variables specified in "theVars"
	Double_t Fill( const std::vector<TMVA::Event*>& events, const std::ve ctor<Int_t>& theVars, Int_t theType = -1 );	Double_t Fill( const std::vector<TMVA::Event*>& events, const std::ve ctor<Int_t>& theVars, Int_t theType = -1 );


End of changes. 3 change blocks.
	2 lines changed or deleted	3 lines changed or added

	BrentMinimizer1D.h	BrentMinimizer1D.h

	// @(#)root/mathcore:$Id: BrentMinimizer1D.h 24477 2008-06-23 12:58:47Z mon eta $	// @(#)root/mathcore:$Id: BrentMinimizer1D.h 31583 2009-12-06 13:55:26Z rdm $
	// Author: David Gonzalez Maline 2/2008	// Author: David Gonzalez Maline 2/2008
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 Maline, CERN/PH-SFT *	* Copyright (c) 2004 Maline, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *
	* *	* *

	skipping to change at line 30	skipping to change at line 30
	* 330, Boston, MA 02111-1307 USA, or contact the author. *	* 330, Boston, MA 02111-1307 USA, or contact the author. *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class BrentMinimizer1D	// Header file for class BrentMinimizer1D
	//	//
	// Created by: Maline at Mon Feb 4 09:32:36 2008	// Created by: Maline at Mon Feb 4 09:32:36 2008
	//	//
	//	//


	#include "IMinimizer1D.h"	#include "Math/IMinimizer1D.h"
	#include "Math/IFunction.h"	#include "Math/IFunction.h"

	#ifndef ROOT_Math_BrentMinimizer1D	#ifndef ROOT_Math_BrentMinimizer1D
	#define ROOT_Math_BrentMinimizer1D	#define ROOT_Math_BrentMinimizer1D

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {

	//_________________________________________________________________________ __________________	//_________________________________________________________________________ __________________
	/**	/**

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	ClassifierFactory.h	ClassifierFactory.h

	// @(#)Root/tmva $Id: ClassifierFactory.h 29122 2009-06-22 06:51:30Z brun $	// @(#)Root/tmva $Id: ClassifierFactory.h 31458 2009-11-30 13:58:20Z stelze r $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Factory *	* Class : Factory *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* This template creates ClassifierFactory stores creator functors *	* This template creates ClassifierFactory stores creator functors *

	skipping to change at line 125	skipping to change at line 125
	/// TMVA::IMethod* CreateMethod()	/// TMVA::IMethod* CreateMethod()
	/// {	/// {
	/// return (TMVA::IMethod*) new TMVA::MethodFisher;	/// return (TMVA::IMethod*) new TMVA::MethodFisher;
	/// }	/// }
	/// Bool_t RegisteredMethod = TMVA::ClassifierFactory<TMVA::MethodBase>: :Instance().	/// Bool_t RegisteredMethod = TMVA::ClassifierFactory<TMVA::MethodBase>: :Instance().
	/// Register("Method", CreateMethodFisher);	/// Register("Method", CreateMethodFisher);
	/// }	/// }
	///	///
	/////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////


	#define REGISTER_METHOD(CLASS) \	#define REGISTER_METHOD(CLASS) \
	namespace \	namespace \
	{ \	{ \
	TMVA::IMethod* CreateMethod##CLASS(const TString& job, const TString& title, TMVA::DataSetInfo& dsi, const TString& option) \	TMVA::IMethod* CreateMethod##CLASS(const TString& job, const TString& title, TMVA::DataSetInfo& dsi, const TString& option) \

	{ \	{ \
	if(job=="" && title=="") { \	if(job=="" && title=="") { \
	return (TMVA::IMethod*) new TMVA::Method##CLASS(dsi, option); \	return (TMVA::IMethod*) new TMVA::Method##CLASS(dsi, option); \
	} else { \	} else { \
	return (TMVA::IMethod*) new TMVA::Method##CLASS(job, title, dsi , option); \	return (TMVA::IMethod*) new TMVA::Method##CLASS(job, title, dsi , option); \
	} \	} \
	} \	} \

	Bool_t RegisteredMethod = TMVA::ClassifierFactory::Instance(). \	Bool_t RegisteredMethod = TMVA::ClassifierFactory::Instance(). \
	Register(#CLASS, CreateMethod##CLASS);	Register(#CLASS, CreateMethod##CLASS); \
	\
	Bool_t AddedTypeMapping = TMVA::Types::Instance().AddTypeMapping(TMVA ::Types::k##CLASS, #CLASS); \	Bool_t AddedTypeMapping = TMVA::Types::Instance().AddTypeMapping(TMVA ::Types::k##CLASS, #CLASS); \
	}	}

	#endif	#endif

End of changes. 4 change blocks.
	8 lines changed or deleted	7 lines changed or added

	FitResult.h	FitResult.h

	// @(#)root/mathcore:$Id: FitResult.h 31261 2009-11-18 07:31:51Z moneta $	// @(#)root/mathcore:$Id: FitResult.h 31604 2009-12-07 19:04:33Z moneta $
	// Author: L. Moneta Wed Aug 30 11:05:34 2006	// Author: L. Moneta Wed Aug 30 11:05:34 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class FitResult	// Header file for class FitResult

	skipping to change at line 122	skipping to change at line 122
	unsigned int NTotalParameters() const { return fParams.size(); }	unsigned int NTotalParameters() const { return fParams.size(); }
	/// total number of parameters (abbreviation)	/// total number of parameters (abbreviation)
	unsigned int NPar() const { return NTotalParameters(); }	unsigned int NPar() const { return NTotalParameters(); }

	/// get total number of free parameters	/// get total number of free parameters
	unsigned int NFreeParameters() const { return fNFree; }	unsigned int NFreeParameters() const { return fNFree; }

	/// minimizer status code	/// minimizer status code
	int Status() const { return fStatus; }	int Status() const { return fStatus; }


		///covariance matrix status code
		/// using Minuit convention : =0 not calculated, =1 approximated, =2 mad
		e pos def , =3 accurate

		int CovMatrixStatus() const { return fCovStatus; }

	/ fitting quantities /	/ fitting quantities /

	/// Return pointer to model (fit) function with fitted parameter values.	/// Return pointer to model (fit) function with fitted parameter values.
	const IModelFunction * FittedFunction() const { return fFitFunc; }	const IModelFunction * FittedFunction() const { return fFitFunc; }

	/// Chi2 fit value	/// Chi2 fit value
	/// in case of likelihood must be computed ?	/// in case of likelihood must be computed ?
	double Chi2() const { return fChi2; }	double Chi2() const { return fChi2; }

	/// Number of degree of freedom	/// Number of degree of freedom

	skipping to change at line 192	skipping to change at line 197
	if (fCovMatrix.size() == 0) return 0; // no matrix is available in ca se of non-valid fits	if (fCovMatrix.size() == 0) return 0; // no matrix is available in ca se of non-valid fits
	double tmp = CovMatrix(i,i)*CovMatrix(j,j);	double tmp = CovMatrix(i,i)*CovMatrix(j,j);
	return ( tmp > 0) ? CovMatrix(i,j)/ std::sqrt(tmp) : 0;	return ( tmp > 0) ? CovMatrix(i,j)/ std::sqrt(tmp) : 0;
	}	}

	/// fill covariance matrix elements using a generic matrix class impleme nting operator(i,j)	/// fill covariance matrix elements using a generic matrix class impleme nting operator(i,j)
	/// the matrix must be previously allocates with right size (npar * npar )	/// the matrix must be previously allocates with right size (npar * npar )
	template<class Matrix>	template<class Matrix>
	void GetCovarianceMatrix(Matrix & mat) const {	void GetCovarianceMatrix(Matrix & mat) const {
	unsigned int npar = fErrors.size();	unsigned int npar = fErrors.size();

	assert(fCovMatrix.size() == npar*(npar+1)/2);	if (fCovMatrix.size() != npar*(npar+1)/2 ) return; // do nothing
	for (unsigned int i = 0; i< npar; ++i) {	for (unsigned int i = 0; i< npar; ++i) {
	for (unsigned int j = 0; j<=i; ++j) {	for (unsigned int j = 0; j<=i; ++j) {
	mat(i,j) = fCovMatrix[j + i*(i+1)/2 ];	mat(i,j) = fCovMatrix[j + i*(i+1)/2 ];
	if (i != j) mat(j,i) = mat(i,j);	if (i != j) mat(j,i) = mat(i,j);
	}	}
	}	}
	}	}

	/// fill a correlation matrix elements using a generic symmetric matrix class implementing operator(i,j)	/// fill a correlation matrix elements using a generic symmetric matrix class implementing operator(i,j)
	/// the matrix must be previously allocates with right size (npar * npar )	/// the matrix must be previously allocates with right size (npar * npar )
	template<class Matrix>	template<class Matrix>
	void GetCorrelationMatrix(Matrix & mat) const {	void GetCorrelationMatrix(Matrix & mat) const {
	unsigned int npar = fErrors.size();	unsigned int npar = fErrors.size();

	assert(fCovMatrix.size() == npar*(npar+1)/2);	if (fCovMatrix.size() != npar*(npar+1)/2) return; // do nothing
	for (unsigned int i = 0; i< npar; ++i) {	for (unsigned int i = 0; i< npar; ++i) {
	for (unsigned int j = 0; j<=i; ++j) {	for (unsigned int j = 0; j<=i; ++j) {
	double tmp = fCovMatrix[i * (i +3)/2 ] * fCovMatrix[ j * (j+3)/ 2 ];	double tmp = fCovMatrix[i * (i +3)/2 ] * fCovMatrix[ j * (j+3)/ 2 ];
	mat(i,j) = (tmp > 0) ? fCovMatrix[j + i*(i+1)/2 ] / std::sqrt(t mp) : 0;	mat(i,j) = (tmp > 0) ? fCovMatrix[j + i*(i+1)/2 ] / std::sqrt(t mp) : 0;
	if (i != j) mat(j,i) = mat(i,j);	if (i != j) mat(j,i) = mat(i,j);
	}	}
	}	}
	}	}

	/**	/**

	skipping to change at line 277	skipping to change at line 282
	void SetModelFunction(IModelFunction * func) { fFitFunc = func; }	void SetModelFunction(IModelFunction * func) { fFitFunc = func; }

	friend class Fitter;	friend class Fitter;

	bool fValid; // flag for indicating valid fit	bool fValid; // flag for indicating valid fit
	bool fNormalized; // flag for indicating is errors are normalized	bool fNormalized; // flag for indicating is errors are normalized
	unsigned int fNFree; // number of fit free parameters (total paramet ers are in size of parameter vector)	unsigned int fNFree; // number of fit free parameters (total paramet ers are in size of parameter vector)
	unsigned int fNdf; // number of degree of freedom	unsigned int fNdf; // number of degree of freedom
	unsigned int fNCalls; // number of function calls	unsigned int fNCalls; // number of function calls
	int fStatus; // minimizer status code	int fStatus; // minimizer status code

		int fCovStatus; // covariance matrix status code
	double fVal; // minimum function value	double fVal; // minimum function value
	double fEdm; // expected distance from mimimum	double fEdm; // expected distance from mimimum
	double fChi2; // fit chi2 value (different than fval in case of chi2 fits)	double fChi2; // fit chi2 value (different than fval in case of chi2 fits)
	IModelFunction * fFitFunc; //! model function resulting from the fit. I t is given by Fitter but it is managed by FitResult	IModelFunction * fFitFunc; //! model function resulting from the fit. I t is given by Fitter but it is managed by FitResult
	std::vector<unsigned int> fFixedParams; // list of fixed parameters	std::vector<unsigned int> fFixedParams; // list of fixed parameters
	std::vector<unsigned int> fBoundParams; // list of limited parameters	std::vector<unsigned int> fBoundParams; // list of limited parameters
	std::vector<double> fParams; // parameter values. Size is total number of parameters	std::vector<double> fParams; // parameter values. Size is total number of parameters
	std::vector<double> fErrors; // errors	std::vector<double> fErrors; // errors
	std::vector<double> fCovMatrix; // covariance matrix (size is n par*(npar+1)/2) where npar is total parameters	std::vector<double> fCovMatrix; // covariance matrix (size is n par*(npar+1)/2) where npar is total parameters
	std::vector<double> fGlobalCC; // global Correlation coefficie nt	std::vector<double> fGlobalCC; // global Correlation coefficie nt

End of changes. 5 change blocks.
	3 lines changed or deleted	10 lines changed or added

	GSLMinimizer.h	GSLMinimizer.h

	// @(#)root/mathmore:$Id: GSLMinimizer.h 29068 2009-06-17 16:28:51Z moneta $	// @(#)root/mathmore:$Id: GSLMinimizer.h 31604 2009-12-07 19:04:33Z moneta $
	// Author: L. Moneta Wed Oct 18 11:48:00 2006	// Author: L. Moneta Wed Oct 18 11:48:00 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 185	skipping to change at line 185
	virtual const double * Errors() const {	virtual const double * Errors() const {
	return 0;	return 0;
	}	}

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int , unsigned int ) const { return 0; }	virtual double CovMatrix(unsigned int , unsigned int ) const { return 0; }


	/// minos error for variable i, return false if Minos failed
	virtual bool GetMinosError(unsigned int , double & /* errLow */ , double
	& /* errUp */ ) { return false; }

	/// return reference to the objective function
	///virtual const ROOT::Math::IGenFunction & Function() const;

	// method of only GSL minimizer (not inherited from interface)	// method of only GSL minimizer (not inherited from interface)

	/// return pointer to used objective gradient function	/// return pointer to used objective gradient function
	const ROOT::Math::IMultiGradFunction * ObjFunction() const { return fObj Func; }	const ROOT::Math::IMultiGradFunction * ObjFunction() const { return fObj Func; }

	/// return transformation function (NULL if not having a transformation)	/// return transformation function (NULL if not having a transformation)
	const ROOT::Math::MinimTransformFunction * TransformFunction() const;	const ROOT::Math::MinimTransformFunction * TransformFunction() const;

	protected:	protected:


End of changes. 2 change blocks.
	8 lines changed or deleted	1 lines changed or added

	GSLNLSMinimizer.h	GSLNLSMinimizer.h

	// @(#)root/mathmore:$Id: GSLNLSMinimizer.h 29104 2009-06-19 13:41:05Z mone ta $	// @(#)root/mathmore:$Id: GSLNLSMinimizer.h 31604 2009-12-07 19:04:33Z mone ta $
	// Author: L. Moneta Wed Dec 20 17:16:32 2006	// Author: L. Moneta Wed Dec 20 17:16:32 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 233	skipping to change at line 233
	virtual unsigned int NDim() const { return fDim; }	virtual unsigned int NDim() const { return fDim; }

	/// number of free variables (real dimension of the problem)	/// number of free variables (real dimension of the problem)
	/// this is <= Function().NDim() which is the total	/// this is <= Function().NDim() which is the total
	virtual unsigned int NFree() const { return fNFree; }	virtual unsigned int NFree() const { return fNFree; }

	/// minimizer provides error and error matrix	/// minimizer provides error and error matrix
	virtual bool ProvidesError() const { return true; }	virtual bool ProvidesError() const { return true; }

	/// return errors at the minimum	/// return errors at the minimum

	virtual const double * Errors() const { return &fErrors.front(); }	virtual const double * Errors() const { return (fErrors.size() > 0) ? &f Errors.front() : 0; }
	// {	// {
	// static std::vector<double> err;	// static std::vector<double> err;
	// err.resize(fDim);	// err.resize(fDim);
	// return &err.front();	// return &err.front();
	// }	// }

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int , unsigned int ) const;	virtual double CovMatrix(unsigned int , unsigned int ) const;


	/// minos error for variable i, return false if Minos failed	/// return covariance matrix status
	virtual bool GetMinosError(unsigned int , double & /* errLow */ , double	virtual int CovMatrixStatus() const;
	& /* errUp */ ) { return false; }

	/// return reference to the objective function
	///virtual const ROOT::Math::IGenFunction & Function() const;

	protected:	protected:

	private:	private:

	unsigned int fDim; // dimension of the function to be minimized	unsigned int fDim; // dimension of the function to be minimized
	unsigned int fNFree; // dimension of the internal function to be mi nimized	unsigned int fNFree; // dimension of the internal function to be mi nimized
	unsigned int fSize; // number of fit points (residuals)	unsigned int fSize; // number of fit points (residuals)

	ROOT::Math::GSLMultiFit * fGSLMultiFit; // pointer to GSL multi f it solver	ROOT::Math::GSLMultiFit * fGSLMultiFit; // pointer to GSL multi f it solver

End of changes. 3 change blocks.
	8 lines changed or deleted	4 lines changed or added

	GSLRndmEngines.h	GSLRndmEngines.h

	// @(#)root/mathmore:$Id: GSLRndmEngines.h 21553 2007-12-21 10:55:46Z monet a $	// @(#)root/mathmore:$Id: GSLRndmEngines.h 31763 2009-12-10 10:40:21Z monet a $
	// Author: L. Moneta, A. Zsenei 08/2005	// Author: L. Moneta, A. Zsenei 08/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 98	skipping to change at line 98
	If no rng is present the default one based on Mersenne and Twister is created	If no rng is present the default one based on Mersenne and Twister is created
	*/	*/
	void Initialize();	void Initialize();

	/**	/**
	delete pointer to contained rng	delete pointer to contained rng
	*/	*/
	void Terminate();	void Terminate();

	/**	/**

	no operation, rng is delete in Terminate()	call Terminate()
	*/	*/

	virtual ~GSLRandomEngine() {}	virtual ~GSLRandomEngine();

	/**	/**
	Generate a random number between ]0,1]	Generate a random number between ]0,1]
	0 is excluded and 1 is included	0 is excluded and 1 is included
	*/	*/
	double operator() () const;	double operator() () const;

	/**	/**
	Generate an integer number between [0,max-1] (including 0 and max -1)	Generate an integer number between [0,max-1] (including 0 and max -1)
	if max is larger than available range of algorithm	if max is larger than available range of algorithm

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	GSLSimAnMinimizer.h	GSLSimAnMinimizer.h

	// @(#)root/mathmore:$Id: GSLSimAnMinimizer.h 29068 2009-06-17 16:28:51Z mo neta $	// @(#)root/mathmore:$Id: GSLSimAnMinimizer.h 31604 2009-12-07 19:04:33Z mo neta $
	// Author: L. Moneta Wed Dec 20 17:16:32 2006	// Author: L. Moneta Wed Dec 20 17:16:32 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *
	* as published by the Free Software Foundation; either version 2 *	* as published by the Free Software Foundation; either version 2 *
	* of the License, or (at your option) any later version. *	* of the License, or (at your option) any later version. *

	skipping to change at line 164	skipping to change at line 164

	/// return errors at the minimum	/// return errors at the minimum
	virtual const double * Errors() const { return 0; }	virtual const double * Errors() const { return 0; }

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int , unsigned int ) const { return 0; }	virtual double CovMatrix(unsigned int , unsigned int ) const { return 0; }


	/// minos error for variable i, return false if Minos failed
	virtual bool GetMinosError(unsigned int , double & /* errLow */ , double
	& /* errUp */ ) { return false; }

	/// return reference to the objective function	/// return reference to the objective function
	///virtual const ROOT::Math::IGenFunction & Function() const;	///virtual const ROOT::Math::IGenFunction & Function() const;

	protected:	protected:

	private:	private:

	unsigned int fDim; // dimension of the function to be minimized	unsigned int fDim; // dimension of the function to be minimized
	bool fOwnFunc; // flag to indicate if objective function is manag ed	bool fOwnFunc; // flag to indicate if objective function is manag ed


End of changes. 2 change blocks.
	5 lines changed or deleted	1 lines changed or added

	HFitInterface.h	HFitInterface.h

	// @(#)root/hist:$Id: HFitInterface.h 31207 2009-11-16 16:52:00Z moneta $	// @(#)root/hist:$Id: HFitInterface.h 31491 2009-12-01 18:11:55Z moneta $
	// Author: L. Moneta Thu Aug 31 10:40:20 2006	// Author: L. Moneta Thu Aug 31 10:40:20 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class HFitInterface	// Header file for class HFitInterface

	skipping to change at line 87	skipping to change at line 87
	TFitResultPtr FitObject(THnSparse * s1, TF1 f1, Foption_t & option, const ROOT::Math::MinimizerOptions & moption, const char goption, ROOT::Fi t::DataRange & range);	TFitResultPtr FitObject(THnSparse * s1, TF1 f1, Foption_t & option, const ROOT::Math::MinimizerOptions & moption, const char goption, ROOT::Fi t::DataRange & range);
	#endif	#endif

	/**	/**
	fit an unbin data set (from tree or from histogram buffer)	fit an unbin data set (from tree or from histogram buffer)
	using a TF1 pointer and fit options.	using a TF1 pointer and fit options.
	N.B. ownership of fit data is passed to the UnBinFit function whi ch will be responsible of	N.B. ownership of fit data is passed to the UnBinFit function whi ch will be responsible of
	deleting the data after the fit. User calling this function MUST NOT delete UnBinData after	deleting the data after the fit. User calling this function MUST NOT delete UnBinData after
	calling it.	calling it.
	*/	*/

	int UnBinFit(ROOT::Fit::UnBinData * data, TF1 * f1 , Foption_t & opti on , const ROOT::Math::MinimizerOptions & moption);	TFitResultPtr UnBinFit(ROOT::Fit::UnBinData * data, TF1 * f1 , Foptio n_t & option , const ROOT::Math::MinimizerOptions & moption);

	/**	/**
	fill the data vector from a TH1. Pass also the TF1 function which is	fill the data vector from a TH1. Pass also the TF1 function which is
	needed in case of integral option and to reject points rejected b y the function	needed in case of integral option and to reject points rejected b y the function
	*/	*/
	void FillData ( BinData & dv, const TH1 * hist, TF1 * func = 0);	void FillData ( BinData & dv, const TH1 * hist, TF1 * func = 0);

	/**	/**
	fill the data vector from a TH1 with sparse data. Pass also the T F1 function which is	fill the data vector from a TH1 with sparse data. Pass also the T F1 function which is
	needed in case of integral option and to reject points rejected b y the function	needed in case of integral option and to reject points rejected b y the function

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	MessageTypes.h	MessageTypes.h

	/* @(#)root/base:$Id: MessageTypes.h 28362 2009-04-27 14:20:39Z rdm $ */	/* @(#)root/base:$Id: MessageTypes.h 31489 2009-12-01 17:37:16Z rdm $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_MessageTypes	#ifndef ROOT_MessageTypes

	skipping to change at line 95	skipping to change at line 95
	kPROOF_LIB_INC_PATH = 1045, //a list of lib/inc paths follows	kPROOF_LIB_INC_PATH = 1045, //a list of lib/inc paths follows
	kPROOF_WORKERLISTS = 1046, //an action on any of the worker l ist follows	kPROOF_WORKERLISTS = 1046, //an action on any of the worker l ist follows
	kPROOF_DATASET_STATUS = 1047, //status of data set preparation b efore processing	kPROOF_DATASET_STATUS = 1047, //status of data set preparation b efore processing
	kPROOF_OUTPUTOBJECT = 1048, //output object follows	kPROOF_OUTPUTOBJECT = 1048, //output object follows
	kPROOF_SETENV = 1049, //buffer with env vars to set	kPROOF_SETENV = 1049, //buffer with env vars to set
	kPROOF_REALTIMELOG = 1050, //switch on/off real-time retrieva l of log messages	kPROOF_REALTIMELOG = 1050, //switch on/off real-time retrieva l of log messages
	kPROOF_VERSARCHCOMP = 1051, //String with worker version/archi tecture/compiler follows	kPROOF_VERSARCHCOMP = 1051, //String with worker version/archi tecture/compiler follows
	kPROOF_ENDINIT = 1052, //signals end of initialization on worker	kPROOF_ENDINIT = 1052, //signals end of initialization on worker
	kPROOF_TOUCH = 1053, //touch the client admin file	kPROOF_TOUCH = 1053, //touch the client admin file
	kPROOF_FORK = 1054, //ask the worker to clone itself	kPROOF_FORK = 1054, //ask the worker to clone itself

	kPROOF_GOASYNC = 1055, //Switch to asynchronous mode	kPROOF_GOASYNC = 1055, //switch to asynchronous mode
		kPROOF_SUBMERGER = 1056, //sub-merger based approach in fin
		alization

	//---- ROOTD message opcodes (2000 - 2099)	//---- ROOTD message opcodes (2000 - 2099)
	kROOTD_USER = 2000, //user id follows	kROOTD_USER = 2000, //user id follows
	kROOTD_PASS = 2001, //passwd follows	kROOTD_PASS = 2001, //passwd follows
	kROOTD_AUTH = 2002, //authorization status (to client)	kROOTD_AUTH = 2002, //authorization status (to client)
	kROOTD_FSTAT = 2003, //filename follows	kROOTD_FSTAT = 2003, //filename follows
	kROOTD_OPEN = 2004, //filename follows + mode	kROOTD_OPEN = 2004, //filename follows + mode
	kROOTD_PUT = 2005, //offset, number of bytes and buff er	kROOTD_PUT = 2005, //offset, number of bytes and buff er
	kROOTD_GET = 2006, //offset, number of bytes	kROOTD_GET = 2006, //offset, number of bytes
	kROOTD_FLUSH = 2007, //flush file	kROOTD_FLUSH = 2007, //flush file

End of changes. 2 change blocks.

	HybridCalculator.h	HybridCalculator.h

	// @(#)root/roostats:$Id: HybridCalculator.h 31285 2009-11-18 16:38:36Z mon eta $	// @(#)root/roostats:$Id: HybridCalculator.h 31741 2009-12-09 17:27:53Z mon eta $

	/*************************************************************************	/*************************************************************************
	* Project: RooStats *	* Project: RooStats *
	* Package: RooFit/RooStats *	* Package: RooFit/RooStats *
	* Authors: *	* Authors: *
	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *	* Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke *
	*************************************************************************	*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *

	skipping to change at line 142	skipping to change at line 142

	private:	private:

	void RunToys(std::vector<double>& bVals, std::vector<double>& sbVals, unsigned int nToys, bool usePriors) const;	void RunToys(std::vector<double>& bVals, std::vector<double>& sbVals, unsigned int nToys, bool usePriors) const;

	// check input parameters before performing the calculation	// check input parameters before performing the calculation
	bool DoCheckInputs() const;	bool DoCheckInputs() const;

	unsigned int fTestStatisticsIdx; // Index of the test statistics to u se	unsigned int fTestStatisticsIdx; // Index of the test statistics to u se
	unsigned int fNToys; // number of Toys MC	unsigned int fNToys; // number of Toys MC

	bool fUsePriorPdf; // use a prior for nuisance paramet ers
	RooAbsPdf* fSbModel; // The pdf of the signal+background model	RooAbsPdf* fSbModel; // The pdf of the signal+background model
	RooAbsPdf* fBModel; // The pdf of the background model	RooAbsPdf* fBModel; // The pdf of the background model
	mutable RooArgList* fObservables; // Collection of the observables of the model	mutable RooArgList* fObservables; // Collection of the observables of the model
	const RooArgSet* fNuisanceParameters; // Collection of the nuisance parameters in the model	const RooArgSet* fNuisanceParameters; // Collection of the nuisance parameters in the model
	RooAbsPdf* fPriorPdf; // Prior PDF of the nuisance parameters	RooAbsPdf* fPriorPdf; // Prior PDF of the nuisance parameters
	RooAbsData * fData; // pointer to the data sets	RooAbsData * fData; // pointer to the data sets
	bool fGenerateBinned; //Flag to control binned generation	bool fGenerateBinned; //Flag to control binned generation

		bool fUsePriorPdf; // use a prior for nuisance paramet ers

	// TString fSbModelName; // name of pdf of the signal+background mo del	// TString fSbModelName; // name of pdf of the signal+background mo del
	// TString fBModelName; // name of pdf of the background model	// TString fBModelName; // name of pdf of the background model
	// TString fPriorPdfName; // name of pdf of the background model	// TString fPriorPdfName; // name of pdf of the background model
	// TString fDataName; // name of the dataset in the workspace	// TString fDataName; // name of the dataset in the workspace

	protected:	protected:
	ClassDef(HybridCalculator,1) // Hypothesis test calculator using a B ayesian-frequentist hybrid method	ClassDef(HybridCalculator,1) // Hypothesis test calculator using a B ayesian-frequentist hybrid method
	};	};
	}	}

End of changes. 3 change blocks.
	2 lines changed or deleted	2 lines changed or added

	MethodBoost.h	MethodBoost.h

	// @(#)root/tmva $Id: MethodBoost.h 29122 2009-06-22 06:51:30Z brun $	// @(#)root/tmva $Id: MethodBoost.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCompositeBase *	* Class : MethodCompositeBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Virtual base class for all MVA method *	* Virtual base class for all MVA method *

	skipping to change at line 127	skipping to change at line 127
	//training a single classifier	//training a single classifier
	void SingleTrain();	void SingleTrain();

	//calculating a boosting weight from the classifier, storing it in th e next one	//calculating a boosting weight from the classifier, storing it in th e next one
	void SingleBoost();	void SingleBoost();

	//writing the monitoring histograms and tree to a file	//writing the monitoring histograms and tree to a file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	// write evaluation histograms into target file	// write evaluation histograms into target file

	virtual void WriteEvaluationHistosToFile();	virtual void WriteEvaluationHistosToFile(Types::ETreeType treetype);

	// performs the MethodBase testing + testing of each boosted classifi er	// performs the MethodBase testing + testing of each boosted classifi er
	virtual void TestClassification();	virtual void TestClassification();

	//finding the MVA to cut between sig and bgd according to fMVACutPerc ,fMVACutType	//finding the MVA to cut between sig and bgd according to fMVACutPerc ,fMVACutType
	void FindMVACut();	void FindMVACut();

	//setting all the boost weights to 1	//setting all the boost weights to 1
	void ResetBoostWeights();	void ResetBoostWeights();


End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	MethodCuts.h	MethodCuts.h

	// @(#)root/tmva $Id: MethodCuts.h 29246 2009-06-26 16:50:00Z brun $	// @(#)root/tmva $Id: MethodCuts.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Matt Jachowski, Peter Speckmayer, Helge Voss, K ai Voss	// Author: Andreas Hoecker, Matt Jachowski, Peter Speckmayer, Helge Voss, K ai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : MethodCuts *	* Class : MethodCuts *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Multivariate optimisation of signal efficiency for given background *	* Multivariate optimisation of signal efficiency for given background *

	skipping to change at line 99	skipping to change at line 99
	// this is a workaround which is necessary since CINT is not capable of handling dynamic casts	// this is a workaround which is necessary since CINT is not capable of handling dynamic casts
	static MethodCuts* DynamicCast( IMethod* method ) { return dynamic_ca st<MethodCuts*>(method); }	static MethodCuts* DynamicCast( IMethod* method ) { return dynamic_ca st<MethodCuts*>(method); }

	virtual ~MethodCuts( void );	virtual ~MethodCuts( void );

	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );	virtual Bool_t HasAnalysisType( Types::EAnalysisType type, UInt_t num berClasses, UInt_t numberTargets );

	// training method	// training method
	void Train( void );	void Train( void );


	using MethodBase::WriteWeightsToStream;
	using MethodBase::ReadWeightsFromStream;	using MethodBase::ReadWeightsFromStream;


	void WriteWeightsToStream ( std::ostream & o ) const;
	void AddWeightsXMLTo ( void* parent ) const;	void AddWeightsXMLTo ( void* parent ) const;

	void ReadWeightsFromStream( std::istream & i );	void ReadWeightsFromStream( std::istream & i );
	void ReadWeightsFromXML ( void* wghtnode );	void ReadWeightsFromXML ( void* wghtnode );

	// calculate the MVA value (for CUTs this is just a dummy)	// calculate the MVA value (for CUTs this is just a dummy)
	Double_t GetMvaValue( Double_t* err = 0 );	Double_t GetMvaValue( Double_t* err = 0 );

	// write method specific histos to target file	// write method specific histos to target file
	void WriteMonitoringHistosToFile( void ) const;	void WriteMonitoringHistosToFile( void ) const;

	skipping to change at line 182	skipping to change at line 180
	// - kUseEventSelection: computes efficiencies from given data sample	// - kUseEventSelection: computes efficiencies from given data sample
	// - kUsePDFs : creates smoothed PDFs from data samples, and	// - kUsePDFs : creates smoothed PDFs from data samples, and
	// uses this to compute efficiencies	// uses this to compute efficiencies
	enum EEffMethod { kUseEventSelection = 0,	enum EEffMethod { kUseEventSelection = 0,
	kUsePDFs };	kUsePDFs };

	// improve the Monte Carlo by providing some additional information	// improve the Monte Carlo by providing some additional information
	enum EFitParameters { kNotEnforced = 0,	enum EFitParameters { kNotEnforced = 0,
	kForceMin,	kForceMin,
	kForceMax,	kForceMax,

	kForceSmart,	kForceSmart };
	kForceVerySmart };

	// general	// general
	TString fFitMethodS; // chosen fit method (st ring)	TString fFitMethodS; // chosen fit method (st ring)
	EFitMethodType fFitMethod; // chosen fit method	EFitMethodType fFitMethod; // chosen fit method
	TString fEffMethodS; // chosen efficiency cal culation method (string)	TString fEffMethodS; // chosen efficiency cal culation method (string)
	EEffMethod fEffMethod; // chosen efficiency cal culation method	EEffMethod fEffMethod; // chosen efficiency cal culation method
	std::vector<EFitParameters>* fFitParams; // vector for series of fit methods	std::vector<EFitParameters>* fFitParams; // vector for series of fit methods
	Double_t fTestSignalEff; // used to test optimize d signal efficiency	Double_t fTestSignalEff; // used to test optimize d signal efficiency
	Double_t fEffSMin; // used to test optimize d signal efficiency	Double_t fEffSMin; // used to test optimize d signal efficiency
	Double_t fEffSMax; // used to test optimize d signal efficiency	Double_t fEffSMax; // used to test optimize d signal efficiency

End of changes. 4 change blocks.
	5 lines changed or deleted	2 lines changed or added

	MinimTransformFunction.h	MinimTransformFunction.h

	// @(#)root/mathmore:$Id: MinimTransformFunction.h 29104 2009-06-19 13:41:0 5Z moneta $	// @(#)root/mathmore:$Id: MinimTransformFunction.h 31763 2009-12-10 10:40:2 1Z moneta $
	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class MinimTransformFunction	// Header file for class MinimTransformFunction

	#ifndef ROOT_Math_MinimTransformFunction	#ifndef ROOT_Math_MinimTransformFunction

	skipping to change at line 119	skipping to change at line 119
	MinimTransformFunction & operator= ( const MinimTransformFunction & ) {	MinimTransformFunction & operator= ( const MinimTransformFunction & ) {
	return *this;	return *this;
	}	}

	private:	private:

	mutable std::vector<double> fX; // internal cached of exte rnal values	mutable std::vector<double> fX; // internal cached of exte rnal values
	std::vector<MinimizerVariable> fVariables; // vector of variable sett ings and tranformation function	std::vector<MinimizerVariable> fVariables; // vector of variable sett ings and tranformation function
	std::vector<unsigned int> fIndex; // vector with external in dices for internal variables	std::vector<unsigned int> fIndex; // vector with external in dices for internal variables
	const IMultiGradFunction * fFunc; // user function	const IMultiGradFunction * fFunc; // user function

	bool fHasTransform; // a function transformation is applied

	};	};

	} // end namespace Math	} // end namespace Math

	} // end namespace ROOT	} // end namespace ROOT

	#endif /* ROOT_Math_MinimTransformFunction */	#endif /* ROOT_Math_MinimTransformFunction */

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	Minimizer.h	Minimizer.h

	// @(#)root/mathcore:$Id: Minimizer.h 31180 2009-11-16 10:54:05Z moneta $	// @(#)root/mathcore:$Id: Minimizer.h 31604 2009-12-07 19:04:33Z moneta $
	// Author: L. Moneta Fri Sep 22 15:06:47 2006	// Author: L. Moneta Fri Sep 22 15:06:47 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class Minimizer	// Header file for class Minimizer

	skipping to change at line 235	skipping to change at line 235
	virtual const double * Errors() const = 0;	virtual const double * Errors() const = 0;

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int i, unsigned int j) const = 0;	virtual double CovMatrix(unsigned int i, unsigned int j) const = 0;

	///return status of covariance matrix	///return status of covariance matrix
	/// using Minuit convention {0 not calculated 1 approximated 2 made pos def , 3 accurate}	/// using Minuit convention {0 not calculated 1 approximated 2 made pos def , 3 accurate}

	virtual int CovMatrixStatus() const { return ( (fValidError) ? 3 : 1);	/// Minimizer who implements covariance matrix calculation will re-imple
	}	ment the method
		virtual int CovMatrixStatus() const { return 0; }

	/**	/**
	return correlation coefficient between variable i and j.	return correlation coefficient between variable i and j.
	If the variable is fixed or const the return value is zero	If the variable is fixed or const the return value is zero
	*/	*/
	virtual double Correlation(unsigned int i, unsigned int j ) const {	virtual double Correlation(unsigned int i, unsigned int j ) const {
	double tmp = CovMatrix(i,i) * CovMatrix(j,j);	double tmp = CovMatrix(i,i) * CovMatrix(j,j);
	return ( tmp < 0) ? 0 : CovMatrix(i,j) / std::sqrt( tmp );	return ( tmp < 0) ? 0 : CovMatrix(i,j) / std::sqrt( tmp );
	}	}


	skipping to change at line 257	skipping to change at line 258
	return global correlation coefficient for variable i	return global correlation coefficient for variable i
	This is a number between zero and one which gives	This is a number between zero and one which gives
	the correlation between the i-th parameter and that linear combinati on of all	the correlation between the i-th parameter and that linear combinati on of all
	other parameters which is most strongly correlated with i.	other parameters which is most strongly correlated with i.
	Minimizer must overload method if implemented	Minimizer must overload method if implemented
	*/	*/
	virtual double GlobalCC(unsigned int ) const { return -1; }	virtual double GlobalCC(unsigned int ) const { return -1; }

	/**	/**
	minos error for variable i, return false if Minos failed or not suppo rted	minos error for variable i, return false if Minos failed or not suppo rted

		and the lower and upper errors are returned in errLow and errUp
		An extra flag specifies if only the lower (runopt=-1) or the upper (
		runopt=+1) error calculation is run
		(This feature isnot yet implemented)
	*/	*/

	virtual bool GetMinosError(unsigned int /* i */, double & errLow, double & errUp) {	virtual bool GetMinosError(unsigned int /* i */, double & errLow, double & errUp, int = 0) {
	errLow = 0; errUp = 0;	errLow = 0; errUp = 0;
	return false;	return false;
	}	}

	/**	/**
	perform a full calculation of the Hessian matrix for error calculatio n	perform a full calculation of the Hessian matrix for error calculatio n
	*/	*/
	virtual bool Hesse() { return false; }	virtual bool Hesse() { return false; }

	/**	/**

End of changes. 4 change blocks.
	4 lines changed or deleted	9 lines changed or added

	Minuit2Minimizer.h	Minuit2Minimizer.h

	skipping to change at line 214	skipping to change at line 214
	A minimizaiton must be performed befre, return false if no minimizati on has been done	A minimizaiton must be performed befre, return false if no minimizati on has been done
	In case of Minos failed the status error is updated as following	In case of Minos failed the status error is updated as following
	status += 10 * minosStatus where the minos status is:	status += 10 * minosStatus where the minos status is:
	status = 1 : maximum number of function calls exceeded when runni ng for lower error	status = 1 : maximum number of function calls exceeded when runni ng for lower error
	status = 2 : maximum number of function calls exceeded when runni ng for upper error	status = 2 : maximum number of function calls exceeded when runni ng for upper error
	status = 3 : new minimum found when running for lower error	status = 3 : new minimum found when running for lower error
	status = 4 : new minimum found when running for upper error	status = 4 : new minimum found when running for upper error
	status = 5 : any other failure	status = 5 : any other failure

	*/	*/

	virtual bool GetMinosError(unsigned int i, double & errLow, double & err Up);	virtual bool GetMinosError(unsigned int i, double & errLow, double & err Up, int = 0);

	/**	/**
	scan a parameter i around the minimum. A minimization must have been done before,	scan a parameter i around the minimum. A minimization must have been done before,
	return false if it is not the case	return false if it is not the case
	*/	*/
	virtual bool Scan(unsigned int i, unsigned int & nstep, double * x, doub le * y, double xmin = 0, double xmax = 0);	virtual bool Scan(unsigned int i, unsigned int & nstep, double * x, doub le * y, double xmin = 0, double xmax = 0);

	/**	/**
	find the contour points (xi,xj) of the function for parameter i and j around the minimum	find the contour points (xi,xj) of the function for parameter i and j around the minimum
	The contour will be find for value of the function = Min + ErrorUp();	The contour will be find for value of the function = Min + ErrorUp();

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	RooDataSet.h	RooDataSet.h

	skipping to change at line 75	skipping to change at line 75
	const RooCmdArg& arg5=RooCmdArg::none(), const R ooCmdArg& arg6=RooCmdArg::none(),	const RooCmdArg& arg5=RooCmdArg::none(), const R ooCmdArg& arg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(), const R ooCmdArg& arg8=RooCmdArg::none()) const ;	const RooCmdArg& arg7=RooCmdArg::none(), const R ooCmdArg& arg8=RooCmdArg::none()) const ;

	// Read data from a text file and create a dataset from it.	// Read data from a text file and create a dataset from it.
	// The possible options are: (D)ebug, (Q)uiet.	// The possible options are: (D)ebug, (Q)uiet.
	static RooDataSet read(const char filename, const RooArgList &variables ,	static RooDataSet read(const char filename, const RooArgList &variables ,
	const char opts= "", const char commonPath="",	const char opts= "", const char commonPath="",
	const char *indexCatName=0) ;	const char *indexCatName=0) ;
	Bool_t write(const char* filename) ;	Bool_t write(const char* filename) ;


	/* void setWeightVar(const char* name=0) ; */	void setWeightVar(const char* name=0) ;
	/* void setWeightVar(const RooAbsArg& arg) { */	void setWeightVar(const RooAbsArg& arg) {
	/* // Interpret given argument as event weight */	// Interpret given argument as event weight
	/* setWeightVar(arg.GetName()) ; */	setWeightVar(arg.GetName()) ;
	/* } */	}

	virtual Bool_t isWeighted() const ;	virtual Bool_t isWeighted() const ;
	virtual Bool_t isNonPoissonWeighted() const ;	virtual Bool_t isNonPoissonWeighted() const ;

	virtual Double_t weight() const ;	virtual Double_t weight() const ;
	virtual void weightError(Double_t& lo, Double_t& hi,ErrorType etype=SumW2 ) const ;	virtual void weightError(Double_t& lo, Double_t& hi,ErrorType etype=SumW2 ) const ;
	Double_t weightError(ErrorType etype=SumW2) const ;	Double_t weightError(ErrorType etype=SumW2) const ;

	virtual const RooArgSet* get(Int_t index) const;	virtual const RooArgSet* get(Int_t index) const;
	virtual const RooArgSet* get() const ;	virtual const RooArgSet* get() const ;


End of changes. 1 change blocks.
	5 lines changed or deleted	6 lines changed or added

	RooProfileLL.h	RooProfileLL.h

	skipping to change at line 37	skipping to change at line 37
	RooProfileLL(const RooProfileLL& other, const char* name=0) ;	RooProfileLL(const RooProfileLL& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooProfile LL(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooProfile LL(*this,newname); }
	virtual ~RooProfileLL() ;	virtual ~RooProfileLL() ;

	void setAlwaysStartFromMin(Bool_t flag) { _startFromMin = flag ; }	void setAlwaysStartFromMin(Bool_t flag) { _startFromMin = flag ; }
	Bool_t alwaysStartFromMin() const { return _startFromMin ; }	Bool_t alwaysStartFromMin() const { return _startFromMin ; }

	RooMinuit* minuit() { return _minuit ; }	RooMinuit* minuit() { return _minuit ; }
	RooAbsReal& nll() { return const_cast<RooAbsReal&>(_nll.arg()) ; }	RooAbsReal& nll() { return const_cast<RooAbsReal&>(_nll.arg()) ; }
	const RooArgSet& bestFitParams() const ;	const RooArgSet& bestFitParams() const ;

		const RooArgSet& bestFitObs() const ;

	virtual RooAbsReal* createProfile(const RooArgSet& paramsOfInterest) ;	virtual RooAbsReal* createProfile(const RooArgSet& paramsOfInterest) ;

	virtual Bool_t redirectServersHook(const RooAbsCollection& /newServerLis t/, Bool_t /mustReplaceAll/, Bool_t /nameChange/, Bool_t /isRecursive /) ;	virtual Bool_t redirectServersHook(const RooAbsCollection& /newServerLis t/, Bool_t /mustReplaceAll/, Bool_t /nameChange/, Bool_t /isRecursive /) ;

	void clearAbsMin() { _absMinValid = kFALSE ; }	void clearAbsMin() { _absMinValid = kFALSE ; }

	protected:	protected:

	void validateAbsMin() const ;	void validateAbsMin() const ;

	skipping to change at line 61	skipping to change at line 62
	Bool_t _startFromMin ; // Always start minimization for global minimum?	Bool_t _startFromMin ; // Always start minimization for global minimum?

	TIterator* _piter ; //! Iterator over profile likelihood parameters to be minimized	TIterator* _piter ; //! Iterator over profile likelihood parameters to be minimized
	TIterator* _oiter ; //! Iterator of profile likelihood output parameter(s )	TIterator* _oiter ; //! Iterator of profile likelihood output parameter(s )

	mutable RooMinuit* _minuit ; //! Internal minuit instance	mutable RooMinuit* _minuit ; //! Internal minuit instance

	mutable Bool_t _absMinValid ; // flag if absmin is up-to-date	mutable Bool_t _absMinValid ; // flag if absmin is up-to-date
	mutable Double_t _absMin ; // absolute minimum of -log(L)	mutable Double_t _absMin ; // absolute minimum of -log(L)
	mutable RooArgSet _paramAbsMin ; // Parameter values at absolute minimum	mutable RooArgSet _paramAbsMin ; // Parameter values at absolute minimum

		mutable RooArgSet _obsAbsMin ; // Observable values at absolute minimum
	mutable std::map<std::string,bool> _paramFixed ; // Parameter constant st atus at last time of use	mutable std::map<std::string,bool> _paramFixed ; // Parameter constant st atus at last time of use

	Double_t evaluate() const ;	Double_t evaluate() const ;

	private:	private:

	ClassDef(RooProfileLL,0) // Real-valued function representing profile lik elihood of external (likelihood) function	ClassDef(RooProfileLL,0) // Real-valued function representing profile lik elihood of external (likelihood) function
	};	};

	#endif	#endif

End of changes. 2 change blocks.
	0 lines changed or deleted	2 lines changed or added

	RuleEnsemble.h	RuleEnsemble.h

	// @(#)root/tmva $Id: RuleEnsemble.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: RuleEnsemble.h 31458 2009-11-30 13:58:20Z stelzer $
	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss	// Author: Andreas Hoecker, Joerg Stelzer, Fredrik Tegenfeldt, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : RuleEnsemble *	* Class : RuleEnsemble *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* A class generating an ensemble of rules *	* A class generating an ensemble of rules *

	skipping to change at line 555	skipping to change at line 555
	rval += EvalLinEvent( evtidx, lincoefs );	rval += EvalLinEvent( evtidx, lincoefs );
	}	}
	return rval;	return rval;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________
	inline Double_t TMVA::RuleEnsemble::EvalLinEventRaw( UInt_t vind, const TMV A::Event & e, Bool_t norm) const	inline Double_t TMVA::RuleEnsemble::EvalLinEventRaw( UInt_t vind, const TMV A::Event & e, Bool_t norm) const
	{	{
	// evaluate the event linearly (not normalized)	// evaluate the event linearly (not normalized)


	Double_t val = e.GetVal(vind);	Double_t val = e.GetValue(vind);
	Double_t rval = TMath::Min( fLinDP[vind], TMath::Max( fLinDM[vind], val ) );	Double_t rval = TMath::Min( fLinDP[vind], TMath::Max( fLinDM[vind], val ) );
	if (norm) rval *= fLinNorm[vind];	if (norm) rval *= fLinNorm[vind];
	return rval;	return rval;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________
	inline Double_t TMVA::RuleEnsemble::EvalLinEventRaw( UInt_t vind, UInt_t ev tidx, Bool_t norm) const	inline Double_t TMVA::RuleEnsemble::EvalLinEventRaw( UInt_t vind, UInt_t ev tidx, Bool_t norm) const
	{	{
	// evaluate the event linearly (not normalized)	// evaluate the event linearly (not normalized)


	Double_t val = (*fRuleMapEvents)[evtidx]->GetVal(vind);	Double_t val = (*fRuleMapEvents)[evtidx]->GetValue(vind);
	Double_t rval = TMath::Min( fLinDP[vind], TMath::Max( fLinDM[vind], val ) );	Double_t rval = TMath::Min( fLinDP[vind], TMath::Max( fLinDM[vind], val ) );
	if (norm) rval *= fLinNorm[vind];	if (norm) rval *= fLinNorm[vind];
	return rval;	return rval;
	}	}

	//_______________________________________________________________________	//_______________________________________________________________________
	inline Double_t TMVA::RuleEnsemble::EvalLinEvent() const	inline Double_t TMVA::RuleEnsemble::EvalLinEvent() const
	{	{
	// evaluate event linearly	// evaluate event linearly


End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	SimulatedAnnealing.h	SimulatedAnnealing.h

	// @(#)root/tmva $Id: SimulatedAnnealing.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/tmva $Id: SimulatedAnnealing.h 31574 2009-12-05 18:23:21Z stelz er $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Krzysztof Danielowsk i, Kamil Kraszewski, Maciej Kruk	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Krzysztof Danielowsk i, Kamil Kraszewski, Maciej Kruk

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : SimulatedAnnealing *	* Class : SimulatedAnnealing *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Implementation of simulated annealing fitting procedure *	* Implementation of simulated annealing fitting procedure *

	skipping to change at line 58	skipping to change at line 58
	namespace TMVA {	namespace TMVA {

	class IFitterTarget;	class IFitterTarget;
	class Interval;	class Interval;
	class MsgLogger;	class MsgLogger;

	class SimulatedAnnealing {	class SimulatedAnnealing {

	public:	public:


	SimulatedAnnealing( IFitterTarget& target, const std::vector<Interval *>& ranges );	SimulatedAnnealing( IFitterTarget& target, const std::vector<TMVA::In terval*>& ranges );
	virtual ~SimulatedAnnealing();	virtual ~SimulatedAnnealing();

	// returns FCN value at minimum	// returns FCN value at minimum
	Double_t Minimize( std::vector<Double_t>& parameters );	Double_t Minimize( std::vector<Double_t>& parameters );

	// accessors	// accessors
	void SetMaxCalls ( Int_t mc ) { fMaxCalls = mc; }	void SetMaxCalls ( Int_t mc ) { fMaxCalls = mc; }
	void SetInitTemp ( Double_t it ) { fInitialTemperature = it; }	void SetInitTemp ( Double_t it ) { fInitialTemperature = it; }
	void SetMinTemp ( Double_t min ) { fMinTemperature = min; }	void SetMinTemp ( Double_t min ) { fMinTemperature = min; }
	void SetAccuracy ( Double_t eps ) { fEps = eps; }	void SetAccuracy ( Double_t eps ) { fEps = eps; }

	skipping to change at line 99	skipping to change at line 99
	void ReWriteParameters( std::vector<Double_t>& from, std::vector<Doub le_t>& to );	void ReWriteParameters( std::vector<Double_t>& from, std::vector<Doub le_t>& to );
	void GenerateNewTemperature(Double_t& currentTemperature, Int_t Iter );	void GenerateNewTemperature(Double_t& currentTemperature, Int_t Iter );
	void GenerateNeighbour( std::vector<Double_t>& parameters, std::vecto r<Double_t>& oldParameters, Double_t currentTemperature );	void GenerateNeighbour( std::vector<Double_t>& parameters, std::vecto r<Double_t>& oldParameters, Double_t currentTemperature );
	Bool_t ShouldGoIn( Double_t currentFit, Double_t localFit, Double_t c urrentTemperature );	Bool_t ShouldGoIn( Double_t currentFit, Double_t localFit, Double_t c urrentTemperature );
	void SetDefaultScale();	void SetDefaultScale();
	Double_t GenerateMaxTemperature( std::vector<Double_t>& parameters );	Double_t GenerateMaxTemperature( std::vector<Double_t>& parameters );
	std::vector<Double_t> GenerateNeighbour( std::vector<Double_t>& param eters, Double_t currentTemperature );	std::vector<Double_t> GenerateNeighbour( std::vector<Double_t>& param eters, Double_t currentTemperature );

	IFitterTarget& fFitterTarget; // the fitter target	IFitterTarget& fFitterTarget; // the fitter target
	TRandom* fRandom; // random gene rator	TRandom* fRandom; // random gene rator

	const std::vector<Interval*>& fRanges; // parameter r anges	const std::vector<TMVA::Interval*>& fRanges; // param eter ranges

	// fitter setup	// fitter setup
	Int_t fMaxCalls; // maximum num ber of minimisation calls	Int_t fMaxCalls; // maximum num ber of minimisation calls
	Double_t fInitialTemperature; // initial tem perature	Double_t fInitialTemperature; // initial tem perature
	Double_t fMinTemperature; // mimimum tem perature	Double_t fMinTemperature; // mimimum tem perature
	Double_t fEps; // epsilon	Double_t fEps; // epsilon
	Double_t fTemperatureScale; // how fast te mperature change	Double_t fTemperatureScale; // how fast te mperature change
	Double_t fAdaptiveSpeed; // how fast te mperature change in adaptive (in adaptive two variables describe	Double_t fAdaptiveSpeed; // how fast te mperature change in adaptive (in adaptive two variables describe
	// the change of temperature, but fAdaptiveSpeed should be 1.0 and its not	// the change of temperature, but fAdaptiveSpeed should be 1.0 and its not
	// recomended to change it)	// recomended to change it)

End of changes. 3 change blocks.
	3 lines changed or deleted	3 lines changed or added

	TApplication.h	TApplication.h

	// @(#)root/base:$Id: TApplication.h 27160 2009-01-15 16:24:27Z pcanal $	// @(#)root/base:$Id: TApplication.h 31670 2009-12-08 15:22:08Z rdm $
	// Author: Fons Rademakers 22/12/95	// Author: Fons Rademakers 22/12/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 61	skipping to change at line 61

	private:	private:
	Int_t fArgc; //Number of com mand line argument s	Int_t fArgc; //Number of com mand line argument s
	char **fArgv; //Command line arguments	char **fArgv; //Command line arguments
	TApplicationImp *fAppImp; //!Window system specific applicatio n implementation	TApplicationImp *fAppImp; //!Window system specific applicatio n implementation
	Bool_t fIsRunning; //True when in event loop (Run() has been called)	Bool_t fIsRunning; //True when in event loop (Run() has been called)
	Bool_t fReturnFromRun; //When true return from Run()	Bool_t fReturnFromRun; //When true return from Run()
	Bool_t fNoLog; //Do not process logon and logoff ma cros	Bool_t fNoLog; //Do not process logon and logoff ma cros
	Bool_t fNoLogo; //Do not show splash screen and welc ome message	Bool_t fNoLogo; //Do not show splash screen and welc ome message
	Bool_t fQuit; //Exit after having processed input files	Bool_t fQuit; //Exit after having processed input files

	Bool_t fGraphInit; //True if graphics has been initiali zed
	TObjArray *fFiles; //Array of input files (TObjString's ) specified via argv	TObjArray *fFiles; //Array of input files (TObjString's ) specified via argv
	TString fWorkDir; //Working directory specified via ar gv	TString fWorkDir; //Working directory specified via ar gv
	TString fIdleCommand; //Command to execute while applicati on is idle	TString fIdleCommand; //Command to execute while applicati on is idle
	TTimer *fIdleTimer; //Idle timer	TTimer *fIdleTimer; //Idle timer
	TSignalHandler *fSigHandler; //Interrupt handler	TSignalHandler *fSigHandler; //Interrupt handler

	static Bool_t fgGraphNeeded; // True if graphics libs need to be initialized	static Bool_t fgGraphNeeded; // True if graphics libs need to be initialized
	static Bool_t fgGraphInit; // True if graphics libs initialized	static Bool_t fgGraphInit; // True if graphics libs initialized

	TApplication(const TApplication&); // not implemented	TApplication(const TApplication&); // not implemented

End of changes. 2 change blocks.
	2 lines changed or deleted	1 lines changed or added

	TClass.h	TClass.h

	// @(#)root/meta:$Id: TClass.h 29000 2009-06-15 13:53:52Z rdm $	// @(#)root/meta:$Id: TClass.h 31472 2009-11-30 17:59:33Z pcanal $
	// Author: Rene Brun 07/01/95	// Author: Rene Brun 07/01/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 290	skipping to change at line 290
	TVirtualStreamerInfo *GetStreamerInfo(Int_t version=0) const;	TVirtualStreamerInfo *GetStreamerInfo(Int_t version=0) const;
	const type_info *GetTypeInfo() const { return fTypeInfo; };	const type_info *GetTypeInfo() const { return fTypeInfo; };
	void IgnoreTObjectStreamer(Bool_t ignore=kTRUE);	void IgnoreTObjectStreamer(Bool_t ignore=kTRUE);
	Bool_t InheritsFrom(const char *cl) const;	Bool_t InheritsFrom(const char *cl) const;
	Bool_t InheritsFrom(const TClass *cl) const;	Bool_t InheritsFrom(const TClass *cl) const;
	Bool_t IsFolder() const { return kTRUE; }	Bool_t IsFolder() const { return kTRUE; }
	Bool_t IsLoaded() const;	Bool_t IsLoaded() const;
	Bool_t IsForeign() const;	Bool_t IsForeign() const;
	Bool_t IsStartingWithTObject() const;	Bool_t IsStartingWithTObject() const;
	Bool_t IsTObject() const;	Bool_t IsTObject() const;

		void ls(Option_t *opt="") const;
	void MakeCustomMenuList();	void MakeCustomMenuList();
	void Move(void arenaFrom, void arenaTo) const;	void Move(void arenaFrom, void arenaTo) const;
	void *New(ENewType defConstructor = kClassNew) const;	void *New(ENewType defConstructor = kClassNew) const;
	void New(void arena, ENewType defConstructor = kClassNew) const;	void New(void arena, ENewType defConstructor = kClassNew) const;
	void *NewArray(Long_t nElements, ENewType defConstructor = kClassNew) const;	void *NewArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
	void NewArray(Long_t nElements, void arena, ENewType defC onstructor = kClassNew) const;	void NewArray(Long_t nElements, void arena, ENewType defC onstructor = kClassNew) const;
	virtual void PostLoadCheck();	virtual void PostLoadCheck();
	Long_t Property() const;	Long_t Property() const;
	Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count);	Int_t ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count);
	Int_t ReadBuffer(TBuffer &b, void *pointer);	Int_t ReadBuffer(TBuffer &b, void *pointer);

End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	TFileCacheRead.h	TFileCacheRead.h

	// @(#)root/io:$Id: TFileCacheRead.h 31077 2009-11-11 08:51:57Z brun $	// @(#)root/io:$Id: TFileCacheRead.h 31503 2009-12-02 10:36:50Z brun $
	// Author: Rene Brun 19/05/2006	// Author: Rene Brun 19/05/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 67	skipping to change at line 67
	TFileCacheRead(const TFileCacheRead &); //cannot be copied	TFileCacheRead(const TFileCacheRead &); //cannot be copied
	TFileCacheRead& operator=(const TFileCacheRead &);	TFileCacheRead& operator=(const TFileCacheRead &);

	public:	public:
	TFileCacheRead();	TFileCacheRead();
	TFileCacheRead(TFile *file, Int_t buffersize);	TFileCacheRead(TFile *file, Int_t buffersize);
	virtual ~TFileCacheRead();	virtual ~TFileCacheRead();
	virtual void AddBranch(TBranch * /b/, Bool_t /subbranches/ = kFALSE) {}	virtual void AddBranch(TBranch * /b/, Bool_t /subbranches/ = kFALSE) {}
	virtual void AddBranch(const char * /branch/, Bool_t /subbranc hes/ = kFALSE) {}	virtual void AddBranch(const char * /branch/, Bool_t /subbranc hes/ = kFALSE) {}
	virtual Int_t GetBufferSize() const { return fBufferSize; };	virtual Int_t GetBufferSize() const { return fBufferSize; };

		virtual Int_t GetUnzipBuffer(char ** /buf/, Long64_t /pos/, In t_t /len/, Bool_t * /free/) { return -1; }
	virtual Bool_t IsAsyncReading() const { return fAsyncReading; };	virtual Bool_t IsAsyncReading() const { return fAsyncReading; };
	virtual Bool_t IsLearning() const {return kFALSE;}	virtual Bool_t IsLearning() const {return kFALSE;}
	virtual void Prefetch(Long64_t pos, Int_t len);	virtual void Prefetch(Long64_t pos, Int_t len);
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual Int_t ReadBufferExt(char *buf, Long64_t pos, Int_t len, In t_t &loc);	virtual Int_t ReadBufferExt(char *buf, Long64_t pos, Int_t len, In t_t &loc);
	virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len);	virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len);
	virtual void SetFile(TFile *file);	virtual void SetFile(TFile *file);
	virtual void SetSkipZip(Bool_t /skip/ = kTRUE) {} // This funct ion is only used by TTreeCacheUnzip (ignore it)	virtual void SetSkipZip(Bool_t /skip/ = kTRUE) {} // This funct ion is only used by TTreeCacheUnzip (ignore it)
	virtual void Sort();	virtual void Sort();


End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	TFumiliMinimizer.h	TFumiliMinimizer.h

	// @(#)root/fumili:$Id: TFumiliMinimizer.h 26866 2008-12-12 10:50:07Z monet a $	// @(#)root/fumili:$Id: TFumiliMinimizer.h 31604 2009-12-07 19:04:33Z monet a $
	// Author: L. Moneta Wed Oct 25 16:28:55 2006	// Author: L. Moneta Wed Oct 25 16:28:55 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class TFumiliMinimizer	// Header file for class TFumiliMinimizer

	skipping to change at line 137	skipping to change at line 137
	virtual const double * Errors() const { return &fErrors.front(); }	virtual const double * Errors() const { return &fErrors.front(); }

	/** return covariance matrices elements	/** return covariance matrices elements
	if the variable is fixed the matrix is zero	if the variable is fixed the matrix is zero
	The ordering of the variables is the same as in errors	The ordering of the variables is the same as in errors
	*/	*/
	virtual double CovMatrix(unsigned int i, unsigned int j) const {	virtual double CovMatrix(unsigned int i, unsigned int j) const {
	return fCovar[i + fDim* j];	return fCovar[i + fDim* j];
	}	}


		/*
		return covariance matrix status
		*/
		virtual int CovMatrixStatus() const {
		if (fCovar.size() == 0) return 0;
		return (fStatus ==0) ? 3 : 1;
		}

	protected:	protected:

	/// implementation of FCN for Fumili	/// implementation of FCN for Fumili
	static void Fcn( int &, double * , double & f, double * , int);	static void Fcn( int &, double * , double & f, double * , int);
	/// implementation of FCN for Fumili when user provided gradient is used	/// implementation of FCN for Fumili when user provided gradient is used
	//static void FcnGrad( int &, double * g, double & f, double * , int);	//static void FcnGrad( int &, double * g, double & f, double * , int);

	/// static function implementing the evaluation of the FCN (it uses stat ic instance fgFumili)	/// static function implementing the evaluation of the FCN (it uses stat ic instance fgFumili)
	static double EvaluateFCN(const double * x, double * g);	static double EvaluateFCN(const double * x, double * g);


End of changes. 2 change blocks.
	1 lines changed or deleted	9 lines changed or added

	TGLPerspectiveCamera.h	TGLPerspectiveCamera.h

	// @(#)root/gl:$Id: TGLPerspectiveCamera.h 28201 2009-04-14 16:04:20Z matev z $	// @(#)root/gl:$Id: TGLPerspectiveCamera.h 31821 2009-12-10 18:22:44Z matev z $
	// Author: Richard Maunder 25/05/2005	// Author: Richard Maunder 25/05/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 45	skipping to change at line 45

	static Double_t fgFOVMin, fgFOVDefault, fgFOVMax;	static Double_t fgFOVMin, fgFOVDefault, fgFOVMax;
	static UInt_t fgFOVDeltaSens;	static UInt_t fgFOVDeltaSens;

	public:	public:
	TGLPerspectiveCamera(const TGLVector3 & hAxis, const TGLVector3 & vAxis) ;	TGLPerspectiveCamera(const TGLVector3 & hAxis, const TGLVector3 & vAxis) ;
	virtual ~TGLPerspectiveCamera();	virtual ~TGLPerspectiveCamera();

	virtual Bool_t IsPerspective() const { return kTRUE; }	virtual Bool_t IsPerspective() const { return kTRUE; }


		Double_t GetFOV() const { return fFOV; }

	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);	virtual void Setup(const TGLBoundingBox & box, Bool_t reset=kTRUE);
	virtual void Reset();	virtual void Reset();
	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);	virtual Bool_t Zoom (Int_t delta, Bool_t mod1, Bool_t mod2);
	using TGLCamera::Truck;	using TGLCamera::Truck;
	virtual Bool_t Truck(Int_t xDelta, Int_t yDelta, Bool_t mod1, Bool_t mod 2);	virtual Bool_t Truck(Int_t xDelta, Int_t yDelta, Bool_t mod1, Bool_t mod 2);
	virtual void Apply(const TGLBoundingBox & box, const TGLRect * pickRec t = 0) const;	virtual void Apply(const TGLBoundingBox & box, const TGLRect * pickRec t = 0) const;

	// External scripting control	// External scripting control
	virtual void Configure(Double_t fov, Double_t dolly, Double_t center[3],	virtual void Configure(Double_t fov, Double_t dolly, Double_t center[3],
	Double_t hRotate, Double_t vRotate);	Double_t hRotate, Double_t vRotate);

End of changes. 2 change blocks.
	1 lines changed or deleted	3 lines changed or added

	TGeoPainter.h	TGeoPainter.h

	skipping to change at line 71	skipping to change at line 71
	TString fVolInfo; // volume info	TString fVolInfo; // volume info
	TGeoNode *fCheckedNode; // checked node	TGeoNode *fCheckedNode; // checked node
	TGeoOverlap *fOverlap; // current overlap	TGeoOverlap *fOverlap; // current overlap
	TGeoHMatrix *fGlobal; // current global matrix	TGeoHMatrix *fGlobal; // current global matrix
	TBuffer3D *fBuffer; // buffer used for painting	TBuffer3D *fBuffer; // buffer used for painting
	TGeoManager *fGeoManager; // geometry to which applies	TGeoManager *fGeoManager; // geometry to which applies
	TGeoChecker *fChecker; // geometry checker	TGeoChecker *fChecker; // geometry checker
	TGeoShape *fClippingShape; // clipping shape	TGeoShape *fClippingShape; // clipping shape
	TGeoVolume *fTopVolume; // top drawn volume	TGeoVolume *fTopVolume; // top drawn volume
	TGeoVolume *fLastVolume; // last drawn volume	TGeoVolume *fLastVolume; // last drawn volume

		TGeoIteratorPlugin
		*fPlugin; // User iterator plugin for changi
		ng pain volume properties
	TObjArray *fVisVolumes; // list of visible volumes	TObjArray *fVisVolumes; // list of visible volumes
	Bool_t fIsEditable; // flag that geometry is editable	Bool_t fIsEditable; // flag that geometry is editable

	void DefineColors() const;	void DefineColors() const;
	void LocalToMasterVect(const Double_t local, Double_t ma ster) const;	void LocalToMasterVect(const Double_t local, Double_t ma ster) const;

	protected:	protected:
	virtual void ClearVisibleVolumes();	virtual void ClearVisibleVolumes();

	public:	public:

	skipping to change at line 156	skipping to change at line 158
	virtual void RandomPoints(const TGeoVolume vol, Int_t npoints, Op tion_t option="");	virtual void RandomPoints(const TGeoVolume vol, Int_t npoints, Op tion_t option="");
	virtual void RandomRays(Int_t nrays, Double_t startx, Double_t sta rty, Double_t startz);	virtual void RandomRays(Int_t nrays, Double_t startx, Double_t sta rty, Double_t startz);
	virtual void Raytrace(Option_t *option="");	virtual void Raytrace(Option_t *option="");
	virtual TGeoNode SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char g3path);	virtual TGeoNode SamplePoints(Int_t npoints, Double_t &dist, Double_t epsil, const char g3path);
	virtual void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3 , Double_t bombz=1.3, Double_t bombr=1.3);	virtual void SetBombFactors(Double_t bombx=1.3, Double_t bomby=1.3 , Double_t bombz=1.3, Double_t bombr=1.3);
	virtual void SetClippingShape(TGeoShape *shape) {fClippingShape = shape;}	virtual void SetClippingShape(TGeoShape *shape) {fClippingShape = shape;}
	virtual void SetExplodedView(Int_t iopt=0);	virtual void SetExplodedView(Int_t iopt=0);
	virtual void SetNsegments(Int_t nseg=20);	virtual void SetNsegments(Int_t nseg=20);
	virtual void SetNmeshPoints(Int_t npoints);	virtual void SetNmeshPoints(Int_t npoints);
	virtual void SetGeoManager(TGeoManager *geom) {fGeoManager=geom;}	virtual void SetGeoManager(TGeoManager *geom) {fGeoManager=geom;}

		virtual void SetIteratorPlugin(TGeoIteratorPlugin *plugin) {fPlugi n = plugin; ModifiedPad();}
	virtual void SetCheckedNode(TGeoNode *node);	virtual void SetCheckedNode(TGeoNode *node);
	virtual void SetRaytracing(Bool_t flag=kTRUE) {fIsRaytracing = fla g;}	virtual void SetRaytracing(Bool_t flag=kTRUE) {fIsRaytracing = fla g;}
	virtual void SetTopVisible(Bool_t vis=kTRUE);	virtual void SetTopVisible(Bool_t vis=kTRUE);
	virtual void SetTopVolume(TGeoVolume *vol) {fTopVolume = vol;}	virtual void SetTopVolume(TGeoVolume *vol) {fTopVolume = vol;}
	virtual void SetVisLevel(Int_t level=3);	virtual void SetVisLevel(Int_t level=3);
	virtual void SetVisOption(Int_t option=0);	virtual void SetVisOption(Int_t option=0);
	virtual Int_t ShapeDistancetoPrimitive(const TGeoShape *shape, Int_ t numpoints, Int_t px, Int_t py) const;	virtual Int_t ShapeDistancetoPrimitive(const TGeoShape *shape, Int_ t numpoints, Int_t px, Int_t py) const;
	virtual void Test(Int_t npoints, Option_t *option);	virtual void Test(Int_t npoints, Option_t *option);
	virtual void TestOverlaps(const char *path);	virtual void TestOverlaps(const char *path);
	virtual Bool_t TestVoxels(TGeoVolume *vol);	virtual Bool_t TestVoxels(TGeoVolume *vol);

End of changes. 2 change blocks.
	0 lines changed or deleted	4 lines changed or added

	TGraph.h	TGraph.h

	// @(#)root/hist:$Id: TGraph.h 31207 2009-11-16 16:52:00Z moneta $	// @(#)root/hist:$Id: TGraph.h 31491 2009-12-01 18:11:55Z moneta $
	// Author: Rene Brun, Olivier Couet 12/12/94	// Author: Rene Brun, Olivier Couet 12/12/94

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 50	skipping to change at line 50
	#endif	#endif

	class TBrowser;	class TBrowser;
	class TAxis;	class TAxis;
	class TH1;	class TH1;
	class TH1F;	class TH1F;
	class TCollection;	class TCollection;
	class TF1;	class TF1;
	class TSpline;	class TSpline;


		#include "TFitResultPtr.h"

	class TGraph : public TNamed, public TAttLine, public TAttFill, public TAtt Marker {	class TGraph : public TNamed, public TAttLine, public TAttFill, public TAtt Marker {

	protected:	protected:

	Int_t fMaxSize; //!Current dimension of arrays fX and fY	Int_t fMaxSize; //!Current dimension of arrays fX and fY
	Int_t fNpoints; //Number of points <= fMaxSize	Int_t fNpoints; //Number of points <= fMaxSize
	Double_t *fX; //[fNpoints] array of X points	Double_t *fX; //[fNpoints] array of X points
	Double_t *fY; //[fNpoints] array of Y points	Double_t *fY; //[fNpoints] array of Y points
	TList *fFunctions; //Pointer to list of functions (fits and user)	TList *fFunctions; //Pointer to list of functions (fits and user)
	TH1F *fHistogram; //Pointer to histogram used for drawing a xis	TH1F *fHistogram; //Pointer to histogram used for drawing a xis

	skipping to change at line 116	skipping to change at line 118
	virtual void DrawGraph(Int_t n, const Int_t x, const Int_t y, Option_t *option="");	virtual void DrawGraph(Int_t n, const Int_t x, const Int_t y, Option_t *option="");
	virtual void DrawGraph(Int_t n, const Float_t x, const Float_t y, Option_t *option="");	virtual void DrawGraph(Int_t n, const Float_t x, const Float_t y, Option_t *option="");
	virtual void DrawGraph(Int_t n, const Double_t x=0, const Doub le_t y=0, Option_t *option="");	virtual void DrawGraph(Int_t n, const Double_t x=0, const Doub le_t y=0, Option_t *option="");
	virtual void DrawPanel(); // MENU	virtual void DrawPanel(); // MENU
	virtual Double_t Eval(Double_t x, TSpline spline=0, Option_t opti on="") const;	virtual Double_t Eval(Double_t x, TSpline spline=0, Option_t opti on="") const;
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	virtual void Expand(Int_t newsize);	virtual void Expand(Int_t newsize);
	virtual void Expand(Int_t newsize, Int_t step);	virtual void Expand(Int_t newsize, Int_t step);
	virtual TObject FindObject(const char name) const;	virtual TObject FindObject(const char name) const;
	virtual TObject FindObject(const TObject obj) const;	virtual TObject FindObject(const TObject obj) const;

	virtual Int_t Fit(const char formula ,Option_t option="" ,Opti	virtual TFitResultPtr Fit(const char formula ,Option_t option="" ,Opti
	on_t goption="", Axis_t xmin=0, Axis_t xmax=0); // MENU*	on_t goption="", Axis_t xmin=0, Axis_t xmax=0); // MENU*
	virtual Int_t Fit(TF1 f1 ,Option_t option="" ,Option_t *goptio	virtual TFitResultPtr Fit(TF1 f1 ,Option_t option="" ,Option_t *goptio
	n="", Axis_t xmin=0, Axis_t xmax=0);	n="", Axis_t xmin=0, Axis_t xmax=0);
	virtual void FitPanel(); // MENU	virtual void FitPanel(); // MENU
	Bool_t GetEditable() const;	Bool_t GetEditable() const;
	TF1 GetFunction(const char name) const;	TF1 GetFunction(const char name) const;
	TH1F *GetHistogram() const;	TH1F *GetHistogram() const;
	TList *GetListOfFunctions() const { return fFunctions; }	TList *GetListOfFunctions() const { return fFunctions; }
	virtual Double_t GetCorrelationFactor() const;	virtual Double_t GetCorrelationFactor() const;
	virtual Double_t GetCovariance() const;	virtual Double_t GetCovariance() const;
	virtual Double_t GetMean(Int_t axis=1) const;	virtual Double_t GetMean(Int_t axis=1) const;
	virtual Double_t GetRMS(Int_t axis=1) const;	virtual Double_t GetRMS(Int_t axis=1) const;
	Int_t GetMaxSize() const {return fMaxSize;}	Int_t GetMaxSize() const {return fMaxSize;}

End of changes. 3 change blocks.
	5 lines changed or deleted	7 lines changed or added

	TInetAddress.h	TInetAddress.h

	// @(#)root/base:$Id: TInetAddress.h 20877 2007-11-19 11:17:07Z rdm $	// @(#)root/base:$Id: TInetAddress.h 31825 2009-12-10 20:16:27Z pcanal $
	// Author: Fons Rademakers 16/12/96	// Author: Fons Rademakers 16/12/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 54	skipping to change at line 54
	friend class TSocket;	friend class TSocket;
	friend class TServerSocket;	friend class TServerSocket;
	friend class TXSocket; // special for BaBar	friend class TXSocket; // special for BaBar

	public:	public:
	typedef std::vector<UInt_t> AddressList_t;	typedef std::vector<UInt_t> AddressList_t;
	typedef std::vector<TString> AliasList_t;	typedef std::vector<TString> AliasList_t;

	private:	private:
	TString fHostname; // fully qualified hostname	TString fHostname; // fully qualified hostname

	UInt_t fAddress; // IP address in host byte order
	Int_t fFamily; // address family	Int_t fFamily; // address family
	Int_t fPort; // port through which we are connected	Int_t fPort; // port through which we are connected
	AddressList_t fAddresses; // list of all IP addresses in host byte ord er	AddressList_t fAddresses; // list of all IP addresses in host byte ord er
	AliasList_t fAliases; // list of aliases	AliasList_t fAliases; // list of aliases

	TInetAddress(const char *host, UInt_t addr, Int_t family, Int_t port = - 1);	TInetAddress(const char *host, UInt_t addr, Int_t family, Int_t port = - 1);
	void AddAddress(UInt_t addr);	void AddAddress(UInt_t addr);
	void AddAlias(const char *alias);	void AddAlias(const char *alias);

	public:	public:

	skipping to change at line 83	skipping to change at line 82
	const char GetHostName() const { return (const char ) fHostname; }	const char GetHostName() const { return (const char ) fHostname; }
	Int_t GetFamily() const { return fFamily; }	Int_t GetFamily() const { return fFamily; }
	Int_t GetPort() const { return fPort; }	Int_t GetPort() const { return fPort; }
	const AddressList_t &GetAddresses() const { return fAddresses; }	const AddressList_t &GetAddresses() const { return fAddresses; }
	const AliasList_t &GetAliases() const { return fAliases; }	const AliasList_t &GetAliases() const { return fAliases; }
	Bool_t IsValid() const { return fFamily == -1 ? kFALSE : kTRUE; }	Bool_t IsValid() const { return fFamily == -1 ? kFALSE : kTRUE; }
	void Print(Option_t *option="") const;	void Print(Option_t *option="") const;

	static const char *GetHostAddress(UInt_t addr);	static const char *GetHostAddress(UInt_t addr);


	ClassDef(TInetAddress,3) //Represents an Internet Protocol (IP) address	ClassDef(TInetAddress,4) //Represents an Internet Protocol (IP) address
	};	};

	#endif	#endif

End of changes. 3 change blocks.
	3 lines changed or deleted	2 lines changed or added

	TMinuitMinimizer.h	TMinuitMinimizer.h

	// @(#)root/minuit:$Id: TMinuitMinimizer.h 31181 2009-11-16 11:00:58Z monet a $	// @(#)root/minuit:$Id: TMinuitMinimizer.h 31604 2009-12-07 19:04:33Z monet a $
	// Author: L. Moneta Wed Oct 25 16:28:55 2006	// Author: L. Moneta Wed Oct 25 16:28:55 2006

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for class TMinuitMinimizer	// Header file for class TMinuitMinimizer

	skipping to change at line 152	skipping to change at line 152
	return ( fCovar.size() > (i + fDim* j) ) ? fCovar[i + fDim* j] : 0;	return ( fCovar.size() > (i + fDim* j) ) ? fCovar[i + fDim* j] : 0;
	}	}

	///return status of covariance matrix	///return status of covariance matrix
	virtual int CovMatrixStatus() const;	virtual int CovMatrixStatus() const;

	///global correlation coefficient for variable i	///global correlation coefficient for variable i
	virtual double GlobalCC(unsigned int ) const;	virtual double GlobalCC(unsigned int ) const;

	/// minos error for variable i, return false if Minos failed	/// minos error for variable i, return false if Minos failed

	virtual bool GetMinosError(unsigned int i, double & errLow, double & err Up);	virtual bool GetMinosError(unsigned int i, double & errLow, double & err Up, int = 0);

	/**	/**
	perform a full calculation of the Hessian matrix for error calculatio n	perform a full calculation of the Hessian matrix for error calculatio n
	*/	*/
	virtual bool Hesse();	virtual bool Hesse();

	/**	/**
	scan a parameter i around the minimum. A minimization must have been done before,	scan a parameter i around the minimum. A minimization must have been done before,
	return false if it is not the case	return false if it is not the case
	*/	*/

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	TMultiGraph.h	TMultiGraph.h

	// @(#)root/hist:$Id: TMultiGraph.h 31207 2009-11-16 16:52:00Z moneta $	// @(#)root/hist:$Id: TMultiGraph.h 31491 2009-12-01 18:11:55Z moneta $
	// Author: Rene Brun 12/10/2000	// Author: Rene Brun 12/10/2000

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 34	skipping to change at line 34
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

	#include "TF1.h"	#include "TF1.h"

	class TH1F;	class TH1F;
	class TAxis;	class TAxis;
	class TBrowser;	class TBrowser;
	class TGraph;	class TGraph;


		#include "TFitResultPtr.h"

	class TMultiGraph : public TNamed {	class TMultiGraph : public TNamed {

	protected:	protected:
	TList *fGraphs; //Pointer to list of TGraphs	TList *fGraphs; //Pointer to list of TGraphs
	TList *fFunctions; //Pointer to list of functions (fits and user)	TList *fFunctions; //Pointer to list of functions (fits and user)
	TH1F *fHistogram; //Pointer to histogram used for drawing axis	TH1F *fHistogram; //Pointer to histogram used for drawing axis
	Double_t fMaximum; //Maximum value for plotting along y	Double_t fMaximum; //Maximum value for plotting along y
	Double_t fMinimum; //Minimum value for plotting along y	Double_t fMinimum; //Minimum value for plotting along y

	TMultiGraph(const TMultiGraph&);	TMultiGraph(const TMultiGraph&);

	skipping to change at line 56	skipping to change at line 58
	public:	public:
	TMultiGraph();	TMultiGraph();
	TMultiGraph(const char name, const char title);	TMultiGraph(const char name, const char title);
	virtual ~TMultiGraph();	virtual ~TMultiGraph();

	virtual void Add(TGraph graph, Option_t chopt="");	virtual void Add(TGraph graph, Option_t chopt="");
	virtual void Add(TMultiGraph multigraph, Option_t chopt="");	virtual void Add(TMultiGraph multigraph, Option_t chopt="");
	virtual void Browse(TBrowser *b);	virtual void Browse(TBrowser *b);
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void Draw(Option_t *chopt="");	virtual void Draw(Option_t *chopt="");

	virtual Int_t Fit(const char formula ,Option_t option="" ,Option_t	virtual TFitResultPtr Fit(const char formula ,Option_t option="" ,Opti
	*goption="", Axis_t xmin=0, Axis_t xmax=0);	on_t *goption="", Axis_t xmin=0, Axis_t xmax=0);
	virtual Int_t Fit(TF1 f1 ,Option_t option="" ,Option_t *goption=""	virtual TFitResultPtr Fit(TF1 f1 ,Option_t option="" ,Option_t *goptio
	, Axis_t rxmin=0, Axis_t rxmax=0);	n="", Axis_t rxmin=0, Axis_t rxmax=0);
	virtual void FitPanel(); // MENU	virtual void FitPanel(); // MENU
	virtual Option_t GetGraphDrawOption(const TGraph gr) const;	virtual Option_t GetGraphDrawOption(const TGraph gr) const;
	virtual void LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double _t &a1, Int_t &ifail, Double_t xmin, Double_t xmax);	virtual void LeastSquareLinearFit(Int_t ndata, Double_t &a0, Double _t &a1, Int_t &ifail, Double_t xmin, Double_t xmax);
	virtual void LeastSquareFit(Int_t m, Double_t *a, Double_t xmin, Do uble_t xmax);	virtual void LeastSquareFit(Int_t m, Double_t *a, Double_t xmin, Do uble_t xmax);
	virtual void InitPolynom(Double_t xmin, Double_t xmax);	virtual void InitPolynom(Double_t xmin, Double_t xmax);
	virtual void InitExpo(Double_t xmin, Double_t xmax);	virtual void InitExpo(Double_t xmin, Double_t xmax);
	virtual void InitGaus(Double_t xmin, Double_t xmax);	virtual void InitGaus(Double_t xmin, Double_t xmax);
	TH1F *GetHistogram() const;	TH1F *GetHistogram() const;
	TF1 GetFunction(const char name) const;	TF1 GetFunction(const char name) const;
	TList *GetListOfGraphs() const { return fGraphs; }	TList *GetListOfGraphs() const { return fGraphs; }

End of changes. 3 change blocks.
	5 lines changed or deleted	7 lines changed or added