ROOT: headers diff between 5.28.00 and 5.29.02 versions

	BasicFunctionMinimum.h	BasicFunctionMinimum.h

	// @(#)root/minuit2:$Id: BasicFunctionMinimum.h 23654 2008-05-06 07:30:34Z moneta $	// @(#)root/minuit2:$Id: BasicFunctionMinimum.h 38738 2011-04-05 13:54:46Z moneta $
	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Minuit2_BasicFunctionMinimum	#ifndef ROOT_Minuit2_BasicFunctionMinimum
	#define ROOT_Minuit2_BasicFunctionMinimum	#define ROOT_Minuit2_BasicFunctionMinimum

	skipping to change at line 70	skipping to change at line 70
	fErrorDef = min.fErrorDef;	fErrorDef = min.fErrorDef;
	fAboveMaxEdm = min.fAboveMaxEdm;	fAboveMaxEdm = min.fAboveMaxEdm;
	fReachedCallLimit = min.fReachedCallLimit;	fReachedCallLimit = min.fReachedCallLimit;
	fUserState = min.fUserState;	fUserState = min.fUserState;
	return *this;	return *this;
	}	}

	~BasicFunctionMinimum() {}	~BasicFunctionMinimum() {}

	/// add latest minimization state (for example add Hesse result after Mi grad)	/// add latest minimization state (for example add Hesse result after Mi grad)

	void Add(const MinimumState& state) {	void Add(const MinimumState& state ) {
	fStates.push_back(state);	fStates.push_back(state);
	// LM : update also the user state	// LM : update also the user state
	fUserState = MnUserParameterState(State(), Up(), Seed().Trafo());	fUserState = MnUserParameterState(State(), Up(), Seed().Trafo());

		// reset maxedm flag. If new state has edm over max other method must
		be used
		fAboveMaxEdm = false;
		}

		///Add a new state and flag that edm is above maximum
		void Add(const MinimumState& state, MnAboveMaxEdm) {
		Add(state);
		fAboveMaxEdm = true;
	}	}

	const MinimumSeed& Seed() const {return fSeed;}	const MinimumSeed& Seed() const {return fSeed;}
	const std::vector<MinimumState>& States() const {return fStates;}	const std::vector<MinimumState>& States() const {return fStates;}

	// user representation of state at Minimum	// user representation of state at Minimum
	const MnUserParameterState& UserState() const {	const MnUserParameterState& UserState() const {
	if(!fUserState.IsValid())	if(!fUserState.IsValid())
	fUserState = MnUserParameterState(State(), Up(), Seed().Trafo());	fUserState = MnUserParameterState(State(), Up(), Seed().Trafo());
	return fUserState;	return fUserState;

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

	BayesianCalculator.h	BayesianCalculator.h

	// @(#)root/roostats:$Id: BayesianCalculator.h 37084 2010-11-29 21:37:13Z m oneta $	// @(#)root/roostats:$Id: BayesianCalculator.h 38933 2011-04-19 20:15:51Z 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 111	skipping to change at line 111
	void SetShortestInterval() { fLeftSideFraction = -1; }	void SetShortestInterval() { fLeftSideFraction = -1; }

	// set the precision of the Root Finder	// set the precision of the Root Finder
	void SetBrfPrecision( double precision ) { fBrfPrecision = precision; }	void SetBrfPrecision( double precision ) { fBrfPrecision = precision; }

	// use directly the approximate posterior function obtained by binnin g it in nbins	// use directly the approximate posterior function obtained by binnin g it in nbins
	// by default the cdf is used by integrating the posterior	// by default the cdf is used by integrating the posterior
	// if a value of nbin <= 0 the cdf function will be used	// if a value of nbin <= 0 the cdf function will be used
	void SetScanOfPosterior(int nbin = 100) { fNScanBins = nbin; }	void SetScanOfPosterior(int nbin = 100) { fNScanBins = nbin; }


	// set the integration type (possible type are)	// set the number of iterations when running a MC integration algorit
	// 1D: adaptive, gauss, nonadaptive	hm
	// multidim: adaptive, vegas, miser, plain. These last 3 are based on	// If not set use default algorithmic values
	MC integration	// In case of ToyMC sampling of the nuisance the value is 100
		// In case of using the GSL MCintegrations types the default value is
		// defined in ROOT::Math::IntegratorMultiDimOptions::DefaultNCalls()
		virtual void SetNumIters(Int_t numIters) { fNumIterations = numIters
		; }

		// set the integration type (possible type are) :
		// 1D integration ( used when only one nuisance and when the posterio
		r is scanned):
		// adaptive , gauss, nonadaptive
		// multidim:
		// ADAPTIVE, adaptive numerical integration
		// niter defines here the max numnber of function
		calls - can be reduced to make it faster
		// but the required tolerance will not be reached
		// VEGAS MC integration method based on importance sampling -
		niter is number of calls + extra parameter
		// can be configured using IntegratorMultiDimOptions
		class
		// MISER MC integration method based on stratified sampling
		// See also http://en.wikipedia.org/wiki/Monte_Carlo_i
		ntegration for VEGAS and MISER description
		// PLAIN simple MC integration method, niter defines number
		of calls
		//
		// Extra integration types are:
		//
		// TOYMC:
		// evaluate posterior by generating toy MC for the nuisance par
		ameters. It is a MC
		// integration, where the function is sampled according to the
		nuisance. It is convenient to use when all
		// the nuisance are uncorrelated and it is efficient to generat
		e them
		// The toy are generated by default for each poi values
		// (this method has been proposed and provided by J.P Chou)
		// 1-TOYMC : same method as before but in this case the toys are
		generated for each poi value
		//
		// ROOFIT:
		// use roofit default integration methods which will produce a
		nested integral (not reccomended for more
		// than 1 nuisance parameters)
		//
	// if type = 0 use default specified via class IntegratorMultiDimOpti ons::SetDefaultIntegrator	// if type = 0 use default specified via class IntegratorMultiDimOpti ons::SetDefaultIntegrator
	void SetIntegrationType(const char * type);	void SetIntegrationType(const char * type);

	// return the mode (most probable value of the posterior function)	// return the mode (most probable value of the posterior function)
	double GetMode() const;	double GetMode() const;


		// force the nuisance pdf when using the toy mc sampling
		void ForceNuisancePdf(RooAbsPdf & pdf) { fNuisancePdf = &pdf; }

	protected:	protected:

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

	void ApproximatePosterior() const;	void ApproximatePosterior() const;

	void ComputeIntervalFromApproxPosterior(double c1, double c2) const;	void ComputeIntervalFromApproxPosterior(double c1, double c2) const;

	void ComputeIntervalFromCdf(double c1, double c2) const;	void ComputeIntervalFromCdf(double c1, double c2) const;

	void ComputeIntervalUsingRooFit(double c1, double c2) const;	void ComputeIntervalUsingRooFit(double c1, double c2) const;

	void ComputeShortestInterval() const;	void ComputeShortestInterval() const;

	private:	private:

	// plan to replace the above: return a SimpleInterval integrating	// plan to replace the above: return a SimpleInterval integrating
	// over all other parameters except the one specified as argument	// over all other parameters except the one specified as argument
	//virtual SimpleInterval* GetInterval( RooRealVar* parameter ) const { return 0; }	//virtual SimpleInterval* GetInterval( RooRealVar* parameter ) const { return 0; }


	RooAbsData* fData;	RooAbsData* fData; // data set
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf; // model pdf (could conta
	RooArgSet fPOI;	in the nuisance pdf as constraint term)
	RooAbsPdf* fPriorPOI;	RooArgSet fPOI; // POI
		RooAbsPdf* fPriorPOI; // prior pdf for POI
		RooAbsPdf* fNuisancePdf; // nuisance pdf (needed wh
		en using nuisance sampling technique)
	RooArgSet fNuisanceParameters;	RooArgSet fNuisanceParameters;

	mutable RooAbsPdf* fProductPdf; // internal pointer to m odel * prior	mutable RooAbsPdf* fProductPdf; // internal pointer to m odel * prior
	mutable RooAbsReal* fLogLike; // internal pointer to l og likelihood function	mutable RooAbsReal* fLogLike; // internal pointer to l og likelihood function
	mutable RooAbsReal* fLikelihood; // internal pointer to l ikelihood function	mutable RooAbsReal* fLikelihood; // internal pointer to l ikelihood function
	mutable RooAbsReal* fIntegratedLikelihood; // integrated likelihood function, i.e - unnormalized posterior function	mutable RooAbsReal* fIntegratedLikelihood; // integrated likelihood function, i.e - unnormalized posterior function
	mutable RooAbsPdf* fPosteriorPdf; // normalized (on the p oi) posterior pdf	mutable RooAbsPdf* fPosteriorPdf; // normalized (on the p oi) posterior pdf
	mutable ROOT::Math::IGenFunction * fPosteriorFunction; // function representing the posterior	mutable ROOT::Math::IGenFunction * fPosteriorFunction; // function representing the posterior
	mutable TF1 * fApproxPosterior; // TF1 representing the scanned po sterior function	mutable TF1 * fApproxPosterior; // TF1 representing the scanned po sterior function
	mutable Double_t fLower; // computer lower interval bound	mutable Double_t fLower; // computer lower interval bound
	mutable Double_t fUpper; // upper interval bound	mutable Double_t fUpper; // upper interval bound
	mutable Double_t fNLLMin; // minimum value of Nll	mutable Double_t fNLLMin; // minimum value of Nll
	double fSize; // size used for getting the interval	double fSize; // size used for getting the interval
	double fLeftSideFraction; // fraction of probability content on le ft side of interval	double fLeftSideFraction; // fraction of probability content on le ft side of interval
	double fBrfPrecision; // root finder precision	double fBrfPrecision; // root finder precision

	int fNScanBins; // number of bins to scan, if = -1 no scan	mutable int fNScanBins; // number of bins to scan, if = -1
	is done (default)	no scan is done (default)
		int fNumIterations; // number of iterations (when using ToyMC)
	mutable Bool_t fValidInterval;	mutable Bool_t fValidInterval;

	TString fIntegrationType;	TString fIntegrationType;

	protected:	protected:

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

	};	};
	}	}

End of changes. 5 change blocks.
	11 lines changed or deleted	61 lines changed or added

	BinarySearchTreeNode.h	BinarySearchTreeNode.h

	// @(#)root/tmva $Id: BinarySearchTreeNode.h 33928 2010-06-15 16:19:31Z ste lzer $	// @(#)root/tmva $Id: BinarySearchTreeNode.h 38719 2011-04-04 12:22:28Z evt $
	// 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 62	skipping to change at line 62
	class Event;	class Event;

	// 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)
	// (currently it is NOT UNIQUE... but could eventually made it	// (currently it is NOT UNIQUE... but could eventually made it
	// a node in the tree structure	// a node in the tree structure
	class BinarySearchTreeNode : public Node {	class BinarySearchTreeNode : public Node {

	public:	public:

	// constructor of a node for the search tree	// constructor of a node for the search tree

	BinarySearchTreeNode( const Event* e = NULL );	BinarySearchTreeNode( const Event* e = NULL, UInt_t signalClass=0 );

	// constructor of a daughter node as a daughter of 'p'	// constructor of a daughter node as a daughter of 'p'
	BinarySearchTreeNode( BinarySearchTreeNode* parent, char pos );	BinarySearchTreeNode( BinarySearchTreeNode* parent, char pos );

	// copy constructor	// copy constructor
	BinarySearchTreeNode ( const BinarySearchTreeNode &n,	BinarySearchTreeNode ( const BinarySearchTreeNode &n,
	BinarySearchTreeNode* parent = NULL);	BinarySearchTreeNode* parent = NULL);

	// destructor	// destructor
	virtual ~BinarySearchTreeNode ();	virtual ~BinarySearchTreeNode ();

	skipping to change at line 92	skipping to change at line 92

	virtual Bool_t EqualsMe ( const Event& ) const;	virtual Bool_t EqualsMe ( const Event& ) const;

	// set index of variable used for discrimination at this node	// set index of variable used for discrimination at this node
	inline void SetSelector( Short_t i) { fSelector = i; }	inline void SetSelector( Short_t i) { fSelector = i; }
	// return index of variable used for discrimination at this node	// return index of variable used for discrimination at this node
	inline Short_t GetSelector() const { return fSelector; }	inline Short_t GetSelector() const { return fSelector; }

	const std::vector<Float_t> & GetEventV() const { return fEventV; }	const std::vector<Float_t> & GetEventV() const { return fEventV; }
	Float_t GetWeight() const { return fWeight; }	Float_t GetWeight() const { return fWeight; }

	Bool_t IsSignal() const { return (fClass == 0)	UInt_t GetClass() const { return fClass; }
	; }	// Bool_t IsSignal() const { return (fClass ==
		fSignalClass); }

	const std::vector<Float_t> & GetTargets() const { return fTargets; }	const std::vector<Float_t> & GetTargets() const { return fTargets; }

	// printout of the node	// printout of the node
	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;

	skipping to change at line 114	skipping to change at line 115

	private:	private:
	// Read the data block	// Read the data block
	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM VA_VERSION_CODE );	virtual void ReadAttributes(void* node, UInt_t tmva_Version_Code = TM VA_VERSION_CODE );
	virtual Bool_t ReadDataRecord( std::istream& is, UInt_t tmva_Version_ Code = TMVA_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;	UInt_t fClass;
	UInt_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)

	ClassDef(BinarySearchTreeNode,0) // Node for the BinarySearchTree	ClassDef(BinarySearchTreeNode,0) // Node for the BinarySearchTree
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	BinaryTree.h	BinaryTree.h

	// @(#)root/tmva $Id: BinaryTree.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: BinaryTree.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard vo
		n Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* *	* *
	* 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 *

		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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	#ifndef ROOT_TMVA_Version

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

	Chebyshev.h	Chebyshev.h

	// @(#)root/mathmore:$Id: Chebyshev.h 21503 2007-12-19 17:34:54Z moneta $	// @(#)root/mathmore:$Id: Chebyshev.h 38026 2011-02-10 11:46:12Z rdm $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: 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 54	skipping to change at line 54

	#ifndef ROOT_Math_IFunctionfwd	#ifndef ROOT_Math_IFunctionfwd
	#include "Math/IFunctionfwd.h"	#include "Math/IFunctionfwd.h"
	#endif	#endif

	#ifndef ROOT_Math_GSLFunctionAdapter	#ifndef ROOT_Math_GSLFunctionAdapter
	#include "Math/GSLFunctionAdapter.h"	#include "Math/GSLFunctionAdapter.h"
	#endif	#endif

	#include <memory>	#include <memory>

		#include <cstddef>

	namespace ROOT {	namespace ROOT {
	namespace Math {	namespace Math {

	class GSLChebSeries;	class GSLChebSeries;
	class GSLFunctionWrapper;	class GSLFunctionWrapper;

	//_________________________________________________________________________ ___	//_________________________________________________________________________ ___
	/**	/**
	Class describing a Chebyshev series which can be used to approximate a	Class describing a Chebyshev series which can be used to approximate a

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

	Class.h	Class.h

	skipping to change at line 62	skipping to change at line 62
	const char *Name() ;	const char *Name() ;
	const char *Fullname();	const char *Fullname();
	const char *Title() ;	const char *Title() ;
	int Size() ;	int Size() ;
	long Property();	long Property();
	int NDataMembers();	int NDataMembers();
	int NMethods();	int NMethods();
	long IsBase(const char *classname);	long IsBase(const char *classname);
	long IsBase(G__ClassInfo& a);	long IsBase(G__ClassInfo& a);
	void* DynamicCast(G__ClassInfo& to, void* obj);	void* DynamicCast(G__ClassInfo& to, void* obj);

	long Tagnum() const { return(tagnum); }	int Tagnum() const { return(tagnum); }
	G__ClassInfo EnclosingClass() ;	G__ClassInfo EnclosingClass() ;
	G__ClassInfo EnclosingSpace() ;	G__ClassInfo EnclosingSpace() ;
	struct G__friendtag* GetFriendInfo();	struct G__friendtag* GetFriendInfo();

	void SetGlobalcomp(int globalcomp);	void SetGlobalcomp(G__SIGNEDCHAR_T globalcomp);
	void SetProtectedAccess(int protectedaccess);	void SetProtectedAccess(int protectedaccess);
	#ifdef G__OLDIMPLEMENTATION1218_YET	#ifdef G__OLDIMPLEMENTATION1218_YET
	int IsValid() { return 0<=tagnum && tagnum<G__struct.alltag ? 1 : 0; }	int IsValid() { return 0<=tagnum && tagnum<G__struct.alltag ? 1 : 0; }
	#else	#else
	int IsValid();	int IsValid();
	#endif	#endif
	int IsLoaded();	int IsLoaded();
	int SetFilePos(const char *fname);	int SetFilePos(const char *fname);
	int Next();	int Next();
	int Linkage();	int Linkage();

	const char *FileName() ;	const char *FileName() ;
	int LineNumber() ;	int LineNumber() ;

	int IsTmplt();	int IsTmplt();
	const char* TmpltName();	const char* TmpltName();
	const char* TmpltArg();	const char* TmpltArg();

	protected:	protected:

	long tagnum; // class,struct,union,enum key for cint dictionary	int tagnum; // class,struct,union,enum key for cint dictionary
	long class_property; // cache value (expensive to get)	long class_property; // cache value (expensive to get)

	///////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////
	// Following things have to be added for ROOT	// Following things have to be added for ROOT
	///////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////
	public:	public:
	void SetDefFile(char *deffilein);	void SetDefFile(char *deffilein);
	void SetDefLine(int deflinein);	void SetDefLine(int deflinein);
	void SetImpFile(char *impfilein);	void SetImpFile(char *impfilein);
	void SetImpLine(int implinein);	void SetImpLine(int implinein);

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

	ClassBuilder.h	ClassBuilder.h

	// @(#)root/reflex:$Id: ClassBuilder.h 32228 2010-02-05 16:13:09Z axel $	// @(#)root/reflex:$Id: ClassBuilder.h 38267 2011-03-01 18:49:15Z pcanal $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.	// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.
	//	//
	// Permission to use, copy, modify, and distribute this software for any	// Permission to use, copy, modify, and distribute this software for any
	// purpose is hereby granted without fee, provided that this copyright and	// purpose is hereby granted without fee, provided that this copyright and
	// permissions notice appear in all copies and derivatives.	// permissions notice appear in all copies and derivatives.
	//	//
	// This software is provided "as is" without express or implied warranty.	// This software is provided "as is" without express or implied warranty.


	skipping to change at line 26	skipping to change at line 26
	#include "Reflex/Kernel.h"	#include "Reflex/Kernel.h"
	#include "Reflex/Tools.h"	#include "Reflex/Tools.h"
	#include "Reflex/Member.h"	#include "Reflex/Member.h"
	#include "Reflex/Callback.h"	#include "Reflex/Callback.h"
	#include "Reflex/Builder/TypeBuilder.h"	#include "Reflex/Builder/TypeBuilder.h"

	// Forward declaration for 'friendship' purpose.	// Forward declaration for 'friendship' purpose.
	namespace Cint { namespace Internal {} }	namespace Cint { namespace Internal {} }

	namespace Reflex {	namespace Reflex {


		/* Helper class to avoid compiler warning about casting function pointer
		** to void pointer.
		*/
		class BuilderFunc2Void {
		typedef void (*funcptr_t)();

		union funcptr_and_voidptr {
		typedef void (*funcptr_t)();

		funcptr_and_voidptr(void *val) : _read(val) {}

		void *_read;
		funcptr_t _write;
		};

		funcptr_and_voidptr _tmp;
		public:
		template <typename T>
		BuilderFunc2Void( T vfp ) : _tmp(0) {
		_tmp._write = ( funcptr_t )vfp;
		}

		operator void*() const {
		return _tmp._read;
		}
		};

	// forward declarations	// forward declarations
	class Class;	class Class;
	class ClassBuilder;	class ClassBuilder;
	class OnDemandBuilderForScope;	class OnDemandBuilderForScope;

	template <typename C> class ClassBuilderT;	template <typename C> class ClassBuilderT;

	/**	/**
	* @class ClassBuilderImpl ClassBuilder.h Reflex/Builder/ClassBuilder.h	* @class ClassBuilderImpl ClassBuilder.h Reflex/Builder/ClassBuilder.h
	* @author Stefan Roiser	* @author Stefan Roiser

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

	Config.h	Config.h

	// @(#)root/tmva $Id: Config.h 33931 2010-06-15 16:49:02Z stelzer $	// @(#)root/tmva $Id: Config.h 38719 2011-04-04 12:22:28Z evt $
	// 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 : Config *	* Class : Config *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* GLobal configuration settings (singleton) *	* GLobal configuration settings (singleton) *

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

	// publicly accessible global settings	// publicly accessible global settings
	class VariablePlotting {	class VariablePlotting {
	// data collection class to configure plotting of variables	// data collection class to configure plotting of variables
	public:	public:

	Float_t fTimesRMS;	Float_t fTimesRMS;
	Int_t fNbins1D;	Int_t fNbins1D;
	Int_t fNbins2D;	Int_t fNbins2D;
	Int_t fMaxNumOfAllowedVariablesForScatterPlots;	Int_t fMaxNumOfAllowedVariablesForScatterPlots;

		Int_t fNbinsMVAoutput;
	Int_t fNbinsXOfROCCurve;	Int_t fNbinsXOfROCCurve;
	} fVariablePlotting; // Customisable plotting properties	} fVariablePlotting; // Customisable plotting properties

	// for file names and similar	// for file names and similar
	class IONames {	class IONames {

	public:	public:

	TString fWeightFileDir;	TString fWeightFileDir;
	TString fWeightFileExtension;	TString fWeightFileExtension;

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

	CrossEntropy.h	CrossEntropy.h

	// @(#)root/tmva $Id: CrossEntropy.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: CrossEntropy.h 38943 2011-04-20 08:03:25Z evt $
	// 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 : CrossEntropy *	* Class : CrossEntropy *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: Implementation of the CrossEntropy as separation criterion *	* Description: Implementation of the CrossEntropy as separation criterion *
	* *	* *

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

	DataMbr.h	DataMbr.h

	skipping to change at line 55	skipping to change at line 55

	long Handle() { return(handle); }	long Handle() { return(handle); }
	int Index() { return ((int)index); }	int Index() { return ((int)index); }
	const char *Name();	const char *Name();
	const char *Title();	const char *Title();
	G__TypeInfo* Type();	G__TypeInfo* Type();
	long Property();	long Property();
	long Offset() ;	long Offset() ;
	int Bitfield();	int Bitfield();
	int ArrayDim() ;	int ArrayDim() ;

	int MaxIndex(int dim) ;	long MaxIndex(int dim) ;
	G__ClassInfo* MemberOf();	G__ClassInfo* MemberOf();

	void SetGlobalcomp(int globalcomp);	void SetGlobalcomp(G__SIGNEDCHAR_T globalcomp);
	int IsValid();	int IsValid();
	int SetFilePos(const char* fname);	int SetFilePos(const char* fname);
	int Next();	int Next();
	int Prev();	int Prev();

	enum error_code { VALID, NOT_INT, NOT_DEF, IS_PRIVATE, UNKNOWN };	enum error_code { VALID, NOT_INT, NOT_DEF, IS_PRIVATE, UNKNOWN };
	const char ValidArrayIndex(int errnum = 0, char **errstr = 0);	const char ValidArrayIndex(int errnum = 0, char **errstr = 0);

	const char *FileName();	const char *FileName();
	int LineNumber();	int LineNumber();

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

	DataSet.h	DataSet.h

	// @(#)root/tmva $Id: DataSet.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: DataSet.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, 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 : DataSet *	* Class : DataSet *
	* 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 92	skipping to change at line 92
	public:	public:

	DataSet(const DataSetInfo&);	DataSet(const DataSetInfo&);
	virtual ~DataSet();	virtual ~DataSet();

	void AddEvent( Event *, Types::ETreeType );	void AddEvent( Event *, Types::ETreeType );

	Long64_t GetNEvents( Types::ETreeType type = Types::kMaxTreeType ) c onst;	Long64_t GetNEvents( Types::ETreeType type = Types::kMaxTreeType ) c onst;
	Long64_t GetNTrainingEvents() const { return GetNEvents (Types::kTraining); }	Long64_t GetNTrainingEvents() const { return GetNEvents (Types::kTraining); }
	Long64_t GetNTestEvents() const { return GetNEvents (Types::kTesting); }	Long64_t GetNTestEvents() const { return GetNEvents (Types::kTesting); }

	Event* GetEvent() const;	Event* GetEvent() const; // returns event w
	Event* GetEvent ( Long64_t ievt ) const { fCurrentEventIdx	ithout transformations
	= ievt; return GetEvent(); }	Event* GetEvent ( Long64_t ievt ) const { fCurrentEventIdx
		= ievt; return GetEvent(); } // returns event without transformations
	Event* GetTrainingEvent( Long64_t ievt ) const { return GetEvent(i evt, Types::kTraining); }	Event* GetTrainingEvent( Long64_t ievt ) const { return GetEvent(i evt, Types::kTraining); }
	Event* GetTestEvent ( Long64_t ievt ) const { return GetEvent(i evt, Types::kTesting); }	Event* GetTestEvent ( Long64_t ievt ) const { return GetEvent(i evt, Types::kTesting); }
	Event* GetEvent ( Long64_t ievt, Types::ETreeType type ) co nst {	Event* GetEvent ( Long64_t ievt, Types::ETreeType type ) co nst {
	fCurrentTreeIdx = TreeIndex(type); fCurrentEventIdx = ievt; return GetEvent();	fCurrentTreeIdx = TreeIndex(type); fCurrentEventIdx = ievt; return GetEvent();
	}	}

	UInt_t GetNVariables() const;	UInt_t GetNVariables() const;
	UInt_t GetNTargets() const;	UInt_t GetNTargets() const;
	UInt_t GetNSpectators() const;	UInt_t GetNSpectators() const;


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

	DecisionTree.h	DecisionTree.h

	// @(#)root/tmva $Id: DecisionTree.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: DecisionTree.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Jan Therha
		ag, Eckhard von Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 : DecisionTree *	* Class : DecisionTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Implementation of a Decision Tree *	* Implementation of a Decision Tree *
	* *	* *
	* 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 *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
		*
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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://mva.sourceforge.net/license.txt) *	* (http://mva.sourceforge.net/license.txt) *
	* *	* *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_DecisionTree	#ifndef ROOT_TMVA_DecisionTree
	#define ROOT_TMVA_DecisionTree	#define ROOT_TMVA_DecisionTree


	skipping to change at line 192	skipping to change at line 195

	void SetTreeID(Int_t treeID){fTreeID = treeID;};	void SetTreeID(Int_t treeID){fTreeID = treeID;};
	Int_t GetTreeID(){return fTreeID;};	Int_t GetTreeID(){return fTreeID;};

	Bool_t DoRegression() const { return fAnalysisType == Types::kRegress ion; }	Bool_t DoRegression() const { return fAnalysisType == Types::kRegress ion; }
	void SetAnalysisType (Types::EAnalysisType t) { fAnalysisType = t;}	void SetAnalysisType (Types::EAnalysisType t) { fAnalysisType = t;}
	Types::EAnalysisType GetAnalysisType ( void ) { return fAnalysisType; }	Types::EAnalysisType GetAnalysisType ( void ) { return fAnalysisType; }
	inline void SetUseFisherCuts(Bool_t t=kTRUE) { fUseFisherCuts = t;}	inline void SetUseFisherCuts(Bool_t t=kTRUE) { fUseFisherCuts = t;}
	inline void SetMinLinCorrForFisher(Double_t min){fMinLinCorrForFisher = min;}	inline void SetMinLinCorrForFisher(Double_t min){fMinLinCorrForFisher = min;}
	inline void SetUseExclusiveVars(Bool_t t=kTRUE){fUseExclusiveVars = t ;}	inline void SetUseExclusiveVars(Bool_t t=kTRUE){fUseExclusiveVars = t ;}

		inline void SetPairNegWeightsInNode(){fPairNegWeightsInNode=kTRUE;}

	private:	private:
	// utility functions	// utility functions

	// calculate the Purity out of the number of sig and bkg events colle cted	// calculate the Purity out of the number of sig and bkg events colle cted
	// from individual samples.	// from individual samples.

	// calculates the purity S/(S+B) of a given event sample	// calculates the purity S/(S+B) of a given event sample
	Double_t SamplePurity(EventList eventSample);	Double_t SamplePurity(EventList eventSample);


	skipping to change at line 231	skipping to change at line 235
	Bool_t fRandomisedTree; // choose at each node splitting a random set of variables	Bool_t fRandomisedTree; // choose at each node splitting a random set of variables
	Int_t fUseNvars; // the number of variables used in randomi sed trees;	Int_t fUseNvars; // the number of variables used in randomi sed trees;
	Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number bu t as mean of a possion distr. in each split	Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number bu t as mean of a possion distr. in each split

	TRandom3 *fMyTrandom; // random number generator for randomised trees	TRandom3 *fMyTrandom; // random number generator for randomised trees

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

	UInt_t fNNodesMax; // max # of nodes	UInt_t fNNodesMax; // max # of nodes
	UInt_t fMaxDepth; // max depth	UInt_t fMaxDepth; // max depth

	UInt_t fClass; // class which is treated as signal when b	UInt_t fSigClass; // class which is treated as signal when b
	uilding the tree	uilding the tree
		Bool_t fPairNegWeightsInNode; // randomly pair miscl. ev. with n
		eg. and pos. weights in node and don't boost them
	static const Int_t fgDebugLevel = 0; // debug level determining some printout/control plots etc.	static const Int_t fgDebugLevel = 0; // debug level determining some printout/control plots etc.
	Int_t fTreeID; // just an ID number given to the tree.. ma kes debugging easier as tree knows who he is.	Int_t fTreeID; // just an ID number given to the tree.. ma kes debugging easier as tree knows who he is.

	Types::EAnalysisType fAnalysisType; // kClassification(=0=false) o r kRegression(=1=true)	Types::EAnalysisType fAnalysisType; // kClassification(=0=false) o r kRegression(=1=true)

	ClassDef(DecisionTree,0) // implementation of a Decisio n Tree	ClassDef(DecisionTree,0) // implementation of a Decisio n Tree
	};	};

	} // namespace TMVA	} // namespace TMVA


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

	Event.h	Event.h

	// @(#)root/tmva $Id: Event.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: Event.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ja
		n Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* *	* *
	* 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 *	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - 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) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

	* LAPP, Annecy, France *	* U. of Bonn, 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://mva.sourceforge.net/license.txt) *	* (http://mva.sourceforge.net/license.txt) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_Event	#ifndef ROOT_TMVA_Event
	#define ROOT_TMVA_Event	#define ROOT_TMVA_Event

	#include <iosfwd>	#include <iosfwd>

	skipping to change at line 79	skipping to change at line 80
	explicit Event( const std::vector<Float_t>&, UInt_t nvar );	explicit Event( const std::vector<Float_t>&, UInt_t nvar );

	~Event();	~Event();

	// accessors	// accessors
	Bool_t IsDynamic() const {return fDynamic; }	Bool_t IsDynamic() const {return fDynamic; }

	Double_t GetWeight() const { return fWeight*fBoostWeight; }	Double_t GetWeight() const { return fWeight*fBoostWeight; }
	Double_t GetOriginalWeight() const { return fWeight; }	Double_t GetOriginalWeight() const { return fWeight; }
	Double_t GetBoostWeight() const { return TMath::Max(Double_t(0.000 1),fBoostWeight); }	Double_t GetBoostWeight() const { return TMath::Max(Double_t(0.000 1),fBoostWeight); }

	UInt_t GetClass() const { return fClass; }	UInt_t GetClass() const { return fClass; }


	UInt_t GetNVariables() const;	UInt_t GetNVariables() const;
	UInt_t GetNTargets() const;	UInt_t GetNTargets() const;
	UInt_t GetNSpectators() const;	UInt_t GetNSpectators() const;


	const std::vector<UInt_t>* GetVariableArrangement() const { return fV	Float_t GetValue( UInt_t ivar) const;
	ariableArrangement; }

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


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


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


	void ScaleWeight ( Double_t s ) { fWeight*=s; }	void ScaleWeight ( Double_t s ) { fWeight*=s; }
	void SetWeight ( Double_t w ) { fWeight=w; }	void SetWeight ( Double_t w ) { fWeight=w; }
	void SetBoostWeight ( Double_t w ) { fBoostWeight=w; }	void SetBoostWeight ( Double_t w ) { fDoNotBoost ? fDoNotB
	void ScaleBoostWeight ( Double_t s ) { fBoostWeight *= s; }	oost = kFALSE : fBoostWeight=w; }
	void SetClass ( UInt_t t ) { fClass=t; }	void ScaleBoostWeight ( Double_t s ) { fDoNotBoost ? fDoNotB
	void SetVal ( UInt_t ivar, Float_t val );	oost = kFALSE : fBoostWeight *= s; }
	void SetTarget ( UInt_t itgt, Float_t value );	void SetClass ( UInt_t t ) { fClass=t; }
	void SetSpectator ( UInt_t ivar, Float_t value );	void SetVal ( UInt_t ivar, Float_t val );
	void SetVariableArrangement( std::vector<UInt_t>* const m ) const;	void SetTarget ( UInt_t itgt, Float_t value );
		void SetSpectator ( UInt_t ivar, Float_t value );


	static void ClearDynamicVariables();	void SetDoNotBoost () { fDoNotBoost = kTRUE; }
		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 va	mutable std::vector<Float_t> fValues; // the event values
	lues	mutable std::vector<Float_t> fValuesDynamic; // the event values
	mutable std::vector<Float_t> fValuesDynamic; // the event val	mutable std::vector<Float_t> fTargets; // target values for
	ues	regression
	mutable std::vector<Float_t> fTargets; // target value	mutable std::vector<Float_t> fSpectators; // "visisting" varia
	s for regression	bles not used in MVAs
	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; // class number
	Double_t fWeight; // event weight (pro duct of global and individual weights)	Double_t fWeight; // event weight (pro duct of global and individual weights)
	Double_t fBoostWeight; // internal weight t o be set by boosting algorithm	Double_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

		Bool_t fDoNotBoost; // mark event as no t to be boosted (used to compensate for events with negative event weights
	};	};
	}	}

	#endif	#endif

End of changes. 15 change blocks.
	37 lines changed or deleted	35 lines changed or added

	Factory.h	Factory.h

	// @(#)root/tmva $Id: Factory.h 37535 2010-12-10 22:40:29Z evt $	// @(#)root/tmva $Id: Factory.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
	i Voss	i Voss, Eckhard von Toerne, Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 is the main MVA steering class: it creates (books) all MVA met hods, *	* This is the main MVA steering class: it creates (books) all MVA met hods, *
	* and guides them through the training, testing and evaluation phases . *	* and guides them through the training, testing and evaluation phases . *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany *	* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany *
	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@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 *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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_Factory	#ifndef ROOT_TMVA_Factory
	#define ROOT_TMVA_Factory	#define ROOT_TMVA_Factory

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

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

	FastAllocString.h	FastAllocString.h

	skipping to change at line 55	skipping to change at line 55
	// use by a G__FastAllocString object requesting a same of smaller size	// use by a G__FastAllocString object requesting a same of smaller size
	// buffer. This class is optimized for both speed and low memory	// buffer. This class is optimized for both speed and low memory
	// use despite the reservoir.	// use despite the reservoir.
	//	//
	class	class
	#ifndef __CINT__	#ifndef __CINT__
	G__EXPORT	G__EXPORT
	#endif	#endif
	G__FastAllocString {	G__FastAllocString {
	public:	public:

	G__FastAllocString(int reqsize = 1024): fBuf(0), fCapacity(reqsize) {	G__FastAllocString(size_t reqsize = 1024): fBuf(0), fCapacity(reqsize) {
	// GetBuf takes as parameter the size in bytes	// GetBuf takes as parameter the size in bytes
	// and modify the parameter (fBucket) to hold the	// and modify the parameter (fBucket) to hold the
	// bucket number.	// bucket number.
	fBuf = GetBuf(fCapacity);	fBuf = GetBuf(fCapacity);
	}	}
	G__FastAllocString(const char* s);	G__FastAllocString(const char* s);
	G__FastAllocString(const G__FastAllocString&);	G__FastAllocString(const G__FastAllocString&);

	~G__FastAllocString();	~G__FastAllocString();


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

	FunctionMinimum.h	FunctionMinimum.h

	// @(#)root/minuit2:$Id: FunctionMinimum.h 23654 2008-05-06 07:30:34Z monet a $	// @(#)root/minuit2:$Id: FunctionMinimum.h 38738 2011-04-05 13:54:46Z monet a $
	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Minuit2_FunctionMinimum	#ifndef ROOT_Minuit2_FunctionMinimum
	#define ROOT_Minuit2_FunctionMinimum	#define ROOT_Minuit2_FunctionMinimum

	skipping to change at line 61	skipping to change at line 61
	/// copy constructo	/// copy constructo
	FunctionMinimum(const FunctionMinimum& min) : fData(min.fData) {}	FunctionMinimum(const FunctionMinimum& min) : fData(min.fData) {}

	FunctionMinimum& operator=(const FunctionMinimum& min) {	FunctionMinimum& operator=(const FunctionMinimum& min) {
	fData = min.fData;	fData = min.fData;
	return *this;	return *this;
	}	}

	~FunctionMinimum() {}	~FunctionMinimum() {}


	// why not	// add new state
	void Add(const MinimumState& state) {fData->Add(state);}	void Add(const MinimumState& state) {fData->Add(state);}


		// add new state
		void Add(const MinimumState& state, MnAboveMaxEdm) {fData->Add(state,Bas
		icFunctionMinimum::MnAboveMaxEdm());}

	const MinimumSeed& Seed() const {return fData->Seed();}	const MinimumSeed& Seed() const {return fData->Seed();}
	const std::vector<ROOT::Minuit2::MinimumState>& States() const {return f Data->States();}	const std::vector<ROOT::Minuit2::MinimumState>& States() const {return f Data->States();}

	// user representation of state at Minimum	// user representation of state at Minimum
	const MnUserParameterState& UserState() const {	const MnUserParameterState& UserState() const {
	return fData->UserState();	return fData->UserState();
	}	}
	const MnUserParameters& UserParameters() const {	const MnUserParameters& UserParameters() const {
	return fData->UserParameters();	return fData->UserParameters();
	}	}

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

	G__ci.h	G__ci.h

	skipping to change at line 1712	skipping to change at line 1712
	public:	public:
	template <typename T>	template <typename T>
	G__func2void( T vfp ) : _tmp(0) {	G__func2void( T vfp ) : _tmp(0) {
	_tmp._write = ( funcptr_t )vfp;	_tmp._write = ( funcptr_t )vfp;
	}	}

	operator void* () const {	operator void* () const {
	return _tmp._read;	return _tmp._read;
	}	}
	};	};

	#elif !__CINT__	#elif !defined(__CINT__)
	typedef union {	typedef union {
	void *_read;	void *_read;
	void (*_write)();	void (*_write)();
	} funcptr_and_voidptr;	} funcptr_and_voidptr;
	#endif /* __cplusplus && ! __CINT__*/	#endif /* __cplusplus && ! __CINT__*/

	#endif /* __MAKECINT__ */	#endif /* __MAKECINT__ */
	/**************************************************************************	/**************************************************************************
	* endif #ifndef G__MAKECINT	* endif #ifndef G__MAKECINT
	**************************************************************************/	**************************************************************************/

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

	HelperOps.h	HelperOps.h

	// @(#)root/smatrix:$Id: HelperOps.h 34742 2010-08-06 09:25:40Z moneta $	// @(#)root/smatrix:$Id: HelperOps.h 38791 2011-04-11 09:32:49Z moneta $
	// Authors: J. Palacios 2006	// Authors: J. Palacios 2006

	#ifndef ROOT_Math_HelperOps	#ifndef ROOT_Math_HelperOps
	#define ROOT_Math_HelperOps 1	#define ROOT_Math_HelperOps 1

	// Include files	// Include files

	/** @class HelperOps HelperOps.h Math/HelperOps.h	/** @class HelperOps HelperOps.h Math/HelperOps.h
	*	*
	*	*

	skipping to change at line 541	skipping to change at line 541
	if (check) assert( begin + R::kSize == end);	if (check) assert( begin + R::kSize == end);
	// copy directly the elements	// copy directly the elements
	std::copy(begin, end, lhs.fRep.Array() );	std::copy(begin, end, lhs.fRep.Array() );
	}	}
	}	}

	}; // struct AssignItr	}; // struct AssignItr

	/**	/**
	Specialized structure for assignment to a symmetrix matrix from itera tor.	Specialized structure for assignment to a symmetrix matrix from itera tor.

	Optionally a check isdone that iterator size	Optionally a check is done that iterator size
	is the same as the matrix size	is the same as the matrix size
	*/	*/
	template <class T, unsigned int D1, unsigned int D2>	template <class T, unsigned int D1, unsigned int D2>
	struct AssignItr<T, D1, D2, MatRepSym<T,D1> > {	struct AssignItr<T, D1, D2, MatRepSym<T,D1> > {
	template<class Iterator>	template<class Iterator>
	static void Evaluate(SMatrix<T,D1,D2,MatRepSym<T,D1> >& lhs, Iterator begin, Iterator end, bool , bool lower, bool check = true) {	static void Evaluate(SMatrix<T,D1,D2,MatRepSym<T,D1> >& lhs, Iterator begin, Iterator end, bool , bool lower, bool check = true) {

	if (lower) {	if (lower) {
	if (check) {	if (check) {

	const int size = MatRepSym<T,D1>::kSize;	assert(begin+ static_cast<const int>( MatRepSym<T,D1>::kSize
	assert( begin + size == end);	) == end);
	}	}
	std::copy(begin, end, lhs.fRep.Array() );	std::copy(begin, end, lhs.fRep.Array() );
	}	}
	else {	else {
	Iterator itr = begin;	Iterator itr = begin;
	for (unsigned int i = 0; i < D1; ++i)	for (unsigned int i = 0; i < D1; ++i)
	for (unsigned int j = i; j <D2; ++j) {	for (unsigned int j = i; j <D2; ++j) {
	if (itr != end)	if (itr != end)
	lhs(i,j) = *itr++;	lhs(i,j) = *itr++;
	else	else

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

	Hepevt.h	Hepevt.h

	/* @(#)root/eg:$Id: Hepevt.h 30815 2009-10-20 13:49:22Z rdm $ */	/* @(#)root/eg:$Id: Hepevt.h 38170 2011-02-21 11:18:32Z 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_Hepevt	#ifndef ROOT_Hepevt

	skipping to change at line 25	skipping to change at line 25
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	extern "C" {	extern "C" {

	#ifndef __CFORTRAN_LOADED	#ifndef __CFORTRAN_LOADED
	#include "cfortran.h"	#include "cfortran.h"
	#endif	#endif

	typedef struct {	typedef struct {

	Int_t nevhep;	Int_t nevhep;
	Int_t nhep;	Int_t nhep;
	Int_t isthep[4000];	Int_t isthep[4000];
	Int_t idhep[4000];	Int_t idhep[4000];
	Int_t jmohep[4000][2];	Int_t jmohep[4000][2];
	Int_t jdahep[4000][2];	Int_t jdahep[4000][2];
	Double_t phep[4000][5];	Double_t phep[4000][5];
	Double_t vhep[4000][4];	Double_t vhep[4000][4];
	} HEPEVT_DEF;	} HEPEVT_DEF;

	#define HEPEVT COMMON_BLOCK(HEPEVT,hepevt)	#define HEPEVT COMMON_BLOCK(HEPEVT,hepevt)

	COMMON_BLOCK_DEF(HEPEVT_DEF,HEPEVT);	COMMON_BLOCK_DEF(HEPEVT_DEF,HEPEVT);

	HEPEVT_DEF HEPEVT;	HEPEVT_DEF HEPEVT;

	}	}


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

	Interval.h	Interval.h

	// @(#)root/tmva $Id: Interval.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: Interval.h 38943 2011-04-20 08:03:25Z evt $
	// 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 : Interval *	* Class : Interval *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Generic range definition (used, eg, in genetic algorithm) *	* Generic range definition (used, eg, in genetic algorithm) *

	skipping to change at line 87	skipping to change at line 87
	Double_t GetRndm( TRandom3& ) const;	Double_t GetRndm( TRandom3& ) const;
	Double_t GetElement( Int_t position ) const;	Double_t GetElement( Int_t position ) const;
	Double_t GetStepSize() const;	Double_t GetStepSize() const;

	void SetMax( Double_t m ) { fMax = m; }	void SetMax( Double_t m ) { fMax = m; }
	void SetMin( Double_t m ) { fMin = m; }	void SetMin( Double_t m ) { fMin = m; }

	private:	private:

	Double_t fMin, fMax; // the constraints of the Interval	Double_t fMin, fMax; // the constraints of the Interval

	Int_t fNbins; // when >0 : number of bins (discrete interva l); when =0 continuous interval	Int_t fNbins; // when >0 : number of bins (discrete interva l); when ==0 continuous interval

	static MsgLogger* fgLogger; // message logger	static MsgLogger* fgLogger; // message logger
	MsgLogger& Log() const { return *fgLogger; }	MsgLogger& Log() const { return *fgLogger; }

	ClassDef(Interval,0) // Interval definition, continous and discret e	ClassDef(Interval,0) // Interval definition, continous and discret e
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	MethodBDT.h	MethodBDT.h

	// @(#)root/tmva $Id: MethodBDT.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: MethodBDT.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Jan Therha
		ag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *	* Jan Therhaag <jan.therhaag@cern.ch> - U. of Bonn, Germany *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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_MethodBDT	#ifndef ROOT_TMVA_MethodBDT
	#define ROOT_TMVA_MethodBDT	#define ROOT_TMVA_MethodBDT

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

	skipping to change at line 112	skipping to change at line 113
	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* errUpper = 0);	Double_t GetMvaValue( Double_t* err = 0, Double_t* errUpper = 0);

	private:	private:
	Double_t GetMvaValue( Double_t* err, Double_t* errUpper, UInt_t useNT rees );	Double_t GetMvaValue( Double_t* err, Double_t* errUpper, UInt_t useNT rees );

		Double_t PrivateGetMvaValue( TMVA::Event& ev, Double_t* err=0, Double
		_t* errUpper=0, UInt_t useNTrees=0 );
		void BoostMonitor(Int_t iTree);

	public:	public:
	const std::vector<Float_t>& GetMulticlassValues();	const std::vector<Float_t>& GetMulticlassValues();

	// 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<TMVA::Event>, DecisionTree dt, Int_t iT ree, UInt_t cls = 0);	Double_t Boost( std::vector<TMVA::Event>, DecisionTree dt, Int_t iT ree, UInt_t cls = 0);


	skipping to change at line 159	skipping to change at line 162
	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;


	virtual Bool_t IsSignalLike() { return GetMvaValue() > 0;}
	protected:	protected:
	void DeclareCompatibilityOptions();	void DeclareCompatibilityOptions();

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


		void PreProcessNegativeEventWeights();

	// boosting algorithm (adaptive boosting)	// boosting algorithm (adaptive boosting)
	Double_t AdaBoost( std::vector<TMVA::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<TMVA::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<TMVA::Event>, DecisionTree dt );	Double_t RegBoost( std::vector<TMVA::Event>, DecisionTree dt );

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

	skipping to change at line 235	skipping to change at line 239
	TString fPruneMethodS; // prune method op tion String	TString fPruneMethodS; // prune method op tion String
	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
	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
	Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number but as mean of a possion distr. in each split	Bool_t fUsePoissonNvars; // use "fUseNvars" not as fixed number but as mean of a possion distr. in each split
	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


	Double_t fSampleSizeFraction; // relative siz	Double_t fSampleSizeFraction; // relative
	e of bagged event sample to original sample size	size of bagged event sample to original sample size
		TString fNegWeightTreatment; // variable
		that holds the option of how to treat negative event weights in training
	Bool_t fNoNegWeightsInTraining; // ignore n egative event weights in the training	Bool_t fNoNegWeightsInTraining; // ignore n egative event weights in the training

		Bool_t fInverseBoostNegWeights; // boost ev
		. with neg. weights with 1/boostweight rathre than boostweight
		Bool_t fPairNegWeightsGlobal; // pair ev.
		with neg. and pos. weights in traning sample and "annihilate" them
		Bool_t fPairNegWeightsInNode; // randomly
		pair miscl. ev. with neg. and pos. weights in node and don't boost them
		Bool_t fTrainWithNegWeights; // yes there a
		re negative event weights and we don't ignore them
		Bool_t fDoBoostMonitor; //create control pl
		ot with ROC integral vs tree number

	//some histograms for monitoring	//some histograms for monitoring
	TTree* fMonitorNtuple; // monitoring ntup le	TTree* fMonitorNtuple; // monitoring ntup le
	Int_t fITree; // ntuple var: ith tree	Int_t fITree; // ntuple var: ith tree
	Double_t fBoostWeight; // ntuple var: boo st weight	Double_t fBoostWeight; // ntuple var: boo st weight
	Double_t fErrorFraction; // ntuple var: mis classification error fraction	Double_t fErrorFraction; // ntuple var: mis classification error fraction

	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

End of changes. 8 change blocks.
	6 lines changed or deleted	24 lines changed or added

	MethodBase.h	MethodBase.h

	// @(#)root/tmva $Id: MethodBase.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodBase.h 38719 2011-04-04 12:22:28Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
	i Voss	i Voss, Eckhard von Toerne, Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@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 *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

	* LAPP, Annecy, France *	* U. of Bonn, 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_MethodBase	#ifndef ROOT_TMVA_MethodBase
	#define ROOT_TMVA_MethodBase	#define ROOT_TMVA_MethodBase

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

	skipping to change at line 77	skipping to change at line 79
	#include "TMVA/TransformationHandler.h"	#include "TMVA/TransformationHandler.h"
	#endif	#endif
	#ifndef ROOT_TMVA_OptimizeConfigParameters	#ifndef ROOT_TMVA_OptimizeConfigParameters
	#include "TMVA/OptimizeConfigParameters.h"	#include "TMVA/OptimizeConfigParameters.h"
	#endif	#endif

	class TGraph;	class TGraph;
	class TTree;	class TTree;
	class TDirectory;	class TDirectory;
	class TSpline;	class TSpline;

		class TH1F;
		class TH1D;

	namespace TMVA {	namespace TMVA {

	class Ranking;	class Ranking;
	class PDF;	class PDF;
	class TSpline1;	class TSpline1;
	class MethodCuts;	class MethodCuts;
	class MethodBoost;	class MethodBoost;
	class DataSetInfo;	class DataSetInfo;

	class MethodBase : virtual public IMethod, public Configurable {	class MethodBase : virtual public IMethod, public Configurable {


		friend class Factory;

	public:	public:

	enum EWeightFileType { kROOT=0, kTEXT };	enum EWeightFileType { kROOT=0, kTEXT };

	// default constructur	// default constructur
	MethodBase( const TString& jobName,	MethodBase( const TString& jobName,
	Types::EMVA methodType,	Types::EMVA methodType,
	const TString& methodTitle,	const TString& methodTitle,
	DataSetInfo& dsi,	DataSetInfo& dsi,
	const TString& theOption = "",	const TString& theOption = "",

	skipping to change at line 272	skipping to change at line 278

	// variables (and private menber functions) for the Evaluation:	// variables (and private menber functions) for the Evaluation:
	// get the effiency. It fills a histogram for efficiency/vs/bkg	// get the effiency. It fills a histogram for efficiency/vs/bkg
	// and returns the one value fo the efficiency demanded for	// and returns the one value fo the efficiency demanded for
	// in the TString argument. (Watch the string format)	// in the TString argument. (Watch the string format)
	virtual Double_t GetEfficiency( const TString&, Types::ETreeType, Dou ble_t& err );	virtual Double_t GetEfficiency( const TString&, Types::ETreeType, Dou ble_t& err );
	virtual Double_t GetTrainingEfficiency(const TString& );	virtual Double_t GetTrainingEfficiency(const TString& );
	virtual std::vector<Float_t> GetMulticlassEfficiency( std::vector<std ::vector<Float_t> >& purity );	virtual std::vector<Float_t> GetMulticlassEfficiency( std::vector<std ::vector<Float_t> >& purity );
	virtual std::vector<Float_t> GetMulticlassTrainingEfficiency(std::vec tor<std::vector<Float_t> >& purity );	virtual std::vector<Float_t> GetMulticlassTrainingEfficiency(std::vec tor<std::vector<Float_t> >& purity );
	virtual Double_t GetSignificance() const;	virtual Double_t GetSignificance() const;

		virtual Double_t GetROCIntegral(TH1F histS, TH1F histB) const;
		// virtual Double_t GetROCIntegral(TH1D histS, TH1D histB) con
		st;
	virtual Double_t GetROCIntegral(PDF pdfS=0, PDF pdfB=0) const;	virtual Double_t GetROCIntegral(PDF pdfS=0, PDF pdfB=0) const;
	virtual Double_t GetMaximumSignificance( Double_t SignalEvents, Doubl e_t BackgroundEvents,	virtual Double_t GetMaximumSignificance( Double_t SignalEvents, Doubl e_t BackgroundEvents,
	Double_t& optimal_significan ce_value ) const;	Double_t& optimal_significan ce_value ) const;
	virtual Double_t GetSeparation( TH1, TH1 ) const;	virtual Double_t GetSeparation( TH1, TH1 ) const;
	virtual Double_t GetSeparation( PDF* pdfS = 0, PDF* pdfB = 0 ) const;	virtual Double_t GetSeparation( PDF* pdfS = 0, PDF* pdfB = 0 ) const;

	virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType t ype, Double_t& stddev,Double_t& stddev90Percent ) const;	virtual void GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType t ype, Double_t& stddev,Double_t& stddev90Percent ) const;
	// ---------- public accessors -------------------------------------- ---------	// ---------- public accessors -------------------------------------- ---------

	// classifier naming (a lot of names ... aren't they ;-)	// classifier naming (a lot of names ... aren't they ;-)

	skipping to change at line 313	skipping to change at line 321
	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(); }

	// normalisation and limit accessors	// normalisation and limit accessors
	Double_t GetMean( Int_t ivar ) const { return GetTransformati onHandler().GetMean(ivar); }	Double_t GetMean( Int_t ivar ) const { return GetTransformati onHandler().GetMean(ivar); }
	Double_t GetRMS ( Int_t ivar ) const { return GetTransformati onHandler().GetRMS(ivar); }	Double_t GetRMS ( Int_t ivar ) const { return GetTransformati onHandler().GetRMS(ivar); }
	Double_t GetXmin( Int_t ivar ) const { return GetTransformati onHandler().GetMin(ivar); }	Double_t GetXmin( Int_t ivar ) const { return GetTransformati onHandler().GetMin(ivar); }
	Double_t GetXmax( Int_t ivar ) const { return GetTransformati onHandler().GetMax(ivar); }	Double_t GetXmax( Int_t ivar ) const { return GetTransformati onHandler().GetMax(ivar); }

	// 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; }

		Double_t GetSignalReferenceCutOrientation() const { return fS ignalReferenceCutOrientation; }

	// 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; }

		void SetSignalReferenceCutOrientation( Double_t cutOrient ation ) { fSignalReferenceCutOrientation = cutOrientation; }

	// 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 SetBaseDir( TDirectory* methodDir ){ fBaseDir = meth odDir; }
	void SetMethodBaseDir( TDirectory* methodDir ){ fMethodBa seDir = methodDir; }	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	TransformationHandler& GetTransformationHandler(Bool_t takeRer
	ansformation; }	outedIfAvailable=true)
	const TransformationHandler& GetTransformationHandler() const { retu	{
	rn fTransformation; }	if(fTransformationPointer && takeReroutedIfAvailable) return *f
		TransformationPointer; else return fTransformation;
		}
		const TransformationHandler& GetTransformationHandler(Bool_t takeRer
		outedIfAvailable=true) const
		{
		if(fTransformationPointer && takeReroutedIfAvailable) return *f
		TransformationPointer; else return fTransformation;
		}

		void RerouteTransformationHandler (TransformationHandler*
		fTargetTransformation) { fTransformationPointer=fTargetTransformation; }

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

	skipping to change at line 358	skipping to change at line 376
	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<TMVA::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	virtual Bool_t IsSignalLike();
	alReferenceCut() ? kTRUE : kFALSE; }	virtual Bool_t IsSignalLike(Double_t mvaVal);

	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; }
	Bool_t DoMulticlass() const { return fAnalysisType == Types::kMulticlass; }	Bool_t DoMulticlass() const { return fAnalysisType == Types::kMulticlass; }

	// setter method for suppressing writing to XML and writing of standa lone classes	// setter method for suppressing writing to XML and writing of standa lone classes

	skipping to change at line 477	skipping to change at line 496

	// 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 );
	virtual void AddMulticlassOutput ( Types::ETreeType type );	virtual void AddMulticlassOutput ( Types::ETreeType type );

	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 );	static void CreateVariableTransforms(const TString& trafoDefinit
		ion,
		TMVA::DataSetInfo& dataInfo,
		TMVA::TransformationHandler&
		transformationHandler,
		TMVA::MsgLogger& log );

	// ========== class members ========================================= =========	// ========== 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	Int_t fNbins; // number of bins in inp
	resentative histograms	ut variable histograms
		Int_t fNbinsMVAoutput; // number of bins in MVA
		output 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 es for the regression	std::vector<Float_t>* fRegressionReturnVal; // holds the return-valu es for the regression
	std::vector<Float_t>* fMulticlassReturnVal; // holds the return-valu es for the multiclass classification	std::vector<Float_t>* fMulticlassReturnVal; // holds the return-valu es for the multiclass classification

	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	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

		Double_t fSignalReferenceCutOrientation; // minimum requirem ent 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 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 fConstructedFromWeightFile; // is it obtained from w eight file?	Bool_t fConstructedFromWeightFile; // is it obtained from w eight file?

	skipping to change at line 537	skipping to change at line 562
	TString fWeightFile; // weight file name	TString fWeightFile; // weight file name

	private:	private:

	TH1* fEffS; // efficiency histogram for ro otfinder	TH1* fEffS; // efficiency histogram for ro otfinder

	PDF* fDefaultPDF; // default PDF definitions	PDF* fDefaultPDF; // default PDF definitions
	PDF* fMVAPdfS; // signal MVA PDF	PDF* fMVAPdfS; // signal MVA PDF
	PDF* fMVAPdfB; // background MVA PDF	PDF* fMVAPdfB; // background MVA PDF


		TH1F* fmvaS; // PDFs of MVA distribution (s
		ignal)
		TH1F* fmvaB; // PDFs of MVA distribution (b
		ackground)
	PDF* fSplS; // PDFs of MVA distribution (s ignal)	PDF* fSplS; // PDFs of MVA distribution (s ignal)
	PDF* fSplB; // PDFs of MVA distribution (b ackground)	PDF* fSplB; // PDFs of MVA distribution (b ackground)
	TSpline* fSpleffBvsS; // splines for signal eff. ver sus background eff.	TSpline* fSpleffBvsS; // splines for signal eff. ver sus background eff.

	PDF* fSplTrainS; // PDFs of training MVA distri bution (signal)	PDF* fSplTrainS; // PDFs of training MVA distri bution (signal)
	PDF* fSplTrainB; // PDFs of training MVA distri bution (background)	PDF* fSplTrainB; // PDFs of training MVA distri bution (background)
	TSpline* fSplTrainEffBvsS; // splines for training signal eff. versus background eff.	TSpline* fSplTrainEffBvsS; // splines for training signal eff. versus background eff.

	private:	private:


	skipping to change at line 558	skipping to change at line 585
	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
	TString fVarTransformString; // labels variable tra nsform method	TString fVarTransformString; // labels variable tra nsform method


	TransformationHandler fTransformation; // the list of transfo	TransformationHandler* fTransformationPointer; // pointer to the res
	rmations	t of transformations
		TransformationHandler fTransformation; // the list of transf
		ormations

	// 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


End of changes. 16 change blocks.
	17 lines changed or deleted	55 lines changed or added

	MethodBoost.h	MethodBoost.h

	// @(#)root/tmva $Id: MethodBoost.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodBoost.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss,Or Cohen, J
		an Therhaag, Eckhard von Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* *	* *
	* 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	* Peter Speckmayer <Peter.Speckmazer@cern.ch> - CERN, Switzerland
	*	*
	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, Ger	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland
	many *	*
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canad	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, G
	a *	ermany *
	* Or Cohen <orcohenor@gmail.com> - Weizmann Inst., Israe	* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
	l *	*
	* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany	* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
	*	*
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

	* LAPP, Annecy, France *	* U. of Bonn, 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_MethodBoost	#ifndef ROOT_TMVA_MethodBoost
	#define ROOT_TMVA_MethodBoost	#define ROOT_TMVA_MethodBoost

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

	skipping to change at line 121	skipping to change at line 121
	void Init();	void Init();
	void InitHistos();	void InitHistos();
	void CheckSetup();	void CheckSetup();

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

	MethodBoost* SetStage( Types::EBoostStage stage ) { fBoostStage = sta ge; return this; }	MethodBoost* SetStage( Types::EBoostStage stage ) { fBoostStage = sta ge; return this; }


	//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 t he next one
	void SingleBoost();	void SingleBoost();

	// calculate weight of single method	// calculate weight of single method
	void CalcMethodWeight();	void CalcMethodWeight();

	// return ROC integral on training/testing sample	// return ROC integral on training/testing sample
	Double_t GetBoostROCIntegral(Bool_t, Types::ETreeType, Bool_t CalcOve rlapIntergral=kFALSE);	Double_t GetBoostROCIntegral(Bool_t, Types::ETreeType, Bool_t CalcOve rlapIntergral=kFALSE);


	//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(Types::ETreeType treetype);	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 fMVACutPer c,fMVACutType
	void FindMVACut();	void FindMVACut();


	//setting all the boost weights to 1	// setting all the boost weights to 1
	void ResetBoostWeights();	void ResetBoostWeights();


	//creating the vectors of histogram for monitoring MVA response of ea ch classifier	// creating the vectors of histogram for monitoring MVA response of e ach classifier
	void CreateMVAHistorgrams();	void CreateMVAHistorgrams();

	// calculate MVA values of current trained method on training	// calculate MVA values of current trained method on training
	// sample	// sample
	void CalcMVAValues();	void CalcMVAValues();


	//Number of times the classifier is boosted (set by the user)	Int_t fBoostNum; // Number of times the classi
	Int_t fBoostNum;	fier is boosted
	// string specifying the boost type (AdaBoost / Bagging )	TString fBoostType; // string specifying the boos
	TString fBoostType;	t type
		TString fMethodWeightType; // string specifying the boos
		t type
		Double_t fMethodError; // estimation of the level er
		ror of the classifier
		// analysing the train datase
		t
		Double_t fOrigMethodError; // estimation of the level er
		ror of the classifier
		// analysing the train datase
		t (with unboosted weights)
		Double_t fBoostWeight; // the weight used to boost t
		he next classifier
		TString fTransformString; // min and max values for the
		classifier response
		Bool_t fDetailedMonitoring; // produce detailed monitorin
		g histograms (boost-wise)

		Double_t fADABoostBeta; // ADA boost parameter, defau
		lt is 1
		UInt_t fRandomSeed; // seed for random number gen
		erator used for bagging

		TString fBoostedMethodName; // details of the boosted c
		lassifier
		TString fBoostedMethodTitle; // title
		TString fBoostedMethodOptions; // options


	// string specifying the boost type ( ByError,Average,LastMethod )	std::vector<TH1> fMonitorHist; // histograms to monitor va
	TString fMethodWeightType;	lues during the boosting
		Bool_t fMonitorBoostedMethod; // monitor the MVA response
		of every classifier


	//estimation of the level error of the classifier analysing the train	// MVA output from each classifier over the training hist, using orig
	dataset	nal events weights
	Double_t fMethodError;
	//estimation of the level error of the classifier analysing the train
	dataset (with unboosted weights)
	Double_t fOrigMethodError;

	//the weight used to boost the next classifier
	Double_t fBoostWeight;

	// min and max values for the classifier response
	TString fTransformString;

	//ADA boost parameter, default is 1
	Double_t fADABoostBeta;

	// seed for random number generator used for bagging
	UInt_t fRandomSeed;

	// details of the boosted classifier
	TString fBoostedMethodName;
	TString fBoostedMethodTitle;
	TString fBoostedMethodOptions;

	// histograms to monitor values during the boosting
	std::vector<TH1> fMonitorHist;

	//whether to monitor the MVA response of every classifier using the
	Bool_t fMonitorBoostedMethod;

	//MVA output from each classifier over the training hist, using orign
	al events weights
	std::vector< TH1* > fTrainSigMVAHist;	std::vector< TH1* > fTrainSigMVAHist;
	std::vector< TH1* > fTrainBgdMVAHist;	std::vector< TH1* > fTrainBgdMVAHist;

	//MVA output from each classifier over the training hist, using boost ed events weights	// MVA output from each classifier over the training hist, using boos ted events weights
	std::vector< TH1* > fBTrainSigMVAHist;	std::vector< TH1* > fBTrainSigMVAHist;
	std::vector< TH1* > fBTrainBgdMVAHist;	std::vector< TH1* > fBTrainBgdMVAHist;

	//MVA output from each classifier over the testing hist	// MVA output from each classifier over the testing hist
	std::vector< TH1* > fTestSigMVAHist;	std::vector< TH1* > fTestSigMVAHist;
	std::vector< TH1* > fTestBgdMVAHist;	std::vector< TH1* > fTestBgdMVAHist;


	// tree to monitor values during the boosting	TTree* fMonitorTree; // tree to monitor values du
	TTree* fMonitorTree;	ring the boosting
		Types::EBoostStage fBoostStage; // stage of the boosting
	// the stage of the boosting	Int_t fDefaultHistNum; // number of histogram filled
	Types::EBoostStage fBoostStage;	for every type of boosted classifier
		Bool_t fRecalculateMVACut; // whether to recalculate the
	//the number of histogram filled for every type of boosted classifier	MVA cut at every boosting step
	Int_t fDefaultHistNum;	Double_t fROC_training; // roc integral of last train
		ed method (on training sample)
	//whether to recalculate the MVA cut at every boosting step
	Bool_t fRecalculateMVACut;

	// roc integral of last trained method (on training sample)
	Double_t fROC_training;

	// overlap integral of mva distributions for signal and	// overlap integral of mva distributions for signal and
	// background (training sample)	// background (training sample)

	Double_t fOverlap_integral;	Double_t fOverlap_integral;


	// mva values for the last trained method (on training sample)	std::vector<Float_t> *fMVAvalues; // mva values for the last tr
	std::vector<Float_t> *fMVAvalues;	ained method


	DataSetManager* fDataSetManager; // DSMTEST	DataSetManager* fDataSetManager; // DSMTEST
	friend class Factory; // DSMTEST	friend class Factory; // DSMTEST
	friend class Reader; // DSMTEST	friend class Reader; // DSMTEST

	protected:	protected:

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

	ClassDef(MethodBoost,0)	ClassDef(MethodBoost,0)
	};	};
	}	}


End of changes. 19 change blocks.
	82 lines changed or deleted	76 lines changed or added

	MethodCategory.h	MethodCategory.h

	// @(#)root/tmva $Id: MethodCategory.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodCategory.h 38475 2011-03-17 10:46:00Z evt $
	// 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 96	skipping to change at line 96
	const TString& theVariables,	const TString& theVariables,
	Types::EMVA theMethod,	Types::EMVA theMethod,
	const TString& theTitle,	const TString& theTitle,
	const TString& theOptions);	const TString& theOptions);

	void AddWeightsXMLTo( void* parent ) const;	void AddWeightsXMLTo( void* parent ) const;
	void ReadWeightsFromXML( void* wghtnode );	void ReadWeightsFromXML( void* wghtnode );

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


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

	virtual void MakeClass( const TString& = TString("") ) const {};	virtual void MakeClass( const TString& = TString("") ) const {};

	private :	private :

	// initializing mostly monitoring tools of the category process	// initializing mostly monitoring tools of the category process
	void Init();	void Init();

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

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

	MethodHMatrix.h	MethodHMatrix.h

	// @(#)root/tmva $Id: MethodHMatrix.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodHMatrix.h 38475 2011-03-17 10:46:00Z evt $
	// 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 112	skipping to change at line 112
	// 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();

	// returns chi2 estimator for given type (signal or background)	// returns chi2 estimator for given type (signal or background)

	Double_t GetChi2( Event* e, Types::ESBType ) const;	Double_t GetChi2( Types::ESBType );
	Double_t GetChi2( Types::ESBType ) const;

	// compute correlation matrices	// compute correlation matrices
	void ComputeCovariance( Bool_t, TMatrixD* );	void ComputeCovariance( Bool_t, TMatrixD* );

	// arrays of input evt vs. variable	// arrays of input evt vs. variable
	TMatrixD* fInvHMatrixS; // inverse H-matrix (signal)	TMatrixD* fInvHMatrixS; // inverse H-matrix (signal)
	TMatrixD* fInvHMatrixB; // inverse H-matrix (background)	TMatrixD* fInvHMatrixB; // inverse H-matrix (background)
	TVectorD* fVecMeanS; // vector of mean values (signal)	TVectorD* fVecMeanS; // vector of mean values (signal)
	TVectorD* fVecMeanB; // vector of mean values (background)	TVectorD* fVecMeanB; // vector of mean values (background)


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

	MethodLD.h	MethodLD.h

	skipping to change at line 19	skipping to change at line 19
	* 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, Switzerla nd *	* 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-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* PAN, Poland *	* PAN, Poland *

		* U. of Bonn, 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_MethodLD	#ifndef ROOT_TMVA_MethodLD
	#define ROOT_TMVA_MethodLD	#define ROOT_TMVA_MethodLD


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

	MethodLikelihood.h	MethodLikelihood.h

	// @(#)root/tmva $Id: MethodLikelihood.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodLikelihood.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Peter Spec
		kmayer, Eckhard von Toerne, Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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") *
	* Also implemented is a "diagonalized likelihood approach", *	* Also implemented is a "diagonalized likelihood approach", *
	* which improves over the uncorrelated likelihood ansatz by transform ing *	* which improves over the uncorrelated likelihood ansatz by transform ing *
	* linearly the input variables into a diagonal space, using the squar e-root *	* linearly the input variables into a diagonal space, using the squar e-root *
	* of the covariance matrix. This approach can be chosen by inserting *	* of the covariance matrix. This approach can be chosen by inserting *
	* the letter "D" into the option string. *	* the letter "D" into the option string. *
	* *	* *
	* 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	* Peter Speckmayer <Peter.Speckmazer@cern.ch> - CERN, Switzerland
	y *	*
		* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland
		*
		* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, G
		ermany *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
		*
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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_MethodLikelihood	#ifndef ROOT_TMVA_MethodLikelihood
	#define ROOT_TMVA_MethodLikelihood	#define ROOT_TMVA_MethodLikelihood

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

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

	MethodMLP.h	MethodMLP.h

	// @(#)root/tmva $Id: MethodMLP.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodMLP.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski	// Author: Krzysztof Danielowski, Andreas Hoecker, Matt Jachowski, Kamil Kr
		aszewski, Maciej Kruk, Peter Speckmayer, Joerg Stelzer, Eckhard von Toerne,
		Jan Therhaag, Jiahang Zhong

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* from background. BFGS implementation based on TMultiLayerPerceptro n *	* from background. BFGS implementation based on TMultiLayerPerceptro n *
	* class from ROOT (http://root.cern.ch). *	* class from ROOT (http://root.cern.ch). *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Krzysztof Danielowski <danielow@cern.ch> - IFJ & AGH, Poland *	* Krzysztof Danielowski <danielow@cern.ch> - IFJ & AGH, Poland *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *

	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerlan d *
	* Matt Jachowski <jachowski@stanford.edu> - Stanford Universit y, USA *	* Matt Jachowski <jachowski@stanford.edu> - Stanford Universit y, USA *
	* Kamil Kraszewski <kalq@cern.ch> - IFJ & UJ, Poland *	* Kamil Kraszewski <kalq@cern.ch> - IFJ & UJ, Poland *
	* Maciej Kruk <mkruk@cern.ch> - IFJ & AGH, Poland *	* Maciej Kruk <mkruk@cern.ch> - IFJ & AGH, Poland *

		* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerlan
		d *
		* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany
		*
		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
		*
		* Jiahang Zhong <Jiahang.Zhong@cern.ch> - Academia Sinica, T
		aipei *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *

		* U. of Victoria, Canada
		*
		* MPI-K Heidelberg, Germany
		*
		* U. of Bonn, Germany
		*
	* *	* *
	* Redistribution and use in source and binary forms, with or without *	* 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_MethodMLP	#ifndef ROOT_TMVA_MethodMLP
	#define ROOT_TMVA_MethodMLP	#define ROOT_TMVA_MethodMLP

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

	skipping to change at line 115	skipping to change at line 122
	void Train() { Train(NumCycles()); }	void Train() { Train(NumCycles()); }

	// for GA	// for GA
	Double_t ComputeEstimator ( std::vector<Double_t>& parameters );	Double_t ComputeEstimator ( std::vector<Double_t>& parameters );
	Double_t EstimatorFunction( std::vector<Double_t>& parameters );	Double_t EstimatorFunction( std::vector<Double_t>& parameters );

	enum ETrainingMethod { kBP=0, kBFGS, kGA };	enum ETrainingMethod { kBP=0, kBFGS, kGA };
	enum EBPTrainingMode { kSequential=0, kBatch };	enum EBPTrainingMode { kSequential=0, kBatch };

	bool HasInverseHessian() { return fCalculateErrors; }	bool HasInverseHessian() { return fCalculateErrors; }

	Double_t GetMvaValueAsymError( Double_t* errUpper, Double_t* errLower );	Double_t GetMvaValue( Double_t* err=0, Double_t* errUpper=0 );

	protected:	protected:

	// 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:

	skipping to change at line 221	skipping to change at line 228
	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!)	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


		// regression, storage of deviations
		std::vector<std::pair<Float_t,Float_t> >* fDeviationsFromTargets; //
		deviation from the targets, event weight

		Float_t fWeightRange; // suppress outliers for the estimat
		or calculation

	#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
	Int_t fNumberOfWeights; // Minuit: number of weights	Int_t fNumberOfWeights; // Minuit: number of weights
	static MethodMLP* fgThis; // Minuit: this pointer	static MethodMLP* fgThis; // Minuit: this pointer
	#endif	#endif

	// debugging flags	// debugging flags
	static const Int_t fgPRINT_ESTIMATOR_INC = 10; // debug flags	static const Int_t fgPRINT_ESTIMATOR_INC = 10; // debug flags
	static const Bool_t fgPRINT_SEQ = kFALSE; // debug flags	static const Bool_t fgPRINT_SEQ = kFALSE; // debug flags
	static const Bool_t fgPRINT_BATCH = kFALSE; // debug flags	static const Bool_t fgPRINT_BATCH = kFALSE; // debug flags

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

	MethodPDEFoam.h	MethodPDEFoam.h

	// @(#)root/tmva $Id: MethodPDEFoam.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodPDEFoam.h 38475 2011-03-17 10:46:00Z evt $
	// 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 *
	* the multi-dimensional phase space in a finite number of hyper-recta ngles *	* the multi-dimensional phase space in a finite number of hyper-recta ngles *
	* (cells) of constant event density. This "foam" of cells is filled w ith *	* (cells) of constant event density. This "foam" of cells is filled w ith *
	* averaged probability-density information sampled from a training ev ent *	* averaged probability-density information sampled from a training ev ent *
	* sample. *	* sample. *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Tancredi Carli - CERN, Switzerland *	* Tancredi Carli - CERN, Switzerland *
	* Dominik Dannheim - CERN, Switzerland *	* Dominik Dannheim - CERN, Switzerland *
	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *

	* Alexander Voigt - CERN, Switzerland *	* Alexander Voigt - TU Dresden, Germany *
	* *	* *
	* Original author of the TFoam implementation: *	* Original author of the TFoam implementation: *
	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *	* S. Jadach - Institute of Nuclear Physics, Cracow, Poland *
	* *	* *

	* Copyright (c) 2008: *	* Copyright (c) 2008, 2010: *
	* 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) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_MethodPDEFoam	#ifndef ROOT_TMVA_MethodPDEFoam
	#define ROOT_TMVA_MethodPDEFoam	#define ROOT_TMVA_MethodPDEFoam

	skipping to change at line 74	skipping to change at line 74
	#endif	#endif

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

	#ifndef ROOT_TMVA_PDEFoam	#ifndef ROOT_TMVA_PDEFoam
	#include "TMVA/PDEFoam.h"	#include "TMVA/PDEFoam.h"
	#endif	#endif


		#ifndef ROOT_TMVA_PDEFoamDecisionTree
		#include "TMVA/PDEFoamDecisionTree.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamEvent
		#include "TMVA/PDEFoamEvent.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamDiscriminant
		#include "TMVA/PDEFoamDiscriminant.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamTarget
		#include "TMVA/PDEFoamTarget.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamMultiTarget
		#include "TMVA/PDEFoamMultiTarget.h"
		#endif

		#ifndef ROOT_TMVA_PDEFoamDensityBase
		#include "TMVA/PDEFoamDensityBase.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamTargetDensity
		#include "TMVA/PDEFoamTargetDensity.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamEventDensity
		#include "TMVA/PDEFoamEventDensity.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamDiscriminantDensity
		#include "TMVA/PDEFoamDiscriminantDensity.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamDecisionTreeDensity
		#include "TMVA/PDEFoamDecisionTreeDensity.h"
		#endif

		#ifndef ROOT_TMVA_PDEFoamKernelBase
		#include "TMVA/PDEFoamKernelBase.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamKernelTrivial
		#include "TMVA/PDEFoamKernelTrivial.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamKernelLinN
		#include "TMVA/PDEFoamKernelLinN.h"
		#endif
		#ifndef ROOT_TMVA_PDEFoamKernelGauss
		#include "TMVA/PDEFoamKernelGauss.h"
		#endif

	namespace TMVA {	namespace TMVA {


		// kernel types
		enum EKernel { kNone=0, kGaus=1, kLinN=2 };

	class MethodPDEFoam : public MethodBase {	class MethodPDEFoam : public MethodBase {

	public:	public:

	MethodPDEFoam( const TString& jobName,	MethodPDEFoam( const TString& jobName,
	const TString& methodTitle,	const TString& methodTitle,
	DataSetInfo& dsi,	DataSetInfo& dsi,
	const TString& theOption = "PDEFoam",	const TString& theOption = "PDEFoam",
	TDirectory* theTargetDir = 0 );	TDirectory* theTargetDir = 0 );


	skipping to change at line 100	skipping to change at line 148
	virtual ~MethodPDEFoam( void );	virtual ~MethodPDEFoam( 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 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

		void TrainMultiClassification(); // Classification: one foa m for every class

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

	// write weights to stream	// write weights to stream
	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 file	// write/read pure foams to/from file
	void WriteFoamsToFile() const;	void WriteFoamsToFile() const;
	void ReadFoamsFromFile();	void ReadFoamsFromFile();

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


		// calculate multiclass MVA values
		const std::vector<Float_t>& GetMulticlassValues();

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


		// reset the method
		virtual void Reset();

	// ranking of input variables	// ranking of input variables

	const Ranking* CreateRanking() { return 0; }	const Ranking* CreateRanking();

		// get number of cuts in every dimension, starting at cell
		void GetNCuts(PDEFoamCell *cell, std::vector<UInt_t> &nCuts);

	// helper functions to convert enum types to UInt_t and back	// helper functions to convert enum types to UInt_t and back
	EKernel GetKernel( void ) { return fKernel; }	EKernel GetKernel( void ) { return fKernel; }
	UInt_t KernelToUInt(EKernel ker) const { return UInt_t(ker); }	UInt_t KernelToUInt(EKernel ker) const { return UInt_t(ker); }
	EKernel UIntToKernel(UInt_t iker);	EKernel UIntToKernel(UInt_t iker);
	UInt_t TargetSelectionToUInt(ETargetSelection ts) const { return UInt _t(ts); }	UInt_t TargetSelectionToUInt(ETargetSelection ts) const { return UInt _t(ts); }
	ETargetSelection UIntToTargetSelection(UInt_t its);	ETargetSelection UIntToTargetSelection(UInt_t its);

	protected:	protected:


	skipping to change at line 144	skipping to change at line 202

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

	// calculate Xmin and Xmax for Foam	// calculate Xmin and Xmax for Foam
	void CalcXminXmax();	void CalcXminXmax();

	// Set Xmin, Xmax in foam with index 'foam_index'	// Set Xmin, Xmax in foam with index 'foam_index'
	void SetXminXmax(TMVA::PDEFoam*);	void SetXminXmax(TMVA::PDEFoam*);


	// Set foam options	// create foam and set foam options
	void InitFoam(TMVA::PDEFoam*, EFoamType);	PDEFoam* InitFoam(TString, EFoamType, UInt_t cls=0);

		// create pdefoam kernel
		PDEFoamKernelBase* CreatePDEFoamKernel();

		// delete all trained foams
		void DeleteFoams();

	// fill variable names into foam	// fill variable names into foam
	void FillVariableNamesToFoam() const;	void FillVariableNamesToFoam() const;

	private:	private:

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

	// nice output	// nice output
	void PrintCoefficients( void );	void PrintCoefficients( void );

	// Square function (fastest implementation)	// Square function (fastest implementation)
	template<typename T> T Sqr(T x) const { return x*x; }	template<typename T> T Sqr(T x) const { return x*x; }

	// 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	Float_t fFrac; // Fraction used for calc of Xmin, Xm
	ax	ax
	Double_t fDiscrErrCut; // cut on discrimant error	Float_t fDiscrErrCut; // cut on discrimant error
	Float_t fVolFrac; // inverse volume fraction (used for	Float_t fVolFrac; // volume fraction (used for density
	density calculation during buildup)	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 fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)	Int_t fEvPerBin; // Maximum events (equiv.) per bin in buid-up (1000)

	Bool_t fCompress; // compress foam output 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; // Keep for bw compatibility: Grabbin g cell with maximal RMS to split next (TFoam default)	Bool_t fCutNmin; // Keep for bw compatibility: Grabbin g cell with maximal RMS to split next (TFoam default)
	UInt_t fMaxDepth; // maximum depth of cell tree	UInt_t fMaxDepth; // maximum depth of cell tree

	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()

		PDEFoamKernelBase *fKernelEstimator;// Kernel estimator
	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.)
	Bool_t fFillFoamWithOrigWeights; // fill the foam with boost w eights	Bool_t fFillFoamWithOrigWeights; // fill the foam with boost w eights
	Bool_t fUseYesNoCell; // return -1 or 1 for bg or signal li ke event	Bool_t fUseYesNoCell; // return -1 or 1 for bg or signal li ke event
	TString fDTLogic; // use DT algorithm to split cells	TString fDTLogic; // use DT algorithm to split cells
	EDTSeparation fDTSeparation; // enum which specifies the separatio n to use for the DT logic	EDTSeparation fDTSeparation; // enum which specifies the separatio n to use for the DT logic

	Bool_t fPeekMax; // peek up cell with max. driver inte gral for split	Bool_t fPeekMax; // BACKWARDS COMPATIBILITY: peek up c ell with max. driver integral for split


	std::vector<Double_t> fXmin, fXmax; // range for histograms and foams	std::vector<Float_t> fXmin, fXmax; // range for histograms and foams

	// foams and densities	// foams and densities
	// foam[0]=signal, if Sig and BG are Seperated; else foam[0]=signal/b g	// foam[0]=signal, if Sig and BG are Seperated; else foam[0]=signal/b g
	// foam[1]=background, if Sig and BG are Seperated; else it is not us ed	// foam[1]=background, if Sig and BG are Seperated; else it is not us ed
	std::vector<PDEFoam*> fFoam;	std::vector<PDEFoam*> fFoam;

	// 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) // Multi-dimensional probability density es timator using TFoam (PDE-Foam)
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif // MethodPDEFoam_H	#endif // MethodPDEFoam_H

End of changes. 15 change blocks.
	16 lines changed or deleted	79 lines changed or added

	MethodSVM.h	MethodSVM.h

	// @(#)root/tmva $Id: MethodSVM.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodSVM.h 38719 2011-04-04 12:22:28Z evt $
	// 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 115	skipping to change at line 115
	// 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 DeclareCompatibilityOptions();
	void ProcessOptions();	void ProcessOptions();


	Float_t fCost; // cost value	Float_t fCost; // cost value
	Float_t fTolerance; // tolerance parameter	Float_t fTolerance; // tolerance para
	UInt_t fMaxIter; // max number of iteration	meter
	UShort_t fNSubSets; // nr of subsets, default 1	UInt_t fMaxIter; // max number of
	Float_t fBparm; // free plane coefficient	iteration
	Float_t fGamma; // RBF Kernel parameter	UShort_t fNSubSets; // nr of subsets,
	SVWorkingSet* fWgSet; // svm working set	default 1
	std::vector<TMVA::SVEvent> fInputData; // vector of training	Float_t fBparm; // free plane coe
	data in SVM format	fficient
	std::vector<TMVA::SVEvent> fSupportVectors; // contains support ve	Float_t fGamma; // RBF Kernel par
	ctors	ameter
	SVKernelFunction* fSVKernelFunction; // kernel function	SVWorkingSet* fWgSet; // svm working se
		t
		std::vector<TMVA::SVEvent> fInputData; // vector of trai
		ning data in SVM format
		std::vector<TMVA::SVEvent> fSupportVectors; // contains suppo
		rt vectors
		SVKernelFunction* fSVKernelFunction; // kernel functio
		n


	TVectorD* fMinVars; // for normalization //is i	TVectorD* fMinVars; // for normalizat
	t still needed??	ion //is it still needed??
	TVectorD* fMaxVars; // for normalization //is i	TVectorD* fMaxVars; // for normalizat
	t still needed??	ion //is it still needed??

	// for backward compatibility	// for backward compatibility

	TString fTheKernel; // kernel name	TString fTheKernel; // kernel name
	Float_t fDoubleSigmaSquared; // for RBF Kernel	Float_t fDoubleSigmaSquared; // for RBF Kernel
	Int_t fOrder; // for Polynomial Kernel ( polynomi	Int_t fOrder; // for Polynomial
	al order )	Kernel ( polynomial order )
	Float_t fTheta; // for Sigmoidal Kernel	Float_t fTheta; // for Sigmoidal
	Float_t fKappa; // for Sigmoidal Kernel	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. 4 change blocks.
	23 lines changed or deleted	32 lines changed or added

	MinuitParameter.h	MinuitParameter.h

	// @(#)root/minuit2:$Id: MinuitParameter.h 24400 2008-06-20 07:28:49Z monet a $	// @(#)root/minuit2:$Id: MinuitParameter.h 38242 2011-02-28 11:07:54Z monet a $
	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Minuit2_MinuitParameter	#ifndef ROOT_Minuit2_MinuitParameter
	#define ROOT_Minuit2_MinuitParameter	#define ROOT_Minuit2_MinuitParameter

	skipping to change at line 37	skipping to change at line 37
	possible interactions: Fix/release, set/remove limits, set Value/error;	possible interactions: Fix/release, set/remove limits, set Value/error;

	From version 5.20: use string to store the name to avoid limitation of	From version 5.20: use string to store the name to avoid limitation of
	name length of 20 characters	name length of 20 characters
	*/	*/

	class MinuitParameter {	class MinuitParameter {

	public:	public:


		//default constructor standard with value/error = 0
		MinuitParameter() :
		fNum(0), fValue(0), fError(0.), fConst(false), fFix(false),
		fLoLimit(0.), fUpLimit(0.), fLoLimValid(false), fUpLimValid(false),
		fName("")
		{}

	//constructor for constant Parameter	//constructor for constant Parameter
	MinuitParameter(unsigned int num, const std::string & name, double val) :	MinuitParameter(unsigned int num, const std::string & name, double val) :
	fNum(num), fValue(val), fError(0.), fConst(true), fFix(false),	fNum(num), fValue(val), fError(0.), fConst(true), fFix(false),
	fLoLimit(0.), fUpLimit(0.), fLoLimValid(false), fUpLimValid(false),	fLoLimit(0.), fUpLimit(0.), fLoLimValid(false), fUpLimValid(false),
	fName(name)	fName(name)

	{}	{}

	//constructor for standard Parameter	//constructor for standard Parameter
	MinuitParameter(unsigned int num, const std::string & name, double val, double err) :	MinuitParameter(unsigned int num, const std::string & name, double val, double err) :
	fNum(num), fValue(val), fError(err), fConst(false), fFix(false),	fNum(num), fValue(val), fError(err), fConst(false), fFix(false),
	fLoLimit(0.), fUpLimit(0.), fLoLimValid(false), fUpLimValid(false),	fLoLimit(0.), fUpLimit(0.), fLoLimValid(false), fUpLimValid(false),
	fName(name)	fName(name)
	{}	{}

	//constructor for limited Parameter	//constructor for limited Parameter
	MinuitParameter(unsigned int num, const std::string & name, double val, double err,	MinuitParameter(unsigned int num, const std::string & name, double val, double err,

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

	MnPrint.h	MnPrint.h

	// @(#)root/minuit2:$Id: MnPrint.h 34256 2010-06-30 21:07:32Z moneta $	// @(#)root/minuit2:$Id: MnPrint.h 38953 2011-04-20 09:58:40Z moneta $
	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *	* Copyright (c) 2005 LCG ROOT Math team, CERN/PH-SFT *
	* *	* *
	**********************************************************************/	**********************************************************************/

	#ifndef ROOT_Minuit2_MnPrint	#ifndef ROOT_Minuit2_MnPrint
	#define ROOT_Minuit2_MnPrint	#define ROOT_Minuit2_MnPrint

	skipping to change at line 67	skipping to change at line 67

	class MnMachinePrecision;	class MnMachinePrecision;
	std::ostream& operator<<(std::ostream&, const MnMachinePrecision&);	std::ostream& operator<<(std::ostream&, const MnMachinePrecision&);

	class MinosError;	class MinosError;
	std::ostream& operator<<(std::ostream&, const MinosError&);	std::ostream& operator<<(std::ostream&, const MinosError&);

	class ContoursError;	class ContoursError;
	std::ostream& operator<<(std::ostream&, const ContoursError&);	std::ostream& operator<<(std::ostream&, const ContoursError&);


		// class define static print level values

		class MnPrint {

		public:
		// set print level and return the previous one
		static int SetLevel(int level);

		// return current level
		static int Level();

		// print current minimization state
		static void PrintState(std::ostream & os, const MinimumState &, const ch
		ar * msg, int iter = -1);
		};

	} // namespace Minuit2	} // namespace Minuit2

	} // namespace ROOT	} // namespace ROOT

	// macro to report messages	// macro to report messages

	#ifndef USE_ROOT_ERROR	#ifndef USE_ROOT_ERROR

	#ifndef MNLOG	#ifndef MNLOG
	#define MN_OS std::cerr	#define MN_OS std::cerr

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

	MsgLogger.h	MsgLogger.h

	// @(#)root/tmva $Id: MsgLogger.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MsgLogger.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Attila Krasznahorkay	// Author: Attila Krasznahorkay, Andreas Hoecker, Joerg Stelzer, Eckhard vo
		n Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* *	* *
	* Author: *	* Author: *
	* Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch> - CERN, Switzer land *	* Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch> - CERN, Switzer land *

		* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland
		*
		* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany
		*
		* Eckhard v. Toerne <evt@uni-bonn.de> - U of Bonn, Germany
		*
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *

		* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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_MsgLogger	#ifndef ROOT_TMVA_MsgLogger
	#define ROOT_TMVA_MsgLogger	#define ROOT_TMVA_MsgLogger

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

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

	Node.h	Node.h

	// @(#)root/tmva $Id: Node.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: Node.h 38943 2011-04-20 08:03:25Z evt $
	// 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 *

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

	NumEventsTestStat.h	NumEventsTestStat.h

	// @(#)root/roostats:$Id: NumEventsTestStat.h 36222 2010-10-09 18:27:06Z wo uter $	// @(#)root/roostats:$Id: NumEventsTestStat.h 37983 2011-02-04 16:03:47Z mo neta $
	// 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_NumEventsTestStat	#ifndef ROOSTATS_NumEventsTestStat

	skipping to change at line 42	skipping to change at line 42
	#include "RooStats/SamplingDistribution.h"	#include "RooStats/SamplingDistribution.h"
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"

	#include "RooRealVar.h"	#include "RooRealVar.h"

	namespace RooStats {	namespace RooStats {

	class NumEventsTestStat : public TestStatistic{	class NumEventsTestStat : public TestStatistic{

	public:	public:

		NumEventsTestStat() : fPdf(0) { }
	NumEventsTestStat(RooAbsPdf& pdf) {	NumEventsTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;
	}	}
	virtual ~NumEventsTestStat() {	virtual ~NumEventsTestStat() {
	// delete fRand;	// delete fRand;
	// delete fTestStatistic;	// delete fTestStatistic;
	}	}

	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /paramsOfInter est/) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& /paramsOfInter est/) {

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

	PDEFoam.h	PDEFoam.h

		// @(#)root/tmva $Id: PDEFoam.h 38943 2011-04-20 08:03:25Z evt $
		// Author: S. Jadach, 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 *
	* Classes: PDEFoam *	* Classes: PDEFoam *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Class for PDEFoam object *	* 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 - TU Dresden, Germany *
	* *	* *

	* Copyright (c) 2008: *	* Copyright (c) 2008, 2010: *
	* 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) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_PDEFoam	#ifndef ROOT_TMVA_PDEFoam
	#define ROOT_TMVA_PDEFoam	#define ROOT_TMVA_PDEFoam

	skipping to change at line 63	skipping to change at line 65
	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif
	#ifndef ROOT_TRandom3	#ifndef ROOT_TRandom3
	#include "TRandom3.h"	#include "TRandom3.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {
	class PDEFoamCell;	class PDEFoamCell;
	class PDEFoamVect;	class PDEFoamVect;

	class PDEFoamDistr;	class PDEFoamDensityBase;
		class PDEFoamKernelBase;
	class PDEFoam;	class PDEFoam;


	enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget };	// separation types
		enum EDTSeparation { kFoam, kGiniIndex, kMisClassificationError,
		kCrossEntropy, kGiniIndexWithLaplace, kSdivSqrtSplus
		B };

		// foam types
		enum EFoamType { kSeparate, kDiscr, kMonoTarget, kMultiTarget, kMultiCla
		ss };

		// enum type for possible foam cell values
		// kValue : cell value who's rms is minimized
		// kValueError : error on kValue
		// kValueDensity : volume density of kValue
		// kMeanValue : mean sampling value (saved in fIntegral)
		// kRms : rms of sampling distribution (saved in fDriver)
		// kRmsOvMean : rms/mean of sampling distribution (saved in
		// fDriver and fIntegral)
		enum ECellValue { kValue, kValueError, kValueDensity, kMeanValue,
		kRms, kRmsOvMean, kCellVolume };
	}	}


	#ifndef ROOT_TMVA_PDEFoamDistr	#ifndef ROOT_TMVA_PDEFoamDensityBase
	#include "TMVA/PDEFoamDistr.h"	#include "TMVA/PDEFoamDensityBase.h"
	#endif	#endif
	#ifndef ROOT_TMVA_PDEFoamVect	#ifndef ROOT_TMVA_PDEFoamVect
	#include "TMVA/PDEFoamVect.h"	#include "TMVA/PDEFoamVect.h"
	#endif	#endif
	#ifndef ROOT_TMVA_PDEFoamCell	#ifndef ROOT_TMVA_PDEFoamCell
	#include "TMVA/PDEFoamCell.h"	#include "TMVA/PDEFoamCell.h"
	#endif	#endif

		#ifndef ROOT_TMVA_PDEFoamKernelBase
		#include "TMVA/PDEFoamKernelBase.h"
		#endif

	namespace TMVA {	namespace TMVA {

	enum EKernel { kNone=0, kGaus=1, kLinN=2 };
	enum ETargetSelection { kMean=0, kMpv=1 };
	enum ECellType { kAll, kActive, kInActive };

	// enum type for possible foam cell values
	// kNev : number of events (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)
	// kTargetError : error on target 0 (saved in cell element 1)
	// kMeanValue : mean sampling value (saved in fIntegral)
	// kRms : rms of sampling distribution (saved in fDriver)
	// kRmsOvMean : rms/mean of sampling distribution (saved in
	// fDriver and fIntegral)
	// kDensity : number of events/cell volume
	enum ECellValue { kNev, kDiscriminator, kDiscriminatorError, kTarget0,
	kTarget0Error, kMeanValue, kRms, kRmsOvMean, kDensity
	};
	// separation quantity to use (kFoam: use PDEFoam algorithm)
	enum EDTSeparation { kFoam, kGiniIndex, kMisClassificationError,
	kCrossEntropy };
	}

	namespace TMVA {

	std::ostream& operator<< ( std::ostream& os, const 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
	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 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

	skipping to change at line 133	skipping to change at line 129
	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----------------------------
	TObjArray *fHistEdg; // Histograms of wt, one for each cell edg e	TObjArray *fHistEdg; // Histograms of wt, one for each cell edg e
	Double_t *fRvec; // [fDim] random number vector from r.n. g enerator fDim+1 maximum elements	Double_t *fRvec; // [fDim] random number vector from r.n. g enerator fDim+1 maximum elements
	//----------- Procedures	//----------- Procedures
	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers	TRandom3 *fPseRan; // Pointer to user-defined generator of ps eudorandom numbers
	//---------- 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	EFoamType fFoamType; // BACKWARDS COMPATIBILITY: 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; // BACKWARDS COMPATIBILITY: number of variab les in every 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
	UInt_t fMaxDepth; // maximum depth of cell tree	UInt_t fMaxDepth; // maximum depth of cell tree

	Float_t fVolFrac; // volume fraction (with respect to total ph	Float_t fVolFrac; // BACKWARDS COMPATIBILITY: volume fraction
	ase space	(with respect to total phase space
	Bool_t fFillFoamWithOrigWeights; // fill the foam with boost or orig.	Bool_t fFillFoamWithOrigWeights; // BACKWARDS COMPATIBILITY: fill the
	weights	foam with boost or orig. weights
	EDTSeparation fDTSeparation; // split cells according to decision tre	EDTSeparation fDTSeparation; // BACKWARDS COMPATIBILITY: split cells
	e logic	according to decision tree logic
	Bool_t fPeekMax; // peek up cell with max. driver integral fo	Bool_t fPeekMax; // BACKWARDS COMPATIBILITY: peek up cell wit
	r split	h max. driver integral for split
	PDEFoamDistr *fDistr; //! distribution of training events	PDEFoamDensityBase *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
	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger

	/////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////
	// METHODS //	// METHODS //
	/////////////////////////////////////////////////////////////////	/////////////////////////////////////////////////////////////////

	private:
	// Square function (fastest implementation)
	template<typename T> T Sqr(T x) const { return x*x; }
	PDEFoamDistr* GetDistr() const { assert(fDistr); return fDistr; }

	protected:	protected:
	// ---------- TMVA console output	// ---------- TMVA console output

	void OutputGrow(Bool_t finished = false ); // nice TMVA console outpu t	void OutputGrow(Bool_t finished = false ); // nice TMVA console outpu t


	// ---------- Weighting functions for kernels

	Float_t WeightGaus(PDEFoamCell*, std::vector<Float_t>&, UInt_t dim=0)
	;

	Double_t WeightLinNeighbors( std::vector<Float_t> &txvec, ECellValue
	cv,
	Int_t dim1=-1, Int_t dim2=-1,
	Bool_t TreatEmptyCells=kFALSE );

	// ---------- Foam build-up functions	// ---------- Foam build-up functions

	// Internal foam initialization functions	// Internal foam initialization functions
	void InitCells(); // Initialisation of all foam cel ls	void InitCells(); // Initialisation of all foam cel ls
	Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and r eturn its index	Int_t CellFill(Int_t, PDEFoamCell*);// Allocates new empty cell and r eturn its index

	void Explore(PDEFoamCell *Cell); // Exploration of the new cell, d	virtual void Explore(PDEFoamCell *Cell); // Exploration of the new ce
	etermine <wt>, wtMax etc.	ll, determine <wt>, wtMax etc.
	void DTExplore(PDEFoamCell *Cell); // Exploration of the new cell ac
	cording to decision tree logic
	void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction	void Varedu(Double_t [], Int_t&, Double_t&,Double_t&); // Determines the best edge, variace reduction
	void MakeAlpha(); // Provides random point inside hyperre ctangle	void MakeAlpha(); // Provides random point inside hyperre ctangle
	void Grow(); // build up foam	void Grow(); // build up foam
	Long_t PeekMax(); // peek cell with max. driver integral	Long_t PeekMax(); // peek cell with max. driver integral

	Long_t PeekLast(); // peek last created cell
	Int_t Divide(PDEFoamCell *); // Divide iCell into two daughters; iCe ll retained, taged as inactive	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'	Double_t Eval(Double_t *xRand, Double_t &event_density); // evaluate distribution on point 'xRand'

	Float_t GetSeparation(Float_t s, Float_t b); // calculate separation

	// ---------- Cell value access functions	// ---------- Cell value access functions

	// low level functions to access a certain cell value	// low level functions to access a certain cell value

	Double_t GetCellElement(PDEFoamCell *cell, UInt_t i); // get Element 'i' in cell 'cell'	Double_t GetCellElement(const PDEFoamCell *cell, UInt_t i) const; // 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 SetCellElement(PDEFoamCell *cell, UInt_t i, Double_t value); // set Element 'i' in cell 'cell' to value 'value'


	// helper functions to access cell data
	Double_t GetCellValue(PDEFoamCell*, ECellValue);

	// specific function used during evaluation; determines, whether a ce ll value is undefined	// specific function used during evaluation; determines, whether a ce ll value is undefined

	Bool_t CellValueIsUndefined( PDEFoamCell* );	virtual Bool_t CellValueIsUndefined( PDEFoamCell* );

	// finds cell according to given event variables	// finds cell according to given event variables

	PDEFoamCell* FindCell(std::vector<Float_t>&); //!	PDEFoamCell* FindCell(const std::vector<Float_t>&) const ;
	std::vector<TMVA::PDEFoamCell*> FindCells(std::vector<Float_t>&); //!	std::vector<TMVA::PDEFoamCell*> FindCells(const std::vector<Float_t>&
		) const;
		std::vector<TMVA::PDEFoamCell*> FindCells(const std::map<Int_t,Float_
		t>&) const;
		void FindCells(const std::map<Int_t, Float_t>&, PDEFoamCell*, std::ve
		ctor<PDEFoamCell*> &) const;


	// find cells, which fit a given event vector	// get internal density
	void FindCellsRecursive(std::vector<Float_t>&, PDEFoamCell*,	PDEFoamDensityBase* GetDistr() const { assert(fDistr); return fDistr;
	std::vector<PDEFoamCell*> &);	}

	// calculates the mean/ mpv target values for a given event 'tvals'	// Square function (fastest implementation)
	std::vector<Float_t> GetCellTargets( std::vector<Float_t> &tvals, ETa	template<typename T> T Sqr(T x) const { return x*x; }
	rgetSelection ts );
	// get number of events in cell during foam build-up
	Double_t GetBuildUpCellEvents(PDEFoamCell* cell);

	PDEFoam(const PDEFoam&); // Copy Constructor NOT USED	PDEFoam(const PDEFoam&); // Copy Constructor NOT USED

	// ---------- Public functions ----------------------------------	// ---------- Public functions ----------------------------------
	public:	public:
	PDEFoam(); // Default constructor (used only by ROOT streamer)	PDEFoam(); // Default constructor (used only by ROOT streamer)
	PDEFoam(const TString&); // Principal user-defined constructor	PDEFoam(const TString&); // Principal user-defined constructor
	virtual ~PDEFoam(); // Default destructor	virtual ~PDEFoam(); // Default destructor

	// ---------- Foam creation functions	// ---------- Foam creation functions


	void Init(); // initialize PDEFoamDistr	void Initialize(){}; // initialize the PDEFoam
	void FillBinarySearchTree( const Event* ev, Bool_t NoNegWeights=kFALS	void FillBinarySearchTree( const Event* ev ); // fill event into BST
	E );
	void Create(); // build-up foam	void Create(); // build-up foam

	// function to fill created cell with given value	// function to fill created cell with given value

	void FillFoamCells(const Event* ev, Bool_t NoNegWeights=kFALSE);	virtual void FillFoamCells(const Event* ev, Float_t wt);


	// functions to calc discriminators/ mean targets for every cell	// remove all cell elements
	// using filled cell values	void ResetCellElements();
	void CalcCellDiscr();
	void CalcCellTarget();


	// init TObject pointer on cells	// function to call after foam is grown
	void ResetCellElements(Bool_t allcells = false);	virtual void Finalize(){};

	// ---------- Getters and Setters	// ---------- Getters and Setters

	void SetDim(Int_t kDim); // Sets dimension of cubical space	void SetDim(Int_t kDim); // Sets dimension of cubical space
	void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum numb er of cells	void SetnCells(Long_t nCells){fNCells =nCells;} // Sets maximum numb er of cells
	void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC eve nts in cell exploration	void SetnSampl(Long_t nSampl){fNSampl =nSampl;} // Sets no of MC eve nts in cell exploration
	void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins i n histogs in cell exploration	void SetnBin(Int_t nBin){fNBin = nBin;} // Sets no of bins i n histogs in cell exploration
	void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. n o. of effective events per bin	void SetEvPerBin(Int_t EvPerBin){fEvPerBin =EvPerBin;} // Sets max. n o. of effective events per bin
	void SetInhiDiv(Int_t, Int_t ); // Set inhibition of cell division al ong certain edge	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	void SetDensity(PDEFoamDensityBase *dens) { fDistr = dens; }
	element (TVectorD*)
	void SetVolumeFraction(Float_t vfr){fVolFrac = vfr;} // set VolFrac
	void SetFoamType(EFoamType ft); // set foam type
	void SetFillFoamWithOrigWeights(Bool_t new_val){fFillFoamWithOrigWeig
	hts=new_val;}
	void SetDTSeparation(EDTSeparation new_val){fDTSeparation=new_val;}
	void SetPeekMax(Bool_t new_val){ fPeekMax = new_val; }

	// coverity[ -tainted_data_return ]	// coverity[ -tainted_data_return ]
	Int_t GetTotDim() const {return fDim; } // Get total dimension	Int_t GetTotDim() const {return fDim; } // Get total dimension
	TString GetFoamName() const {return fName; } // Get name of foam	TString GetFoamName() const {return fName; } // Get name of foam

	UInt_t GetNElements() const {return fNElements; } // returns number
	of elements, saved on every cell
	Float_t GetVolumeFraction() const {return fVolFrac;} // get VolFrac
	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 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 GetNInActiveCells() const {return GetNCells()-GetNActiveCell s();}; // returns number of not active cells
	UInt_t GetNCells() const {return fNCells;}; // returns nu mber of cells	UInt_t GetNCells() const {return fNCells;}; // returns nu mber of cells
	PDEFoamCell* GetRootCell() const {return fCells[0];}; // get pointe r to root cell	PDEFoamCell* GetRootCell() const {return fCells[0];}; // get pointe r to root cell

	// Getters and Setters for user cut options	// Getters and Setters for user cut options
	void SetNmin(UInt_t val) { fNmin=val; }	void SetNmin(UInt_t val) { fNmin=val; }
	UInt_t GetNmin() { return fNmin; }	UInt_t GetNmin() { return fNmin; }

	Bool_t GetFillFoamWithOrigWeights() const { return fFillFoamWithOri gWeights; }
	void SetMaxDepth(UInt_t maxdepth) { fMaxDepth = maxdepth; }	void SetMaxDepth(UInt_t maxdepth) { fMaxDepth = maxdepth; }
	UInt_t GetMaxDepth() const { return fMaxDepth; }	UInt_t GetMaxDepth() const { return fMaxDepth; }

	// Getters and Setters for foam boundaries	// Getters and Setters for foam boundaries
	void SetXmin(Int_t idim, Double_t wmin);	void SetXmin(Int_t idim, Double_t wmin);
	void SetXmax(Int_t idim, Double_t wmax);	void SetXmax(Int_t idim, Double_t wmax);
	Double_t GetXmin(Int_t idim) const {return fXmin[idim];}	Double_t GetXmin(Int_t idim) const {return fXmin[idim];}
	Double_t GetXmax(Int_t idim) const {return fXmax[idim];}	Double_t GetXmax(Int_t idim) const {return fXmax[idim];}

	// Getters and Setters for variable names	// Getters and Setters for variable names

	skipping to change at line 287	skipping to change at line 253
	TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjStrin g*>(fVariableNames->At(idx));}	TObjString* GetVariableName(Int_t idx) {return dynamic_cast<TObjStrin g*>(fVariableNames->At(idx));}

	// Delete the fDistr object, which contains the binary search	// Delete the fDistr object, which contains the binary search
	// tree	// tree
	void DeleteBinarySearchTree();	void DeleteBinarySearchTree();

	// ---------- Transformation functions for event variables into foam boundaries	// ---------- Transformation functions for event variables into foam boundaries
	// reason: foam allways has boundaries [0, 1]	// reason: foam allways has boundaries [0, 1]

	Float_t VarTransform(Int_t idim, Float_t x) const; // transform [xmin , xmax] --> [0, 1]	Float_t VarTransform(Int_t idim, Float_t x) const; // transform [xmin , xmax] --> [0, 1]

	std::vector<Float_t> VarTransform(std::vector<Float_t> &invec) const;	std::vector<Float_t> VarTransform(const std::vector<Float_t> &invec) const;
	Float_t VarTransformInvers(Int_t idim, Float_t x) const; // transform [0, 1] --> [xmin, xmax]	Float_t VarTransformInvers(Int_t idim, Float_t x) const; // transform [0, 1] --> [xmin, xmax]

	std::vector<Float_t> VarTransformInvers(std::vector<Float_t> &invec) const;	std::vector<Float_t> VarTransformInvers(const std::vector<Float_t> &i nvec) const;

	// ---------- Debug functions	// ---------- Debug functions

	void CheckAll(Int_t); // Checks correctness of the entire data s tructure in the FOAM object	void CheckAll(Int_t); // Checks correctness of the entire data s tructure in the FOAM object
	void PrintCell(Long_t iCell=0); // Print content of cell	void PrintCell(Long_t iCell=0); // Print content of cell
	void PrintCells(); // Prints content of all cells	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

	// Message logger	// Message logger
	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }


	// ---------- Foam output

	friend std::ostream& operator<< ( std::ostream& os, const PDEFoam& pd
	efoam );
	friend std::istream& operator>> ( std::istream& istr, PDEFoam& pd
	efoam );

	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

	// ---------- Foam projection methods	// ---------- Foam projection methods

	// project foam to two-dimensional histogram	// project foam to two-dimensional histogram

	TH2D* Project2(Int_t idim1, Int_t idim2, const char *opt="cell_value"	virtual TH2D* Project2(Int_t idim1, Int_t idim2, ECellValue cell_valu
	,	e=kValue,
	const char *ker="kNone", UInt_t maxbins=50);	PDEFoamKernelBase *kernel=NULL, UInt_t maxbins=
		50);
	// helper function for Project2()
	Double_t GetProjectionCellValue( PDEFoamCell* cell,
	Int_t idim1, Int_t idim2, ECellValue
	cv );

	// Project one-dimensional foam to a 1-dim histogram	// Project one-dimensional foam to a 1-dim histogram

	TH1D* Draw1Dim(const char *opt, Int_t nbin);	TH1D* Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase * kernel=NULL);

	// Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)	// Generates C++ code (root macro) for drawing foam with boxes (only 2-dim!)
	void RootPlot2dim( const TString& filename, TString opt,	void RootPlot2dim( const TString& filename, TString opt,

	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE
	,	);
	Bool_t log_colors = kFALSE );

	// ---------- Foam evaluation functions	// ---------- Foam evaluation functions

	// get cell value for a given event	// get cell value for a given event

	Double_t GetCellValue(std::vector<Float_t>&, ECellValue);	virtual Float_t GetCellValue( const std::vector<Float_t>& xvec, ECell
		Value cv, PDEFoamKernelBase* );
	// helper functions to access cell data with kernel
	Double_t GetCellDiscr(std::vector<Float_t> &xvec, EKernel kernel=kNon
	e);
	Double_t GetCellDensity(std::vector<Float_t> &xvec, EKernel kernel=kN
	one);


	// calc mean cell value of neighbor cells	// get cell values for a given (incomplete) event vector
	Double_t GetAverageNeighborsValue(std::vector<Float_t> &txvec, ECellV	virtual std::vector<Float_t> GetCellValue( const std::map<Int_t,Float
	alue cv);	_t>& xvec, ECellValue cv );


	// returns regression value (mono target regression)	// get cell value stored in a foam cell
	Double_t GetCellRegValue0(std::vector<Float_t>&, EKernel kernel=kNone	virtual Float_t GetCellValue( const PDEFoamCell* cell, ECellValue cv
	);	);


	// returns regression value i, given all variables (multi target regr	// ---------- friend classes
	ession)	friend class PDEFoamKernelBase;
	std::vector<Float_t> GetProjectedRegValue(std::vector<Float_t> &vals,	friend class PDEFoamKernelTrivial;
	EKernel kernel=kNone, ETargetSelection ts=kMean);	friend class PDEFoamKernelLinN;
		friend class PDEFoamKernelGauss;

	// ---------- ROOT class definition	// ---------- ROOT class definition

	ClassDef(PDEFoam,5) // Tree of PDEFoamCells	ClassDef(PDEFoam,6) // Tree of PDEFoamCells
	}; // end of PDEFoam	}; // end of PDEFoam

	} // namespace TMVA	} // namespace TMVA

	// ---------- Inline functions	// ---------- Inline functions

	//_____________________________________________________________________	//_____________________________________________________________________
	inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x) const	inline Float_t TMVA::PDEFoam::VarTransform(Int_t idim, Float_t x) const
	{	{
	// transform variable x from [xmin, xmax] --> [0, 1]	// transform variable x from [xmin, xmax] --> [0, 1]
	return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);	return (x-fXmin[idim])/(fXmax[idim]-fXmin[idim]);
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________

	inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(std::vector<Float_t > &invec) const	inline std::vector<Float_t> TMVA::PDEFoam::VarTransform(const std::vector<F loat_t> &invec) const
	{	{
	// transform vector invec from [xmin, xmax] --> [0, 1]	// transform vector invec from [xmin, xmax] --> [0, 1]
	std::vector<Float_t> outvec;	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransform(i, invec.at(i)));	outvec.push_back(VarTransform(i, invec.at(i)));
	return outvec;	return outvec;
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________
	inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x) con st	inline Float_t TMVA::PDEFoam::VarTransformInvers(Int_t idim, Float_t x) con st
	{	{
	// transform variable x from [0, 1] --> [xmin, xmax]	// transform variable x from [0, 1] --> [xmin, xmax]
	return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];	return x*(fXmax[idim]-fXmin[idim]) + fXmin[idim];
	}	}

	//_____________________________________________________________________	//_____________________________________________________________________

	inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(std::vector<F loat_t> &invec) const	inline std::vector<Float_t> TMVA::PDEFoam::VarTransformInvers(const std::ve ctor<Float_t> &invec) const
	{	{
	// transform vector invec from [0, 1] --> [xmin, xmax]	// transform vector invec from [0, 1] --> [xmin, xmax]
	std::vector<Float_t> outvec;	std::vector<Float_t> outvec;
	for(UInt_t i=0; i<invec.size(); i++)	for(UInt_t i=0; i<invec.size(); i++)
	outvec.push_back(VarTransformInvers(i, invec.at(i)));	outvec.push_back(VarTransformInvers(i, invec.at(i)));
	return outvec;	return outvec;
	}	}

	#endif	#endif

End of changes. 42 change blocks.
	158 lines changed or deleted	91 lines changed or added

	PDEFoamCell.h	PDEFoamCell.h

		// @(#)root/tmva $Id: PDEFoamCell.h 38475 2011-03-17 10:46:00Z evt $
		// Author: S. Jadach, 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 *
	* Classes: PDEFoamCell *	* Classes: PDEFoamCell *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Objects of this class are hyperrectangular cells organized in *	* Objects of this class are hyperrectangular cells organized in *
	* the binary tree. Special algoritm for encoding relalive *	* the binary tree. Special algoritm for encoding relalive *
	* positioning of the cells saves total memory allocation needed *	* positioning of the cells saves total memory allocation needed *
	* for the system of cells. *	* for the system of cells. *
	* *	* *
	* 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 - TU Dresden, Germany *
	* *	* *
	* Copyright (c) 2008: *	* Copyright (c) 2008: *
	* 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) *
	************************************************************************ ******/	************************************************************************ ******/


	skipping to change at line 106	skipping to change at line 108
	void SetStat(Int_t Stat){ fStatus=Stat;} // Set Status	void SetStat(Int_t Stat){ fStatus=Stat;} // Set Status
	PDEFoamCell* GetPare() const { return (PDEFoamCell*) fParent.GetObjec t(); } // Get Pointer to parent cell	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* 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	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 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 SetDau1(PDEFoamCell* Daug){ fDaught1 = Daug;} // Set point er to 2-nd daughter
	void SetPare(PDEFoamCell* Pare){ fParent = Pare;} // Set point er to parent	void SetPare(PDEFoamCell* Pare){ fParent = Pare;} // Set point er to parent
	void SetSerial(Int_t Serial){ fSerial=Serial;} // Set serial number	void SetSerial(Int_t Serial){ fSerial=Serial;} // Set serial number
	Int_t GetSerial() const { return fSerial;} // Get serial number	Int_t GetSerial() const { return fSerial;} // Get serial number
	UInt_t GetDepth(); // Get depth i n binary tree	UInt_t GetDepth(); // Get depth i n binary tree

		UInt_t GetTreeDepth(UInt_t depth=0); // Get depth o f binary tree
	//--- other ---	//--- other ---
	void Print(Option_t *option) const ; // Prints cell content	void Print(Option_t *option) const ; // Prints cell content
	//--- getter and setter for user variable ---	//--- getter and setter for user variable ---
	void SetElement(TObject* fobj){ fElement = fobj; } // Set user va riable	void SetElement(TObject* fobj){ fElement = fobj; } // Set user va riable
	TObject* GetElement() const { return fElement; } // Get pointer to user varibale	TObject* GetElement() const { return fElement; } // Get pointer to user varibale
	///////////////////////////////////////////////////////////////////// ///////	///////////////////////////////////////////////////////////////////// ///////

	ClassDef(PDEFoamCell,1) //Single cell of FOAM	ClassDef(PDEFoamCell,2) //Single cell of FOAM
	}; // end of PDEFoamCell	}; // end of PDEFoamCell
	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	PDEFoamVect.h	PDEFoamVect.h

		// @(#)root/tmva $Id: PDEFoamVect.h 38475 2011-03-17 10:46:00Z evt $
		// Author: S. Jadach, 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 *
	* Classes: PDEFoamVect *	* Classes: PDEFoamVect *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Auxiliary class PDEFoamVect of n-dimensional vector, with dynamic *	* Auxiliary class PDEFoamVect of n-dimensional vector, with dynamic *
	* allocation used for the cartesian geometry of the PDEFoam cells *	* allocation used for the cartesian geometry of the PDEFoam cells *
	* *	* *
	* 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 - TU Dresden, Germany *
	* *	* *
	* Copyright (c) 2008: *	* Copyright (c) 2008: *
	* 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) *
	************************************************************************ ******/	************************************************************************ ******/


	skipping to change at line 66	skipping to change at line 68
	////////////////////////// OTHER METHODS /////////////////////// ///////////	////////////////////////// OTHER METHODS /////////////////////// ///////////
	PDEFoamVect& operator+=( const PDEFoamVect& ); // +=; add vector u+ =v (FAST)	PDEFoamVect& operator+=( const PDEFoamVect& ); // +=; add vector u+ =v (FAST)
	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 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!!!
	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 Print(Option_t *option) const; // Prints vector
	Int_t GetDim() const { return fDim; } // Returns dimension	Int_t GetDim() const { return fDim; } // Returns dimension
	Double_t GetCoord(Int_t i) const { return fCoords[i]; } // Return s coordinate	Double_t GetCoord(Int_t i) const { return fCoords[i]; } // Return s coordinate


	ClassDef(PDEFoamVect,1) //n-dimensional vector with dynamical allocat ion	ClassDef(PDEFoamVect,2) //n-dimensional vector with dynamical allocat ion
	}; // end of PDEFoamVect	}; // end of PDEFoamVect
	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	PDF.h	PDF.h

	// @(#)root/tmva $Id: PDF.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: PDF.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Asen Christov, Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai V	// Author: Asen Christov, Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai V
	oss	oss , Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 : PDF *	* Class : PDF *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* PDF wrapper for histograms; uses user-defined spline interpolation *	* PDF wrapper for histograms; uses user-defined spline interpolation *
	* and kernel density estimation *	* and kernel density estimation *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Asen Christov <christov@physik.uni-freiburg.de> - Freiburg U., Ge rmany *	* Asen Christov <christov@physik.uni-freiburg.de> - Freiburg U., Ge rmany *
	* 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 *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *
	* Freiburg U., Germany *	* Freiburg U., Germany *

		* U. of Bonn, 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_PDF	#ifndef ROOT_TMVA_PDF
	#define ROOT_TMVA_PDF	#define ROOT_TMVA_PDF

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

	skipping to change at line 88	skipping to change at line 90
	explicit PDF( const TString& name, const TH1* theHist,	explicit PDF( const TString& name, const TH1* theHist,
	KDEKernel::EKernelType ktype, KDEKernel::EKernelIter ki ter, KDEKernel::EKernelBorder	KDEKernel::EKernelType ktype, KDEKernel::EKernelIter ki ter, KDEKernel::EKernelBorder
	kborder, Float_t FineFactor, Bool_t norm=kTRUE );	kborder, Float_t FineFactor, Bool_t norm=kTRUE );
	explicit PDF( const TString& name, const TString& options, const TStr ing& suffix = "", PDF* defaultPDF = 0, Bool_t norm=kTRUE);	explicit PDF( const TString& name, const TString& options, const TStr ing& suffix = "", PDF* defaultPDF = 0, Bool_t norm=kTRUE);
	virtual ~PDF();	virtual ~PDF();

	//creates the pdf after the definitions have been stored in	//creates the pdf after the definitions have been stored in
	void BuildPDF (const TH1* theHist);	void BuildPDF (const TH1* theHist);

	// returns probability density at given abscissa	// returns probability density at given abscissa

	Double_t GetVal( Double_t x ) const;	Double_t GetVal ( Double_t x ) const;
		Double_t GetValInverse( Double_t y, Bool_t isMonotonouslyIncreasingFu
		nction=kFALSE ) const;

	void AddXMLTo( void* parent );	void AddXMLTo( void* parent );
	void ReadXML( void* pdfnode );	void ReadXML( void* pdfnode );

	// histogram underlying the PDF	// histogram underlying the PDF
	TH1* GetPDFHist() const { return fPDFHist; }	TH1* GetPDFHist() const { return fPDFHist; }
	TH1* GetOriginalHist() const { return fHistOriginal; }	TH1* GetOriginalHist() const { return fHistOriginal; }
	TH1* GetSmoothedHist() const { return fHist; }	TH1* GetSmoothedHist() const { return fHist; }
	TH1* GetNSmoothHist() const { return fNSmoothHist; }	TH1* GetNSmoothHist() const { return fNSmoothHist; }


	skipping to change at line 147	skipping to change at line 150
	void FillHistToGraph();	void FillHistToGraph();
	Double_t GetIntegral() const;	Double_t GetIntegral() const;
	Double_t GetPdfHistBinWidth() const {	Double_t GetPdfHistBinWidth() const {
	TH1* h = GetPDFHist();	TH1* h = GetPDFHist();
	return (fPDFHist) ? (h->GetXaxis()->GetXmax() - h->GetXaxis()->Get Xmin())/h->GetNbinsX() : 1;	return (fPDFHist) ? (h->GetXaxis()->GetXmax() - h->GetXaxis()->Get Xmin())/h->GetNbinsX() : 1;
	}	}

	// do we use the original histogram as reference ?	// do we use the original histogram as reference ?
	Bool_t UseHistogram() const { return fUseHistogram; }	Bool_t UseHistogram() const { return fUseHistogram; }


		void FindBinInverse( const TH1* histogram, Int_t& lowerBin, Int_t& hi
		gherBin, Double_t& lowerBinValue, Double_t& higherBinValue,
		Double_t y, Bool_t isMonotonouslyIncreasingFuncti
		on=kFALSE ) const;

	void BuildSplinePDF();	void BuildSplinePDF();

	// flag that indicates that no splines are produced and no smoothing	// flag that indicates that no splines are produced and no smoothing
	// is applied, i.e., the original histogram is used as reference	// is applied, i.e., the original histogram is used as reference
	// this is useful for discrete variables	// this is useful for discrete variables
	Bool_t fUseHistogram; // spline0 uses histogram as reference	Bool_t fUseHistogram; // spline0 uses histogram as reference

	// static configuration variables ----------------------------	// static configuration variables ----------------------------
	// to increase computation speed, the final PDF is filled in	// to increase computation speed, the final PDF is filled in
	// a high-binned histogram; "GetValue" then returns the histogram	// a high-binned histogram; "GetValue" then returns the histogram

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

	PiecewiseInterpolation.h	PiecewiseInterpolation.h

	skipping to change at line 16	skipping to change at line 16
	* 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_ADDITION	#ifndef ROO_PIECEWISEINTERPOLATION
	#define ROO_ADDITION	#define ROO_PIECEWISEINTERPOLATION

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"


		#include "RooObjCacheManager.h"

	class RooRealVar;	class RooRealVar;
	class RooArgList ;	class RooArgList ;

	class PiecewiseInterpolation : public RooAbsReal {	class PiecewiseInterpolation : public RooAbsReal {
	public:	public:

	PiecewiseInterpolation() ;	PiecewiseInterpolation() ;
	PiecewiseInterpolation(const char name, const char title, const RooAbsR eal& nominal, const RooArgList& lowSet, const RooArgList& highSet, const Ro oArgList& paramSet, Bool_t takeOwnerShip=kFALSE) ;	PiecewiseInterpolation(const char name, const char title, const RooAbsR eal& nominal, const RooArgList& lowSet, const RooArgList& highSet, const Ro oArgList& paramSet, Bool_t takeOwnerShip=kFALSE) ;
	virtual ~PiecewiseInterpolation() ;	virtual ~PiecewiseInterpolation() ;


	skipping to change at line 44	skipping to change at line 46
	virtual TObject* clone(const char* newname) const { return new PiecewiseI nterpolation(*this, newname); }	virtual TObject* clone(const char* newname) const { return new PiecewiseI nterpolation(*this, newname); }

	// virtual Double_t defaultErrorLevel() const ;	// virtual Double_t defaultErrorLevel() const ;

	// void printMetaArgs(ostream& os) const ;	// void printMetaArgs(ostream& os) const ;

	const RooArgList& lowList() const { return _lowSet ; }	const RooArgList& lowList() const { return _lowSet ; }
	const RooArgList& highList() const { return _highSet ; }	const RooArgList& highList() const { return _highSet ; }
	const RooArgList& paramList() const { return _paramSet ; }	const RooArgList& paramList() const { return _paramSet ; }


		virtual Bool_t forceAnalyticalInt(const RooAbsArg&) const { return kTRUE
		; }

		Int_t getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, co
		nst RooArgSet* normSet,const char* rangeName=0) const ;
		Double_t analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const
		char* rangeName=0) const ;

		void setPositiveDefinite(bool flag=true){_positiveDefinite=flag;}
	protected:	protected:


		class CacheElem : public RooAbsCacheElement {
		public:
		CacheElem() {} ;
		virtual ~CacheElem() {} ;
		virtual RooArgList containedArgs(Action) {
		RooArgList ret(_funcIntList) ;
		ret.add(_lowIntList);
		ret.add(_highIntList);
		return ret ;
		}
		RooArgList _funcIntList ;
		RooArgList _lowIntList ;
		RooArgList _highIntList ;
		// will want vector<RooRealVar*> for low and high also
		} ;
		mutable RooObjCacheManager _normIntMgr ; // The integration cache manager

	RooRealProxy _nominal; // The nominal value	RooRealProxy _nominal; // The nominal value
	RooArgList _ownedList ; // List of owned components	RooArgList _ownedList ; // List of owned components
	RooListProxy _lowSet ; // Low-side variation	RooListProxy _lowSet ; // Low-side variation
	RooListProxy _highSet ; // High-side varaition	RooListProxy _highSet ; // High-side varaition
	RooListProxy _paramSet ; // interpolation parameters	RooListProxy _paramSet ; // interpolation parameters
	mutable TIterator* _paramIter ; //! Iterator over paramSet	mutable TIterator* _paramIter ; //! Iterator over paramSet
	mutable TIterator* _lowIter ; //! Iterator over lowSet	mutable TIterator* _lowIter ; //! Iterator over lowSet
	mutable TIterator* _highIter ; //! Iterator over highSet	mutable TIterator* _highIter ; //! Iterator over highSet

		Bool_t _positiveDefinite; // protect against negative and 0 bins.

	Double_t evaluate() const;	Double_t evaluate() const;


	ClassDef(PiecewiseInterpolation,1) // Sum of RooAbsReal objects	ClassDef(PiecewiseInterpolation,2) // Sum of RooAbsReal objects
	};	};

	#endif	#endif

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

	ProfileLikelihoodTestStat.h	ProfileLikelihoodTestStat.h

	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 36602 2010-11-11 16:5 2:13Z moneta $	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 38599 2011-03-24 08:3 7:05Z 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 63	skipping to change at line 63
	class ProfileLikelihoodTestStat : public TestStatistic{	class ProfileLikelihoodTestStat : public TestStatistic{

	public:	public:
	ProfileLikelihoodTestStat() {	ProfileLikelihoodTestStat() {
	// Proof constructor. Do not use.	// Proof constructor. Do not use.
	fPdf = 0;	fPdf = 0;
	fProfile = 0;	fProfile = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;

		fOneSided = false;
	}	}
	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;
	fProfile = 0;	fProfile = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;

		fOneSided = false;
	}	}
	virtual ~ProfileLikelihoodTestStat() {	virtual ~ProfileLikelihoodTestStat() {
	// delete fRand;	// delete fRand;
	// delete fTestStatistic;	// delete fTestStatistic;
	if(fProfile) delete fProfile;	if(fProfile) delete fProfile;
	if(fNll) delete fNll;	if(fNll) delete fNll;
	if(fCachedBestFitParams) delete fCachedBestFitParams;	if(fCachedBestFitParams) delete fCachedBestFitParams;
	}	}

		void SetOneSided(Bool_t flag=true) {fOneSided = flag;}

	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {
	if (!&data) {	if (!&data) {
	cout << "problem with data" << endl;	cout << "problem with data" << endl;
	return 0 ;	return 0 ;
	}	}


		RooRealVar* firstPOI = (RooRealVar*) paramsOfInterest.first();
		double initial_mu_value = firstPOI->getVal();
		//paramsOfInterest.getRealValue(firstPOI->GetName());

	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelo w();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBelo w();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	// simple	// simple
	RooAbsReal* nll = fPdf->createNLL(data, RooFit::CloneData(kFALSE));	RooAbsReal* nll = fPdf->createNLL(data, RooFit::CloneData(kFALSE));
	RooAbsReal* profile = nll->createProfile(paramsOfInterest);	RooAbsReal* profile = nll->createProfile(paramsOfInterest);
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	RooArgSet* attachedSet = nll->getVariables();	RooArgSet* attachedSet = nll->getVariables();
	*attachedSet = paramsOfInterest;	*attachedSet = paramsOfInterest;

		// fPdf->setEvalErrorLoggingMode(RooAbsReal::CountErrors);
		// profile->setEvalErrorLoggingMode(RooAbsReal::CountErrors);
		// ((RooProfileLL*)profile)->nll().setEvalErrorLoggingMode(Roo
		AbsReal::CountErrors);
		// nll->setEvalErrorLoggingMode(RooAbsReal::CountErrors);
	double ret = profile->getVal();	double ret = profile->getVal();

		// cout <<"eval errors pdf = "<<fPdf->numEvalErrors() << endl;
		// cout <<"eval errors profile = "<<profile->numEvalErrors() <
		< endl;
		// cout <<"eval errors profile->nll = "<<((RooProfileLL*)profi
		le)->nll().numEvalErrors() << endl;
		// cout <<"eval errors nll = "<<nll->numEvalErrors() << endl;
		// if(profile->numEvalErrors()>0)
		// cout <<"eval errors = "<<profile->numEvalErrors() <
		< endl;
	// paramsOfInterest.Print("v");	// paramsOfInterest.Print("v");

		// cout << "ret = " << ret << endl;

		if(fOneSided){
		double fit_favored_mu = ((RooProfileLL*) profile)->bestFitObs().get
		RealValue(firstPOI->GetName()) ;

		if( fit_favored_mu > initial_mu_value)
		// cout <<"fit-favored_mu, initial value" << fit_favored_mu << "
		" << initial_mu_value<<endl;
		ret = 0 ;
		}
	delete attachedSet;	delete attachedSet;
	delete nll;	delete nll;
	nll = 0;	nll = 0;
	delete profile;	delete profile;
	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);

	// cout << "ret = " << ret << endl;


		//////////////////////////////////////////////////////
	// return here and forget about the following code	// return here and forget about the following code
	return ret;	return ret;


		//////////////////////////////////////////////////////////
	// OLD version with some handling for local minima	// OLD version with some handling for local minima
	// (not used right now)	// (not used right now)

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

	bool needToRebuild = true; // try to avoid rebuilding if possible	bool needToRebuild = true; // try to avoid rebuilding if possible

	if (fLastData == &data) // simple pointer comparison for now (note NLL makes COPY of data)	if (fLastData == &data) // simple pointer comparison for now (note NLL makes COPY of data)
	needToRebuild = false;	needToRebuild = false;
	else fLastData = &data; // keep a copy of pointer to original data	else fLastData = &data; // keep a copy of pointer to original data

	// pointer comparison causing problems. See multiple datasets wit h same value of pointer	// pointer comparison causing problems. See multiple datasets wit h same value of pointer
	// but actually a new dataset	// but actually a new dataset
	needToRebuild = true;	needToRebuild = true;

	skipping to change at line 266	skipping to change at line 294

	// const bool PValueIsRightTail(void) { return false; } // overw rites default	// const bool PValueIsRightTail(void) { return false; } // overw rites default

	private:	private:
	RooProfileLL* fProfile;	RooProfileLL* fProfile;
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf;
	RooNLLVar* fNll;	RooNLLVar* fNll;
	const RooArgSet* fCachedBestFitParams;	const RooArgSet* fCachedBestFitParams;
	RooAbsData* fLastData;	RooAbsData* fLastData;
	// Double_t fLastMLE;	// Double_t fLastMLE;

		Bool_t fOneSided;

	protected:	protected:

	ClassDef(ProfileLikelihoodTestStat,1) // implements the profile lik elihood ratio as a test statistic to be used with several tools	ClassDef(ProfileLikelihoodTestStat,2) // implements the profile lik elihood ratio as a test statistic to be used with several tools
	};	};
	}	}

	#endif	#endif

End of changes. 14 change blocks.
	3 lines changed or deleted	38 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.28/00"	#define ROOT_RELEASE "5.29/02"
	#define ROOT_RELEASE_DATE "Dec 14 2010"	#define ROOT_RELEASE_DATE "Apr 21 2011"
	#define ROOT_RELEASE_TIME "08:34:00"	#define ROOT_RELEASE_TIME "14:56:23"
	#define ROOT_SVN_REVISION 37583	#define ROOT_SVN_REVISION 39003
	#define ROOT_SVN_BRANCH "trunk"	#define ROOT_SVN_BRANCH "trunk"

	#define ROOT_VERSION_CODE 334848	#define ROOT_VERSION_CODE 335106
	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

		#define ROOT_FULL_VERSION_CODE 85787136
		#define ROOT_FULL_VERSION(a,b,c,p) (((a) << 24) + ((b) << 16) + ((c) << 8)
		+ (p))

	#endif	#endif

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

	Reader.h	Reader.h

	// @(#)root/tmva $Id: Reader.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: Reader.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
	i Voss	i Voss, Eckhard von Toerne, Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* MVAs in an analysis context *	* MVAs in an analysis context *
	* *	* *
	* Authors (alphabetical order): *	* Authors (alphabetical order): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <peter.speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany
		*
		* Eckhard v. Toerne <evt@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 *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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://ttmva.sourceforge.net/LICENSE) *	* (http://ttmva.sourceforge.net/LICENSE) *
	************************************************************************ ******/	************************************************************************ ******/

	#ifndef ROOT_TMVA_Reader	#ifndef ROOT_TMVA_Reader
	#define ROOT_TMVA_Reader	#define ROOT_TMVA_Reader

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

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

	Results.h	Results.h

	// @(#)root/tmva $Id: Results.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: Results.h 38475 2011-03-17 10:46:00Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, 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 : Results *	* Class : Results *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Base-class for result-vectors *	* Base-class for result-vectors *

	skipping to change at line 55	skipping to change at line 55
	#endif	#endif

	#ifndef ROOT_TMVA_Types	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"	#include "TMVA/Types.h"
	#endif	#endif
	#ifndef ROOT_TMVA_DataSetInfo	#ifndef ROOT_TMVA_DataSetInfo
	#include "TMVA/DataSetInfo.h"	#include "TMVA/DataSetInfo.h"
	#endif	#endif

	class TH1;	class TH1;

		class TGraph;

	namespace TMVA {	namespace TMVA {

	class DataSet;	class DataSet;
	class MsgLogger;	class MsgLogger;

	class Results {	class Results {

	public:	public:


	skipping to change at line 79	skipping to change at line 80
	void Store( TObject* obj, const char* alias=0 );	void Store( TObject* obj, const char* alias=0 );
	void SetTreeType( Types::ETreeType type ) { fTreeType = type; }	void SetTreeType( Types::ETreeType type ) { fTreeType = type; }

	// getters	// getters
	Types::ETreeType GetTreeType() const { return fTreeType; }	Types::ETreeType GetTreeType() const { return fTreeType; }
	const DataSetInfo* GetDataSetInfo() const { return fDsi; }	const DataSetInfo* GetDataSetInfo() const { return fDsi; }
	DataSet* GetDataSet() const { return fDsi->GetDataSet( ); }	DataSet* GetDataSet() const { return fDsi->GetDataSet( ); }
	TList* GetStorage() const { return fStorage; }	TList* GetStorage() const { return fStorage; }
	TObject* GetObject(const TString & alias) const;	TObject* GetObject(const TString & alias) const;
	TH1* GetHist(const TString & alias) const;	TH1* GetHist(const TString & alias) const;

		TGraph* GetGraph(const TString & alias) const;
	virtual Types::EAnalysisType GetAnalysisType() { return Types::kNoAn alysisType; }	virtual Types::EAnalysisType GetAnalysisType() { return Types::kNoAn alysisType; }

	// delete all stored data	// delete all stored data
	void Delete();	void Delete();

	virtual const std::vector< Float_t >& operator [] ( Int_t ievt ) con st = 0;	virtual const std::vector< Float_t >& operator [] ( Int_t ievt ) con st = 0;

	private:	private:
	Types::ETreeType fTreeType; //! tree type for this res ult	Types::ETreeType fTreeType; //! tree type for this res ult
	const DataSetInfo* fDsi; //! a pointer to the datas etinfo-object	const DataSetInfo* fDsi; //! a pointer to the datas etinfo-object

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

	ResultsMulticlass.h	ResultsMulticlass.h

	// @(#)root/tmva $Id: ResultsMulticlass.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: ResultsMulticlass.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ja
		n Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 : ResultsMulticlass *	* Class : ResultsMulticlass *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Base-class for result-vectors *	* Base-class for result-vectors *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - 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) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* U. of Victoria, Canada *	* U. of Victoria, Canada *
	* MPI-K Heidelberg, Germany *	* MPI-K Heidelberg, Germany *

		* U. of Bonn, 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_ResultsMulticlass	#ifndef ROOT_TMVA_ResultsMulticlass
	#define ROOT_TMVA_ResultsMulticlass	#define ROOT_TMVA_ResultsMulticlass

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

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

	RooNDKeysPdf.h	RooNDKeysPdf.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitModels *	* Package: RooFitModels *

	* File: $Id: RooNDKeysPdf.h 30854 2009-10-23 15:23:44Z wouter $	* File: $Id: RooNDKeysPdf.h 37727 2011-01-06 13:56:56Z wouter $
	* Authors: *	* Authors: *
	* Max Baak, CERN, mbaak@cern.ch *	* Max Baak, CERN, mbaak@cern.ch *
	* *	* *
	* 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) *
	************************************************************************ */	************************************************************************ */

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

	RooPoisson.h	RooPoisson.h

	skipping to change at line 32	skipping to change at line 32
	RooPoisson(const RooPoisson& other, const char* name=0) ;	RooPoisson(const RooPoisson& other, const char* name=0) ;
	virtual TObject* clone(const char* newname) const { return new RooPoisson (*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooPoisson (*this,newname); }
	inline virtual ~RooPoisson() { }	inline virtual ~RooPoisson() { }

	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVars, cons t char* rangeName=0) const ;
	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;

	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;	Int_t getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK=kTRUE) const;
	void generateEvent(Int_t code);	void generateEvent(Int_t code);


		void setNoRounding(bool flag = kTRUE){_noRounding = flag;}
		void protectNegativeMean(bool flag = kTRUE){_protectNegative = flag;}

	protected:	protected:

	RooRealProxy x ;	RooRealProxy x ;
	RooRealProxy mean ;	RooRealProxy mean ;
	Bool_t _noRounding ;	Bool_t _noRounding ;

		Bool_t _protectNegative ;

	Double_t evaluate() const ;	Double_t evaluate() const ;
	Double_t evaluate(Double_t k) const;	Double_t evaluate(Double_t k) const;

	private:	private:


	ClassDef(RooPoisson,2) // A Poisson PDF	ClassDef(RooPoisson,3) // A Poisson PDF
	};	};

	#endif	#endif

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

	RootFinder.h	RootFinder.h

	// @(#)root/tmva $Id: RootFinder.h 29195 2009-06-24 10:39:49Z brun $	// @(#)root/mathmore:$Id: RootFinder.h 33942 2010-06-16 13:12:17Z moneta $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Authors: L. Moneta, A. Zsenei 08/2005


	/**************************************************************************	/**********************************************************************
	********	* *
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	*	* *
	* Package: TMVA	* This library is free software; you can redistribute it and/or *
	*	* modify it under the terms of the GNU General Public License *
	* Class : RootFinder	* as published by the Free Software Foundation; either version 2 *
	*	* 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 *
	* Description:	* General Public License for more details. *
	*	* *
	* Root finding using Brents algorithm	* You should have received a copy of the GNU General Public License *
	*	* along with this library (see file COPYING); if not, write *
	* (translated from CERNLIB function RZERO)	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *
	*	* 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	//
	y *	// Last update: Sun Nov 14 16:59:55 2004
	* 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_TObject	#ifndef ROOT_Math_IFunctionfwd
	#include "TObject.h"	#include "Math/IFunctionfwd.h"
	#endif	#endif


	namespace TMVA {	#ifndef ROOT_Math_IRootFinderMethod
		#include "Math/IRootFinderMethod.h"
	class MsgLogger;	#endif

	class RootFinder : public TObject {

	public:

	RootFinder( Double_t (*rootVal)( Double_t ),
	Double_t rootMin, Double_t rootMax,
	Int_t maxIterations = 100,
	Double_t absTolerance = 0.0 );
	virtual ~RootFinder( void );

	// returns the root of the function
	Double_t Root( Double_t refValue );


	private:	/**
		@defgroup RootFinders One-dimensional Root-Finding algorithms
		Various implementation esists in MathCore and MathMore
		The user interacts with a proxy class ROOT::Math::RootFinder which creat
		es behing
		the choosen algorithms which are implemented using the ROOT::Math::IRoot
		FinderMethod interface

		@ingroup NumAlgo
		*/

		namespace ROOT {
		namespace Math {

		//_________________________________________________________________________
		____________
		/**
		User Class to find the Root of one dimensional functions.
		The GSL Methods are implemented in MathMore and they are loaded au
		tomatically
		via the plug-in manager

		The possible types of Root-finding algorithms are:
		<ul>
		<li>Root Bracketing Algorithms which do not require function deriv
		atives
		<ol>
		<li>RootFinder::kBRENT (default method implemented in MathCore)
		<li>RootFinder::kGSL_BISECTION
		<li>RootFinder::kGSL_FALSE_POS
		<li>RootFinder::kGSL_BRENT
		</ol>
		<li>Root Finding Algorithms using Derivatives
		<ol>
		<li>RootFinder::kGSL_NEWTON
		<li>RootFinder::kGSL_SECANT
		<li>RootFinder::kGSL_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:

		bool 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)
		*/

		bool 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
		*/

		bool SetFunction( const IGradFunction & f, double xstart) {
		return fSolver->SetFunction( f, xstart);
		}

		template<class Function, class Derivative>
		bool Solve(Function &f, Derivative &d, double start,
		int maxIter = 100, double absTol = 1E-8, double relTol =
		1E-10);

		template<class Function>
		bool Solve(Function &f, double min, double max,
		int maxIter = 100, double absTol = 1E-8, double relTol =
		1E-10);

		/**
		Compute the roots iterating until the estimate of the Root is
		within the required tolerance returning
		the iteration Status
		*/
		bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol
		= 1E-10) {
		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 status of the last estimate of the Root
		= 0 OK, not zero failure
		*/
		int Status() const {
		return fSolver->Status();
		}

		/**
		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();
		}

		protected:

		private:

		IRootFinderMethod* fSolver; // type of algorithm to be used


	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


	// function pointer	} // namespace Math
	Double_t (*fGetRootVal)( Double_t );	} // namespace ROOT


	mutable MsgLogger* fLogger; //! message logger	#ifndef ROOT_Math_WrappedFunction
	MsgLogger& Log() const { return *fLogger; }	#include "Math/WrappedFunction.h"
		#endif


	ClassDef(RootFinder,0) // Root finding using Brents algorithm	#ifndef ROOT_Math_Functor
	};	#include "Math/Functor.h"
		#endif


	} // namespace TMVA	template<class Function, class Derivative>
		bool ROOT::Math::RootFinder::Solve(Function &f, Derivative &d, double start
		,
		int maxIter, double absTol, double relTol
		)
		{
		if (!fSolver) return false;
		ROOT::Math::GradFunctor1D wf(f, d);
		bool ret = fSolver->SetFunction(wf, start);
		if (!ret) return false;
		return Solve(maxIter, absTol, relTol);
		}

		template<class Function>
		bool ROOT::Math::RootFinder::Solve(Function &f, double min, double max,
		int maxIter, double absTol, double relTol
		)
		{
		if (!fSolver) return false;
		ROOT::Math::WrappedFunction<Function &> wf(f);
		bool ret = fSolver->SetFunction(wf, min, max);
		if (!ret) return false;
		return Solve(maxIter, absTol, relTol);
		}


	#endif	#endif /* ROOT_Math_RootFinder */

End of changes. 11 change blocks.
	92 lines changed or deleted	254 lines changed or added

	SVEvent.h	SVEvent.h

	// @(#)root/tmva $Id: SVEvent.h 37252 2010-12-04 09:57:53Z evt $	// @(#)root/tmva $Id: SVEvent.h 38719 2011-04-04 12:22:28Z evt $
	// 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 47	skipping to change at line 47

	namespace TMVA	namespace TMVA
	{	{
	class Event;	class Event;

	class SVEvent {	class SVEvent {

	public:	public:

	SVEvent();	SVEvent();

	SVEvent( const Event*, Float_t );	SVEvent( const Event*, Float_t, Bool_t isSignal = kFALSE );
	SVEvent( const std::vector<Float_t>*, Float_t alpha, Int_t typeFlag, UInt_t ns );	SVEvent( const std::vector<Float_t>*, Float_t alpha, Int_t typeFlag, UInt_t ns );
	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t alpha_p, Int_t typeFlag);	SVEvent( const std::vector<Float_t>* svector, Float_t alpha, Float_t alpha_p, 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; }

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

	SamplingDistribution.h	SamplingDistribution.h

	// @(#)root/roostats:$Id: SamplingDistribution.h 36604 2010-11-11 16:58:54Z moneta $	// @(#)root/roostats:$Id: SamplingDistribution.h 38933 2011-04-19 20:15:51Z 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 66	skipping to change at line 66
	// together with the inverse based on sampling variation	// together with the inverse based on sampling variation
	Double_t InverseCDF(Double_t pvalue, Double_t sigmaVariaton, Double_t& inverseVariation);	Double_t InverseCDF(Double_t pvalue, Double_t sigmaVariaton, Double_t& inverseVariation);

	// merge two sampling distributions	// merge two sampling distributions
	void Add(const SamplingDistribution* other);	void Add(const SamplingDistribution* other);

	// size of samples	// size of samples
	Int_t GetSize() const{return fSamplingDist.size();}	Int_t GetSize() const{return fSamplingDist.size();}

	// Get test statistics values	// Get test statistics values

	std::vector<Double_t> GetSamplingDistribution() const {return fSampling Dist;}	const std::vector<Double_t> & GetSamplingDistribution() const {return f SamplingDist;}
	// Get the sampling weights	// Get the sampling weights

	std::vector<Double_t> GetSampleWeights() const {return fSampleWeights;}	const std::vector<Double_t> & GetSampleWeights() const {return fSampleW eights;}

	const TString GetVarName() const {return fVarName;}	const TString GetVarName() const {return fVarName;}

	// numerical integral in these limits	// numerical integral in these limits

	Double_t Integral(Double_t low, Double_t high, Bool_t normalize = kTRUE	Double_t Integral(Double_t low, Double_t high, Bool_t normalize = kTRUE
	) const;	, Bool_t lowClosed = kTRUE, Bool_t highClosed = kFALSE) const;

		// numerical integral in these limits including error estimation
		Double_t IntegralAndError(Double_t & error, Double_t low, Double_t high
		, Bool_t normalize = kTRUE,
		Bool_t lowClosed = kTRUE, Bool_t highClosed =
		kFALSE) const;

	// calculate CDF as a special case of Integral(...) with lower limit eq ual to -inf	// calculate CDF as a special case of Integral(...) with lower limit eq ual to -inf
	Double_t CDF(Double_t x) const;	Double_t CDF(Double_t x) const;

	private:	private:
	std::vector<Double_t> fSamplingDist; // vector of points for the sampli ng distribution	std::vector<Double_t> fSamplingDist; // vector of points for the sampli ng distribution
	std::vector<Double_t> fSampleWeights; // vector of weights for the samp les	std::vector<Double_t> fSampleWeights; // vector of weights for the samp les
	// store a RooRealVar that this distribution corresponds to?	// store a RooRealVar that this distribution corresponds to?

	TString fVarName;	TString fVarName;

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

	SdivSqrtSplusB.h	SdivSqrtSplusB.h

	// @(#)root/tmva $Id: SdivSqrtSplusB.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: SdivSqrtSplusB.h 38943 2011-04-20 08:03:25Z evt $
	// 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 : SdivSqrtSplusB *	* Class : SdivSqrtSplusB *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: Implementation of the SdivSqrtSplusB as separation criterio n *	* Description: Implementation of the SdivSqrtSplusB as separation criterio n *
	* S/sqrt(S + B) *	* S/sqrt(S + B) *

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

	SeparationBase.h	SeparationBase.h

	// @(#)root/tmva $Id: SeparationBase.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: SeparationBase.h 38943 2011-04-20 08:03:25Z evt $
	// 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 : SeparationBase *	* Class : SeparationBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: An interface to different separation critiera useded in var ious *	* Description: An interface to different separation critiera useded in var ious *
	* training algorithms, as there are: *	* training algorithms, as there are: *

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

	SimpleLikelihoodRatioTestStat.h	SimpleLikelihoodRatioTestStat.h

	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 36602 2010-11-11 16:52:13Z moneta $	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 38947 2011-04-20 08:23:25Z moneta $
	/*************************************************************************	/*************************************************************************
	* 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_SimpleLikelihoodRatioTestStat	#ifndef ROOSTATS_SimpleLikelihoodRatioTestStat
	#define ROOSTATS_SimpleLikelihoodRatioTestStat	#define ROOSTATS_SimpleLikelihoodRatioTestStat

	skipping to change at line 33	skipping to change at line 33

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif

	#ifndef ROO_NLL_VAR	#ifndef ROO_NLL_VAR
	#include "RooNLLVar.h"	#include "RooNLLVar.h"
	#endif	#endif

	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"

		#include "RooWorkspace.h"

	namespace RooStats {	namespace RooStats {

	class SimpleLikelihoodRatioTestStat : public TestStatistic {	class SimpleLikelihoodRatioTestStat : public TestStatistic {

	public:	public:

	//__________________________________	//__________________________________
	SimpleLikelihoodRatioTestStat() :	SimpleLikelihoodRatioTestStat() :
	fNullPdf(NULL), fAltPdf(NULL)	fNullPdf(NULL), fAltPdf(NULL)

	skipping to change at line 157	skipping to change at line 158
	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	RooAbsReal *nll;	RooAbsReal *nll;
	nll = fNullPdf->createNLL(data, RooFit::CloneData(kFALSE));	nll = fNullPdf->createNLL(data, RooFit::CloneData(kFALSE));
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	RooArgSet* attachedSet = nll->getVariables();	RooArgSet* attachedSet = nll->getVariables();
	attachedSet = fNullParameters;	attachedSet = fNullParameters;
	*attachedSet = nullPOI;	*attachedSet = nullPOI;
	double nullNLL = nll->getVal();	double nullNLL = nll->getVal();


	delete nll;	delete nll;
	delete attachedSet;	delete attachedSet;

	nll = fAltPdf->createNLL(data, RooFit::CloneData(kFALSE));	nll = fAltPdf->createNLL(data, RooFit::CloneData(kFALSE));
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	attachedSet = nll->getVariables();	attachedSet = nll->getVariables();
	attachedSet = fAltParameters;	attachedSet = fAltParameters;
	double altNLL = nll->getVal();	double altNLL = nll->getVal();


	delete nll;	delete nll;
	delete attachedSet;	delete attachedSet;

	RooMsgService::instance().setGlobalKillBelow(msglevel);	RooMsgService::instance().setGlobalKillBelow(msglevel);
	return nullNLL - altNLL;	return nullNLL - altNLL;
	}	}

	virtual const TString GetVarName() const {	virtual const TString GetVarName() const {
	return "log(L(#mu_{1}) / L(#mu_{0}))";	return "log(L(#mu_{1}) / L(#mu_{0}))";
	}	}

	private:	private:


	RooWorkspace w;	RooWorkspace w;

	RooAbsPdf* fNullPdf;	RooAbsPdf* fNullPdf;
	RooAbsPdf* fAltPdf;	RooAbsPdf* fAltPdf;
	RooArgSet* fNullParameters;	RooArgSet* fNullParameters;
	RooArgSet* fAltParameters;	RooArgSet* fAltParameters;
	bool fFirstEval;	bool fFirstEval;

	protected:	protected:
	ClassDef(SimpleLikelihoodRatioTestStat,1)	ClassDef(SimpleLikelihoodRatioTestStat,1)

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

	TAttMarker.h	TAttMarker.h

	// @(#)root/base:$Id: TAttMarker.h 27860 2009-03-18 08:36:17Z brun $	// @(#)root/base:$Id: TAttMarker.h 38648 2011-03-29 08:02:56Z couet $
	// Author: Rene Brun 12/05/95	// Author: Rene Brun 12/05/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
	virtual void SetMarkerSize(Size_t msize=1) { fMarkerSize = msize ;}	virtual void SetMarkerSize(Size_t msize=1) { fMarkerSize = msize ;}

	ClassDef(TAttMarker,2); //Marker attributes	ClassDef(TAttMarker,2); //Marker attributes
	};	};

	enum EMarkerStyle {kDot=1, kPlus, kStar, kCircle=4, kMultiply=5,	enum EMarkerStyle {kDot=1, kPlus, kStar, kCircle=4, kMultiply=5,
	kFullDotSmall=6, kFullDotMedium=7, kFullDotLarge=8,	kFullDotSmall=6, kFullDotMedium=7, kFullDotLarge=8,
	kFullCircle=20, kFullSquare=21, kFullTriangleUp=22,	kFullCircle=20, kFullSquare=21, kFullTriangleUp=22,
	kFullTriangleDown=23, kOpenCircle=24, kOpenSquare=25,	kFullTriangleDown=23, kOpenCircle=24, kOpenSquare=25,
	kOpenTriangleUp=26, kOpenDiamond=27, kOpenCross=28,	kOpenTriangleUp=26, kOpenDiamond=27, kOpenCross=28,

	kFullStar=29, kOpenStar=30};	kFullStar=29, kOpenStar=30, kOpenTriangleDown=32,
		kFullDiamond=33, kFullCross=34};

	#endif	#endif

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

	TBranchRef.h	TBranchRef.h

	// @(#)root/tree:$Id: TBranchRef.h 37275 2010-12-04 21:32:11Z pcanal $	// @(#)root/tree:$Id: TBranchRef.h 38854 2011-04-14 18:03:34Z pcanal $
	// Author: Rene Brun 19/08/2004	// Author: Rene Brun 19/08/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 32	skipping to change at line 32
	#ifndef ROOT_TBranch	#ifndef ROOT_TBranch
	#include "TBranch.h"	#include "TBranch.h"
	#endif	#endif
	#ifndef ROOT_TRefTable	#ifndef ROOT_TRefTable
	#include "TRefTable.h"	#include "TRefTable.h"
	#endif	#endif

	class TTree;	class TTree;

	class TBranchRef : public TBranch {	class TBranchRef : public TBranch {

		private:
		Long64_t fRequestedEntry; //! Cursor indicating which entry is being
		requested.

	protected:	protected:

	TRefTable *fRefTable; // pointer to the TRefTable	TRefTable *fRefTable; // pointer to the TRefTable

	void ReadLeavesImpl(TBuffer &b);	void ReadLeavesImpl(TBuffer &b);

	public:	public:
	TBranchRef();	TBranchRef();
	TBranchRef(TTree *tree);	TBranchRef(TTree *tree);
	virtual ~TBranchRef();	virtual ~TBranchRef();
	virtual void Clear(Option_t *option="");	virtual void Clear(Option_t *option="");
	virtual Int_t Fill();	virtual Int_t Fill();
	virtual void FillLeaves(TBuffer &b);	virtual void FillLeaves(TBuffer &b);
	TRefTable *GetRefTable() const {return fRefTable;}	TRefTable *GetRefTable() const {return fRefTable;}
	virtual Bool_t Notify();	virtual Bool_t Notify();
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual Int_t SetParent(const TObject* obj, Int_t branchID);	virtual Int_t SetParent(const TObject* obj, Int_t branchID);

	virtual void SetReadEntry(Long64_t entry) {fReadEntry = entry;}	virtual void SetRequestedEntry(Long64_t entry) {fRequestedEntry = ent ry;}

	ClassDef(TBranchRef,1); //to support referenced objects on other branch es	ClassDef(TBranchRef,1); //to support referenced objects on other branch es
	};	};

	#endif	#endif

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

	TCint.h	TCint.h

	// @(#)root/meta:$Id: TCint.h 34701 2010-08-02 20:10:24Z pcanal $	// @(#)root/meta:$Id: TCint.h 38517 2011-03-18 20:20:16Z pcanal $
	// Author: Fons Rademakers 01/03/96	// Author: Fons Rademakers 01/03/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 114	skipping to change at line 114
	Int_t UnloadLibraryMap(const char *library);	Int_t UnloadLibraryMap(const char *library);
	Long_t ProcessLine(const char line, EErrorCode error = 0);	Long_t ProcessLine(const char line, EErrorCode error = 0);
	Long_t ProcessLineAsynch(const char line, EErrorCode error = 0);	Long_t ProcessLineAsynch(const char line, EErrorCode error = 0);
	Long_t ProcessLineSynch(const char line, EErrorCode error = 0);	Long_t ProcessLineSynch(const char line, EErrorCode error = 0);
	void PrintIntro();	void PrintIntro();
	void SetGetline(char(getlineFunc)(const char* prompt),	void SetGetline(char(getlineFunc)(const char* prompt),
	void (histaddFunc)(char line));	void (histaddFunc)(char line));
	void Reset();	void Reset();
	void ResetAll();	void ResetAll();
	void ResetGlobals();	void ResetGlobals();

		void ResetGlobalVar(void *obj);
	void RewindDictionary();	void RewindDictionary();
	Int_t DeleteGlobal(void *obj);	Int_t DeleteGlobal(void *obj);
	void SaveContext();	void SaveContext();
	void SaveGlobalsContext();	void SaveGlobalsContext();
	void UpdateListOfGlobals();	void UpdateListOfGlobals();
	void UpdateListOfGlobalFunctions();	void UpdateListOfGlobalFunctions();
	void UpdateListOfTypes();	void UpdateListOfTypes();
	void SetClassInfo(TClass *cl, Bool_t reload = kFALSE);	void SetClassInfo(TClass *cl, Bool_t reload = kFALSE);
	Bool_t CheckClassInfo(const char *name, Bool_t autoload = kTRUE);	Bool_t CheckClassInfo(const char *name, Bool_t autoload = kTRUE);
	Long_t Calc(const char line, EErrorCode error = 0);	Long_t Calc(const char line, EErrorCode error = 0);

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

	TClassEdit.h	TClassEdit.h

	// @(#)root/base:$Id: TClassEdit.h 33299 2010-04-29 14:43:56Z rdm $	// @(#)root/base:$Id: TClassEdit.h 38309 2011-03-04 17:14:19Z pcanal $
	// Author: Victor Perev 10/04/2003	// Author: Victor Perev 10/04/2003
	// Philippe Canal 05/2004	// Philippe Canal 05/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, 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 44	skipping to change at line 44
	enum EModType {	enum EModType {
	kNone = 0,	kNone = 0,
	kDropTrailStar = 1<<0,	kDropTrailStar = 1<<0,
	kDropDefaultAlloc = 1<<1,	kDropDefaultAlloc = 1<<1,
	kDropAlloc = 1<<2,	kDropAlloc = 1<<2,
	kInnerClass = 1<<3,	kInnerClass = 1<<3,
	kInnedMostClass = 1<<4,	kInnedMostClass = 1<<4,
	kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */	kDropStlDefault = 1<<5, /* implies kDropDefaultAlloc */
	kDropComparator = 1<<6, /* if the class has a comparator, drops BOT H the comparator and the Allocator */	kDropComparator = 1<<6, /* if the class has a comparator, drops BOT H the comparator and the Allocator */
	kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */	kDropAllDefault = 1<<7, /* Drop default template parameter even in non STL classes */

	kLong64 = 1<<8 /* replace all 'long long' with Long64_t. *	kLong64 = 1<<8, /* replace all 'long long' with Long64_t. *
	/	/
		kDropStd = 1<<9 /* Drop any std:: */
	};	};

	enum ESTLType {	enum ESTLType {
	kNotSTL = 0,	kNotSTL = 0,
	kVector = 1,	kVector = 1,
	kList = 2,	kList = 2,
	kDeque = 3,	kDeque = 3,
	kMap = 4,	kMap = 4,
	kMultiMap = 5,	kMultiMap = 5,
	kSet = 6,	kSet = 6,

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

	TError.h	TError.h

	// @(#)root/base:$Id: TError.h 35549 2010-09-21 14:18:04Z rdm $	// @(#)root/base:$Id: TError.h 38832 2011-04-13 17:54:49Z rdm $
	// Author: Fons Rademakers 29/07/95	// Author: Fons Rademakers 29/07/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 90	skipping to change at line 90
	#endif	#endif
	;	;
	extern void Fatal(const char location, const char msgfmt, ...)	extern void Fatal(const char location, const char msgfmt, ...)
	#if defined(__GNUC__) && !defined(__CINT__)	#if defined(__GNUC__) && !defined(__CINT__)
	__attribute__((format(printf, 2, 3)))	__attribute__((format(printf, 2, 3)))
	#endif	#endif
	;	;

	extern void AbstractMethod(const char *method);	extern void AbstractMethod(const char *method);
	extern void MayNotUse(const char *method);	extern void MayNotUse(const char *method);

		extern void Obsolete(const char function, const char asOfVers, const char *removedFromVers);

	R__EXTERN const char *kAssertMsg;	R__EXTERN const char *kAssertMsg;
	R__EXTERN const char *kCheckMsg;	R__EXTERN const char *kCheckMsg;

	#define R__ASSERT(e) \	#define R__ASSERT(e) \
	do { \	do { \
	if (!(e)) ::Fatal("", kAssertMsg, _QUOTE_(e), __LINE__, __FILE__); \	if (!(e)) ::Fatal("", kAssertMsg, _QUOTE_(e), __LINE__, __FILE__); \
	} while (0)	} while (0)
	#define R__CHECK(e) \	#define R__CHECK(e) \
	do { \	do { \

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

	TEvePathMark.h	TEvePathMark.h

	// @(#)root/eve:$Id: TEvePathMark.h 32933 2010-04-09 17:28:46Z matevz $	// @(#)root/eve:$Id: TEvePathMark.h 38721 2011-04-04 13:37:12Z matevz $
	// Author: Matevz Tadel 2010	// Author: Matevz Tadel 2010

	/*************************************************************************	/*************************************************************************
	* 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 45	skipping to change at line 45

	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, TT time=0) :	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, TT time=0) :
	fType(type), fV(v), fP(), fE(), fTime(time) {}	fType(type), fV(v), fP(), fE(), fTime(time) {}

	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, const TEveVectorT< TT>& p, TT time=0) :	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, const TEveVectorT< TT>& p, TT time=0) :
	fType(type), fV(v), fP(p), fE(), fTime(time) {}	fType(type), fV(v), fP(p), fE(), fTime(time) {}

	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, const TEveVectorT< TT>& p, const TEveVectorT<TT>& e, TT time=0) :	TEvePathMarkT(EType_e type, const TEveVectorT<TT>& v, const TEveVectorT< TT>& p, const TEveVectorT<TT>& e, TT time=0) :
	fType(type), fV(v), fP(p), fE(e), fTime(time) {}	fType(type), fV(v), fP(p), fE(e), fTime(time) {}


		template <typename OO>
		TEvePathMarkT(const TEvePathMarkT<OO>& pm) :
		fType((EType_e)pm.fType), fV(pm.fV), fP(pm.fP), fE(pm.fE), fTime(pm.f
		Time) {}

	const char* TypeName();	const char* TypeName();

	ClassDefNV(TEvePathMarkT, 1); // Template for a special point on a track : position/momentum reference, daughter creation or decay.	ClassDefNV(TEvePathMarkT, 1); // Template for a special point on a track : position/momentum reference, daughter creation or decay.
	};	};

	typedef TEvePathMarkT<Float_t> TEvePathMark;	typedef TEvePathMarkT<Float_t> TEvePathMark;
	typedef TEvePathMarkT<Float_t> TEvePathMarkF;	typedef TEvePathMarkT<Float_t> TEvePathMarkF;
	typedef TEvePathMarkT<Double_t> TEvePathMarkD;	typedef TEvePathMarkT<Double_t> TEvePathMarkD;

	#endif	#endif

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

	TEveTrack.h	TEveTrack.h

	// @(#)root/eve:$Id: TEveTrack.h 33864 2010-06-14 09:47:19Z matevz $	// @(#)root/eve:$Id: TEveTrack.h 38721 2011-04-04 13:37:12Z 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 "TEveVector.h"	#include "TEveVector.h"
	#include "TEvePathMark.h"	#include "TEvePathMark.h"

		#include "TEveVSDStructs.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 TEveMCTrack;
	class TParticle;	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:

	typedef std::vector<TEvePathMark> vPathMark_t;	typedef std::vector<TEvePathMarkD> vPathMark_t;
	typedef vPathMark_t::iterator vPathMark_i;	typedef vPathMark_t::iterator vPathMark_i;
	typedef vPathMark_t::const_iterator vPathMark_ci;	typedef vPathMark_t::const_iterator vPathMark_ci;

	// Deprecated -- to be removed.	// Deprecated -- to be removed.
	enum EBreakProjectedTracks_e { kBPTDefault, kBPTAlways, kBPTNever };	enum EBreakProjectedTracks_e { kBPTDefault, kBPTAlways, kBPTNever };

	protected:	protected:

	TEveVector fV; // Starting vertex	TEveVectorD fV; // Starting vertex
	TEveVector fP; // Starting momentum	TEveVectorD fP; // Starting momentum
	TEveVector fPEnd; // Momentum at the last point of extrapo	TEveVectorD fPEnd; // Momentum at the last point of extrapo
	lation	lation
	Double_t fBeta; // Relativistic beta factor	Double_t fBeta; // Relativistic beta factor
	Int_t fPdg; // PDG code	Int_t fPdg; // PDG code
	Int_t fCharge; // Charge in units of e0	Int_t fCharge; // Charge in units of e0
	Int_t fLabel; // Simulation label	Int_t fLabel; // Simulation label
	Int_t fIndex; // Reconstruction index	Int_t fIndex; // Reconstruction index
	Int_t fStatus; // Status-word, user-defined.	Int_t fStatus; // Status-word, user-defined.
	Bool_t fLockPoints; // Lock points that are currently in - d o nothing in MakeTrack().	Bool_t fLockPoints; // Lock points that are currently in - d o nothing in MakeTrack().
	vPathMark_t fPathMarks; // TEveVector of known points along the track	vPathMark_t fPathMarks; // TEveVector of known points along the track
	Int_t fLastPMIdx; //!Last path-mark index tried in track-p ropagation.	Int_t fLastPMIdx; //!Last path-mark index tried in track-p ropagation.

	TEveTrackPropagator *fPropagator; // Pointer to shared render-style	TEveTrackPropagator *fPropagator; // Pointer to shared render-style

	public:	public:
	TEveTrack();	TEveTrack();
	TEveTrack(TParticle* t, Int_t label, TEveTrackPropagator* prop=0);	TEveTrack(TParticle* t, Int_t label, TEveTrackPropagator* prop=0);
	TEveTrack(TEveMCTrack* t, TEveTrackPropagator* prop=0);	TEveTrack(TEveMCTrack* t, TEveTrackPropagator* prop=0);
	TEveTrack(TEveRecTrack* t, TEveTrackPropagator* prop=0);	TEveTrack(TEveRecTrack* t, TEveTrackPropagator* prop=0);

		TEveTrack(TEveRecTrackD* t, TEveTrackPropagator* prop=0);
	TEveTrack(const TEveTrack& t);	TEveTrack(const TEveTrack& t);
	virtual ~TEveTrack();	virtual ~TEveTrack();

	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void SetStdTitle();	virtual void SetStdTitle();

	virtual void SetTrackParams(const TEveTrack& t);	virtual void SetTrackParams(const TEveTrack& t);
	virtual void SetPathMarks (const TEveTrack& t);	virtual void SetPathMarks (const TEveTrack& t);

	virtual void MakeTrack(Bool_t recurse=kTRUE);	virtual void MakeTrack(Bool_t recurse=kTRUE);

	TEveTrackPropagator* GetPropagator() const { return fPropagator; }	TEveTrackPropagator* GetPropagator() const { return fPropagator; }
	Int_t GetLastPMIdx() const { return fLastPMIdx; }	Int_t GetLastPMIdx() const { return fLastPMIdx; }
	void SetPropagator(TEveTrackPropagator* prop);	void SetPropagator(TEveTrackPropagator* prop);
	void SetAttLineAttMarker(TEveTrackList* tl);	void SetAttLineAttMarker(TEveTrackList* tl);


	const TEveVector& GetVertex() const { return fV; }	const TEveVectorD& GetVertex() const { return fV; }
	const TEveVector& GetMomentum() const { return fP; }	const TEveVectorD& GetMomentum() const { return fP; }
	const TEveVector& GetEndMomentum() const { return fPEnd; }	const TEveVectorD& GetEndMomentum() const { return fPEnd; }

	Int_t GetPdg() const { return fPdg; }	Int_t GetPdg() const { return fPdg; }
	void SetPdg(Int_t pdg) { fPdg = pdg; }	void SetPdg(Int_t pdg) { fPdg = pdg; }
	Int_t GetCharge() const { return fCharge; }	Int_t GetCharge() const { return fCharge; }
	void SetCharge(Int_t chg) { fCharge = chg; }	void SetCharge(Int_t chg) { fCharge = chg; }
	Int_t GetLabel() const { return fLabel; }	Int_t GetLabel() const { return fLabel; }
	void SetLabel(Int_t lbl) { fLabel = lbl; }	void SetLabel(Int_t lbl) { fLabel = lbl; }
	Int_t GetIndex() const { return fIndex; }	Int_t GetIndex() const { return fIndex; }
	void SetIndex(Int_t idx) { fIndex = idx; }	void SetIndex(Int_t idx) { fIndex = idx; }
	Int_t GetStatus() const { return fStatus; }	Int_t GetStatus() const { return fStatus; }
	void SetStatus(Int_t idx) { fStatus = idx; }	void SetStatus(Int_t idx) { fStatus = idx; }


	void AddPathMark(const TEvePathMark& pm) { fPathMarks.push_back(pm); }	void AddPathMark(const TEvePathMarkD& pm) { fPathMarks.push_back(pm); }
		void AddPathMark(const TEvePathMark& pm) { fPathMarks.push_back(pm); }

	void SortPathMarksByTime();	void SortPathMarksByTime();
	vPathMark_t& RefPathMarks() { return fPathMarks; }	vPathMark_t& RefPathMarks() { return fPathMarks; }
	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; }

	//-------------------------------------------------------------------	//-------------------------------------------------------------------

	skipping to change at line 131	skipping to change at line 134
	virtual TClass* ProjectedClass(const TEveProjection* p) const;	virtual TClass* ProjectedClass(const TEveProjection* p) const;

	// These functions are deprecated -- use TEveTrackPropagator functions.	// These functions are deprecated -- use TEveTrackPropagator functions.
	// Will be removed after 5.28.	// Will be removed after 5.28.
	Bool_t ShouldBreakTrack() const;	Bool_t ShouldBreakTrack() const;
	UChar_t GetBreakProjectedTracks() const;	UChar_t GetBreakProjectedTracks() const;
	void SetBreakProjectedTracks(UChar_t bt);	void SetBreakProjectedTracks(UChar_t bt);
	static Bool_t GetDefaultBreakProjectedTracks();	static Bool_t GetDefaultBreakProjectedTracks();
	static void SetDefaultBreakProjectedTracks(Bool_t bt);	static void SetDefaultBreakProjectedTracks(Bool_t bt);


	ClassDef(TEveTrack, 1); // Track with given vertex, momentum and optiona l referece-points (path-marks) along its path.	ClassDef(TEveTrack, 0); // Track with given vertex, momentum and optiona l referece-points (path-marks) along its path.
	};	};

	/************************************************************************ **/	/************************************************************************ **/
	// TEveTrackList	// TEveTrackList
	/************************************************************************ **/	/************************************************************************ **/

	class TEveTrackList : public TEveElementList,	class TEveTrackList : public TEveElementList,
	public TAttMarker,	public TAttMarker,
	public TAttLine	public TAttLine
	{	{

	skipping to change at line 156	skipping to change at line 159
	TEveTrackList& operator=(const TEveTrackList&); // Not implemented	TEveTrackList& operator=(const TEveTrackList&); // Not implemented

	protected:	protected:
	TEveTrackPropagator* fPropagator; // Basic track rendering parameters, not enforced to elements.	TEveTrackPropagator* fPropagator; // Basic track rendering parameters, not enforced to elements.

	Bool_t fRecurse; // Recurse when propagating marker/lin e/etc attributes to tracks.	Bool_t fRecurse; // Recurse when propagating marker/lin e/etc attributes to tracks.

	Bool_t fRnrLine; // Render track as line.	Bool_t fRnrLine; // Render track as line.
	Bool_t fRnrPoints; // Render track as points.	Bool_t fRnrPoints; // Render track as points.


	Float_t fMinPt; // Minimum track pT for display select	Double_t fMinPt; // Minimum track pTfor display selecti
	ion.	on.
	Float_t fMaxPt; // Maximum track pT for display select	Double_t fMaxPt; // Maximum track pTfor display selecti
	ion.	on.
	Float_t fLimPt; // Highest track pT in the container.	Double_t fLimPt; // Highest track pT in the container.
	Float_t fMinP; // Minimum track p for display selecti	Double_t fMinP; // Minimum track pfor display selectio
	on.	n.
	Float_t fMaxP; // Maximum track p for display selecti	Double_t fMaxP; // Maximum track pfor display selectio
	on.	n.
	Float_t fLimP; // Highest track p in the container.	Double_t fLimP; // Highest track p in the container.

	void FindMomentumLimits(TEveElement* el, Bool_t recurse=kTRUE);	void FindMomentumLimits(TEveElement* el, Bool_t recurse=kTRUE);
	Float_t RoundMomentumLimit(Float_t x);	Double_t RoundMomentumLimit(Double_t x);
	void SanitizeMinMaxCuts();	void SanitizeMinMaxCuts();

	public:	public:
	TEveTrackList(TEveTrackPropagator* prop=0);	TEveTrackList(TEveTrackPropagator* prop=0);
	TEveTrackList(const char* name, TEveTrackPropagator* prop=0);	TEveTrackList(const char* name, TEveTrackPropagator* prop=0);
	virtual ~TEveTrackList();	virtual ~TEveTrackList();

	void MakeTracks(Bool_t recurse=kTRUE);	void MakeTracks(Bool_t recurse=kTRUE);
	void FindMomentumLimits(Bool_t recurse=kTRUE);	void FindMomentumLimits(Bool_t recurse=kTRUE);

	void SetPropagator(TEveTrackPropagator* prop);	void SetPropagator(TEveTrackPropagator* prop);

	skipping to change at line 206	skipping to change at line 209
	virtual void SetMarkerStyle(Style_t s, TEveElement* el);	virtual void SetMarkerStyle(Style_t s, TEveElement* el);

	void SetRnrLine(Bool_t rnr);	void SetRnrLine(Bool_t rnr);
	void SetRnrLine(Bool_t rnr, TEveElement* el);	void SetRnrLine(Bool_t rnr, TEveElement* el);
	Bool_t GetRnrLine() const { return fRnrLine; }	Bool_t GetRnrLine() const { return fRnrLine; }

	void SetRnrPoints(Bool_t r);	void SetRnrPoints(Bool_t r);
	void SetRnrPoints(Bool_t r, TEveElement* el);	void SetRnrPoints(Bool_t r, TEveElement* el);
	Bool_t GetRnrPoints() const { return fRnrPoints; }	Bool_t GetRnrPoints() const { return fRnrPoints; }


	void SelectByPt(Float_t min_pt, Float_t max_pt);	void SelectByPt(Double_t min_pt, Double_t max_pt);
	void SelectByPt(Float_t min_pt, Float_t max_pt, TEveElement* el);	void SelectByPt(Double_t min_pt, Double_t max_pt, TEveElement* el);
	void SelectByP (Float_t min_p, Float_t max_p);	void SelectByP (Double_t min_p, Double_t max_p);
	void SelectByP (Float_t min_p, Float_t max_p, TEveElement* el);	void SelectByP (Double_t min_p, Double_t max_p, TEveElement* el);

	Float_t GetMinPt() const { return fMinPt; }	Double_t GetMinPt() const { return fMinPt; }
	Float_t GetMaxPt() const { return fMaxPt; }	Double_t GetMaxPt() const { return fMaxPt; }
	Float_t GetLimPt() const { return fLimPt; }	Double_t GetLimPt() const { return fLimPt; }
	Float_t GetMinP() const { return fMinP; }	Double_t GetMinP() const { return fMinP; }
	Float_t GetMaxP() const { return fMaxP; }	Double_t GetMaxP() const { return fMaxP; }
	Float_t GetLimP() const { return fLimP; }	Double_t GetLimP() const { return fLimP; }

	//-------------------------------------------------------------------	//-------------------------------------------------------------------

	TEveTrack* FindTrackByLabel(Int_t label); // MENU	TEveTrack* FindTrackByLabel(Int_t label); // MENU
	TEveTrack* FindTrackByIndex(Int_t index); // MENU	TEveTrack* FindTrackByIndex(Int_t index); // MENU

	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;

End of changes. 11 change blocks.
	37 lines changed or deleted	40 lines changed or added

	TEveTrackPropagator.h	TEveTrackPropagator.h

	// @(#)root/eve:$Id: TEveTrackPropagator.h 33627 2010-05-27 19:19:58Z matev z $	// @(#)root/eve:$Id: TEveTrackPropagator.h 38739 2011-04-05 14:16:41Z 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40
	{	{
	protected:	protected:
	Bool_t fFieldConstant;	Bool_t fFieldConstant;

	public:	public:
	TEveMagField(): fFieldConstant(kFALSE){}	TEveMagField(): fFieldConstant(kFALSE){}
	virtual ~TEveMagField(){}	virtual ~TEveMagField(){}

	virtual Bool_t IsConst() const {return fFieldConstant;};	virtual Bool_t IsConst() const {return fFieldConstant;};


	virtual void PrintField(Float_t x, Float_t y, Float_t z) const	virtual void PrintField(Double_t x, Double_t y, Double_t z) const
	{	{
	TEveVector b = GetField(x, y, z);	TEveVector b = GetField(x, y, z);
	printf("v(%f, %f, %f) B(%f, %f, %f) \n", x, y, z, b.fX, b.fY, b.fZ);	printf("v(%f, %f, %f) B(%f, %f, %f) \n", x, y, z, b.fX, b.fY, b.fZ);
	}	}


	virtual TEveVector GetField(const TEveVector &v) const { return GetField	TEveVectorD GetFieldD(const TEveVectorD &v) const { return GetFieldD(v.f
	(v.fX, v.fY, v.fZ);}	X, v.fY, v.fZ); }
	virtual TEveVector GetField(Float_t x, Float_t y, Float_t z) const = 0;
		// Track propgator uses only GetFieldD() and GetMaxFieldMagD(). Have to
		keep/reuse
		// GetField() and GetMaxFieldMag() because of backward compatibility.

		virtual TEveVectorD GetFieldD(Double_t x, Double_t y, Double_t z) const
		{ return GetField(x, y, z); }
		virtual Double_t GetMaxFieldMagD() const { return GetMaxFieldMag(); } //
		not abstract because of backward compatibility

		virtual TEveVector GetField(Float_t, Float_t, Float_t) const { return TE
		veVector(); }
	virtual Float_t GetMaxFieldMag() const { return 4; } // not abstract bec ause of backward compatibility	virtual Float_t GetMaxFieldMag() const { return 4; } // not abstract bec ause of backward compatibility

	ClassDef(TEveMagField, 0); // Abstract interface to magnetic field	ClassDef(TEveMagField, 0); // Abstract interface to magnetic field
	};	};

	//========================================================================= =====	//========================================================================= =====
	// TEveMagFieldConst	// TEveMagFieldConst
	//========================================================================= =====	//========================================================================= =====

	class TEveMagFieldConst : public TEveMagField	class TEveMagFieldConst : public TEveMagField
	{	{
	protected:	protected:

	TEveVector fB;	TEveVectorD fB;

	public:	public:

	TEveMagFieldConst(Float_t x, Float_t y, Float_t z) : TEveMagField(), fB( x, y, z)	TEveMagFieldConst(Double_t x, Double_t y, Double_t z) : TEveMagField(), fB(x, y, z)
	{ fFieldConstant = kTRUE; }	{ fFieldConstant = kTRUE; }
	virtual ~TEveMagFieldConst() {}	virtual ~TEveMagFieldConst() {}

	using TEveMagField::GetField;	using TEveMagField::GetField;

	virtual TEveVector GetField(Float_t /x/, Float_t /y/, Float_t /z/)	virtual TEveVectorD GetFieldD(Double_t /x/, Double_t /y/, Double_t /
	const { return fB; }	z/) const { return fB; }
	virtual Float_t GetMaxFieldMag() const { return fB.Mag(); };	virtual Double_t GetMaxFieldMagD() const { return fB.Mag(); };

	ClassDef(TEveMagFieldConst, 0); // Interface to constant magnetic field.	ClassDef(TEveMagFieldConst, 0); // Interface to constant magnetic field.
	};	};

	//========================================================================= =====	//========================================================================= =====
	// TEveMagFieldDuo	// TEveMagFieldDuo
	//========================================================================= =====	//========================================================================= =====

	class TEveMagFieldDuo : public TEveMagField	class TEveMagFieldDuo : public TEveMagField
	{	{
	protected:	protected:

	TEveVector fBIn;	TEveVectorD fBIn;
	TEveVector fBOut;	TEveVectorD fBOut;
	Float_t fR2;	Double_t fR2;

	public:	public:

	TEveMagFieldDuo(Float_t r, Float_t bIn, Float_t bOut) : TEveMagField(),	TEveMagFieldDuo(Double_t r, Double_t bIn, Double_t bOut) : TEveMagField( ),
	fBIn(0,0,bIn), fBOut(0,0,bOut), fR2(r*r)	fBIn(0,0,bIn), fBOut(0,0,bOut), fR2(r*r)
	{	{
	fFieldConstant = kFALSE;	fFieldConstant = kFALSE;
	}	}
	virtual ~TEveMagFieldDuo() {}	virtual ~TEveMagFieldDuo() {}

	using TEveMagField::GetField;	using TEveMagField::GetField;

	virtual TEveVector GetField(Float_t x, Float_t y, Float_t /z/) const	virtual TEveVectorD GetFieldD(Double_t x, Double_t y, Double_t /z/) co nst
	{ return ((xx+yy)<fR2) ? fBIn : fBOut; }	{ return ((xx+yy)<fR2) ? fBIn : fBOut; }

	virtual Float_t GetMaxFieldMag() const
	{ Float_t b1 = fBIn.Mag(), b2 = fBOut.Mag(); return b1 > b2 ? b1 : b2; }	virtual Double_t GetMaxFieldMagD() const
		{ Double_t b1 = fBIn.Mag(), b2 = fBOut.Mag(); return b1 > b2 ? b1 : b2;
		}

	ClassDef(TEveMagFieldDuo, 0); // Interface to magnetic field with two di fferent values depending of radius.	ClassDef(TEveMagFieldDuo, 0); // Interface to magnetic field with two di fferent values depending of radius.
	};	};

	//========================================================================= =====	//========================================================================= =====
	// TEveTrackPropagator	// TEveTrackPropagator
	//========================================================================= =====	//========================================================================= =====

	class TEveTrackPropagator : public TEveElementList,	class TEveTrackPropagator : public TEveElementList,
	public TEveRefBackPtr	public TEveRefBackPtr
	{	{
	friend class TEveTrackPropagatorSubEditor;	friend class TEveTrackPropagatorSubEditor;

	public:	public:

		enum EStepper_e { kHelix, kRungeKutta };

		enum EProjTrackBreaking_e { kPTB_Break, kPTB_UseFirstPointPos, kPTB_UseL
		astPointPos };

		protected:
	struct Helix_t	struct Helix_t
	{	{

	Int_t fCharge; // Charge of tracked particle.	Int_t fCharge; // Charge of tracked particle.
	Float_t fMaxAng; // Maximum step angle.	Double_t fMaxAng; // Maximum step angle.
	Float_t fMaxStep; // Maximum allowed step size.	Double_t fMaxStep; // Maximum allowed step size.
	Float_t fDelta; // Maximum error in the middle of the step.	Double_t fDelta; // Maximum error in the middle of the step.


	Float_t fPhi; // Accumulated angle to check fMaxOrbs by propagat	Double_t fPhi; // Accumulated angle to check fMaxOrbs by propaga
	or.	tor.
	Bool_t fValid; // Corner case pT~0 or B~0, possible in variable m	Bool_t fValid; // Corner case pT~0 or B~0, possible in variable
	ag field.	mag field.

	// ----------------------------------------------------------------	// ----------------------------------------------------------------

	// helix parameters	// helix parameters

	Float_t fLam; // Momentum ratio pT/pZ.	Double_t fLam; // Momentum ratio pT/pZ.
	Float_t fR; // Helix radius in cm.	Double_t fR; // Helix radius in cm.
	Float_t fPhiStep; // Caluclated from fMinAng and fDelta.	Double_t fPhiStep; // Caluclated from fMinAng and fDelta.
	Float_t fSin, fCos; // Current sin/cos(phistep).	Double_t fSin, fCos; // Current sin/cos(phistep).

	// Runge-Kutta parameters	// Runge-Kutta parameters

	Float_t fRKStep; // Step for Runge-Kutta.	Double_t fRKStep; // Step for Runge-Kutta.

	// cached	// cached

	TEveVector fB; // Current magnetic field, cached.	TEveVectorD fB; // Current magnetic field, cached.
	TEveVector fE1, fE2, fE3; // Base vectors: E1 -> B dir, E2->pT dir, E	TEveVectorD fE1, fE2, fE3; // Base vectors: E1 -> B dir, E2->pT dir,
	3 = E1xE2.	E3 = E1xE2.
	TEveVector fPt, fPl; // Transverse and longitudinal momentum.	TEveVectorD fPt, fPl; // Transverse and longitudinal momentum.
	Float_t fPtMag; // Magnitude of pT.	Double_t fPtMag; // Magnitude of pT.
	Float_t fPlMag; // Momentum parallel to mag field.	Double_t fPlMag; // Momentum parallel to mag field.
	Float_t fLStep; // Transverse step arc-length in cm.	Double_t fLStep; // Transverse step arc-length in cm.

	// ----------------------------------------------------------------	// ----------------------------------------------------------------

	Helix_t();	Helix_t();


	void UpdateCommon(const TEveVector & p, const TEveVector& b);	void UpdateCommon(const TEveVectorD & p, const TEveVectorD& b);
	void UpdateHelix(const TEveVector & p, const TEveVector& b, Bool_t fu	void UpdateHelix (const TEveVectorD & p, const TEveVectorD& b, Bool_t
	ll_update, Bool_t enforce_max_step);	full_update, Bool_t enforce_max_step);
	void UpdateRK (const TEveVector & p, const TEveVector& b);	void UpdateRK (const TEveVectorD & p, const TEveVectorD& b);


	void Step(const TEveVector4& v, const TEveVector& p, TEveVector4& vOu t, TEveVector& pOut);	void Step(const TEveVector4D& v, const TEveVectorD& p, TEveVector4D& vOut, TEveVectorD& pOut);


	Float_t GetStep() { return fLStep * TMath::Sqrt(1 + fLam*fLam); }	Double_t GetStep() { return fLStep * TMath::Sqrt(1 + fLam*fLam); }
	Float_t GetStep2() { return fLStep * fLStep * (1 + fLam*fLam); }	Double_t GetStep2() { return fLStep * fLStep * (1 + fLam*fLam); }
	};	};


	enum EStepper_e { kHelix, kRungeKutta };

	enum EProjTrackBreaking_e { kPTB_Break, kPTB_UseFirstPointPos, kPTB_UseL
	astPointPos };

	private:	private:
	TEveTrackPropagator(const TEveTrackPropagator&); // Not imple mented	TEveTrackPropagator(const TEveTrackPropagator&); // Not imple mented
	TEveTrackPropagator& operator=(const TEveTrackPropagator&); // Not imple mented	TEveTrackPropagator& operator=(const TEveTrackPropagator&); // Not imple mented

	protected:	protected:
	EStepper_e fStepper;	EStepper_e fStepper;

	TEveMagField* fMagFieldObj;	TEveMagField* fMagFieldObj;
	Bool_t fOwnMagFiledObj;	Bool_t fOwnMagFiledObj;

	// Track extrapolation limits	// Track extrapolation limits

	Float_t fMaxR; // Max radius for track extrapo	Double_t fMaxR; // Max radius for track extrap
	lation	olation
	Float_t fMaxZ; // Max z-coordinate for track e	Double_t fMaxZ; // Max z-coordinate for track
	xtrapolation.	extrapolation.
	Int_t fNMax; // Max steps	Int_t fNMax; // Max steps
	// Helix limits	// Helix limits

	Float_t fMaxOrbs; // Maximal angular path of trac ks' orbits (1 ~ 2Pi).	Double_t fMaxOrbs; // Maximal angular path of tra cks' orbits (1 ~ 2Pi).

	// Path-mark / first-vertex control	// Path-mark / first-vertex control
	Bool_t fEditPathMarks; // Show widgets for path-mark c ontrol in GUI editor.	Bool_t fEditPathMarks; // Show widgets for path-mark c ontrol in GUI editor.
	Bool_t fFitDaughters; // Pass through daughter creati on points when extrapolating a track.	Bool_t fFitDaughters; // Pass through daughter creati on points when extrapolating a track.
	Bool_t fFitReferences; // Pass through given track-ref erences when extrapolating a track.	Bool_t fFitReferences; // Pass through given track-ref erences when extrapolating a track.
	Bool_t fFitDecay; // Pass through decay point whe n extrapolating a track.	Bool_t fFitDecay; // Pass through decay point whe n extrapolating a track.
	Bool_t fFitCluster2Ds; // Pass through 2D-clusters whe n extrapolating a track.	Bool_t fFitCluster2Ds; // Pass through 2D-clusters whe n extrapolating a track.
	Bool_t fRnrDaughters; // Render daughter path-marks.	Bool_t fRnrDaughters; // Render daughter path-marks.
	Bool_t fRnrReferences; // Render track-reference path- marks.	Bool_t fRnrReferences; // Render track-reference path- marks.
	Bool_t fRnrDecay; // Render decay path-marks.	Bool_t fRnrDecay; // Render decay path-marks.

	skipping to change at line 198	skipping to change at line 207
	TMarker fFVAtt; // Marker attributes for fits v ertex.	TMarker fFVAtt; // Marker attributes for fits v ertex.

	// Handling of discontinuities in projections	// Handling of discontinuities in projections
	UChar_t fProjTrackBreaking; // Handling of projected-tr ack breaking.	UChar_t fProjTrackBreaking; // Handling of projected-tr ack breaking.
	Bool_t fRnrPTBMarkers; // Render break-points on t racks.	Bool_t fRnrPTBMarkers; // Render break-points on t racks.
	TMarker fPTBAtt; // Marker attributes for tr ack break-points.	TMarker fPTBAtt; // Marker attributes for tr ack break-points.

	// ----------------------------------------------------------------	// ----------------------------------------------------------------

	// Propagation, state of current track	// Propagation, state of current track

	std::vector<TEveVector4> fPoints; // Calculated point.	std::vector<TEveVector4D> fPoints; // Calculated point.
	TEveVector fV; // Start vertex.	TEveVectorD fV; // Start vertex.
	Helix_t fH; // Helix.	Helix_t fH; // Helix.

	void RebuildTracks();	void RebuildTracks();

	void Update(const TEveVector4& v, const TEveVector& p, Bool_t full_up	void Update(const TEveVector4D& v, const TEveVectorD& p, Bool_t full_
	date=kFALSE, Bool_t enforce_max_step=kFALSE);	update=kFALSE, Bool_t enforce_max_step=kFALSE);
	void Step(const TEveVector4 &v, const TEveVector &p, TEveVector4 &vOu	void Step(const TEveVector4D &v, const TEveVectorD &p, TEveVector4D &
	t, TEveVector &pOut);	vOut, TEveVectorD &pOut);


	Bool_t LoopToVertex(TEveVector& v, TEveVector& p);	Bool_t LoopToVertex(TEveVectorD& v, TEveVectorD& p);
	void LoopToBounds(TEveVector& p);	void LoopToBounds(TEveVectorD& p);


	Bool_t LineToVertex (TEveVector& v);	Bool_t LineToVertex (TEveVectorD& v);
	void LineToBounds (TEveVector& p);	void LineToBounds (TEveVectorD& p);

	void StepRungeKutta(Double_t step, Double_t* vect, Double_t* vout);	void StepRungeKutta(Double_t step, Double_t* vect, Double_t* vout);


	Bool_t HelixIntersectPlane(const TEveVector& p, const TEveVector& point	Bool_t HelixIntersectPlane(const TEveVectorD& p, const TEveVectorD& poi
	, const TEveVector& normal,	nt, const TEveVectorD& normal,
	TEveVector& itsect);	TEveVectorD&itsect);
	Bool_t LineIntersectPlane(const TEveVector& p, const TEveVector& point,	Bool_t LineIntersectPlane(const TEveVectorD& p, const TEveVectorD& poin
	const TEveVector& normal,	t, const TEveVectorD& normal,
	TEveVector& itsect);	TEveVectorD& itsect);


	Bool_t PointOverVertex(const TEveVector4& v0, const TEveVector4& v, Floa t_t* p=0);	Bool_t PointOverVertex(const TEveVector4D& v0, const TEveVector4D& v, Do uble_t* p=0);

	public:	public:
	TEveTrackPropagator(const char* n="TEveTrackPropagator", const char* t=" ",	TEveTrackPropagator(const char* n="TEveTrackPropagator", const char* t=" ",
	TEveMagField* field=0, Bool_t own_field=kTRUE);	TEveMagField* field=0, Bool_t own_field=kTRUE);
	virtual ~TEveTrackPropagator();	virtual ~TEveTrackPropagator();

	virtual void OnZeroRefCount();	virtual void OnZeroRefCount();

	virtual void CheckReferenceCount(const TEveException& eh="TEveElement::C heckReferenceCount ");	virtual void CheckReferenceCount(const TEveException& eh="TEveElement::C heckReferenceCount ");

	virtual void ElementChanged(Bool_t update_scenes=kTRUE, Bool_t redraw=kF ALSE);	virtual void ElementChanged(Bool_t update_scenes=kTRUE, Bool_t redraw=kF ALSE);

	// propagation	// propagation

	void InitTrack(TEveVector& v, Int_t charge);	void InitTrack(const TEveVectorD& v, Int_t charge);
	void ResetTrack();	void ResetTrack();

	void GoToBounds(TEveVector& p);	void GoToBounds(TEveVectorD& p);
	Bool_t GoToVertex(TEveVector& v, TEveVector& p);	Bool_t GoToVertex(TEveVectorD& v, TEveVectorD& p);

		// TEveVectorF wrappers
		void InitTrack(const TEveVectorF& v, Int_t charge);
		void GoToBounds(TEveVectorF& p);
		Bool_t GoToVertex(TEveVectorF& v, TEveVectorF&p);


	Bool_t IntersectPlane(const TEveVector& p, const TEveVector& point, cons	Bool_t IntersectPlane(const TEveVectorD& p, const TEveVectorD& point, co
	t TEveVector& normal,	nst TEveVectorD& normal,
	TEveVector& itsect);	TEveVectorD& itsect);

	void FillPointSet(TEvePointSet* ps) const;	void FillPointSet(TEvePointSet* ps) const;

	void SetStepper(EStepper_e s) { fStepper = s; }	void SetStepper(EStepper_e s) { fStepper = s; }


	void SetMagField(Float_t bX, Float_t bY, Float_t bZ);	void SetMagField(Double_t bX, Double_t bY, Double_t bZ);
	void SetMagField(Float_t b) { SetMagField(0.f, 0.f, b); }	void SetMagField(Double_t b) { SetMagField(0, 0, b); }
	void SetMagFieldObj(TEveMagField* field, Bool_t own_field=kTRUE);	void SetMagFieldObj(TEveMagField* field, Bool_t own_field=kTRUE);


	void SetMaxR(Float_t x);	void SetMaxR(Double_t x);
	void SetMaxZ(Float_t x);	void SetMaxZ(Double_t x);
	void SetMaxOrbs(Float_t x);	void SetMaxOrbs(Double_t x);
	void SetMinAng(Float_t x);	void SetMinAng(Double_t x);
	void SetMaxAng(Float_t x);	void SetMaxAng(Double_t x);
	void SetMaxStep(Float_t x);	void SetMaxStep(Double_t x);
	void SetDelta(Float_t x);	void SetDelta(Double_t x);

	void SetEditPathMarks(Bool_t x) { fEditPathMarks = x; }	void SetEditPathMarks(Bool_t x) { fEditPathMarks = x; }
	void SetRnrDaughters(Bool_t x);	void SetRnrDaughters(Bool_t x);
	void SetRnrReferences(Bool_t x);	void SetRnrReferences(Bool_t x);
	void SetRnrDecay(Bool_t x);	void SetRnrDecay(Bool_t x);
	void SetRnrCluster2Ds(Bool_t x);	void SetRnrCluster2Ds(Bool_t x);
	void SetFitDaughters(Bool_t x);	void SetFitDaughters(Bool_t x);
	void SetFitReferences(Bool_t x);	void SetFitReferences(Bool_t x);
	void SetFitDecay(Bool_t x);	void SetFitDecay(Bool_t x);
	void SetFitCluster2Ds(Bool_t x);	void SetFitCluster2Ds(Bool_t x);
	void SetRnrFV(Bool_t x);	void SetRnrFV(Bool_t x);
	void SetProjTrackBreaking(UChar_t x);	void SetProjTrackBreaking(UChar_t x);
	void SetRnrPTBMarkers(Bool_t x);	void SetRnrPTBMarkers(Bool_t x);


	TEveVector GetMagField(Float_t x, Float_t y, Float_t z) { return fMagFie	TEveVectorD GetMagField(Double_t x, Double_t y, Double_t z) { return fMa
	ldObj->GetField(x, y, z); }	gFieldObj->GetField(x, y, z); }
	void PrintMagField(Float_t x, Float_t y, Float_t z) const;	void PrintMagField(Double_t x, Double_t y, Double_t z) const;

	EStepper_e GetStepper() const { return fStepper;}	EStepper_e GetStepper() const { return fStepper;}


	Float_t GetMaxR() const { return fMaxR; }	Double_t GetMaxR() const { return fMaxR; }
	Float_t GetMaxZ() const { return fMaxZ; }	Double_t GetMaxZ() const { return fMaxZ; }
	Float_t GetMaxOrbs() const { return fMaxOrbs; }	Double_t GetMaxOrbs() const { return fMaxOrbs; }
	Float_t GetMinAng() const;	Double_t GetMinAng() const;
	Float_t GetMaxAng() const { return fH.fMaxAng; }	Double_t GetMaxAng() const { return fH.fMaxAng; }
	Float_t GetMaxStep() const { return fH.fMaxStep; }	Double_t GetMaxStep() const { return fH.fMaxStep; }
	Float_t GetDelta() const { return fH.fDelta; }	Double_t GetDelta() const { return fH.fDelta; }

	Bool_t GetEditPathMarks() const { return fEditPathMarks; }	Bool_t GetEditPathMarks() const { return fEditPathMarks; }
	Bool_t GetRnrDaughters() const { return fRnrDaughters; }	Bool_t GetRnrDaughters() const { return fRnrDaughters; }
	Bool_t GetRnrReferences() const { return fRnrReferences; }	Bool_t GetRnrReferences() const { return fRnrReferences; }
	Bool_t GetRnrDecay() const { return fRnrDecay; }	Bool_t GetRnrDecay() const { return fRnrDecay; }
	Bool_t GetRnrCluster2Ds() const { return fRnrCluster2Ds; }	Bool_t GetRnrCluster2Ds() const { return fRnrCluster2Ds; }
	Bool_t GetFitDaughters() const { return fFitDaughters; }	Bool_t GetFitDaughters() const { return fFitDaughters; }
	Bool_t GetFitReferences() const { return fFitReferences; }	Bool_t GetFitReferences() const { return fFitReferences; }
	Bool_t GetFitDecay() const { return fFitDecay; }	Bool_t GetFitDecay() const { return fFitDecay; }
	Bool_t GetFitCluster2Ds() const { return fFitCluster2Ds; }	Bool_t GetFitCluster2Ds() const { return fFitCluster2Ds; }
	Bool_t GetRnrFV() const { return fRnrFV; }	Bool_t GetRnrFV() const { return fRnrFV; }
	UChar_t GetProjTrackBreaking() const { return fProjTrackBreaking; }	UChar_t GetProjTrackBreaking() const { return fProjTrackBreaking; }
	Bool_t GetRnrPTBMarkers() const { return fRnrPTBMarkers; }	Bool_t GetRnrPTBMarkers() const { return fRnrPTBMarkers; }

	TMarker& RefPMAtt() { return fPMAtt; }	TMarker& RefPMAtt() { return fPMAtt; }
	TMarker& RefFVAtt() { return fFVAtt; }	TMarker& RefFVAtt() { return fFVAtt; }
	TMarker& RefPTBAtt() { return fPTBAtt; }	TMarker& RefPTBAtt() { return fPTBAtt; }


	static Bool_t IsOutsideBounds(const TEveVector& point, Float_t maxRsqr, Float_t maxZ);	static Bool_t IsOutsideBounds(const TEveVectorD& point, Double_t maxRsqr , Double_t maxZ);


	static Float_t fgDefMagField; // Default value for constant	static Double_t fgDefMagField; // Default value for constant
	solenoid magnetic field.	solenoid magnetic field.
	static const Float_t fgkB2C; // Constant for conversion of	static const Double_t fgkB2C; // Constant for conversion of
	momentum to curvature.	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	static Double_t fgEditorMaxR; // Max R that can be set in G
	I editor.	UI editor.
	static Float_t fgEditorMaxZ; // Max Z that can be set in GU	static Double_t fgEditorMaxZ; // Max Z that can be set in G
	I editor.	UI 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 TEveVectorD& point
	Float_t maxRsq	,
	r,	Double_t maxRs
	Float_t maxZ)	qr,
		Double_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.

	return TMath::Abs(point.fZ) > maxZ \|\|	return TMath::Abs(point.fZ) > maxZ \|\|
	point.fXpoint.fX + point.fYpoint.fY > maxRsqr;	point.fXpoint.fX + point.fYpoint.fY > maxRsqr;
	}	}

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____

	inline Bool_t TEveTrackPropagator::PointOverVertex(const TEveVector4 &v0,	inline Bool_t TEveTrackPropagator::PointOverVertex(const TEveVector4D &v0,
	const TEveVector4 &v,	const TEveVector4D &v,
	Float_t *p)	Double_t *p)
	{	{

	static const Float_t kMinPl = 1e-5;	static const Double_t kMinPl = 1e-5;


	TEveVector dv; dv.Sub(v0, v);	TEveVectorD dv; dv.Sub(v0, v);


	Float_t dotV;	Double_t dotV;

	if (TMath::Abs(fH.fPlMag) > kMinPl)	if (TMath::Abs(fH.fPlMag) > kMinPl)
	{	{
	// Use longitudinal momentum to determine crossing point.	// Use longitudinal momentum to determine crossing point.
	// Works ok for spiraling helices, also for loopers.	// Works ok for spiraling helices, also for loopers.

	dotV = fH.fE1.Dot(dv);	dotV = fH.fE1.Dot(dv);
	if (fH.fPlMag < 0)	if (fH.fPlMag < 0)
	dotV = -dotV;	dotV = -dotV;
	}	}

End of changes. 43 change blocks.
	118 lines changed or deleted	138 lines changed or added

	TEveVSDStructs.h	TEveVSDStructs.h

	// @(#)root/eve:$Id: TEveVSDStructs.h 31517 2009-12-03 11:56:23Z matevz $	// @(#)root/eve:$Id: TEveVSDStructs.h 38721 2011-04-04 13:37:12Z 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 123	skipping to change at line 123

	TEveCluster() : fDetId(0), fSubdetId(0), fV() { fLabel[0] = fLabel[1] = fLabel[2] = 0; }	TEveCluster() : fDetId(0), fSubdetId(0), fV() { fLabel[0] = fLabel[1] = fLabel[2] = 0; }
	virtual ~TEveCluster() {}	virtual ~TEveCluster() {}

	ClassDef(TEveCluster, 1); // Reconstructed cluster (also used in VSD).	ClassDef(TEveCluster, 1); // Reconstructed cluster (also used in VSD).
	};	};

	/************************************************************************ **/	/************************************************************************ **/
	// TEveRecTrack	// TEveRecTrack
	/************************************************************************ **/	/************************************************************************ **/

		template <typename TT>
	class TEveRecTrack : public TObject	class TEveRecTrackT : public TObject
	{	{
	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 arra
	Int_t fStatus; // Status as exported from reconstruction.	y).
	Int_t fSign; // Charge of the track.	Int_t fStatus; // Status as exported from reconstruction.
	TEveVector fV; // Start vertex from reconstruction.	Int_t fSign; // Charge of the track.
	TEveVector fP; // Reconstructed momentum at start vertex.	TEveVectorT<TT> fV; // Start vertex from reconstruction.
	Float_t fBeta; // Relativistic beta factor.	TEveVectorT<TT> fP; // Reconstructed momentum at start vertex.
		TT fBeta; // Relativistic beta factor.

	// PID data missing	// PID data missing


	TEveRecTrack() : fLabel(-1), fIndex(-1), fStatus(0), fSign(0), fV(), fP(	TEveRecTrackT() : fLabel(-1), fIndex(-1), fStatus(0), fSign(0), fV(), fP
	), fBeta(0) {}	(), fBeta(0) {}
	virtual ~TEveRecTrack() {}	virtual ~TEveRecTrackT() {}

	Float_t Pt() { return fP.Perp(); }	Float_t Pt() { return fP.Perp(); }


	ClassDef(TEveRecTrack, 1); // Reconstructed track (also used in VSD).	ClassDef(TEveRecTrackT, 1); // Template for reconstructed track (also us ed in VSD).
	};	};


		typedef TEveRecTrackT<Float_t> TEveRecTrack;
		typedef TEveRecTrackT<Float_t> TEveRecTrackF;
		typedef TEveRecTrackT<Double_t> TEveRecTrackD;

	/************************************************************************ **/	/************************************************************************ **/
	// TEveRecKink	// TEveRecKink
	/************************************************************************ **/	/************************************************************************ **/

	class TEveRecKink : public TObject	class TEveRecKink : public TObject
	{	{
	public:	public:

	TEveVector fVKink; // Kink vertex: reconstructed position of t he kink	TEveVector fVKink; // Kink vertex: reconstructed position of t he kink
	TEveVector fPMother; // Momentum of the mother track	TEveVector fPMother; // Momentum of the mother track

End of changes. 6 change blocks.
	14 lines changed or deleted	19 lines changed or added

	TFractionFitter.h	TFractionFitter.h

	// @(#)root/hist:$Id: TFractionFitter.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/hist:$Id: TFractionFitter.h 38775 2011-04-08 08:27:27Z moneta $
	// Author: Frank Filthaut filthaut@hef.kun.nl 20/05/2002	// Author: Frank Filthaut F.Filthaut@science.ru.nl 20/05/2002

	#ifndef ROOT_TFractionFitter	#ifndef ROOT_TFractionFitter
	#define ROOT_TFractionFitter	#define ROOT_TFractionFitter

	#ifndef ROOT_TVirtualFitter	#ifndef ROOT_TVirtualFitter
	# include "TVirtualFitter.h"	# include "TVirtualFitter.h"
	#endif	#endif
	#ifndef ROOT_TObjArray	#ifndef ROOT_TObjArray
	# include "TObjArray.h"	# include "TObjArray.h"
	#endif	#endif

		#include <vector>

	class TH1;	class TH1;

	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////
	// TFractionFitter	// TFractionFitter
	//	//
	// Fits MC fractions to data histogram (a la HMCMLL, see R. Barlow and C. B eeston,	// Fits MC fractions to data histogram (a la HMCMLL, see R. Barlow and C. B eeston,
	// Comp. Phys. Comm. 77 (1993) 219-228, and http://www.hep.man.ac.uk/~roger /hfrac.f).	// Comp. Phys. Comm. 77 (1993) 219-228, and http://www.hep.man.ac.uk/~roger /hfrac.f).
	//	//
	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////

	class TFractionFitter: public TObject {	class TFractionFitter: public TObject {
	public:	public:
	TFractionFitter();	TFractionFitter();

	TFractionFitter(TH1* data, TObjArray *MCs);	TFractionFitter(TH1* data, TObjArray MCs, Option_t option="");
	virtual ~TFractionFitter();	virtual ~TFractionFitter();

	TVirtualFitter* GetFitter() const;	TVirtualFitter* GetFitter() const;
	void ErrorAnalysis(Double_t UP);	void ErrorAnalysis(Double_t UP);
	void SetRangeX(Int_t low, Int_t high);	void SetRangeX(Int_t low, Int_t high);
	void ReleaseRangeX();	void ReleaseRangeX();
	void SetRangeY(Int_t low, Int_t high);	void SetRangeY(Int_t low, Int_t high);
	void ReleaseRangeY();	void ReleaseRangeY();
	void SetRangeZ(Int_t low, Int_t high);	void SetRangeZ(Int_t low, Int_t high);
	void ReleaseRangeZ();	void ReleaseRangeZ();

		void ExcludeBin(Int_t bin);
		void IncludeBin(Int_t bin);
	void Constrain(Int_t parm, Double_t low, Double_t high);	void Constrain(Int_t parm, Double_t low, Double_t high);
	void UnConstrain(Int_t parm);	void UnConstrain(Int_t parm);
	void SetData(TH1 *data);	void SetData(TH1 *data);
	void SetMC(Int_t parm, TH1 *MC);	void SetMC(Int_t parm, TH1 *MC);
	void SetWeight(Int_t parm, TH1* weight);	void SetWeight(Int_t parm, TH1* weight);
	Int_t Fit();	Int_t Fit();

	void GetResult(Int_t parm, Double_t& value, Double_t& error) const;	void GetResult(Int_t parm, Double_t& value, Double_t& error) const;
	TH1* GetPlot();	TH1* GetPlot();


	skipping to change at line 67	skipping to change at line 70
	TH1* GetMCPrediction(Int_t parm) const;	TH1* GetMCPrediction(Int_t parm) const;

	private:	private:
	void CheckParNo(Int_t parm) const;	void CheckParNo(Int_t parm) const;
	void CheckConsistency();	void CheckConsistency();
	void FindPrediction(int bin, double* fractions, double& Ti, int& k0, dou ble& Aki) const;	void FindPrediction(int bin, double* fractions, double& Ti, int& k0, dou ble& Aki) const;
	void ComputeFCN(Int_t& npar, Double_t* gin, Double_t& f, Double_t* par, Int_t flag);	void ComputeFCN(Int_t& npar, Double_t* gin, Double_t& f, Double_t* par, Int_t flag);
	void GetRanges(Int_t& minX, Int_t& maxX, Int_t& minY, Int_t& maxY,	void GetRanges(Int_t& minX, Int_t& maxX, Int_t& minY, Int_t& maxY,
	Int_t& minZ, Int_t& maxZ) const;	Int_t& minZ, Int_t& maxZ) const;
	void ComputeChisquareLambda();	void ComputeChisquareLambda();

		bool IsExcluded(Int_t bin) const;

	protected:	protected:
	Bool_t fFitDone; // flags whether a valid fit has been per formed	Bool_t fFitDone; // flags whether a valid fit has been per formed
	Int_t fLowLimitX; // first bin in X dimension	Int_t fLowLimitX; // first bin in X dimension
	Int_t fHighLimitX; // last bin in X dimension	Int_t fHighLimitX; // last bin in X dimension
	Int_t fLowLimitY; // first bin in Y dimension	Int_t fLowLimitY; // first bin in Y dimension
	Int_t fHighLimitY; // last bin in Y dimension	Int_t fHighLimitY; // last bin in Y dimension
	Int_t fLowLimitZ; // first bin in Z dimension	Int_t fLowLimitZ; // first bin in Z dimension
	Int_t fHighLimitZ; // last bin in Z dimension	Int_t fHighLimitZ; // last bin in Z dimension

		std::vector<Int_t> fExcludedBins; // bins excluded from the fit

	Int_t fNpfits; // Number of points used in the fit	Int_t fNpfits; // Number of points used in the fit
	Int_t fNDF; // Number of degrees of freedom in the fi t	Int_t fNDF; // Number of degrees of freedom in the fi t
	Double_t fChisquare; // Template fit chisquare	Double_t fChisquare; // Template fit chisquare

	TObjArray fAji; // array of pointers to predictions of re al template distributions	TObjArray fAji; // array of pointers to predictions of re al template distributions

	// Histograms	// Histograms
	TH1* fData; // pointer to the "data" histogram to be fitted to	TH1* fData; // pointer to the "data" histogram to be fitted to
	TObjArray fMCs; // array of pointers to template histogra ms	TObjArray fMCs; // array of pointers to template histogra ms

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

	TGHtml.h	TGHtml.h

	skipping to change at line 61	skipping to change at line 61

	//----------------------------------------------------------------------	//----------------------------------------------------------------------

	#define HTML_RELIEF_FLAT 0	#define HTML_RELIEF_FLAT 0
	#define HTML_RELIEF_SUNKEN 1	#define HTML_RELIEF_SUNKEN 1
	#define HTML_RELIEF_RAISED 2	#define HTML_RELIEF_RAISED 2

	//#define TABLE_TRIM_BLANK 1	//#define TABLE_TRIM_BLANK 1

	// Debug must be turned on for testing to work.	// Debug must be turned on for testing to work.

		//#define DEBUG
	#define DEBUG

	#define CANT_HAPPEN \	#define CANT_HAPPEN \
	fprintf(stderr, \	fprintf(stderr, \
	"Unplanned behavior in the HTML Widget in file %s line %d\n", \	"Unplanned behavior in the HTML Widget in file %s line %d\n", \
	__FILE__, __LINE__)	__FILE__, __LINE__)

	#define UNTESTED \	#define UNTESTED \
	fprintf(stderr, \	fprintf(stderr, \
	"Untested code executed in the HTML Widget in file %s line %d\n", \	"Untested code executed in the HTML Widget in file %s line %d\n", \
	__FILE__, __LINE__)	__FILE__, __LINE__)

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

	TGLBoxPainter.h	TGLBoxPainter.h
	// @(#)root/gl:$Id$	// @(#)root/gl:$Id$
	// Author: Timur Pocheptsov 31/08/2006	// Author: Timur Pocheptsov 31/08/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2006, 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_TGLBoxPainter	#ifndef ROOT_TGLBoxPainter
	#define ROOT_TGLBoxPainter	#define ROOT_TGLBoxPainter


		#include <vector>

	#ifndef ROOT_TGLPlotPainter	#ifndef ROOT_TGLPlotPainter
	#include "TGLPlotPainter.h"	#include "TGLPlotPainter.h"
	#endif	#endif
	#ifndef ROOT_TGLQuadric	#ifndef ROOT_TGLQuadric
	#include "TGLQuadric.h"	#include "TGLQuadric.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


		//TGLScenePad creates box painter
		//for the case TPad has poly marker and
		//empty TH3 inside.
		//Now it's up to box painter to do everything
		//correctly.
		class TPolyMarker3D;

	class TGLPlotCamera;	class TGLPlotCamera;
	class TAxis;	class TAxis;
	class TH1;	class TH1;

	class TGLBoxPainter : public TGLPlotPainter {	class TGLBoxPainter : public TGLPlotPainter {
	private:	private:
	TGLTH3Slice fXOZSlice;	TGLTH3Slice fXOZSlice;
	TGLTH3Slice fYOZSlice;	TGLTH3Slice fYOZSlice;
	TGLTH3Slice fXOYSlice;	TGLTH3Slice fXOYSlice;


	skipping to change at line 50	skipping to change at line 58
	kBox1 //spheres, not boxes	kBox1 //spheres, not boxes
	};	};

	mutable EBoxType fType;	mutable EBoxType fType;

	TString fPlotInfo;	TString fPlotInfo;
	Rgl::Range_t fMinMaxVal;	Rgl::Range_t fMinMaxVal;

	mutable TGLQuadric fQuadric;	mutable TGLQuadric fQuadric;


		const TPolyMarker3D *fPolymarker; //Polymarker from TTree.
		std::vector<Double_t> fPMPoints; //Cache for polymarker's points.

	TGLBoxPainter(const TGLBoxPainter &);	TGLBoxPainter(const TGLBoxPainter &);
	TGLBoxPainter &operator = (const TGLBoxPainter &);	TGLBoxPainter &operator = (const TGLBoxPainter &);

	public:	public:
	TGLBoxPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *coor d);	TGLBoxPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *coor d);


		TGLBoxPainter(TH1 hist, TPolyMarker3D pm,
		TGLPlotCamera camera, TGLPlotCoordinates coord);

	char *GetPlotInfo(Int_t px, Int_t py);	char *GetPlotInfo(Int_t px, Int_t py);
	Bool_t InitGeometry();	Bool_t InitGeometry();
	void StartPan(Int_t px, Int_t py);	void StartPan(Int_t px, Int_t py);
	void Pan(Int_t px, Int_t py);	void Pan(Int_t px, Int_t py);
	void AddOption(const TString &stringOption);	void AddOption(const TString &stringOption);
	void ProcessEvent(Int_t event, Int_t px, Int_t py);	void ProcessEvent(Int_t event, Int_t px, Int_t py);

	private:	private:
	//Overriders	//Overriders
	void InitGL()const;	void InitGL()const;
	void DeInitGL()const;	void DeInitGL()const;

	void DrawPlot()const;	void DrawPlot()const;

		//Special type of TH3:
		void DrawCloud()const;

	void SetPlotColor()const;	void SetPlotColor()const;

	void DrawSectionXOZ()const;	void DrawSectionXOZ()const;
	void DrawSectionYOZ()const;	void DrawSectionYOZ()const;
	void DrawSectionXOY()const;	void DrawSectionXOY()const;

	void DrawPalette()const;	void DrawPalette()const;
	void DrawPaletteAxis()const;	void DrawPaletteAxis()const;


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

	TGLPlot3D.h	TGLPlot3D.h

	// @(#)root/gl:$Id: TGLPlot3D.h 33579 2010-05-19 12:43:08Z rdm $	// @(#)root/gl:$Id: TGLPlot3D.h 38817 2011-04-13 09:32:44Z couet $
	// 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_TGLPlot3D	#ifndef ROOT_TGLPlot3D
	#define ROOT_TGLPlot3D	#define ROOT_TGLPlot3D

	#include "TGLObject.h"	#include "TGLObject.h"
	#include "TGLPlotPainter.h"	#include "TGLPlotPainter.h"

	class TVirtualPad;	class TVirtualPad;

		class TPolyMarker3D;
		class TH3;

	class TGLPlot3D : public TGLObject	class TGLPlot3D : public TGLObject
	{	{
	private:	private:
	TGLPlot3D(const TGLPlot3D&); // Not implemented	TGLPlot3D(const TGLPlot3D&); // Not implemented
	TGLPlot3D& operator=(const TGLPlot3D&); // Not implemented	TGLPlot3D& operator=(const TGLPlot3D&); // Not implemented

	protected:	protected:
	TGLPlotPainter *fPlotPainter;	TGLPlotPainter *fPlotPainter;
	TGLPlotCoordinates fCoord;	TGLPlotCoordinates fCoord;

	skipping to change at line 40	skipping to change at line 42
	void SetPainter(TGLPlotPainter* p);	void SetPainter(TGLPlotPainter* p);

	static TGLPlot3D* InstantiatePlot(TObject* obj);	static TGLPlot3D* InstantiatePlot(TObject* obj);

	public:	public:
	TGLPlot3D();	TGLPlot3D();
	virtual ~TGLPlot3D();	virtual ~TGLPlot3D();

	virtual Bool_t KeepDuringSmartRefresh() const { return kFALSE; }	virtual Bool_t KeepDuringSmartRefresh() const { return kFALSE; }


		static TGLPlot3D* CreatePlot(TH3 h, TPolyMarker3D pm);
	static TGLPlot3D* CreatePlot(TObject* obj, const Option_t* opt, TVirtual Pad* pad);	static TGLPlot3D* CreatePlot(TObject* obj, const Option_t* opt, TVirtual Pad* pad);
	static TGLPlot3D* CreatePlot(TObject* obj, const Option_t* opt, Bool_t l ogx, Bool_t logy, Bool_t logz);	static TGLPlot3D* CreatePlot(TObject* obj, const Option_t* opt, Bool_t l ogx, Bool_t logy, Bool_t logz);

	ClassDef(TGLPlot3D, 0); // Short description.	ClassDef(TGLPlot3D, 0); // Short description.
	};	};

	#endif	#endif

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

	TGLPlotPainter.h	TGLPlotPainter.h

	// @(#)root/gl:$Id: TGLPlotPainter.h 36773 2010-11-19 12:26:30Z couet $	// @(#)root/gl:$Id: TGLPlotPainter.h 38817 2011-04-13 09:32:44Z couet $
	// Author: Timur Pocheptsov 14/06/2006	// Author: Timur Pocheptsov 14/06/2006

	/*************************************************************************	/*************************************************************************
	* 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 196	skipping to change at line 196
	};	};

	}	}

	class TGLPlotPainter : public TVirtualGLPainter {	class TGLPlotPainter : public TVirtualGLPainter {
	friend class Rgl::PlotTranslation;	friend class Rgl::PlotTranslation;
	private:	private:
	const TColor *fPadColor;	const TColor *fPadColor;

	protected:	protected:

		const Float_t *fPhysicalShapeColor;

	Double_t fPadPhi;	Double_t fPadPhi;
	Double_t fPadTheta;	Double_t fPadTheta;
	TH1 *fHist;	TH1 *fHist;
	TAxis *fXAxis;	TAxis *fXAxis;
	TAxis *fYAxis;	TAxis *fYAxis;
	TAxis *fZAxis;	TAxis *fZAxis;

	TGLPlotCoordinates *fCoord;	TGLPlotCoordinates *fCoord;
	TGLPlotCamera *fCamera;	TGLPlotCamera *fCamera;
	TGLSelectionBuffer fSelection;	TGLSelectionBuffer fSelection;

	skipping to change at line 238	skipping to change at line 240
	public:	public:
	/* TGLPlotPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *c oord, Int_t context,	/* TGLPlotPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *c oord, Int_t context,
	Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSel ectable);	Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSel ectable);
	TGLPlotPainter(TGLPlotCamera camera, Int_t context);/	TGLPlotPainter(TGLPlotCamera camera, Int_t context);/
	TGLPlotPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *coo rd,	TGLPlotPainter(TH1 hist, TGLPlotCamera camera, TGLPlotCoordinates *coo rd,
	Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSel ectable);	Bool_t xoySelectable, Bool_t xozSelectable, Bool_t yozSel ectable);
	TGLPlotPainter(TGL5DDataSet data, TGLPlotCamera camera, TGLPlotCoordin ates *coord);	TGLPlotPainter(TGL5DDataSet data, TGLPlotCamera camera, TGLPlotCoordin ates *coord);
	TGLPlotPainter(TGLPlotCamera *camera);	TGLPlotPainter(TGLPlotCamera *camera);

	const TGLPlotBox& RefBackBox() const { return fBackBox; }	const TGLPlotBox& RefBackBox() const { return fBackBox; }

		void SetPhysicalShapeColor(const Float_t *rgba)
		{
		fPhysicalShapeColor = rgba;
		}

	virtual void InitGL()const = 0;	virtual void InitGL()const = 0;
	virtual void DeInitGL()const = 0;	virtual void DeInitGL()const = 0;
	virtual void DrawPlot()const = 0;	virtual void DrawPlot()const = 0;
	virtual void Paint();	virtual void Paint();

	//Checks, if mouse cursor is above plot.	//Checks, if mouse cursor is above plot.
	virtual Bool_t PlotSelected(Int_t px, Int_t py);	virtual Bool_t PlotSelected(Int_t px, Int_t py);
	//Init geometry does plot's specific initialization.	//Init geometry does plot's specific initialization.
	virtual Bool_t InitGeometry() = 0;	virtual Bool_t InitGeometry() = 0;

	skipping to change at line 408	skipping to change at line 414
	TGLPlotCoordinates(const TGLPlotCoordinates &);	TGLPlotCoordinates(const TGLPlotCoordinates &);
	TGLPlotCoordinates &operator = (const TGLPlotCoordinates &);	TGLPlotCoordinates &operator = (const TGLPlotCoordinates &);

	ClassDef(TGLPlotCoordinates, 0)//Auxilary class, holds plot dimensions.	ClassDef(TGLPlotCoordinates, 0)//Auxilary class, holds plot dimensions.
	};	};

	class TGLLevelPalette;	class TGLLevelPalette;

	namespace Rgl {	namespace Rgl {


	void DrawPalette(const TGLPlotCamera * camera, const TGLLevelPalette & pale	void DrawPalette(const TGLPlotCamera *camera, const TGLLevelPalette &palett
	tte);	e);
	void DrawPaletteAxis(const TGLPlotCamera * camera, const Range_t & minMax,	void DrawPalette(const TGLPlotCamera *camera, const TGLLevelPalette &palett
	Bool_t logZ);	e,
		const std::vector<Double_t> &levels);
		void DrawPaletteAxis(const TGLPlotCamera *camera, const Range_t &minMax, Bo
		ol_t logZ);

	//Polygonal histogram (TH2Poly) is slightly stretched along x and y.	//Polygonal histogram (TH2Poly) is slightly stretched along x and y.
	extern const Double_t gH2PolyScaleXY;	extern const Double_t gH2PolyScaleXY;

	}	}

	#endif	#endif

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

	TGLScenePad.h	TGLScenePad.h

	// @(#)root/gl:$Id: TGLScenePad.h 36884 2010-11-23 17:52:08Z matevz $	// @(#)root/gl:$Id: TGLScenePad.h 38817 2011-04-13 09:32:44Z couet $
	/*************************************************************************	/*************************************************************************
	* 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_TGLScenePad	#ifndef ROOT_TGLScenePad
	#define ROOT_TGLScenePad	#define ROOT_TGLScenePad

	skipping to change at line 25	skipping to change at line 25
	#endif	#endif
	#ifndef ROOT_TVirtualViewer3D	#ifndef ROOT_TVirtualViewer3D
	#include "TVirtualViewer3D.h"	#include "TVirtualViewer3D.h"
	#endif	#endif
	#ifndef ROOT_CsgOps	#ifndef ROOT_CsgOps
	#include "CsgOps.h"	#include "CsgOps.h"
	#endif	#endif

	class TGLViewer;	class TGLViewer;
	class TGLFaceSet;	class TGLFaceSet;

		class TList;

	class TGLScenePad : public TVirtualViewer3D, public TGLScene {	class TGLScenePad : public TVirtualViewer3D, public TGLScene {

	private:	private:
	TGLScenePad(const TGLScenePad&); // Not implemented	TGLScenePad(const TGLScenePad&); // Not implemented
	TGLScenePad& operator=(const TGLScenePad&); // Not implemented	TGLScenePad& operator=(const TGLScenePad&); // Not implemented

	protected:	protected:
	TVirtualPad* fPad;	TVirtualPad* fPad;


	skipping to change at line 46	skipping to change at line 47
	Bool_t fInternalPIDs; //! using internal physical I Ds	Bool_t fInternalPIDs; //! using internal physical I Ds
	UInt_t fNextInternalPID; //! next internal physical ID (from 1 - 0 reserved)	UInt_t fNextInternalPID; //! next internal physical ID (from 1 - 0 reserved)
	UInt_t fLastPID; //! last physical ID that was processed in AddObject()	UInt_t fLastPID; //! last physical ID that was processed in AddObject()
	Int_t fAcceptedPhysicals;	Int_t fAcceptedPhysicals;

	Int_t ValidateObjectBuffer(const TBuffer3D& buffer, Bool_t includeRaw) const;	Int_t ValidateObjectBuffer(const TBuffer3D& buffer, Bool_t includeRaw) const;
	TGLLogicalShape* CreateNewLogical(const TBuffer3D & buffer) const;	TGLLogicalShape* CreateNewLogical(const TBuffer3D & buffer) const;
	TGLPhysicalShape* CreateNewPhysical(UInt_t physicalID, const TBuffer3D& buffer,	TGLPhysicalShape* CreateNewPhysical(UInt_t physicalID, const TBuffer3D& buffer,
	const TGLLogicalShape& logical) con st;	const TGLLogicalShape& logical) con st;


		void ComposePolymarker(const TList *padPrimitives);
	// Composite shape specific	// Composite shape specific
	typedef std::pair<UInt_t, RootCsg::TBaseMesh*> CSPart_t;	typedef std::pair<UInt_t, RootCsg::TBaseMesh*> CSPart_t;
	mutable TGLFaceSet *fComposite; //! Paritally created composite	mutable TGLFaceSet *fComposite; //! Paritally created composite
	UInt_t fCSLevel;	UInt_t fCSLevel;
	std::vector<CSPart_t> fCSTokens;	std::vector<CSPart_t> fCSTokens;
	RootCsg::TBaseMesh* BuildComposite();	RootCsg::TBaseMesh* BuildComposite();

	TGLLogicalShape* AttemptDirectRenderer(TObject* id);	TGLLogicalShape* AttemptDirectRenderer(TObject* id);

	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds	Bool_t fSmartRefresh; //! cache logicals during scene rebuilds

	public:	public:
	TGLScenePad(TVirtualPad* pad);	TGLScenePad(TVirtualPad* pad);
	virtual ~TGLScenePad() {}	virtual ~TGLScenePad() {}

	TVirtualPad* GetPad() const { return fPad; }	TVirtualPad* GetPad() const { return fPad; }
	// void SetPad(TVirtualPad* p) { fPad = p; /* also need to drop contents */ }	// void SetPad(TVirtualPad* p) { fPad = p; /* also need to drop contents */ }

	// Histo import and Sub-pad traversal	// Histo import and Sub-pad traversal

	void AddHistoPhysical(TGLLogicalShape* log);	void AddHistoPhysical(TGLLogicalShape* log, const Float_t *histColor = 0 );
	void SubPadPaint(TVirtualPad* pad);	void SubPadPaint(TVirtualPad* pad);

	// PadPaint wrapper for calls from TGLViewer:	// PadPaint wrapper for calls from TGLViewer:
	virtual void PadPaintFromViewer(TGLViewer* viewer);	virtual void PadPaintFromViewer(TGLViewer* viewer);

	Bool_t GetSmartRefresh() const { return fSmartRefresh; }	Bool_t GetSmartRefresh() const { return fSmartRefresh; }
	void SetSmartRefresh(Bool_t smart_ref) { fSmartRefresh = smart_ref; }	void SetSmartRefresh(Bool_t smart_ref) { fSmartRefresh = smart_ref; }

	// TVirtualViewer3D interface	// TVirtualViewer3D interface


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

	TGLUtil.h	TGLUtil.h

	// @(#)root/gl:$Id: TGLUtil.h 36624 2010-11-12 12:17:06Z couet $	// @(#)root/gl:$Id: TGLUtil.h 38817 2011-04-13 09:32:44Z couet $
	// 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 82	skipping to change at line 82
	enum EGLPlotType {	enum EGLPlotType {
	kGLLegoPlot,	kGLLegoPlot,
	kGLSurfacePlot,	kGLSurfacePlot,
	kGLBoxPlot,	kGLBoxPlot,
	kGLTF3Plot,	kGLTF3Plot,
	kGLStackPlot,	kGLStackPlot,
	kGLParametricPlot,	kGLParametricPlot,
	kGLIsoPlot,	kGLIsoPlot,
	kGL5D,	kGL5D,
	kGLTH3Composition,	kGLTH3Composition,

		kGLVoxel,
	kGLDefaultPlot	kGLDefaultPlot
	};	};

	// TODO: Split these into own h/cxx files - too long now!	// TODO: Split these into own h/cxx files - too long now!

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TGLVertex3 //	// TGLVertex3 //
	// //	// //
	// 3 component (x/y/z) vertex class //	// 3 component (x/y/z) vertex class //

	skipping to change at line 1002	skipping to change at line 1003
	static Float_t LineWidth();	static Float_t LineWidth();

	static void BeginExtendPickRegion(Float_t scale);	static void BeginExtendPickRegion(Float_t scale);
	static void EndExtendPickRegion();	static void EndExtendPickRegion();

	static void RenderPolyMarkers(const TAttMarker& marker, Char_t transp,	static void RenderPolyMarkers(const TAttMarker& marker, Char_t transp,
	Float_t* p, Int_t n,	Float_t* p, Int_t n,
	Int_t pick_radius=0, Bool_t selection=kFAL SE,	Int_t pick_radius=0, Bool_t selection=kFAL SE,
	Bool_t sec_selection=kFALSE);	Bool_t sec_selection=kFALSE);


		static void RenderPolyMarkers(const TAttMarker &marker, const std::vecto
		r<Double_t> &points,
		Double_t dX, Double_t dY, Double_t dZ);

	static void RenderPoints(const TAttMarker& marker,	static void RenderPoints(const TAttMarker& marker,
	Float_t* p, Int_t n,	Float_t* p, Int_t n,
	Int_t pick_radius=0, Bool_t selection=kFALSE,	Int_t pick_radius=0, Bool_t selection=kFALSE,
	Bool_t sec_selection=kFALSE);	Bool_t sec_selection=kFALSE);


		static void RenderPoints(const TAttMarker& marker,
		const std::vector<Double_t> &points);

	static void RenderCrosses(const TAttMarker& marker,	static void RenderCrosses(const TAttMarker& marker,
	Float_t* p, Int_t n,	Float_t* p, Int_t n,
	Bool_t sec_selection=kFALSE);	Bool_t sec_selection=kFALSE);


		static void RenderCrosses(const TAttMarker& marker,
		const std::vector<Double_t> &points,
		Double_t dX, Double_t dY, Double_t dZ);

	static void RenderPolyLine(const TAttLine& aline, Char_t transp,	static void RenderPolyLine(const TAttLine& aline, Char_t transp,
	Float_t* p, Int_t n,	Float_t* p, Int_t n,
	Int_t pick_radius=0, Bool_t selection=kFALSE) ;	Int_t pick_radius=0, Bool_t selection=kFALSE) ;

	static void BeginAttLine(const TAttLine& aline, Char_t transp,	static void BeginAttLine(const TAttLine& aline, Char_t transp,
	Int_t pick_radius=0, Bool_t selection=kFALSE);	Int_t pick_radius=0, Bool_t selection=kFALSE);
	static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE);	static void EndAttLine(Int_t pick_radius=0, Bool_t selection=kFALSE);

	// TODO: These draw routines should take LOD hints	// TODO: These draw routines should take LOD hints
	static void SetDrawColors(const UChar_t rgba[4]);	static void SetDrawColors(const UChar_t rgba[4]);

	skipping to change at line 1205	skipping to change at line 1216
	void DrawQuadFilled(const Double_t v0, const Double_t v1,	void DrawQuadFilled(const Double_t v0, const Double_t v1,
	const Double_t v2, const Double_t v3,	const Double_t v2, const Double_t v3,
	const Double_t *normal);	const Double_t *normal);

	void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,	void DrawSmoothFace(const TGLVertex3 &v1, const TGLVertex3 &v2,
	const TGLVertex3 &v3, const TGLVector3 &norm1,	const TGLVertex3 &v3, const TGLVector3 &norm1,
	const TGLVector3 &norm2, const TGLVector3 &norm3);	const TGLVector3 &norm2, const TGLVector3 &norm3);
	void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMa x,	void DrawBoxFront(Double_t xMin, Double_t xMax, Double_t yMin, Double_t yMa x,
	Double_t zMin, Double_t zMax, Int_t fp);	Double_t zMin, Double_t zMax, Int_t fp);


		void DrawTransparentBox(Double_t xMin, Double_t xMax, Double_t yMin, Double
		_t yMax,
		Double_t zMin, Double_t zMax, Int_t fp);

	void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,	void DrawBoxFrontTextured(Double_t xMin, Double_t xMax, Double_t yMin,
	Double_t yMax, Double_t zMin, Double_t zMax,	Double_t yMax, Double_t zMin, Double_t zMax,
	Double_t tMin, Double_t tMax, Int_t front);	Double_t tMin, Double_t tMax, Int_t front);

	#ifndef __CINT__	#ifndef __CINT__
	void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,	void DrawTrapezoidTextured(const Double_t ver[][2], Double_t zMin, Double_t zMax,
	Double_t tMin, Double_t tMax);	Double_t tMin, Double_t tMax);
	void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double _t texMax);	void DrawTrapezoidTextured(const Double_t ver[][3], Double_t texMin, Double _t texMax);
	void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_ t zMax,	void DrawTrapezoidTextured2(const Double_t ver[][2], Double_t zMin, Double_ t zMax,
	Double_t tMin, Double_t tMax);	Double_t tMin, Double_t tMax);

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

	TGMenu.h	TGMenu.h

	// @(#)root/gui:$Id: TGMenu.h 31295 2009-11-18 20:29:26Z rdm $	// @(#)root/gui:$Id: TGMenu.h 38843 2011-04-14 12:13:31Z bellenot $
	// Author: Fons Rademakers 09/01/98	// Author: Fons Rademakers 09/01/98

	/*************************************************************************	/*************************************************************************
	* 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

	TGX11.h	TGX11.h

	// @(#)root/x11:$Id: TGX11.h 32427 2010-03-01 18:25:58Z rdm $	// @(#)root/x11:$Id: TGX11.h 37734 2011-01-07 09:53:54Z rdm $
	// Author: Rene Brun, Olivier Couet, Fons Rademakers 28/11/94	// Author: Rene Brun, Olivier Couet, Fons Rademakers 28/11/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 37	skipping to change at line 37

	#if !defined(__CINT__)	#if !defined(__CINT__)

	#include <X11/Xlib.h>	#include <X11/Xlib.h>
	#include <X11/Xutil.h>	#include <X11/Xutil.h>
	#include <X11/Xatom.h>	#include <X11/Xatom.h>
	#include <X11/cursorfont.h>	#include <X11/cursorfont.h>
	#include <X11/keysym.h>	#include <X11/keysym.h>
	#include <X11/xpm.h>	#include <X11/xpm.h>


		#ifdef Status
		// Convert Status from a CPP macro to a typedef:
		typedef Status X11Status_t;
		#undef Status
		typedef X11Status_t Status;
		#endif

		#ifdef None
		// Convert None from a CPP macro to a static const int:
		static const unsigned long gX11None = None;
		#undef None
		static const unsigned long None = gX11None;
		#endif

	#else	#else

	typedef unsigned long XID;	typedef unsigned long XID;
	typedef XID Drawable;	typedef XID Drawable;
	typedef XID Cursor;	typedef XID Cursor;
	typedef XID Colormap;	typedef XID Colormap;
	typedef XID Window;	typedef XID Window;

	struct GC;	struct GC;
	struct Display;	struct Display;

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

	TGenCollectionProxy.h	TGenCollectionProxy.h

	// @(#)root/io:$Id: TGenCollectionProxy.h 36061 2010-10-04 16:05:51Z pcanal $	// @(#)root/io:$Id: TGenCollectionProxy.h 38934 2011-04-19 20:26:28Z pcanal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* 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_TGenCollectionProxy	#ifndef ROOT_TGenCollectionProxy

	skipping to change at line 191	skipping to change at line 191
	::operator delete(p);	::operator delete(p);
	}	}
	}	}
	set( b.ReadObjectAny(v->fType) );	set( b.ReadObjectAny(v->fType) );
	}	}

	void read_tstring_pointer(Bool_t vsn3, TBuffer& b) {	void read_tstring_pointer(Bool_t vsn3, TBuffer& b) {
	TString* s = (TString*)ptr();	TString* s = (TString*)ptr();
	if ( vsn3 ) {	if ( vsn3 ) {
	if ( !s ) s = new TString();	if ( !s ) s = new TString();

	s->Replace(0, s->Length(), 0, 0);	else s->Clear();
	s->Streamer(b);	s->Streamer(b);
	set(s);	set(s);
	return;	return;
	}	}
	if ( s ) delete s;	if ( s ) delete s;
	set( b.ReadObjectAny(TString::Class()) );	set( b.ReadObjectAny(TString::Class()) );
	}	}
	void write_tstring_pointer(TBuffer& b) {	void write_tstring_pointer(TBuffer& b) {
	b.WriteObjectAny(ptr(), TString::Class());	b.WriteObjectAny(ptr(), TString::Class());
	}	}

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

	TGenPhaseSpace.h	TGenPhaseSpace.h

	// @(#)root/physics:$Id: TGenPhaseSpace.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/physics:$Id: TGenPhaseSpace.h 38051 2011-02-11 14:30:29Z brun $
	// Author: Rene Brun , Valerio Filippini 06/09/2000	// Author: Rene Brun , Valerio Filippini 06/09/2000

	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////
	// //	// //
	// Phase Space Generator, based on the GENBOD routine of CERNLIB //	// Phase Space Generator, based on the GENBOD routine of CERNLIB //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////

	#ifndef ROOT_TGenPhaseSpace	#ifndef ROOT_TGenPhaseSpace
	#define ROOT_TGenPhaseSpace	#define ROOT_TGenPhaseSpace

	skipping to change at line 31	skipping to change at line 31
	Double_t fWtMax; // maximum weigth	Double_t fWtMax; // maximum weigth
	TLorentzVector fDecPro[18]; //kinematics of the generated particles	TLorentzVector fDecPro[18]; //kinematics of the generated particles

	Double_t PDK(Double_t a, Double_t b, Double_t c);	Double_t PDK(Double_t a, Double_t b, Double_t c);

	public:	public:
	TGenPhaseSpace() {}	TGenPhaseSpace() {}
	TGenPhaseSpace(const TGenPhaseSpace &gen);	TGenPhaseSpace(const TGenPhaseSpace &gen);
	virtual ~TGenPhaseSpace() {}	virtual ~TGenPhaseSpace() {}


	Bool_t SetDecay(TLorentzVector &P, Int_t nt, Double_t mass, Op tion_t opt="");	Bool_t SetDecay(TLorentzVector &P, Int_t nt, const Double_t ma ss, Option_t opt="");
	Double_t Generate();	Double_t Generate();
	TLorentzVector *GetDecay(Int_t n);	TLorentzVector *GetDecay(Int_t n);

	Int_t GetNt() const { return fNt;}	Int_t GetNt() const { return fNt;}
	Double_t GetWtMax() const { return fWtMax;}	Double_t GetWtMax() const { return fWtMax;}

	ClassDef(TGenPhaseSpace,1) //Simple Phase Space Generator	ClassDef(TGenPhaseSpace,1) //Simple Phase Space Generator
	};	};

	#endif	#endif

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

	TH3GL.h	TH3GL.h

	// @(#)root/gl:$Id: TH3GL.h 33579 2010-05-19 12:43:08Z rdm $	// @(#)root/gl:$Id: TH3GL.h 38817 2011-04-13 09:32:44Z couet $
	// 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_TH3GL	#ifndef ROOT_TH3GL
	#define ROOT_TH3GL	#define ROOT_TH3GL

	#include "TGLPlot3D.h"	#include "TGLPlot3D.h"
	#include <TGLUtil.h>	#include <TGLUtil.h>
	#include <TGLAxisPainter.h>	#include <TGLAxisPainter.h>


		class TPolyMarker3D;
	class TGLRnrCtx;	class TGLRnrCtx;
	class TH3;	class TH3;
	class TAxis;	class TAxis;

	class TH3;	class TH3;

	class TH3GL : public TGLPlot3D	class TH3GL : public TGLPlot3D
	{	{
	private:	private:
	TH3GL(const TH3GL&); // Not implemented	TH3GL(const TH3GL&); // Not implemented
	TH3GL& operator=(const TH3GL&); // Not implemented	TH3GL& operator=(const TH3GL&); // Not implemented

	protected:	protected:

	TH3 *fM; // Model object dynamic-casted to TH2.	TH3 *fM; // Model object dynamic-casted to TH3.

	public:	public:
	TH3GL();	TH3GL();

		TH3GL(TH3 h, TPolyMarker3D pm);
	virtual ~TH3GL();	virtual ~TH3GL();

	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();

	virtual void DirectDraw(TGLRnrCtx & rnrCtx) const;	virtual void DirectDraw(TGLRnrCtx & rnrCtx) const;

	// To support two-level selection	// To support two-level selection
	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }	// virtual Bool_t SupportsSecondarySelect() const { return kTRUE; }
	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);	// virtual void ProcessSelection(TGLRnrCtx & rnrCtx, TGLSelectRecord & r ec);

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

	TMath.h	TMath.h

	// @(#)root/mathcore:$Id: TMath.h 36792 2010-11-19 16:53:42Z rdm $	// @(#)root/mathcore:$Id: TMath.h 38578 2011-03-23 14:01:53Z moneta $
	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/95	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/95

	/*************************************************************************	/*************************************************************************
	* 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 34	skipping to change at line 34

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes
	#include "Rtypes.h"	#include "Rtypes.h"
	#endif	#endif
	#ifndef ROOT_TMathBase	#ifndef ROOT_TMathBase
	#include "TMathBase.h"	#include "TMathBase.h"
	#endif	#endif

	#include "TError.h"	#include "TError.h"
	#include <algorithm>	#include <algorithm>

		#include <limits>

	namespace TMath {	namespace TMath {

	/* ************************* */	/* ************************* */
	/* * Fundamental constants * */	/* * Fundamental constants * */
	/* ************************* */	/* ************************* */

	inline Double_t Pi() { return 3.14159265358979323846; }	inline Double_t Pi() { return 3.14159265358979323846; }
	inline Double_t TwoPi() { return 2.0 * Pi(); }	inline Double_t TwoPi() { return 2.0 * Pi(); }
	inline Double_t PiOver2() { return Pi() / 2.0; }	inline Double_t PiOver2() { return Pi() / 2.0; }

	skipping to change at line 167	skipping to change at line 168
	Double_t Factorial(Int_t i);	Double_t Factorial(Int_t i);
	inline Double_t Power(Double_t x, Double_t y);	inline Double_t Power(Double_t x, Double_t y);
	inline Double_t Log(Double_t x);	inline Double_t Log(Double_t x);
	Double_t Log2(Double_t x);	Double_t Log2(Double_t x);
	inline Double_t Log10(Double_t x);	inline Double_t Log10(Double_t x);
	Int_t Nint(Float_t x);	Int_t Nint(Float_t x);
	Int_t Nint(Double_t x);	Int_t Nint(Double_t x);
	inline Int_t Finite(Double_t x);	inline Int_t Finite(Double_t x);
	inline Int_t IsNaN(Double_t x);	inline Int_t IsNaN(Double_t x);


		inline Double_t QuietNaN();
		inline Double_t SignalingNaN();
		inline Double_t Infinity();

		template <typename T>
		struct Limits {
		inline static T Min();
		inline static T Max();
		inline static T Epsilon();
		};

	// Some integer math	// Some integer math
	Long_t Hypot(Long_t x, Long_t y); // sqrt(pxpx + pypy)	Long_t Hypot(Long_t x, Long_t y); // sqrt(pxpx + pypy)

	// Comparing floating points	// Comparing floating points
	inline Bool_t AreEqualAbs(Double_t af, Double_t bf, Double_t epsilon) {	inline Bool_t AreEqualAbs(Double_t af, Double_t bf, Double_t epsilon) {
	//return kTRUE if absolute difference between af and bf is less than epsilon	//return kTRUE if absolute difference between af and bf is less than epsilon
	return TMath::Abs(af-bf) < epsilon;	return TMath::Abs(af-bf) < epsilon;
	}	}
	inline Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec) {	inline Bool_t AreEqualRel(Double_t af, Double_t bf, Double_t relPrec) {
	//return kTRUE if relative difference between af and bf is less than relPrec	//return kTRUE if relative difference between af and bf is less than relPrec

	skipping to change at line 492	skipping to change at line 504
	// from math.h	// from math.h
	{ return isnan(x); }	{ return isnan(x); }
	#else	#else
	// from cmath	// from cmath
	{ return std::isnan(x); }	{ return std::isnan(x); }
	#endif	#endif
	#else	#else
	{ return isnan(x); }	{ return isnan(x); }
	#endif	#endif


		//--------wrapper to numeric_limits
		//_________________________________________________________________________
		___
		inline Double_t TMath::QuietNaN() {
		// returns a quiet NaN as defined by IEEE 754
		// see http://en.wikipedia.org/wiki/NaN#Quiet_NaN
		return std::numeric_limits<Double_t>::quiet_NaN();
		}

		//_________________________________________________________________________
		___
		inline Double_t TMath::SignalingNaN() {
		// returns a signaling NaN as defined by IEEE 754
		// see http://en.wikipedia.org/wiki/NaN#Signaling_NaN
		return std::numeric_limits<Double_t>::signaling_NaN();
		}

		inline Double_t TMath::Infinity() {
		// returns an infinity as defined by the IEEE standard
		return std::numeric_limits<Double_t>::infinity();
		}

		template<typename T>
		inline T TMath::Limits<T>::Min() {
		// returns maximum representation for type T
		return (std::numeric_limits<T>::min)(); //N.B. use this signature to
		avoid class with macro min() on Windows
		}

		template<typename T>
		inline T TMath::Limits<T>::Max() {
		// returns minimum double representation
		return (std::numeric_limits<T>::max)(); //N.B. use this signature to av
		oid class with macro max() on Windows
		}

		template<typename T>
		inline T TMath::Limits<T>::Epsilon() {
		// returns minimum double representation
		return std::numeric_limits<T>::epsilon();
		}

	//-------- Advanced -------------	//-------- Advanced -------------

	template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3] ,T out[3])	template <typename T> inline T TMath::NormCross(const T v1[3],const T v2[3] ,T out[3])
	{	{
	// Calculate the Normalized Cross Product of two vectors	// Calculate the Normalized Cross Product of two vectors
	return Normalize(Cross(v1,v2,out));	return Normalize(Cross(v1,v2,out));
	}	}

	template <typename T>	template <typename T>
	T TMath::MinElement(Long64_t n, const T *a) {	T TMath::MinElement(Long64_t n, const T *a) {

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

	TMatrixDLazy.h	TMatrixDLazy.h

	// @(#)root/matrix:$Id: TMatrixDLazy.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/matrix:$Id: TMatrixDLazy.h 38487 2011-03-17 17:00:01Z pcanal $
	/*************************************************************************	/*************************************************************************
	* 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_TMatrixDLazy	#ifndef ROOT_TMatrixDLazy
	#define ROOT_TMatrixDLazy	#define ROOT_TMatrixDLazy

	skipping to change at line 29	skipping to change at line 29
	// TMatrixTSymLazy <Double_t> //	// TMatrixTSymLazy <Double_t> //
	// THaarMatrixT <Double_t> //	// THaarMatrixT <Double_t> //
	// THilbertMatrixT <Double_t> //	// THilbertMatrixT <Double_t> //
	// THilbertMatrixTSym<Double_t> //	// THilbertMatrixTSym<Double_t> //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMatrixTLazy	#ifndef ROOT_TMatrixTLazy
	#include "TMatrixTLazy.h"	#include "TMatrixTLazy.h"
	#endif	#endif

		#ifndef ROOT_TMatrixDfwd
		#include "TMatrixDfwd.h"
		#endif
		#ifndef ROOT_TMatrixDSymfwd
		#include "TMatrixDSymfwd.h"
		#endif

	typedef TMatrixTLazy <Double_t> TMatrixDLazy;	typedef TMatrixTLazy <Double_t> TMatrixDLazy;
	typedef TMatrixTSymLazy <Double_t> TMatrixDSymLazy;	typedef TMatrixTSymLazy <Double_t> TMatrixDSymLazy;
	typedef THaarMatrixT <Double_t> THaarMatrixD;	typedef THaarMatrixT <Double_t> THaarMatrixD;
	typedef THilbertMatrixT <Double_t> THilbertMatrixD;	typedef THilbertMatrixT <Double_t> THilbertMatrixD;
	typedef THilbertMatrixTSym<Double_t> THilbertMatrixDSym;	typedef THilbertMatrixTSym<Double_t> THilbertMatrixDSym;

	#endif	#endif

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

	TMatrixFBase.h	TMatrixFBase.h

	// @(#)root/matrix:$Id: TMatrixFBase.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/matrix:$Id: TMatrixFBase.h 38486 2011-03-17 16:39:06Z pcanal $
	/*************************************************************************	/*************************************************************************
	* 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_TMatrixFBasefwd	#ifndef ROOT_TMatrixFBase
	#define ROOT_TMatrixFBasefwd	#define ROOT_TMatrixFBase

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TMatrixFBase //	// TMatrixFBase //
	// //	// //
	// Instantation of TMatrixTBase<Float_t> //	// Instantation of TMatrixTBase<Float_t> //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMatrixTBase	#ifndef ROOT_TMatrixTBase

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

	TMatrixFLazy.h	TMatrixFLazy.h

	// @(#)root/matrix:$Id: TMatrixFLazy.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/matrix:$Id: TMatrixFLazy.h 38487 2011-03-17 17:00:01Z pcanal $
	/*************************************************************************	/*************************************************************************
	* 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_TMatrixFLazy	#ifndef ROOT_TMatrixFLazy
	#define ROOT_TMatrixFLazy	#define ROOT_TMatrixFLazy

	skipping to change at line 29	skipping to change at line 29
	// TMatrixTSymLazy <Float_t> //	// TMatrixTSymLazy <Float_t> //
	// THaarMatrixT <Float_t> //	// THaarMatrixT <Float_t> //
	// THilbertMatrixT <Float_t> //	// THilbertMatrixT <Float_t> //
	// THilbertMatrixTSym<Float_t> //	// THilbertMatrixTSym<Float_t> //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TMatrixTLazy	#ifndef ROOT_TMatrixTLazy
	#include "TMatrixTLazy.h"	#include "TMatrixTLazy.h"
	#endif	#endif

		#ifndef ROOT_TMatrixFfwd
		#include "TMatrixFfwd.h"
		#endif
		#ifndef ROOT_TMatrixFSymfwd
		#include "TMatrixFSymfwd.h"
		#endif

	typedef TMatrixTLazy <Float_t> TMatrixFLazy;	typedef TMatrixTLazy <Float_t> TMatrixFLazy;
	typedef TMatrixTSymLazy <Float_t> TMatrixFSymLazy;	typedef TMatrixTSymLazy <Float_t> TMatrixFSymLazy;
	typedef THaarMatrixT <Float_t> THaarMatrixF;	typedef THaarMatrixT <Float_t> THaarMatrixF;
	typedef THilbertMatrixT <Float_t> THilbertMatrixF;	typedef THilbertMatrixT <Float_t> THilbertMatrixF;
	typedef THilbertMatrixTSym<Float_t> THilbertMatrixFSym;	typedef THilbertMatrixTSym<Float_t> THilbertMatrixFSym;

	#endif	#endif

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

	TPacketizerMulti.h	TPacketizerMulti.h

	// $Id: TPacketizerMulti.h 32204 2010-02-03 19:17:40Z ganis $	// $Id: TPacketizerMulti.h 38810 2011-04-12 16:22:59Z ganis $
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TPacketizerMulti	#ifndef ROOT_TPacketizerMulti
	#define ROOT_TPacketizerMulti	#define ROOT_TPacketizerMulti

	skipping to change at line 65	skipping to change at line 65
	TList input, TProofProgressStatus st);	TList input, TProofProgressStatus st);
	virtual ~TPacketizerMulti();	virtual ~TPacketizerMulti();

	TDSetElement GetNextPacket(TSlave wrk, TMessage *r);	TDSetElement GetNextPacket(TSlave wrk, TMessage *r);

	Int_t GetEstEntriesProcessed(Float_t f, Long64_t &ent, Long64_t &byte s, Long64_t &calls)	Int_t GetEstEntriesProcessed(Float_t f, Long64_t &ent, Long64_t &byte s, Long64_t &calls)
	{ if (fCurrent) return fCurrent->GetEstEntriesProcessed (f,ent,bytes,calls);	{ if (fCurrent) return fCurrent->GetEstEntriesProcessed (f,ent,bytes,calls);
	return 1; }	return 1; }
	Float_t GetCurrentRate(Bool_t &all) { all = kTRUE;	Float_t GetCurrentRate(Bool_t &all) { all = kTRUE;
	return (fCurrent? fCurrent->GetCu rrentRate(all) : 0.); }	return (fCurrent? fCurrent->GetCu rrentRate(all) : 0.); }

	void StopProcess(Bool_t abort) { if (fCurrent) fCurrent->StopProcess	void StopProcess(Bool_t abort, Bool_t stoptimer = kFALSE) {
	(abort);	if (fCurrent) fCurrent->StopProcess
	TVirtualPacketizer::StopProcess(abo	(abort, stoptimer);
	rt); }	TVirtualPacketizer::StopProcess(abo
		rt, stoptimer); }
	void MarkBad(TSlave wrk, TProofProgressStatus st, TList **missing)	void MarkBad(TSlave wrk, TProofProgressStatus st, TList **missing)
	{ if (fCurrent) fCurrent->MarkBad(wrk, st, missing); re turn; }	{ if (fCurrent) fCurrent->MarkBad(wrk, st, missing); re turn; }
	Int_t AddProcessed(TSlave wrk, TProofProgressStatus st, Double_t la t, TList **missing)	Int_t AddProcessed(TSlave wrk, TProofProgressStatus st, Double_t la t, TList **missing)
	{ if (fCurrent) return fCurrent->AddProcessed(wrk, st, lat, missing);	{ if (fCurrent) return fCurrent->AddProcessed(wrk, st, lat, missing);
	return -1; }	return -1; }

	Int_t GetActiveWorkers() { if (fCurrent) return fCurrent->GetActiveWo rkers(); return 0; }	Int_t GetActiveWorkers() { if (fCurrent) return fCurrent->GetActiveWo rkers(); return 0; }

	ClassDef(TPacketizerMulti,0) //Generate work packets for parallel proce ssing	ClassDef(TPacketizerMulti,0) //Generate work packets for parallel proce ssing
	};	};

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

	TParameter.h	TParameter.h

	// @(#)root/base:$Id: TParameter.h 20877 2007-11-19 11:17:07Z rdm $	// @(#)root/base:$Id: TParameter.h 38395 2011-03-12 12:29:40Z rdm $
	// Author: Maarten Ballintijn 21/06/2004	// Author: Maarten Ballintijn 21/06/2004

	/*************************************************************************	/*************************************************************************
	* 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 23	skipping to change at line 23
	#define ROOT_TParameter	#define ROOT_TParameter

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TParameter<AParamType> //	// TParameter<AParamType> //
	// //	// //
	// Named parameter, streamable and storable. //	// Named parameter, streamable and storable. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


		#ifndef ROOT_Riostream
		#include "Riostream.h"
		#endif

		#ifndef ROOT_TClass
		#include "TClass.h"
		#endif

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif


		#ifndef ROOT_TCollection
		#include "TCollection.h"
		#endif

	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif


		#ifndef ROOT_TROOT
		#include "TROOT.h"
		#endif

	template <class AParamType>	template <class AParamType>
	class TParameter : public TObject {	class TParameter : public TObject {


		public:
		enum EStatusBits { kMultiply = BIT(16) }; // Use multiplication while me
		rging

	private:	private:
	TString fName;	TString fName;
	AParamType fVal;	AParamType fVal;

	public:	public:
	TParameter() { /* leave fVal uninitialized */ }	TParameter() { /* leave fVal uninitialized */ }
	TParameter(const char *name, const AParamType &val)	TParameter(const char *name, const AParamType &val)

	: fName(name), fVal(val) { }	: fName(name), fVal(val) { ResetBit(kMultiply); }
		TParameter(const char *name, const AParamType &val, char mergemode)
		: fName(name), fVal(val) { SetMergeMode(mergemode); }
	~TParameter() { }	~TParameter() { }

	const char *GetName() const { return fName; }	const char *GetName() const { return fName; }
	const AParamType &GetVal() const { return fVal; }	const AParamType &GetVal() const { return fVal; }
	void SetVal(const AParamType &val) { fVal = val; }	void SetVal(const AParamType &val) { fVal = val; }

		void SetMergeMode(char mergemode = '+') { ResetBit(kMultipl
		y);
		if (mergemode ==
		'*') SetBit(kMultiply); }

		virtual void ls(Option_t *) const {
		// Print this parameter content
		TROOT::IndentLevel();
		cout << "OBJ: " << IsA()->GetName() << "\t" << fName << " = " << fVal
		<< endl;
		}

		virtual void Print(Option_t *) const {
		// Print this parameter content
		TROOT::IndentLevel();
		cout << IsA()->GetName() << "\t" << fName << " = " << fVal << endl;
		}

		virtual Int_t Merge(TCollection *in);


	ClassDef(TParameter,1) //Named templated parameter type	ClassDef(TParameter,2) //Named templated parameter type
	};	};


		template <class AParamType>
		inline Int_t TParameter<AParamType>::Merge(TCollection *in) {
		// Merge objects in the list.
		// Returns the number of objects that were in the list.
		TIter nxo(in);
		Int_t n = 0;
		while (TObject *o = nxo()) {
		TParameter<AParamType> c = dynamic_cast<TParameter<AParamType> >(o)
		;
		if (c) {
		if (TestBit(kMultiply))
		fVal *= c->GetVal();
		else
		fVal += c->GetVal();
		n++;
		}
		}

		return n;
		}

		// Specialization of Merge for Bool_t
		template <>
		inline Int_t TParameter<Bool_t>::Merge(TCollection *in)
		{
		// Merge bool objects in the list.
		// Returns the number of objects that were in the list.
		TIter nxo(in);
		Int_t n = 0;
		while (TObject *o = nxo()) {
		TParameter<Bool_t> c = dynamic_cast<TParameter<Bool_t> >(o);
		if (c) {
		if (TestBit(TParameter::kMultiply))
		fVal &= (Bool_t) c->GetVal();
		else
		fVal \|= (Bool_t) c->GetVal();
		n++;
		}
		}

		return n;
		}

	#endif	#endif

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

	TPerfStats.h	TPerfStats.h

	// @(#)root/proofplayer:$Id: TPerfStats.h 30965 2009-11-04 11:15:25Z ganis $	// @(#)root/proofplayer:$Id: TPerfStats.h 38709 2011-04-01 16:27:30Z ganis $
	// Author: Kristjan Gulbrandsen 11/05/04	// Author: Kristjan Gulbrandsen 11/05/04

	/*************************************************************************	/*************************************************************************
	* 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 27	skipping to change at line 27
	// TPerfStats //	// TPerfStats //
	// //	// //
	// Provides the interface for the PROOF internal performance measurment //	// Provides the interface for the PROOF internal performance measurment //
	// and event tracing. //	// and event tracing. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif

		#ifndef ROOT_TObjArray
		#include "TObjArray.h"
		#endif
	#ifndef ROOT_TTimeStamp	#ifndef ROOT_TTimeStamp
	#include "TTimeStamp.h"	#include "TTimeStamp.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif
	#ifndef ROOT_TVirtualPerfStats	#ifndef ROOT_TVirtualPerfStats
	#include "TVirtualPerfStats.h"	#include "TVirtualPerfStats.h"
	#endif	#endif

	class TTree;	class TTree;
	class TH1D;	class TH1D;
	class TH2D;	class TH2D;
	class TList;	class TList;

	class TVirtualMonitoringWriter;

	class TPerfEvent : public TObject {	class TPerfEvent : public TObject {

	public:	public:
	TString fEvtNode; // node on which the event was generated	TString fEvtNode; // node on which the event was generated
	TTimeStamp fTimeStamp; // time offset from start of r un	TTimeStamp fTimeStamp; // time offset from start of r un
	TVirtualPerfStats::EEventType fType;	TVirtualPerfStats::EEventType fType;
	TString fSlaveName;	TString fSlaveName;
	TString fNodeName;	TString fNodeName;
	TString fFileName;	TString fFileName;

	skipping to change at line 98	skipping to change at line 100
	Long64_t fTotEvents; //!total number of events processed	Long64_t fTotEvents; //!total number of events processed
	Long64_t fNumEvents; //!total number of events to be processed	Long64_t fNumEvents; //!total number of events to be processed
	Int_t fSlaves; //!number of active slaves	Int_t fSlaves; //!number of active slaves

	Bool_t fDoHist; //!Fill histos	Bool_t fDoHist; //!Fill histos
	Bool_t fDoTrace; //!Trace details in master	Bool_t fDoTrace; //!Trace details in master
	Bool_t fDoTraceRate; //!Trace processing rate in master	Bool_t fDoTraceRate; //!Trace processing rate in master
	Bool_t fDoSlaveTrace; //!Full tracing in workers	Bool_t fDoSlaveTrace; //!Full tracing in workers
	Bool_t fDoQuota; //!Save stats on SQL server for quota mana gement	Bool_t fDoQuota; //!Save stats on SQL server for quota mana gement


	TVirtualMonitoringWriter *fMonitoringWriter; //!Monitoring engine	Bool_t fMonitorPerPacket; //!Whether to send the full entry per
		each packet
		Int_t fMonitorInfo; //!Controls what information to monitor

		TObjArray fMonitoringWriters; //!Monitoring engines

		TString fDataSet; //!Dataset string
		Int_t fDataSetLen; //!Maximum size of the dataset string fDat
		aSet
		Int_t fDataSetSize; //!# of files in the dataset
		TList *fOutput; //!Saved pointer to the output list

		static Long_t fgVirtMemMax; //! Max virtual memory used by this proce
		ss
		static Long_t fgResMemMax; //! Max resident memory used by this proc
		ess

	TPerfStats(TList input, TList output);	TPerfStats(TList input, TList output);
	void WriteQueryLog();	void WriteQueryLog();

	public:	public:
	virtual ~TPerfStats() {}	virtual ~TPerfStats() {}

	void SimpleEvent(EEventType type);	void SimpleEvent(EEventType type);
	void PacketEvent(const char slave, const char slavename, const char *f ilename,	void PacketEvent(const char slave, const char slavename, const char *f ilename,
	Long64_t eventsprocessed, Double_t latency,	Long64_t eventsprocessed, Double_t latency,
	Double_t proctime, Double_t cputime, Long64_t bytesRead );	Double_t proctime, Double_t cputime, Long64_t bytesRead );
	void FileEvent(const char slave, const char slavename, const char nod ename, const char filename,	void FileEvent(const char slave, const char slavename, const char nod ename, const char filename,
	Bool_t isStart);	Bool_t isStart);

	void FileOpenEvent(TFile file, const char filename, Double_t start);	void FileOpenEvent(TFile file, const char filename, Double_t start);
	void FileReadEvent(TFile *file, Int_t len, Double_t start);	void FileReadEvent(TFile *file, Int_t len, Double_t start);

		void FileUnzipEvent(TFile *file, Long64_t pos, Double_t start, Int_t com plen, Int_t objlen);
	void RateEvent(Double_t proctime, Double_t deltatime,	void RateEvent(Double_t proctime, Double_t deltatime,
	Long64_t eventsprocessed, Long64_t bytesRead);	Long64_t eventsprocessed, Long64_t bytesRead);
	void SetBytesRead(Long64_t num);	void SetBytesRead(Long64_t num);
	Long64_t GetBytesRead() const;	Long64_t GetBytesRead() const;
	void SetNumEvents(Long64_t num) { fNumEvents = num; }	void SetNumEvents(Long64_t num) { fNumEvents = num; }
	Long64_t GetNumEvents() const { return fNumEvents; }	Long64_t GetNumEvents() const { return fNumEvents; }

	static void Start(TList input, TList output);	static void Start(TList input, TList output);
	static void Stop();	static void Stop();
	static void Setup(TList *input);	static void Setup(TList *input);

		static void SetMemValues();

	ClassDef(TPerfStats,0) // Class for collecting PROOF statistics	ClassDef(TPerfStats,0) // Class for collecting PROOF statistics
	};	};

	#endif	#endif

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

	TProofMgrLite.h	TProofMgrLite.h

	// @(#)root/proofx:$Id: TProofMgrLite.h 26823 2008-12-11 09:26:32Z ganis $	// @(#)root/proofx:$Id: TProofMgrLite.h 38580 2011-03-23 15:24:54Z ganis $
	/*************************************************************************	/*************************************************************************
	* 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_TProofMgrLite	#ifndef ROOT_TProofMgrLite
	#define ROOT_TProofMgrLite	#define ROOT_TProofMgrLite

	skipping to change at line 36	skipping to change at line 36
	#endif	#endif

	class TProofMgrLite : public TProofMgr {	class TProofMgrLite : public TProofMgr {

	public:	public:
	TProofMgrLite(const char url, Int_t loglevel = -1, const char alias = "");	TProofMgrLite(const char url, Int_t loglevel = -1, const char alias = "");
	virtual ~TProofMgrLite() { }	virtual ~TProofMgrLite() { }

	TProof CreateSession(const char = 0, const char * = 0, Int_t = -1 );	TProof CreateSession(const char = 0, const char * = 0, Int_t = -1 );
	TProofLog GetSessionLogs(Int_t ridx = 0, const char stag = 0,	TProofLog GetSessionLogs(Int_t ridx = 0, const char stag = 0,

	const char *pattern = "-v \| SvcMsg");	const char *pattern = "-v \| SvcMsg", Bool_t r escan = kFALSE);
	TObjString ReadBuffer(const char file, Long64_t ofs, Int_t len);	TObjString ReadBuffer(const char file, Long64_t ofs, Int_t len);
	TObjString ReadBuffer(const char file, const char *pattern);	TObjString ReadBuffer(const char file, const char *pattern);

	ClassDef(TProofMgrLite,0) // XrdProofd PROOF manager interface	ClassDef(TProofMgrLite,0) // XrdProofd PROOF manager interface
	};	};

	#endif	#endif

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

	TProofProgressStatus.h	TProofProgressStatus.h

	// @(#)root/proof:$Id: TProofProgressStatus.h 30859 2009-10-24 14:53:07Z ga nis $	// @(#)root/proof:$Id: TProofProgressStatus.h 38810 2011-04-12 16:22:59Z ga nis $
	// Author: Jan Iwaszkiewicz 08/08/08	// Author: Jan Iwaszkiewicz 08/08/08

	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 28	skipping to change at line 28

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TProofProgressStatus //	// TProofProgressStatus //
	// //	// //
	// Small class including processing statistics //	// Small class including processing statistics //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	class TProofProgressStatus : public TObject {	class TProofProgressStatus : public TObject {

		public:
		enum EStatusBits { kFileNotOpen = BIT(15),
		kFileCorrupted = BIT(16)
		};
	private:	private:
	Long64_t fLastEntries; // Last chunck	Long64_t fLastEntries; // Last chunck
	Long64_t fEntries;	Long64_t fEntries;
	Long64_t fBytesRead;	Long64_t fBytesRead;
	Long64_t fReadCalls;	Long64_t fReadCalls;
	Double_t fLearnTime; // the time spent in learning phase	Double_t fLearnTime; // the time spent in learning phase
	Double_t fLastProcTime; // the wallclock time of the last addition	Double_t fLastProcTime; // the wallclock time of the last addition
	Double_t fProcTime; // the wallclock time	Double_t fProcTime; // the wallclock time
	Double_t fCPUTime;	Double_t fCPUTime;
	Double_t fLastUpdate; // Timestamp of last change	Double_t fLastUpdate; // Timestamp of last change

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

	TSVDUnfold.h	TSVDUnfold.h

	skipping to change at line 61	skipping to change at line 61
	class TH1D;	class TH1D;
	class TH2D;	class TH2D;

	class TSVDUnfold : public TObject {	class TSVDUnfold : public TObject {

	public:	public:

	// Constructor	// Constructor
	// Initialisation of unfolding	// Initialisation of unfolding
	// "bdat" - measured data distribution (number of events)	// "bdat" - measured data distribution (number of events)

		// "Bcov" - covariance matrix for measured data distribution
	// "bini" - reconstructed MC distribution (number of events)	// "bini" - reconstructed MC distribution (number of events)
	// "xini" - truth MC distribution (number of events)	// "xini" - truth MC distribution (number of events)
	// "Adet" - detector response matrix (number of events)	// "Adet" - detector response matrix (number of events)
	TSVDUnfold( const TH1D* bdat, const TH1D* bini, const TH1D* xini, const TH2D* Adet );	TSVDUnfold( const TH1D* bdat, const TH1D* bini, const TH1D* xini, const TH2D* Adet );

		TSVDUnfold( const TH1D* bdat, TH2D* Bcov, const TH1D* bini, const TH1D* xini, const TH2D* Adet );
	TSVDUnfold( const TSVDUnfold& other );	TSVDUnfold( const TSVDUnfold& other );

	// Destructor	// Destructor
	virtual ~TSVDUnfold();	virtual ~TSVDUnfold();

	// Set option to normalize unfolded spectrum to unit area	// Set option to normalize unfolded spectrum to unit area
	// "normalize" - switch	// "normalize" - switch
	void SetNormalize ( Bool_t normalize ) { fNormalize = normalize; }	void SetNormalize ( Bool_t normalize ) { fNormalize = normalize; }

	// Do the unfolding	// Do the unfolding

	skipping to change at line 100	skipping to change at line 102

	// Regularisation parameter	// Regularisation parameter
	Int_t GetKReg() const { return fKReg; }	Int_t GetKReg() const { return fKReg; }

	// Obtain the distribution of \|d\| (for determining the regularization)	// Obtain the distribution of \|d\| (for determining the regularization)
	TH1D* GetD() const;	TH1D* GetD() const;

	// Obtain the distribution of singular values	// Obtain the distribution of singular values
	TH1D* GetSV() const;	TH1D* GetSV() const;


		// Obtain the computed regularized covariance matrix
		TH2D* GetXtau() const;

		// Obtain the computed inverse of the covariance matrix
		TH2D* GetXinv() const;

	// Helper functions	// Helper functions

	static Double_t ComputeChiSquared( const TH1D& truspec, const TH1D& unfs pec, const TH2D& covmat, Double_t regpar = 0.01 );	Double_t ComputeChiSquared( const TH1D& truspec, const TH1D& unfspec );

	private:	private:

	// Helper functions for vector and matrix operations	// Helper functions for vector and matrix operations
	void FillCurvatureMatrix( TMatrixD& tCurv, TMatrixD& tC ) con st;	void FillCurvatureMatrix( TMatrixD& tCurv, TMatrixD& tC ) con st;
	static Double_t GetCurvature ( const TVectorD& vec, const TMatrixD & curv );	static Double_t GetCurvature ( const TVectorD& vec, const TMatrixD & curv );

	void InitHistos ( );	void InitHistos ( );

	// Helper functions	// Helper functions
	static void H2V ( const TH1D* histo, TVectorD& vec );	static void H2V ( const TH1D* histo, TVectorD& vec );
	static void H2Verr ( const TH1D* histo, TVectorD& vec );	static void H2Verr ( const TH1D* histo, TVectorD& vec );
	static void V2H ( const TVectorD& vec, TH1D& histo );	static void V2H ( const TVectorD& vec, TH1D& histo );
	static void H2M ( const TH2D* histo, TMatrixD& mat );	static void H2M ( const TH2D* histo, TMatrixD& mat );

		static void M2H ( const TMatrixD& mat, TH2D& histo );
	static TMatrixD MatDivVec( const TMatrixD& mat, const TVectorD& vec, Int _t zero=0 );	static TMatrixD MatDivVec( const TMatrixD& mat, const TVectorD& vec, Int _t zero=0 );
	static TVectorD CompProd ( const TVectorD& vec1, const TVectorD& vec2 );	static TVectorD CompProd ( const TVectorD& vec1, const TVectorD& vec2 );

	static TVectorD VecDiv ( const TVectorD& vec1, const TVe ctorD& vec2, Int_t zero = 0 );	static TVectorD VecDiv ( const TVectorD& vec1, const TVe ctorD& vec2, Int_t zero = 0 );
	static void RegularisedSymMatInvert( TMatrixDSym& mat, Double_t eps = 1e-3 );	static void RegularisedSymMatInvert( TMatrixDSym& mat, Double_t eps = 1e-3 );

	// Class members	// Class members
	Int_t fNdim; //! Truth and reconstructed dimensions	Int_t fNdim; //! Truth and reconstructed dimensions
	Int_t fDdim; //! Derivative for curvature matrix	Int_t fDdim; //! Derivative for curvature matrix
	Bool_t fNormalize; //! Normalize unfolded spectrum to 1	Bool_t fNormalize; //! Normalize unfolded spectrum to 1
	Int_t fKReg; //! Regularisation parameter	Int_t fKReg; //! Regularisation parameter

	TH1D* fDHist; // Distribution of d (for checking regularizat	TH1D* fDHist; //! Distribution of d (for checking regulariza
	ion)	tion)
	TH1D* fSVHist; // Distribution of singular values	TH1D* fSVHist; //! Distribution of singular values
		TH2D* fXtau; //! Computed regularized covariance matrix
		TH2D* fXinv; //! Computed inverse of covariance matrix

	// Input histos	// Input histos
	const TH1D* fBdat; // measured distribution (data)	const TH1D* fBdat; // measured distribution (data)

		TH2D* fBcov; // covariance matrix of measured distribution (data)
	const TH1D* fBini; // reconstructed distribution (MC)	const TH1D* fBini; // reconstructed distribution (MC)
	const TH1D* fXini; // truth distribution (MC)	const TH1D* fXini; // truth distribution (MC)
	const TH2D* fAdet; // Detector response matrix	const TH2D* fAdet; // Detector response matrix

	// Evaluation of covariance matrices	// Evaluation of covariance matrices
	TH1D* fToyhisto; //! Toy MC histogram	TH1D* fToyhisto; //! Toy MC histogram
	TH2D* fToymat; //! Toy MC detector response matrix	TH2D* fToymat; //! Toy MC detector response matrix
	Bool_t fToyMode; //! Internal switch for covariance matrix prop agation	Bool_t fToyMode; //! Internal switch for covariance matrix prop agation
	Bool_t fMatToyMode; //! Internal switch for evaluation of statisti cal uncertainties from response matrix	Bool_t fMatToyMode; //! Internal switch for evaluation of statisti cal uncertainties from response matrix


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

	TSchemaRuleSet.h	TSchemaRuleSet.h

	// @(#)root/core:$Id: TSchemaRuleSet.h 32644 2010-03-17 13:58:28Z pcanal $	// @(#)root/core:$Id: TSchemaRuleSet.h 38140 2011-02-18 10:52:47Z pcanal $
	// author: Lukasz Janyst <ljanyst@cern.ch>	// author: Lukasz Janyst <ljanyst@cern.ch>

	#ifndef ROOT_TSchemaRuleSet	#ifndef ROOT_TSchemaRuleSet
	#define ROOT_TSchemaRuleSet	#define ROOT_TSchemaRuleSet

	class TClass;	class TClass;

	#include "TObject.h"	#include "TObject.h"
	#include "TObjArray.h"	#include "TObjArray.h"
	#include "Rtypes.h"	#include "Rtypes.h"

	skipping to change at line 43	skipping to change at line 43

	enum EConsistencyCheck {	enum EConsistencyCheck {
	kNoCheck = 0,	kNoCheck = 0,
	kCheckAll = 1,	kCheckAll = 1,
	kCheckConflict = 2	kCheckConflict = 2
	};	};

	TSchemaRuleSet();	TSchemaRuleSet();
	virtual ~TSchemaRuleSet();	virtual ~TSchemaRuleSet();


	Bool_t AddRule( TSchemaRule* rule, EConsistencyCheck	Bool_t AddRule( TSchemaRule* rule, EConsistencyCheck
	checkConsistency = kCheckAll );	checkConsistency = kCheckAll, TString *errmsg = 0 );
	Bool_t AddRules( TSchemaRuleSet* rules, EConsistencyC	Bool_t AddRules( TSchemaRuleSet* rules, EConsistencyC
	heck checkConsistency = kCheckAll );	heck checkConsistency = kCheckAll, TString *errmsg = 0);
	Bool_t HasRuleWithSourceClass( const TString &source) const;	Bool_t HasRuleWithSourceClass( const TString &source) const;
	const TObjArray* FindRules( const TString &source ) const;	const TObjArray* FindRules( const TString &source ) const;
	const TSchemaMatch* FindRules( const TString &source, Int_t versio n ) const;	const TSchemaMatch* FindRules( const TString &source, Int_t versio n ) const;
	const TSchemaMatch* FindRules( const TString &source, UInt_t check sum ) const;	const TSchemaMatch* FindRules( const TString &source, UInt_t check sum ) const;
	const TSchemaMatch* FindRules( const TString &source, Int_t versio n, UInt_t checksum ) const;	const TSchemaMatch* FindRules( const TString &source, Int_t versio n, UInt_t checksum ) const;
	TClass* GetClass();	TClass* GetClass();
	UInt_t GetClassCheckSum() const;	UInt_t GetClassCheckSum() const;
	TString GetClassName() const;	TString GetClassName() const;
	Int_t GetClassVersion() const;	Int_t GetClassVersion() const;
	const TObjArray* GetRules() const;	const TObjArray* GetRules() const;

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

	TSelectorCint.h	TSelectorCint.h

	// @(#)root/tree:$Id: TSelectorCint.h 34509 2010-07-20 12:18:17Z rdm $	// @(#)root/tree:$Id: TSelectorCint.h 38871 2011-04-15 11:35:38Z pcanal $
	// Author: Rene Brun 05/02/97	// Author: Rene Brun 05/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 37	skipping to change at line 37
	#include "TInterpreter.h"	#include "TInterpreter.h"
	#endif	#endif

	class TSelectorCint : public TSelector {	class TSelectorCint : public TSelector {

	private:	private:
	void SetFuncProto(CallFunc_t cf, ClassInfo_t cl, const char* fname,	void SetFuncProto(CallFunc_t cf, ClassInfo_t cl, const char* fname,
	const char* argtype, Bool_t required = kTRUE);	const char* argtype, Bool_t required = kTRUE);

	protected:	protected:

	ClassInfo_t *fClass; //!	ClassInfo_t *fClass; //!
	CallFunc_t *fFuncVersion; //!	CallFunc_t *fFuncVersion; //!
	CallFunc_t *fFuncInit; //!	CallFunc_t *fFuncInit; //!
	CallFunc_t *fFuncBegin; //!	CallFunc_t *fFuncBegin; //!
	CallFunc_t *fFuncSlBegin; //!	CallFunc_t *fFuncSlBegin; //!
	CallFunc_t *fFuncNotif; //!	CallFunc_t *fFuncNotif; //!
	CallFunc_t *fFuncSlTerm; //!	CallFunc_t *fFuncSlTerm; //!
	CallFunc_t *fFuncTerm; //!	CallFunc_t *fFuncTerm; //!
	CallFunc_t *fFuncCut; //!	CallFunc_t *fFuncCut; //!
	CallFunc_t *fFuncFill; //!	CallFunc_t *fFuncFill; //!
	CallFunc_t *fFuncProc; //!	CallFunc_t *fFuncProc; //!
	CallFunc_t *fFuncOption; //!	CallFunc_t *fFuncOption; //!
	CallFunc_t *fFuncObj; //!	CallFunc_t *fFuncObj; //!
	CallFunc_t *fFuncInp; //!	CallFunc_t *fFuncInp; //!
	CallFunc_t *fFuncOut; //!	CallFunc_t *fFuncOut; //!
	CallFunc_t *fFuncGetAbort; //!	CallFunc_t *fFuncAbort; //!
	CallFunc_t *fFuncGetStat; //!	CallFunc_t *fFuncGetAbort; //!
	TSelector *fIntSelector; //Pointer to interpreted selector (if inter	CallFunc_t *fFuncResetAbort; //!
	preted)	CallFunc_t *fFuncGetStat; //!
	Bool_t fIsOwner; //True if fIntSelector shoudl be deleted wh	TSelector *fIntSelector; //Pointer to interpreted selector (if int
	en the this object is deleted.	erpreted)
		Bool_t fIsOwner; //True if fIntSelector shoudl be deleted
		when the this object is deleted.

	public:	public:
	TSelectorCint();	TSelectorCint();
	virtual ~TSelectorCint();	virtual ~TSelectorCint();
	virtual void Build(TSelector iselector, ClassInfo_t cl, Bool_t isowner = kTRUE);	virtual void Build(TSelector iselector, ClassInfo_t cl, Bool_t isowner = kTRUE);
	virtual int Version() const;	virtual int Version() const;
	virtual void Init(TTree *);	virtual void Init(TTree *);
	virtual void Begin(TTree *tree);	virtual void Begin(TTree *tree);
	virtual void SlaveBegin(TTree *);	virtual void SlaveBegin(TTree *);
	virtual Bool_t Notify();	virtual Bool_t Notify();
	virtual Bool_t ProcessCut(Long64_t entry);	virtual Bool_t ProcessCut(Long64_t entry);
	virtual void ProcessFill(Long64_t entry);	virtual void ProcessFill(Long64_t entry);
	virtual Bool_t Process(Long64_t entry);	virtual Bool_t Process(Long64_t entry);
	virtual void SetOption(const char *option);	virtual void SetOption(const char *option);
	virtual void SetObject(TObject *obj);	virtual void SetObject(TObject *obj);
	virtual void SetInputList(TList *input);	virtual void SetInputList(TList *input);
	virtual TList *GetOutputList() const;	virtual TList *GetOutputList() const;
	virtual void SlaveTerminate();	virtual void SlaveTerminate();
	virtual void Terminate();	virtual void Terminate();

		virtual void Abort(const char *why, EAbort what = kAbortProcess);
	virtual EAbort GetAbort() const;	virtual EAbort GetAbort() const;

		virtual void ResetAbort();
	virtual Long64_t GetStatus() const;	virtual Long64_t GetStatus() const;
	virtual TClass *GetInterpretedClass() const;	virtual TClass *GetInterpretedClass() const;
	virtual TSelector *GetInterpretedSelector() const { return fIntSelector ; }	virtual TSelector *GetInterpretedSelector() const { return fIntSelector ; }

	ClassDef(TSelectorCint,0) //A utility class for tree and object process ing (interpreted version)	ClassDef(TSelectorCint,0) //A utility class for tree and object process ing (interpreted version)
	};	};

	#endif	#endif

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

	TStatus.h	TStatus.h

	// @(#)root/proofplayer:$Id: TStatus.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/proofplayer:$Id: TStatus.h 38709 2011-04-01 16:27:30Z ganis $
	// Author: Maarten Ballintijn 12/03/2004	// Author: Maarten Ballintijn 12/03/2004

	/*************************************************************************	/*************************************************************************
	* 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 46	skipping to change at line 46
	class TCollection;	class TCollection;

	class TStatus : public TNamed {	class TStatus : public TNamed {

	private:	private:
	typedef std::set<std::string> MsgSet_t;	typedef std::set<std::string> MsgSet_t;
	typedef std::set<std::string>::const_iterator MsgIter_t;	typedef std::set<std::string>::const_iterator MsgIter_t;
	MsgSet_t fMsgs; // list of error messages	MsgSet_t fMsgs; // list of error messages
	MsgIter_t fIter; //!iterator in messages	MsgIter_t fIter; //!iterator in messages


		Long_t fVirtMemMax; // Max virtual memory used by the worker
		Long_t fResMemMax; // Max resident memory used by the worker

	public:	public:
	TStatus();	TStatus();
	virtual ~TStatus() { }	virtual ~TStatus() { }

	Bool_t IsOk() const { return fMsgs.empty(); }	Bool_t IsOk() const { return fMsgs.empty(); }
	void Add(const char *mesg);	void Add(const char *mesg);
	virtual Int_t Merge(TCollection *list);	virtual Int_t Merge(TCollection *list);
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	void Reset();	void Reset();
	const char *NextMesg();	const char *NextMesg();


	ClassDef(TStatus,1); // Status class	Long_t GetResMemMax() const { return fResMemMax; }
		Long_t GetVirtMemMax() const { return fVirtMemMax; }
		void SetMemValues(Long_t vmem = -1, Long_t rmem = -1);

		ClassDef(TStatus,2); // Status class
	};	};

	#endif	#endif

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

	TStreamerInfo.h	TStreamerInfo.h

	// @(#)root/io:$Id: TStreamerInfo.h 36061 2010-10-04 16:05:51Z pcanal $	// @(#)root/io:$Id: TStreamerInfo.h 38460 2011-03-16 15:28:08Z 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 30	skipping to change at line 30
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TVirtualStreamerInfo	#ifndef ROOT_TVirtualStreamerInfo
	#include "TVirtualStreamerInfo.h"	#include "TVirtualStreamerInfo.h"
	#endif	#endif

	#include "TVirtualCollectionProxy.h"	#include "TVirtualCollectionProxy.h"

	#if (defined(_MSC_VER) && (_MSC_VER < 1300)) \|\| defined(R__ALPHA) \|\| \	#if (defined(_MSC_VER) && (_MSC_VER < 1300)) \|\| defined(R__ALPHA) \|\| \

	(defined(R__MACOSX) && defined(R__GNU) && __GNUC__==3 && __GNUC_MINOR<= 3) \|\| \	(defined(R__MACOSX) && defined(R__GNU) && __GNUC__==3 && __GNUC_MINOR__ <=3) \|\| \
	(defined(R__MACOSX) && defined(__xlC__))	(defined(R__MACOSX) && defined(__xlC__))
	#define R__BROKEN_FUNCTION_TEMPLATES	#define R__BROKEN_FUNCTION_TEMPLATES
	#endif	#endif

	class TFile;	class TFile;
	class TClass;	class TClass;
	class TClonesArray;	class TClonesArray;
	class TDataMember;	class TDataMember;
	class TMemberStreamer;	class TMemberStreamer;
	class TStreamerElement;	class TStreamerElement;

	skipping to change at line 139	skipping to change at line 139
	kIgnoreTObjectStreamer = BIT(13), // eventhough BIT(13) is taken up by TObject (to preserverse forward compatibility)	kIgnoreTObjectStreamer = BIT(13), // eventhough BIT(13) is taken up by TObject (to preserverse forward compatibility)
	kRecovered = BIT(14),	kRecovered = BIT(14),
	kNeedCheck = BIT(15),	kNeedCheck = BIT(15),
	kIsCompiled = BIT(16)	kIsCompiled = BIT(16)
	};	};

	enum EReadWrite {	enum EReadWrite {
	kBase = 0, kOffsetL = 20, kOffsetP = 40, kCounter = 6, k CharStar = 7,	kBase = 0, kOffsetL = 20, kOffsetP = 40, kCounter = 6, k CharStar = 7,
	kChar = 1, kShort = 2, kInt = 3, kLong = 4, k Float = 5,	kChar = 1, kShort = 2, kInt = 3, kLong = 4, k Float = 5,
	kDouble = 8, kDouble32= 9,	kDouble = 8, kDouble32= 9,

		kLegacyChar = 10, // Equal to TDataType's kchar
	kUChar = 11, kUShort = 12, kUInt = 13, kULong = 14, k Bits = 15,	kUChar = 11, kUShort = 12, kUInt = 13, kULong = 14, k Bits = 15,
	kLong64 = 16, kULong64 = 17, kBool = 18, kFloat16 = 19,	kLong64 = 16, kULong64 = 17, kBool = 18, kFloat16 = 19,
	kObject = 61, kAny = 62, kObjectp = 63, kObjectP = 64, k TString = 65,	kObject = 61, kAny = 62, kObjectp = 63, kObjectP = 64, k TString = 65,
	kTObject = 66, kTNamed = 67, kAnyp = 68, kAnyP = 69, k AnyPnoVT = 70,	kTObject = 66, kTNamed = 67, kAnyp = 68, kAnyP = 69, k AnyPnoVT = 70,
	kSTLp = 71,	kSTLp = 71,
	kSkip = 100, kSkipL = 120, kSkipP = 140,	kSkip = 100, kSkipL = 120, kSkipP = 140,
	kConv = 200, kConvL = 220, kConvP = 240,	kConv = 200, kConvL = 220, kConvP = 240,
	kSTL = 300, kSTLstring = 365,	kSTL = 300, kSTLstring = 365,
	kStreamer = 500, kStreamLoop = 501,	kStreamer = 500, kStreamLoop = 501,
	kCache = 600, // Cache the value in memory than is not part of the object but is accessible via a SchemaRule	kCache = 600, // Cache the value in memory than is not part of the object but is accessible via a SchemaRule

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

	TString.h	TString.h

	// @(#)root/base:$Id: TString.h 34285 2010-07-01 20:37:52Z rdm $	// @(#)root/base:$Id: TString.h 39006 2011-04-21 18:05:53Z rdm $
	// Author: Fons Rademakers 04/08/95	// Author: Fons Rademakers 04/08/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 30	skipping to change at line 30
	// //	// //
	// Cannot be stored in a TCollection... use TObjString instead. //	// Cannot be stored in a TCollection... use TObjString instead. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef __CINT__	#ifndef __CINT__
	#include <string.h>	#include <string.h>
	#include <stdio.h>	#include <stdio.h>
	#endif	#endif


	#ifndef ROOT_TRefCnt
	#include "TRefCnt.h"
	#endif

	#ifndef ROOT_Riosfwd	#ifndef ROOT_Riosfwd
	#include "Riosfwd.h"	#include "Riosfwd.h"
	#endif	#endif

	#ifndef ROOT_TMathBase	#ifndef ROOT_TMathBase
	#include "TMathBase.h"	#include "TMathBase.h"
	#endif	#endif

	#include <stdarg.h>	#include <stdarg.h>
	#include <string>	#include <string>

	skipping to change at line 79	skipping to change at line 75
	TString operator+(Long64_t i, const TString &s);	TString operator+(Long64_t i, const TString &s);
	TString operator+(ULong64_t i, const TString &s);	TString operator+(ULong64_t i, const TString &s);
	Bool_t operator==(const TString &s1, const TString &s2);	Bool_t operator==(const TString &s1, const TString &s2);
	Bool_t operator==(const TString &s1, const char *s2);	Bool_t operator==(const TString &s1, const char *s2);
	Bool_t operator==(const TSubString &s1, const TSubString &s2);	Bool_t operator==(const TSubString &s1, const TSubString &s2);
	Bool_t operator==(const TSubString &s1, const TString &s2);	Bool_t operator==(const TSubString &s1, const TString &s2);
	Bool_t operator==(const TSubString &s1, const char *s2);	Bool_t operator==(const TSubString &s1, const char *s2);

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

	// TStringRef //
	// //
	// This is the dynamically allocated part of a TString. //
	// It maintains a reference count. It contains no public member //
	// functions. //
	// //
	//////////////////////////////////////////////////////////////////////////
	class TStringRef : public TRefCnt {

	friend class TString;
	friend class TStringLong;
	friend class TSubString;

	private:
	Ssiz_t fCapacity; // Max string length (excluding null)
	Ssiz_t fNchars; // String length (excluding null)

	void UnLink(); // disconnect from a TStringRef, maybe delete it

	Ssiz_t Length() const { return fNchars; }
	Ssiz_t Capacity() const { return fCapacity; }
	char Data() const { return (char)(this+1); }

	char &operator[](Ssiz_t i) { return ((char*)(this+1))[i]; }
	char operator[](Ssiz_t i) const { return ((char*)(this+1))[i]; }

	Ssiz_t First(char c) const;
	Ssiz_t First(const char *s) const;
	UInt_t Hash() const;
	UInt_t HashFoldCase() const;
	Ssiz_t Last(char) const;

	static TStringRef *GetRep(Ssiz_t capac, Ssiz_t nchar);
	};

	//////////////////////////////////////////////////////////////////////////
	// //
	// TSubString //	// TSubString //
	// //	// //
	// The TSubString class allows selected elements to be addressed. //	// The TSubString class allows selected elements to be addressed. //
	// There are no public constructors. //	// There are no public constructors. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	class TSubString {	class TSubString {

	friend class TStringLong;	friend class TStringLong;
	friend class TString;	friend class TString;

	skipping to change at line 174	skipping to change at line 133
	int operator!() const { return fBegin == kNPOS; }	int operator!() const { return fBegin == kNPOS; }
	};	};

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TString //	// TString //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	class TString {	class TString {


		friend class TStringLong;
	friend class TSubString;	friend class TSubString;

	friend class TStringRef;

	friend TString operator+(const TString &s1, const TString &s2);	friend TString operator+(const TString &s1, const TString &s2);
	friend TString operator+(const TString &s, const char *cs);	friend TString operator+(const TString &s, const char *cs);
	friend TString operator+(const char *cs, const TString &s);	friend TString operator+(const char *cs, const TString &s);
	friend TString operator+(const TString &s, char c);	friend TString operator+(const TString &s, char c);
	friend TString operator+(const TString &s, Long_t i);	friend TString operator+(const TString &s, Long_t i);
	friend TString operator+(const TString &s, ULong_t i);	friend TString operator+(const TString &s, ULong_t i);
	friend TString operator+(const TString &s, Long64_t i);	friend TString operator+(const TString &s, Long64_t i);
	friend TString operator+(const TString &s, ULong64_t i);	friend TString operator+(const TString &s, ULong64_t i);
	friend TString operator+(char c, const TString &s);	friend TString operator+(char c, const TString &s);
	friend TString operator+(Long_t i, const TString &s);	friend TString operator+(Long_t i, const TString &s);
	friend TString operator+(ULong_t i, const TString &s);	friend TString operator+(ULong_t i, const TString &s);
	friend TString operator+(Long64_t i, const TString &s);	friend TString operator+(Long64_t i, const TString &s);
	friend TString operator+(ULong64_t i, const TString &s);	friend TString operator+(ULong64_t i, const TString &s);
	friend Bool_t operator==(const TString &s1, const TString &s2);	friend Bool_t operator==(const TString &s1, const TString &s2);
	friend Bool_t operator==(const TString &s1, const char *s2);	friend Bool_t operator==(const TString &s1, const char *s2);

	private:	private:

	static Ssiz_t fgInitialCapac; // Initial allocation Capacity	#ifdef R__BYTESWAP
	static Ssiz_t fgResizeInc; // Resizing increment	enum { kShortMask = 0x01, kLongMask = 0x1 };
	static Ssiz_t fgFreeboard; // Max empty space before reclaim	#else
		enum { kShortMask = 0x80, kLongMask = 0x80000000 };
	void Clone(); // Make self a distinct copy	#endif
	void Clone(Ssiz_t nc); // Make self a distinct copy w. capacit
	y nc	struct LongStr_t
	void FormImp(const char *fmt, va_list ap);	{
		Ssiz_t fCap; // Max string length (including null)
		Ssiz_t fSize; // String length (excluding null)
		char *fData; // Long string data
		};

		enum { kMinCap = (sizeof(LongStr_t) - 1)/sizeof(char) > 2 ?
		(sizeof(LongStr_t) - 1)/sizeof(char) : 2 };

		struct ShortStr_t
		{
		unsigned char fSize; // String length (excluding null)
		char fData[kMinCap]; // Short string data
		};

		union UStr_t { LongStr_t fL; ShortStr_t fS; };

		enum { kNwords = sizeof(UStr_t) / sizeof(Ssiz_t)};

		struct RawStr_t
		{
		Ssiz_t fWords[kNwords];
		};

		struct Rep_t
		{
		union
		{
		LongStr_t fLong;
		ShortStr_t fShort;
		RawStr_t fRaw;
		};
		};

	protected:	protected:

	char *fData; // ref. counted data (TStringRef is in fr	#ifndef __CINT__
	ont)	Rep_t fRep; // String data
		#endif

	// Special concatenation constructor	// Special concatenation constructor
	TString(const char a1, Ssiz_t n1, const char a2, Ssiz_t n2);	TString(const char a1, Ssiz_t n1, const char a2, Ssiz_t n2);

	TStringRef Pref() const { return (((TStringRef) fData) - 1); }
	void AssertElement(Ssiz_t nc) const; // Index in range	void AssertElement(Ssiz_t nc) const; // Index in range
	void Clobber(Ssiz_t nc); // Remove old contents	void Clobber(Ssiz_t nc); // Remove old contents

	void Cow(); // Do copy on write as ne
	eded
	void Cow(Ssiz_t nc); // Do copy on write as ne
	eded
	static Ssiz_t AdjustCapacity(Ssiz_t nc);
	void InitChar(char c); // Initialize from char	void InitChar(char c); // Initialize from char


		enum { kAlignment = 16 };
		static Ssiz_t Align(Ssiz_t s) { return (s + (kAlignment-1)) & ~(kAlignm
		ent-1); }
		static Ssiz_t Recommend(Ssiz_t s) { return (s < kMinCap ? kMinCap : Ali
		gn(s+1)) - 1; }
		static Ssiz_t AdjustCapacity(Ssiz_t nc);

		private:
		Bool_t IsLong() const { return Bool_t(fRep.fShort.fSize & kShort
		Mask); }
		#ifdef R__BYTESWAP
		void SetShortSize(Ssiz_t s) { fRep.fShort.fSize = (unsigned ch
		ar)(s << 1); }
		Ssiz_t GetShortSize() const { return fRep.fShort.fSize >> 1; }
		#else
		void SetShortSize(Ssiz_t s) { fRep.fShort.fSize = (unsigned ch
		ar)s; }
		Ssiz_t GetShortSize() const { return fRep.fShort.fSize; }
		#endif
		void SetLongSize(Ssiz_t s) { fRep.fLong.fSize = s; }
		Ssiz_t GetLongSize() const { return fRep.fLong.fSize; }
		void SetSize(Ssiz_t s) { IsLong() ? SetLongSize(s) : SetShortS
		ize(s); }
		void SetLongCap(Ssiz_t s) { fRep.fLong.fCap = kLongMask \| s; }
		Ssiz_t GetLongCap() const { return fRep.fLong.fCap & ~kLongMask;
		}
		void SetLongPointer(char *p) { fRep.fLong.fData = p; }
		char *GetLongPointer() { return fRep.fLong.fData; }
		const char *GetLongPointer() const { return fRep.fLong.fData; }
		char *GetShortPointer() { return fRep.fShort.fData; }
		const char *GetShortPointer() const { return fRep.fShort.fData; }
		char *GetPointer() { return IsLong() ? GetLongPointer() : GetSh
		ortPointer(); }
		const char *GetPointer() const { return IsLong() ? GetLongPointer() :
		GetShortPointer(); }
		#ifdef R__BYTESWAP
		Ssiz_t MaxSize() const { return kMaxInt - 1; }
		#else
		Ssiz_t MaxSize() const { return (kMaxInt >> 1) - 1; }
		#endif
		void UnLink() const { if (IsLong()) delete [] fRep.fLong.fData
		; }
		void Zero() {
		Ssiz_t (&a)[kNwords] = fRep.fRaw.fWords;
		for (UInt_t i = 0; i < kNwords; ++i)
		a[i] = 0;
		}
		char *Init(Ssiz_t capacity, Ssiz_t nchar);
		void Clone(Ssiz_t nc); // Make self a distinct copy w. capacit
		y nc
		void FormImp(const char *fmt, va_list ap);
		UInt_t HashCase() const;
		UInt_t HashFoldCase() const;

	public:	public:
	enum EStripType { kLeading = 0x1, kTrailing = 0x2, kBoth = 0x3 };	enum EStripType { kLeading = 0x1, kTrailing = 0x2, kBoth = 0x3 };
	enum ECaseCompare { kExact, kIgnoreCase };	enum ECaseCompare { kExact, kIgnoreCase };


	TString(); // Null string	TString(); // Null string
	explicit TString(Ssiz_t ic); // Suggested capacity	explicit TString(Ssiz_t ic); // Suggested capacity
	TString(const TString &s) : // Copy constructor	TString(const TString &s); // Copy constructor
	fData(s.fData) { Pref()->AddReference(); }

	TString(const char *s); // Copy to embedded null	TString(const char *s); // Copy to embedded null
	TString(const char *s, Ssiz_t n); // Copy past any embedded nulls	TString(const char *s, Ssiz_t n); // Copy past any embedded nulls
	TString(const std::string &s);	TString(const std::string &s);

	TString(char c) : fData(0) { InitChar(c); }	TString(char c) { InitChar(c); }
	TString(char c, Ssiz_t s);	TString(char c, Ssiz_t s);
	TString(const TSubString &sub);	TString(const TSubString &sub);

	virtual ~TString();	virtual ~TString();

	// ROOT I/O interface	// ROOT I/O interface
	virtual void FillBuffer(char *&buffer);	virtual void FillBuffer(char *&buffer);
	virtual void ReadBuffer(char *&buffer);	virtual void ReadBuffer(char *&buffer);
	virtual Int_t Sizeof() const;	virtual Int_t Sizeof() const;

	static TString ReadString(TBuffer &b, const TClass clReq);	static TString ReadString(TBuffer &b, const TClass clReq);
	static void WriteString(TBuffer &b, const TString *a);	static void WriteString(TBuffer &b, const TString *a);

	friend TBuffer &operator<<(TBuffer &b, const TString *obj);	friend TBuffer &operator<<(TBuffer &b, const TString *obj);

	// C I/O interface	// C I/O interface
	Bool_t Gets(FILE *fp, Bool_t chop=kTRUE);	Bool_t Gets(FILE *fp, Bool_t chop=kTRUE);
	void Puts(FILE *fp);	void Puts(FILE *fp);

	// Type conversion	// Type conversion

	operator const char*() const { return fData; }	operator const char*() const { return GetPointer(); }

	// Assignment	// Assignment
	TString &operator=(char s); // Replace string	TString &operator=(char s); // Replace string
	TString &operator=(const char *s);	TString &operator=(const char *s);
	TString &operator=(const TString &s);	TString &operator=(const TString &s);
	TString &operator=(const std::string &s);	TString &operator=(const std::string &s);
	TString &operator=(const TSubString &s);	TString &operator=(const TSubString &s);
	TString &operator+=(const char *s); // Append string	TString &operator+=(const char *s); // Append string
	TString &operator+=(const TString &s);	TString &operator+=(const TString &s);
	TString &operator+=(char c);	TString &operator+=(char c);

	skipping to change at line 294	skipping to change at line 325
	TString &Append(const char *cs);	TString &Append(const char *cs);
	TString &Append(const char *cs, Ssiz_t n);	TString &Append(const char *cs, Ssiz_t n);
	TString &Append(const TString &s);	TString &Append(const TString &s);
	TString &Append(const TString &s, Ssiz_t n);	TString &Append(const TString &s, Ssiz_t n);
	TString &Append(char c, Ssiz_t rep = 1); // Append c rep times	TString &Append(char c, Ssiz_t rep = 1); // Append c rep times
	Int_t Atoi() const;	Int_t Atoi() const;
	Long64_t Atoll() const;	Long64_t Atoll() const;
	Double_t Atof() const;	Double_t Atof() const;
	Bool_t BeginsWith(const char *s, ECaseCompare cmp = kExact) c onst;	Bool_t BeginsWith(const char *s, ECaseCompare cmp = kExact) c onst;
	Bool_t BeginsWith(const TString &pat, ECaseCompare cmp = kExact) c onst;	Bool_t BeginsWith(const TString &pat, ECaseCompare cmp = kExact) c onst;

	Ssiz_t Capacity() const { return Pref()->Capacity(); }	Ssiz_t Capacity() const { return (IsLong() ? GetLongCap() : kMinCa p) - 1; }
	Ssiz_t Capacity(Ssiz_t n);	Ssiz_t Capacity(Ssiz_t n);
	TString &Chop();	TString &Chop();
	void Clear();	void Clear();
	int CompareTo(const char *cs, ECaseCompare cmp = kExact) con st;	int CompareTo(const char *cs, ECaseCompare cmp = kExact) con st;
	int CompareTo(const TString &st, ECaseCompare cmp = kExact) con st;	int CompareTo(const TString &st, ECaseCompare cmp = kExact) con st;
	Bool_t Contains(const char *pat, ECaseCompare cmp = kExact) con st;	Bool_t Contains(const char *pat, ECaseCompare cmp = kExact) con st;
	Bool_t Contains(const TString &pat, ECaseCompare cmp = kExact) con st;	Bool_t Contains(const TString &pat, ECaseCompare cmp = kExact) con st;
	Bool_t Contains(const TRegexp &pat) const;	Bool_t Contains(const TRegexp &pat) const;
	Bool_t Contains(TPRegexp &pat) const;	Bool_t Contains(TPRegexp &pat) const;
	Int_t CountChar(Int_t c) const;	Int_t CountChar(Int_t c) const;
	TString Copy() const;	TString Copy() const;

	const char *Data() const { return fData; }	const char *Data() const { return GetPointer(); }
	Bool_t EndsWith(const char *pat, ECaseCompare cmp = kExact) con	Bool_t EndsWith(const char *pat, ECaseCompare cmp = kExact) const;
	st;	Ssiz_t First(char c) const;
	Ssiz_t First(char c) const { return Pref()->First(c); }	Ssiz_t First(const char *cs) const;
	Ssiz_t First(const char *cs) const { return Pref()->First(cs); }
	void Form(const char *fmt, ...)	void Form(const char *fmt, ...)
	#if defined(__GNUC__) && !defined(__CINT__)	#if defined(__GNUC__) && !defined(__CINT__)
	__attribute__((format(printf, 2, 3))) /* 1 is the this pointer */	__attribute__((format(printf, 2, 3))) /* 1 is the this pointer */
	#endif	#endif
	;	;
	UInt_t Hash(ECaseCompare cmp = kExact) const;	UInt_t Hash(ECaseCompare cmp = kExact) const;
	Ssiz_t Index(const char *pat, Ssiz_t i = 0,	Ssiz_t Index(const char *pat, Ssiz_t i = 0,
	ECaseCompare cmp = kExact) const;	ECaseCompare cmp = kExact) const;
	Ssiz_t Index(const TString &s, Ssiz_t i = 0,	Ssiz_t Index(const TString &s, Ssiz_t i = 0,
	ECaseCompare cmp = kExact) const;	ECaseCompare cmp = kExact) const;

	skipping to change at line 338	skipping to change at line 369
	TString &Insert(Ssiz_t pos, const char *s);	TString &Insert(Ssiz_t pos, const char *s);
	TString &Insert(Ssiz_t pos, const char *s, Ssiz_t extent);	TString &Insert(Ssiz_t pos, const char *s, Ssiz_t extent);
	TString &Insert(Ssiz_t pos, const TString &s);	TString &Insert(Ssiz_t pos, const TString &s);
	TString &Insert(Ssiz_t pos, const TString &s, Ssiz_t extent);	TString &Insert(Ssiz_t pos, const TString &s, Ssiz_t extent);
	Bool_t IsAscii() const;	Bool_t IsAscii() const;
	Bool_t IsAlpha() const;	Bool_t IsAlpha() const;
	Bool_t IsAlnum() const;	Bool_t IsAlnum() const;
	Bool_t IsDigit() const;	Bool_t IsDigit() const;
	Bool_t IsFloat() const;	Bool_t IsFloat() const;
	Bool_t IsHex() const;	Bool_t IsHex() const;

	Bool_t IsNull() const { return Pref()->fNchars == 0; }	Bool_t IsNull() const { return Length() == 0; }
	Bool_t IsWhitespace() const { return (Length() == CountChar(' ') ); }	Bool_t IsWhitespace() const { return (Length() == CountChar(' ') ); }

	Ssiz_t Last(char c) const { return Pref()->Last(c); }	Ssiz_t Last(char c) const;
	Ssiz_t Length() const { return Pref()->fNchars; }	Ssiz_t Length() const { return IsLong() ? GetLongSize() :
		GetShortSize(); }
	Bool_t MaybeRegexp() const;	Bool_t MaybeRegexp() const;
	Bool_t MaybeWildcard() const;	Bool_t MaybeWildcard() const;
	TString &Prepend(const char *cs); // Prepend a character string	TString &Prepend(const char *cs); // Prepend a character string
	TString &Prepend(const char *cs, Ssiz_t n);	TString &Prepend(const char *cs, Ssiz_t n);
	TString &Prepend(const TString &s);	TString &Prepend(const TString &s);
	TString &Prepend(const TString &s, Ssiz_t n);	TString &Prepend(const TString &s, Ssiz_t n);
	TString &Prepend(char c, Ssiz_t rep = 1); // Prepend c rep times	TString &Prepend(char c, Ssiz_t rep = 1); // Prepend c rep times
	istream &ReadFile(istream &str); // Read to EOF or null charact er	istream &ReadFile(istream &str); // Read to EOF or null charact er
	istream &ReadLine(istream &str,	istream &ReadLine(istream &str,
	Bool_t skipWhite = kTRUE); // Read to EOF or new line	Bool_t skipWhite = kTRUE); // Read to EOF or new line

	skipping to change at line 388	skipping to change at line 419
	static Ssiz_t ResizeIncrement(Ssiz_t ri = 16); // Resizing increme nt	static Ssiz_t ResizeIncrement(Ssiz_t ri = 16); // Resizing increme nt
	static Ssiz_t GetInitialCapacity();	static Ssiz_t GetInitialCapacity();
	static Ssiz_t GetResizeIncrement();	static Ssiz_t GetResizeIncrement();
	static Ssiz_t GetMaxWaste();	static Ssiz_t GetMaxWaste();
	static TString Format(const char *fmt, ...)	static TString Format(const char *fmt, ...)
	#if defined(__GNUC__) && !defined(__CINT__)	#if defined(__GNUC__) && !defined(__CINT__)
	__attribute__((format(printf, 1, 2)))	__attribute__((format(printf, 1, 2)))
	#endif	#endif
	;	;


	ClassDef(TString,1) //Basic string class	ClassDef(TString,2) //Basic string class
	};	};

	// Related global functions	// Related global functions
	istream &operator>>(istream &str, TString &s);	istream &operator>>(istream &str, TString &s);
	ostream &operator<<(ostream &str, const TString &s);	ostream &operator<<(ostream &str, const TString &s);
	#if defined(R__TEMPLATE_OVERLOAD_BUG)	#if defined(R__TEMPLATE_OVERLOAD_BUG)
	template <>	template <>
	#endif	#endif
	TBuffer &operator>>(TBuffer &buf, TString *&sp);	TBuffer &operator>>(TBuffer &buf, TString *&sp);


	skipping to change at line 435	skipping to change at line 466
	extern int strcasecmp(const char str1, const char str2);	extern int strcasecmp(const char str1, const char str2);
	extern int strncasecmp(const char str1, const char str2, Ssiz_t n);	extern int strncasecmp(const char str1, const char str2, Ssiz_t n);
	#endif	#endif

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// Inlines //	// Inlines //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


	inline void TStringRef::UnLink()
	{ if (RemoveReference() == 0) delete [] (char*)this; }

	inline void TString::Cow()
	{ if (Pref()->References() > 1) Clone(); }

	inline void TString::Cow(Ssiz_t nc)
	{ if (Pref()->References() > 1 \|\| Capacity() < nc) Clone(nc); }

	inline TString &TString::Append(const char *cs)	inline TString &TString::Append(const char *cs)
	{ return Replace(Length(), 0, cs, cs ? strlen(cs) : 0); }	{ return Replace(Length(), 0, cs, cs ? strlen(cs) : 0); }

	inline TString &TString::Append(const char *cs, Ssiz_t n)	inline TString &TString::Append(const char *cs, Ssiz_t n)
	{ return Replace(Length(), 0, cs, n); }	{ return Replace(Length(), 0, cs, n); }

	inline TString &TString::Append(const TString &s)	inline TString &TString::Append(const TString &s)
	{ return Replace(Length(), 0, s.Data(), s.Length()); }	{ return Replace(Length(), 0, s.Data(), s.Length()); }

	inline TString &TString::Append(const TString &s, Ssiz_t n)	inline TString &TString::Append(const TString &s, Ssiz_t n)

	skipping to change at line 484	skipping to change at line 506
	inline TString &TString::operator+=(UShort_t i)	inline TString &TString::operator+=(UShort_t i)
	{ return operator+=((ULong_t) i); }	{ return operator+=((ULong_t) i); }

	inline TString &TString::operator+=(Int_t i)	inline TString &TString::operator+=(Int_t i)
	{ return operator+=((Long_t) i); }	{ return operator+=((Long_t) i); }

	inline TString &TString::operator+=(UInt_t i)	inline TString &TString::operator+=(UInt_t i)
	{ return operator+=((ULong_t) i); }	{ return operator+=((ULong_t) i); }

	inline TString &TString::operator+=(Double_t f)	inline TString &TString::operator+=(Double_t f)

	{ char s[32]; sprintf(s, "%.17g", f); return operator+=(s); }	{
		char s[32];
		// coverity[secure_coding] Buffer is large enough: width specified in fo
		rmat
		sprintf(s, "%.17g", f);
		return operator+=(s);
		}

	inline TString &TString::operator+=(Float_t f)	inline TString &TString::operator+=(Float_t f)
	{ return operator+=((Double_t) f); }	{ return operator+=((Double_t) f); }

	inline TString &TString::operator+=(Long64_t l)	inline TString &TString::operator+=(Long64_t l)

	{ char s[32]; sprintf(s, "%lld", l); return operator+=(s); }	{
		char s[32];
		// coverity[secure_coding] Buffer is large enough (2^64 = 20 digits).
		sprintf(s, "%lld", l);
		return operator+=(s);
		}

	inline TString &TString::operator+=(ULong64_t ul)	inline TString &TString::operator+=(ULong64_t ul)

	{ char s[32]; sprintf(s, "%llu", ul); return operator+=(s); }	{
		char s[32];
		// coverity[secure_coding] Buffer is large enough (2^64 = 20 digits).
		sprintf(s, "%llu", ul);
		return operator+=(s);
		}

	inline Bool_t TString::BeginsWith(const char *s, ECaseCompare cmp) const	inline Bool_t TString::BeginsWith(const char *s, ECaseCompare cmp) const
	{ return Index(s, s ? strlen(s) : (Ssiz_t)0, (Ssiz_t)0, cmp) == 0; }	{ return Index(s, s ? strlen(s) : (Ssiz_t)0, (Ssiz_t)0, cmp) == 0; }

	inline Bool_t TString::BeginsWith(const TString &pat, ECaseCompare cmp) con st	inline Bool_t TString::BeginsWith(const TString &pat, ECaseCompare cmp) con st
	{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) == 0; }	{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) == 0; }

	inline Bool_t TString::Contains(const TString &pat, ECaseCompare cmp) const	inline Bool_t TString::Contains(const TString &pat, ECaseCompare cmp) const
	{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) != kNPOS; }	{ return Index(pat.Data(), pat.Length(), (Ssiz_t)0, cmp) != kNPOS; }


	skipping to change at line 579	skipping to change at line 616
	inline TString &TString::ReplaceAll(const TString &s1, const char *s2)	inline TString &TString::ReplaceAll(const TString &s1, const char *s2)
	{ return ReplaceAll(s1.Data(), s1.Length(), s2, s2 ? strlen(s2) : 0); }	{ return ReplaceAll(s1.Data(), s1.Length(), s2, s2 ? strlen(s2) : 0); }

	inline TString &TString::ReplaceAll(const char *s1, const TString &s2)	inline TString &TString::ReplaceAll(const char *s1, const TString &s2)
	{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2.Data(), s2.Length()); }	{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2.Data(), s2.Length()); }

	inline TString &TString::ReplaceAll(const char s1,const char s2)	inline TString &TString::ReplaceAll(const char s1,const char s2)
	{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2, s2 ? strlen(s2) : 0); }	{ return ReplaceAll(s1, s1 ? strlen(s1) : 0, s2, s2 ? strlen(s2) : 0); }

	inline char &TString::operator()(Ssiz_t i)	inline char &TString::operator()(Ssiz_t i)

	{ Cow(); return fData[i]; }	{ return GetPointer()[i]; }

	inline char TString::operator[](Ssiz_t i) const
	{ AssertElement(i); return fData[i]; }

	inline char TString::operator()(Ssiz_t i) const	inline char TString::operator()(Ssiz_t i) const

	{ return fData[i]; }	{ return GetPointer()[i]; }

		inline char &TString::operator[](Ssiz_t i)
		{ AssertElement(i); return GetPointer()[i]; }

		inline char TString::operator[](Ssiz_t i) const
		{ AssertElement(i); return GetPointer()[i]; }

	inline const char *TSubString::Data() const	inline const char *TSubString::Data() const
	{	{
	// Return a pointer to the beginning of the substring. Note that the	// Return a pointer to the beginning of the substring. Note that the
	// terminating null is in the same place as for the original	// terminating null is in the same place as for the original
	// TString, so this method is not appropriate for converting the	// TString, so this method is not appropriate for converting the
	// TSubString to a string. To do that, construct a TString from the	// TSubString to a string. To do that, construct a TString from the
	// TSubString. For example:	// TSubString. For example:
	//	//
	// root [0] TString s("hello world")	// root [0] TString s("hello world")

	skipping to change at line 608	skipping to change at line 648
	// (const char* 0x857c8b8)"hello world"	// (const char* 0x857c8b8)"hello world"
	// root [3] TString substr(sub)	// root [3] TString substr(sub)
	// root [4] substr	// root [4] substr
	// (class TString)"hello"	// (class TString)"hello"

	return fStr.Data() + fBegin;	return fStr.Data() + fBegin;
	}	}

	// Access to elements of sub-string with bounds checking	// Access to elements of sub-string with bounds checking
	inline char TSubString::operator[](Ssiz_t i) const	inline char TSubString::operator[](Ssiz_t i) const

	{ AssertElement(i); return fStr.fData[fBegin+i]; }	{ AssertElement(i); return fStr.GetPointer()[fBegin+i]; }

	inline char TSubString::operator()(Ssiz_t i) const	inline char TSubString::operator()(Ssiz_t i) const

	{ return fStr.fData[fBegin+i]; }	{ return fStr.GetPointer()[fBegin+i]; }

	inline TSubString &TSubString::operator=(const TSubString &s)	inline TSubString &TSubString::operator=(const TSubString &s)
	{ fStr = s.fStr; fBegin = s.fBegin; fExtent = s.fExtent; return *this; }	{ fStr = s.fStr; fBegin = s.fBegin; fExtent = s.fExtent; return *this; }

	// String Logical operators	// String Logical operators

	#if !defined(R__ALPHA)
	inline Bool_t operator==(const TString &s1, const TString &s2)	inline Bool_t operator==(const TString &s1, const TString &s2)
	{	{
	return ((s1.Length() == s2.Length()) &&	return ((s1.Length() == s2.Length()) &&
	!memcmp(s1.Data(), s2.Data(), s1.Length()));	!memcmp(s1.Data(), s2.Data(), s1.Length()));
	}	}

	#endif

	inline Bool_t operator!=(const TString &s1, const TString &s2)	inline Bool_t operator!=(const TString &s1, const TString &s2)
	{ return !(s1 == s2); }	{ return !(s1 == s2); }

	inline Bool_t operator<(const TString &s1, const TString &s2)	inline Bool_t operator<(const TString &s1, const TString &s2)
	{ return s1.CompareTo(s2) < 0; }	{ return s1.CompareTo(s2) < 0; }

	inline Bool_t operator>(const TString &s1, const TString &s2)	inline Bool_t operator>(const TString &s1, const TString &s2)
	{ return s1.CompareTo(s2) > 0; }	{ return s1.CompareTo(s2) > 0; }


End of changes. 28 change blocks.
	97 lines changed or deleted	143 lines changed or added

	TTree.h	TTree.h

	// @(#)root/tree:$Id: TTree.h 37444 2010-12-09 18:12:26Z pcanal $	// @(#)root/tree:$Id: TTree.h 38741 2011-04-05 18:12:39Z pcanal $
	// 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 154	skipping to change at line 154
	protected:	protected:
	void AddClone(TTree*);	void AddClone(TTree*);
	virtual void KeepCircular();	virtual void KeepCircular();
	virtual TBranch BranchImp(const char branchname, const char* classname , TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);	virtual TBranch BranchImp(const char branchname, const char* classname , TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);
	virtual TBranch BranchImp(const char branchname, TClass* ptrClass, voi d* addobj, Int_t bufsize, Int_t splitlevel);	virtual TBranch BranchImp(const char branchname, TClass* ptrClass, voi d* addobj, Int_t bufsize, Int_t splitlevel);
	virtual TBranch BranchImpRef(const char branchname, const char* classn ame, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);	virtual TBranch BranchImpRef(const char branchname, const char* classn ame, TClass* ptrClass, void* addobj, Int_t bufsize, Int_t splitlevel);
	virtual TBranch BranchImpRef(const char branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel);	virtual TBranch BranchImpRef(const char branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t splitlevel);
	virtual Int_t CheckBranchAddressType(TBranch* branch, TClass* ptrClas s, EDataType datatype, Bool_t ptr);	virtual Int_t CheckBranchAddressType(TBranch* branch, TClass* ptrClas s, EDataType datatype, Bool_t ptr);
	virtual TBranch BronchExec(const char name, const char* classname, voi d* addobj, Bool_t isptrptr, Int_t bufsize, Int_t splitlevel);	virtual TBranch BronchExec(const char name, const char* classname, voi d* addobj, Bool_t isptrptr, Int_t bufsize, Int_t splitlevel);
	friend TBranch TTreeBranchImpRef(TTree tree, const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t sp litlevel);	friend TBranch TTreeBranchImpRef(TTree tree, const char* branchname, TClass* ptrClass, EDataType datatype, void* addobj, Int_t bufsize, Int_t sp litlevel);

		Int_t SetBranchAddressImp(TBranch branch, void addr, TBranch** ptr) ;

	class TFriendLock {	class TFriendLock {
	// Helper class to prevent infinite recursion in the	// Helper class to prevent infinite recursion in the
	// usage of TTree Friends. Implemented in TTree.cxx.	// usage of TTree Friends. Implemented in TTree.cxx.
	TTree *fTree; // Pointer to the locked tree	TTree *fTree; // Pointer to the locked tree
	UInt_t fMethodBit; // BIT for the locked method	UInt_t fMethodBit; // BIT for the locked method
	Bool_t fPrevious; // Previous value of the BIT.	Bool_t fPrevious; // Previous value of the BIT.

	protected:	protected:
	TFriendLock(const TFriendLock&);	TFriendLock(const TFriendLock&);
	TFriendLock& operator=(const TFriendLock&);	TFriendLock& operator=(const TFriendLock&);

	public:	public:
	TFriendLock(TTree* tree, UInt_t methodbit);	TFriendLock(TTree* tree, UInt_t methodbit);
	~TFriendLock();	~TFriendLock();
	};	};
	friend class TFriendLock;	friend class TFriendLock;

		// So that the index class can use TFriendLock:
		friend class TTreeIndex;
		friend class TChainIndex;

	// use to update fFriendLockStatus	// use to update fFriendLockStatus
	enum ELockStatusBits {	enum ELockStatusBits {
	kFindBranch = BIT(0),	kFindBranch = BIT(0),
	kFindLeaf = BIT(1),	kFindLeaf = BIT(1),
	kGetAlias = BIT(2),	kGetAlias = BIT(2),
	kGetBranch = BIT(3),	kGetBranch = BIT(3),
	kGetEntry = BIT(4),	kGetEntry = BIT(4),
	kGetEntryWithIndex = BIT(5),	kGetEntryWithIndex = BIT(5),
	kGetFriend = BIT(6),	kGetFriend = BIT(6),

	skipping to change at line 361	skipping to change at line 365
	virtual Int_t GetScanField() const { return fScanField; }	virtual Int_t GetScanField() const { return fScanField; }
	TTreeFormula *GetSelect() { return GetPlayer()->GetSelect() ; }	TTreeFormula *GetSelect() { return GetPlayer()->GetSelect() ; }
	virtual Long64_t GetSelectedRows() { return GetPlayer()->GetSelec tedRows(); }	virtual Long64_t GetSelectedRows() { return GetPlayer()->GetSelec tedRows(); }
	virtual Int_t GetTimerInterval() const { return fTimerInterval ; }	virtual Int_t GetTimerInterval() const { return fTimerInterval ; }
	virtual Long64_t GetTotBytes() const { return fTotBytes; }	virtual Long64_t GetTotBytes() const { return fTotBytes; }
	virtual TTree GetTree() const { return const_cast<TTree>(this ); }	virtual TTree GetTree() const { return const_cast<TTree>(this ); }
	virtual TVirtualIndex *GetTreeIndex() const { return fTreeIndex; }	virtual TVirtualIndex *GetTreeIndex() const { return fTreeIndex; }
	virtual Int_t GetTreeNumber() const { return 0; }	virtual Int_t GetTreeNumber() const { return 0; }
	virtual Int_t GetUpdate() const { return fUpdate; }	virtual Int_t GetUpdate() const { return fUpdate; }
	virtual TList *GetUserInfo();	virtual TList *GetUserInfo();

		// See TSelectorDraw::GetVar
	TTreeFormula *GetVar(Int_t i) { return GetPlayer()->GetVar(i) ; }	TTreeFormula *GetVar(Int_t i) { return GetPlayer()->GetVar(i) ; }

		// See TSelectorDraw::GetVar
	TTreeFormula *GetVar1() { return GetPlayer()->GetVar1(); }	TTreeFormula *GetVar1() { return GetPlayer()->GetVar1(); }

		// See TSelectorDraw::GetVar
	TTreeFormula *GetVar2() { return GetPlayer()->GetVar2(); }	TTreeFormula *GetVar2() { return GetPlayer()->GetVar2(); }

		// See TSelectorDraw::GetVar
	TTreeFormula *GetVar3() { return GetPlayer()->GetVar3(); }	TTreeFormula *GetVar3() { return GetPlayer()->GetVar3(); }

		// See TSelectorDraw::GetVar
	TTreeFormula *GetVar4() { return GetPlayer()->GetVar4(); }	TTreeFormula *GetVar4() { return GetPlayer()->GetVar4(); }

		// See TSelectorDraw::GetVal
	virtual Double_t *GetVal(Int_t i) { return GetPlayer()->GetVal(i ); }	virtual Double_t *GetVal(Int_t i) { return GetPlayer()->GetVal(i ); }

		// See TSelectorDraw::GetVal
	virtual Double_t *GetV1() { return GetPlayer()->GetV1(); }	virtual Double_t *GetV1() { return GetPlayer()->GetV1(); }

		// See TSelectorDraw::GetVal
	virtual Double_t *GetV2() { return GetPlayer()->GetV2(); }	virtual Double_t *GetV2() { return GetPlayer()->GetV2(); }

		// See TSelectorDraw::GetVal
	virtual Double_t *GetV3() { return GetPlayer()->GetV3(); }	virtual Double_t *GetV3() { return GetPlayer()->GetV3(); }

		// See TSelectorDraw::GetVal
	virtual Double_t *GetV4() { return GetPlayer()->GetV4(); }	virtual Double_t *GetV4() { return GetPlayer()->GetV4(); }
	virtual Double_t *GetW() { return GetPlayer()->GetW(); }	virtual Double_t *GetW() { return GetPlayer()->GetW(); }
	virtual Double_t GetWeight() const { return fWeight; }	virtual Double_t GetWeight() const { return fWeight; }
	virtual Long64_t GetZipBytes() const { return fZipBytes; }	virtual Long64_t GetZipBytes() const { return fZipBytes; }
	virtual void IncrementTotalBuffers(Int_t nbytes) { fTotalBuff ers += nbytes; }	virtual void IncrementTotalBuffers(Int_t nbytes) { fTotalBuff ers += nbytes; }
	Bool_t IsFolder() const { return kTRUE; }	Bool_t IsFolder() const { return kTRUE; }
	virtual Int_t LoadBaskets(Long64_t maxmemory = 2000000000);	virtual Int_t LoadBaskets(Long64_t maxmemory = 2000000000);
	virtual Long64_t LoadTree(Long64_t entry);	virtual Long64_t LoadTree(Long64_t entry);
	virtual Long64_t LoadTreeFriend(Long64_t entry, TTree* T);	virtual Long64_t LoadTreeFriend(Long64_t entry, TTree* T);
	virtual Int_t MakeClass(const char* classname = 0, Option_t* o ption = "");	virtual Int_t MakeClass(const char* classname = 0, Option_t* o ption = "");

	skipping to change at line 420	skipping to change at line 434
	virtual Bool_t SetAlias(const char* aliasName, const char* alia sFormula);	virtual Bool_t SetAlias(const char* aliasName, const char* alia sFormula);
	virtual void SetAutoSave(Long64_t autos = 300000000);	virtual void SetAutoSave(Long64_t autos = 300000000);
	virtual void SetAutoFlush(Long64_t autof = 30000000);	virtual void SetAutoFlush(Long64_t autof = 30000000);
	virtual void SetBasketSize(const char* bname, Int_t buffsize = 16000);	virtual void SetBasketSize(const char* bname, Int_t buffsize = 16000);
	#if !defined(__CINT__)	#if !defined(__CINT__)
	virtual Int_t SetBranchAddress(const char bname,void add, TB ranch **ptr = 0);	virtual Int_t SetBranchAddress(const char bname,void add, TB ranch **ptr = 0);
	#endif	#endif
	virtual Int_t SetBranchAddress(const char bname,void add, TC lass *realClass, EDataType datatype, Bool_t isptr);	virtual Int_t SetBranchAddress(const char bname,void add, TC lass *realClass, EDataType datatype, Bool_t isptr);
	virtual Int_t SetBranchAddress(const char bname,void add, TB ranch *ptr, TClass realClass, EDataType datatype, Bool_t isptr);	virtual Int_t SetBranchAddress(const char bname,void add, TB ranch *ptr, TClass realClass, EDataType datatype, Bool_t isptr);
	template <class T> Int_t SetBranchAddress(const char bname, T add, TB ranch *ptr = 0) {	template <class T> Int_t SetBranchAddress(const char bname, T add, TB ranch *ptr = 0) {

	return SetBranchAddress(bname,add,ptr,TClass::GetClass(typeid(T)),TDa	TClass *cl = TClass::GetClass(typeid(T));
	taType::GetType(typeid(T)),true);	EDataType type = kOther_t;
		if (cl==0) type = TDataType::GetType(typeid(T));
		return SetBranchAddress(bname,add,ptr,cl,type,true);
	}	}
	#ifndef R__NO_CLASS_TEMPLATE_SPECIALIZATION	#ifndef R__NO_CLASS_TEMPLATE_SPECIALIZATION
	// This can only be used when the template overload resolution can distr inguish between	// This can only be used when the template overload resolution can distr inguish between
	// T* and T**	// T* and T**
	template <class T> Int_t SetBranchAddress(const char bname, T add, TBr anch **ptr = 0) {	template <class T> Int_t SetBranchAddress(const char bname, T add, TBr anch **ptr = 0) {

	return SetBranchAddress(bname,add,ptr,TClass::GetClass(typeid(T)),TDa	TClass *cl = TClass::GetClass(typeid(T));
	taType::GetType(typeid(T)),false);	EDataType type = kOther_t;
		if (cl==0) type = TDataType::GetType(typeid(T));
		return SetBranchAddress(bname,add,ptr,cl,type,false);
	}	}
	#endif	#endif
	virtual void SetBranchStatus(const char* bname, Bool_t status = 1, UInt_t* found = 0);	virtual void SetBranchStatus(const char* bname, Bool_t status = 1, UInt_t* found = 0);
	static void SetBranchStyle(Int_t style = 1); //style=0 for old branch, =1 for new branch style	static void SetBranchStyle(Int_t style = 1); //style=0 for old branch, =1 for new branch style
	virtual void SetCacheSize(Long64_t cachesize = -1);	virtual void SetCacheSize(Long64_t cachesize = -1);
	virtual void SetCacheEntryRange(Long64_t first, Long64_t last );	virtual void SetCacheEntryRange(Long64_t first, Long64_t last );
	virtual void SetCacheLearnEntries(Int_t n=10);	virtual void SetCacheLearnEntries(Int_t n=10);
	virtual void SetChainOffset(Long64_t offset = 0) { fChainOffs et=offset; }	virtual void SetChainOffset(Long64_t offset = 0) { fChainOffs et=offset; }
	virtual void SetCircular(Long64_t maxEntries);	virtual void SetCircular(Long64_t maxEntries);
	virtual void SetDebug(Int_t level = 1, Long64_t min = 0, Long 64_t max = 9999999); // MENU	virtual void SetDebug(Int_t level = 1, Long64_t min = 0, Long 64_t max = 9999999); // MENU

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

	TTreeCloner.h	TTreeCloner.h

	// @(#)root/tree:$Id: TTreeCloner.h 29413 2009-07-09 14:10:29Z pcanal $	// @(#)root/tree:$Id: TTreeCloner.h 37921 2011-01-31 22:20:01Z pcanal $
	// Author: Philippe Canal 07/11/2005	// Author: Philippe Canal 07/11/2005

	/*************************************************************************	/*************************************************************************
	* 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 91	skipping to change at line 91
	CompareEntry(TTreeCloner *obj) : fObject(obj) {}	CompareEntry(TTreeCloner *obj) : fObject(obj) {}
	bool operator()(UInt_t i1, UInt_t i2);	bool operator()(UInt_t i1, UInt_t i2);
	};	};

	friend class CompareSeek;	friend class CompareSeek;
	friend class CompareEntry;	friend class CompareEntry;

	public:	public:
	enum EClonerOptions {	enum EClonerOptions {
	kNone = 0,	kNone = 0,

	kNoWarnings = BIT(1)	kNoWarnings = BIT(1),
		kIgnoreMissingTopLevel = BIT(2)
	};	};

	TTreeCloner(TTree from, TTree to, Option_t *method, UInt_t options = k None);	TTreeCloner(TTree from, TTree to, Option_t *method, UInt_t options = k None);
	virtual ~TTreeCloner();	virtual ~TTreeCloner();

	void CloseOutWriteBaskets();	void CloseOutWriteBaskets();
	UInt_t CollectBranches(TBranch from, TBranch to);	UInt_t CollectBranches(TBranch from, TBranch to);
	UInt_t CollectBranches(TObjArray from, TObjArray to);	UInt_t CollectBranches(TObjArray from, TObjArray to);
	UInt_t CollectBranches();	UInt_t CollectBranches();
	void CollectBaskets();	void CollectBaskets();

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

	TVirtualDragManager.h	TVirtualDragManager.h

	skipping to change at line 48	skipping to change at line 48
	TGFrame *fTarget; // drop target	TGFrame *fTarget; // drop target
	TGFrame *fPasteFrame; //	TGFrame *fPasteFrame; //

	protected:	protected:
	virtual void Init();	virtual void Init();

	public:	public:
	TVirtualDragManager();	TVirtualDragManager();
	virtual ~TVirtualDragManager() {}	virtual ~TVirtualDragManager() {}


	EDragType GetDragType() const { return fDragType; }	EDragType GetEDragType() const { return fDragType; }
	Bool_t IsMoveWaiting() const { return fMoveWaiting; }	Bool_t IsMoveWaiting() const { return fMoveWaiting; }
	Bool_t IsDragging() const { return fDragging; }	Bool_t IsDragging() const { return fDragging; }
	Bool_t IsDropping() const { return fDropping; }	Bool_t IsDropping() const { return fDropping; }
	Bool_t IsPasting() const { return fPasting; }	Bool_t IsPasting() const { return fPasting; }
	TGFrame *GetTarget() const { return fTarget; }	TGFrame *GetTarget() const { return fTarget; }
	TGFrame *GetSource() const { return fSource; }	TGFrame *GetSource() const { return fSource; }
	TGFrame *GetFrameUnder() const { return fFrameUnder; }	TGFrame *GetFrameUnder() const { return fFrameUnder; }
	TGFrame *GetPasteFrame() const { return fPasteFrame; }	TGFrame *GetPasteFrame() const { return fPasteFrame; }

	virtual void SetTarget(TGFrame *f) { fTarget = f; }	virtual void SetTarget(TGFrame *f) { fTarget = f; }

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

	TVirtualMC.h	TVirtualMC.h

	// @(#)root/vmc:$Name: $:$Id: TVirtualMC.h 34836 2010-08-18 09:52:27Z ivan a $	// @(#)root/vmc:$Name: $:$Id: TVirtualMC.h 38344 2011-03-09 17:03:14Z ivan a $
	// Authors: Ivana Hrivnacova, Rene Brun, Federico Carminati 13/04/2002	// Authors: Ivana Hrivnacova, Rene Brun, Federico Carminati 13/04/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002, ALICE Experiment at CERN. *	* Copyright (C) 2002, ALICE Experiment at CERN. *
	* 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
	// Info about supporting geometry defined via Root	// Info about supporting geometry defined via Root
	virtual Bool_t IsRootGeometrySupported() const { return kFALSE; }	virtual Bool_t IsRootGeometrySupported() const { return kFALSE; }
	// make this function =0 with next release	// make this function =0 with next release

	//	//
	// functions from GCONS	// functions from GCONS
	// ------------------------------------------------	// ------------------------------------------------
	//	//

	// Return parameters for material specified by material number imat	// Return parameters for material specified by material number imat

		// Deprecated - replaced with GetMaterial()
	virtual void Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,	virtual void Gfmate(Int_t imat, char *name, Float_t &a, Float_t &z,
	Float_t &dens, Float_t &radl, Float_t &absl,	Float_t &dens, Float_t &radl, Float_t &absl,
	Float_t* ubuf, Int_t& nbuf) = 0;	Float_t* ubuf, Int_t& nbuf) = 0;

	// Return parameters for material specified by material number imat	// Return parameters for material specified by material number imat
	// (in double precision)	// (in double precision)

		// Deprecated - replaced with GetMaterial()
	virtual void Gfmate(Int_t imat, char *name, Double_t &a, Double_t &z,	virtual void Gfmate(Int_t imat, char *name, Double_t &a, Double_t &z,
	Double_t &dens, Double_t &radl, Double_t &absl,	Double_t &dens, Double_t &radl, Double_t &absl,
	Double_t* ubuf, Int_t& nbuf) = 0;	Double_t* ubuf, Int_t& nbuf) = 0;

	// Check the parameters of a tracking medium	// Check the parameters of a tracking medium

		// Deprecated
	virtual void Gckmat(Int_t imed, char* name) = 0;	virtual void Gckmat(Int_t imed, char* name) = 0;

	// Define a material	// Define a material
	// kmat number assigned to the material	// kmat number assigned to the material
	// name material name	// name material name
	// a atomic mass in au	// a atomic mass in au
	// z atomic number	// z atomic number
	// dens density in g/cm3	// dens density in g/cm3
	// absl absorption length in cm;	// absl absorption length in cm;
	// if >=0 it is ignored and the program	// if >=0 it is ignored and the program

	skipping to change at line 380	skipping to change at line 383
	// Return the transformation matrix between the volume specified by	// Return the transformation matrix between the volume specified by
	// the path volumePath and the top or master volume.	// the path volumePath and the top or master volume.
	virtual Bool_t GetTransformation(const TString& volumePath,	virtual Bool_t GetTransformation(const TString& volumePath,
	TGeoHMatrix& matrix) = 0;	TGeoHMatrix& matrix) = 0;

	// Return the name of the shape (shapeType) and its parameters par	// Return the name of the shape (shapeType) and its parameters par
	// for the volume specified by the path volumePath .	// for the volume specified by the path volumePath .
	virtual Bool_t GetShape(const TString& volumePath,	virtual Bool_t GetShape(const TString& volumePath,
	TString& shapeType, TArrayD& par) = 0;	TString& shapeType, TArrayD& par) = 0;


		// Return the material parameters for the material specified by
		// the material Id - NEW
		virtual Bool_t GetMaterial(Int_t imat, TString& name,
		Double_t& a, Double_t& z, Double_t& density,
		Double_t& radl, Double_t& inter, TArrayD& pa
		r);

	// Return the material parameters for the volume specified by	// Return the material parameters for the volume specified by
	// the volumeName.	// the volumeName.
	virtual Bool_t GetMaterial(const TString& volumeName,	virtual Bool_t GetMaterial(const TString& volumeName,
	TString& name, Int_t& imat,	TString& name, Int_t& imat,
	Double_t& a, Double_t& z, Double_t& density,	Double_t& a, Double_t& z, Double_t& density,
	Double_t& radl, Double_t& inter, TArrayD& pa r) = 0;	Double_t& radl, Double_t& inter, TArrayD& pa r) = 0;

	// Return the medium parameters for the volume specified by the	// Return the medium parameters for the volume specified by the
	// volumeName.	// volumeName.
	virtual Bool_t GetMedium(const TString& volumeName,	virtual Bool_t GetMedium(const TString& volumeName,
	TString& name, Int_t& imed,	TString& name, Int_t& imed,
	Int_t& nmat, Int_t& isvol, Int_t& ifield,	Int_t& nmat, Int_t& isvol, Int_t& ifield,
	Double_t& fieldm, Double_t& tmaxfd, Double_t& stemax,	Double_t& fieldm, Double_t& tmaxfd, Double_t& stemax,
	Double_t& deemax, Double_t& epsil, Double_t& s tmin,	Double_t& deemax, Double_t& epsil, Double_t& s tmin,
	TArrayD& par) = 0;	TArrayD& par) = 0;


	//
	// functions for drawing
	// to be removed with complete move to TGeo
	// ------------------------------------------------
	//

	// Deprecated - Geant3
	virtual void DrawOneSpec(const char* name) = 0;
	// Deprecated - Geant3
	virtual void Gsatt(const char* name, const char* att, Int_t val) = 0;
	// Deprecated - Geant3
	virtual void Gdraw(const char*,Double_t theta = 30, Double_t phi = 30,
	Double_t psi = 0, Double_t u0 = 10, Double_t v0 = 1
	0,
	Double_t ul = 0.01, Double_t vl = 0.01) = 0;

	// Write out the geometry of the detector in EUCLID file format	// Write out the geometry of the detector in EUCLID file format
	// filnam file name - will be with the extension .euc *	// filnam file name - will be with the extension .euc *
	// topvol volume name of the starting node	// topvol volume name of the starting node
	// number copy number of topvol (relevant for gsposp)	// number copy number of topvol (relevant for gsposp)
	// nlevel number of levels in the tree structure	// nlevel number of levels in the tree structure
	// to be written out, starting from topvol	// to be written out, starting from topvol
	// (Geant3 only)	// (Geant3 only)

		// Deprecated
	virtual void WriteEuclid(const char* filnam, const char* topvol,	virtual void WriteEuclid(const char* filnam, const char* topvol,
	Int_t number, Int_t nlevel) = 0;	Int_t number, Int_t nlevel) = 0;

	// Set geometry from Root (built via TGeo)	// Set geometry from Root (built via TGeo)
	virtual void SetRootGeometry() = 0;	virtual void SetRootGeometry() = 0;

	// Activate the parameters defined in tracking media	// Activate the parameters defined in tracking media
	// (DEEMAX, STMIN, STEMAX), which are, be default, ignored.	// (DEEMAX, STMIN, STEMAX), which are, be default, ignored.
	// In Geant4 case, only STEMAX is taken into account.	// In Geant4 case, only STEMAX is taken into account.
	// In FLUKA, all tracking media parameters are ignored.	// In FLUKA, all tracking media parameters are ignored.

	skipping to change at line 562	skipping to change at line 557

	// Set a user phase space decay for a particle	// Set a user phase space decay for a particle
	// pdg particle PDG encoding	// pdg particle PDG encoding
	// bratios the array with branching ratios (in %)	// bratios the array with branching ratios (in %)
	// mode[6][3] the array with daughters particles PDG codes for eac h	// mode[6][3] the array with daughters particles PDG codes for eac h
	// decay channel	// decay channel
	virtual Bool_t SetDecayMode(Int_t pdg, Float_t bratio[6], Int_t mode[6 ][3]) = 0;	virtual Bool_t SetDecayMode(Int_t pdg, Float_t bratio[6], Int_t mode[6 ][3]) = 0;

	// Calculate X-sections	// Calculate X-sections
	// (Geant3 only)	// (Geant3 only)

		// Deprecated
	virtual Double_t Xsec(char*, Double_t, Int_t, Int_t) = 0;	virtual Double_t Xsec(char*, Double_t, Int_t, Int_t) = 0;

	//	//
	// particle table usage	// particle table usage
	// ------------------------------------------------	// ------------------------------------------------
	//	//

	// Return MC specific code from a PDG and pseudo ENDF code (pdg)	// Return MC specific code from a PDG and pseudo ENDF code (pdg)
	virtual Int_t IdFromPDG(Int_t pdg) const =0;	virtual Int_t IdFromPDG(Int_t pdg) const =0;


	skipping to change at line 655	skipping to change at line 651
	virtual const char* CurrentVolName() const =0;	virtual const char* CurrentVolName() const =0;

	// Return the current volume off upward in the geometrical tree	// Return the current volume off upward in the geometrical tree
	// name and copy number'	// name and copy number'
	// if name=0 no name is returned	// if name=0 no name is returned
	virtual const char* CurrentVolOffName(Int_t off) const =0;	virtual const char* CurrentVolOffName(Int_t off) const =0;

	// Return the path in geometry tree for the current volume	// Return the path in geometry tree for the current volume
	virtual const char* CurrentVolPath() = 0;	virtual const char* CurrentVolPath() = 0;


	// If track is on a geometry boundary, fill the normal vector of the cro	// If track is on a geometry boundary, fill the normal vector of the cro
	ssing volume	ssing
	// surface and return true, return false otherwise	// volume surface and return true, return false otherwise - NEW
	virtual Bool_t CurrentBoundaryNormal(Double_t &x, Double_t &y, Double_t	virtual Bool_t CurrentBoundaryNormal(
	&z) const;	Double_t &x, Double_t &y, Double_t &z) const;

	// Return the parameters of the current material during transport	// Return the parameters of the current material during transport
	virtual Int_t CurrentMaterial(Float_t &a, Float_t &z,	virtual Int_t CurrentMaterial(Float_t &a, Float_t &z,
	Float_t &dens, Float_t &radl, Float_t &absl) const = 0;	Float_t &dens, Float_t &radl, Float_t &absl) const = 0;

	// Return the number of the current medium	// Return the number of the current medium
	virtual Int_t CurrentMedium() const = 0;	virtual Int_t CurrentMedium() const = 0;
	// new function (to replace GetMedium() const)	// new function (to replace GetMedium() const)

	// Return the number of the current event	// Return the number of the current event

	skipping to change at line 812	skipping to change at line 809

	// Return the array of the VMC code of the processes active in the curre nt	// Return the array of the VMC code of the processes active in the curre nt
	// step	// step
	virtual Int_t StepProcesses(TArrayI &proc) const = 0;	virtual Int_t StepProcesses(TArrayI &proc) const = 0;

	// Return the information about the transport order needed by the stack	// Return the information about the transport order needed by the stack
	virtual Bool_t SecondariesAreOrdered() const = 0;	virtual Bool_t SecondariesAreOrdered() const = 0;

	//	//
	// ------------------------------------------------	// ------------------------------------------------

	// Geant3 specific methods
	// !!! to be removed with move to TGeo
	// ------------------------------------------------
	//

	// Set/modify the drawing options.
	// Deprecated - G3 only
	virtual void Gdopt(const char,const char) = 0;

	// This function allows subtractions (via boolean operation) of BOX shap
	e
	// from any part of the detector, therefore showing its inner contents
	// Deprecated - G3 only
	virtual void SetClipBox(const char*,Double_t=-9999,Double_t=0, Double_t=
	-9999,
	Double_t=0,Double_t=-9999,Double_t=0) = 0;

	// Deprecated - G3 only
	virtual void DefaultRange() = 0;

	// Deprecated - G3 only
	virtual void Gdhead(Int_t, const char*, Double_t=0) = 0;

	// Deprecated - G3 only
	virtual void Gdman(Double_t, Double_t, const char*) = 0;

	//
	// ------------------------------------------------
	// Control methods	// Control methods
	// ------------------------------------------------	// ------------------------------------------------
	//	//

	// Initialize MC	// Initialize MC
	virtual void Init() = 0;	virtual void Init() = 0;

	// Initialize MC physics	// Initialize MC physics
	virtual void BuildPhysics() = 0;	virtual void BuildPhysics() = 0;

	// Process one event	// Process one event

		// Deprecated
	virtual void ProcessEvent() = 0;	virtual void ProcessEvent() = 0;

	// Process one run and return true if run has finished successfully,	// Process one run and return true if run has finished successfully,
	// return false in other cases (run aborted by user)	// return false in other cases (run aborted by user)
	virtual Bool_t ProcessRun(Int_t nevent) = 0;	virtual Bool_t ProcessRun(Int_t nevent) = 0;

	// Set switches for lego transport	// Set switches for lego transport
	virtual void InitLego() = 0;	virtual void InitLego() = 0;

	// (In)Activate collecting TGeo tracks	// (In)Activate collecting TGeo tracks

	virtual void SetCollectTracks(Bool_t collectTracks);	virtual void SetCollectTracks(Bool_t collectTracks) = 0;

	// Return the info if collecting tracks is activated	// Return the info if collecting tracks is activated

	virtual Bool_t IsCollectTracks() const;	virtual Bool_t IsCollectTracks() const = 0;

	//	//
	// ------------------------------------------------	// ------------------------------------------------
	// Set methods	// Set methods
	// ------------------------------------------------	// ------------------------------------------------
	//	//

	// Set the particle stack	// Set the particle stack
	virtual void SetStack(TVirtualMCStack* stack);	virtual void SetStack(TVirtualMCStack* stack);


	skipping to change at line 919	skipping to change at line 891
	TVirtualMCStack* fStack; //! Particles stack	TVirtualMCStack* fStack; //! Particles stack
	TVirtualMCDecayer* fDecayer; //! External decayer	TVirtualMCDecayer* fDecayer; //! External decayer
	TRandom* fRandom; //! Random number generator	TRandom* fRandom; //! Random number generator
	TVirtualMagField* fMagField;//! Magnetic field	TVirtualMagField* fMagField;//! Magnetic field

	ClassDef(TVirtualMC,1) //Interface to Monte Carlo	ClassDef(TVirtualMC,1) //Interface to Monte Carlo
	};	};

	// new functions	// new functions


	inline Bool_t TVirtualMC::CurrentBoundaryNormal(Double_t& /x/, Double_t&	inline Bool_t TVirtualMC::CurrentBoundaryNormal(
	/y/, Double_t& /z/) const {	Double_t& /x/, Double_t& /y/, Double_t& /z/) con
	// If track is on a geometry boundary, fill the normal vector of the cro	st {
	ssing volume	// If track is on a geometry boundary, fill the normal vector of the cro
	// surface and return true, return false otherwise	ssing
		// volume surface and return true, return false otherwise
	Warning("CurrentBoundaryNormal", "New function - not yet implemented.");	Warning("CurrentBoundaryNormal", "New function - not yet implemented.");
	return kFALSE;	return kFALSE;
	}	}


	inline void TVirtualMC::SetCollectTracks(Bool_t /collectTracks/) {	inline Bool_t TVirtualMC::GetMaterial(Int_t /imat/, TString& /name/,
	// Activate collecting tracks	Double_t& /a/, Double_t& /z/, Double_t& /*density
	// Currently working only with TGeant3TGeo	*/,
	Warning("SetCollectTracks", "New function - not yet implemented.");	Double_t& /radl/, Double_t& /inter/, TArrayD& /*p
	}	ar*/) {
		// Return the material parameters for the material specified by
	inline Bool_t TVirtualMC::IsCollectTracks() const {	// the material Id
	// Return the info if collecting tracks is activated	Warning("GetMaterial(Int_t imat, ...)", "New function - not yet implemen
	Warning("IsCollectTracks", "New function - not yet implemented.");	ted.");
	return kFALSE;	return kFALSE;
	}	}

	R__EXTERN TVirtualMC *gMC;	R__EXTERN TVirtualMC *gMC;

	#endif //ROOT_TVirtualMC	#endif //ROOT_TVirtualMC

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

	TXSlave.h	TXSlave.h

	// @(#)root/proofx:$Id: TXSlave.h 25734 2008-10-07 22:40:37Z ganis $	// @(#)root/proofx:$Id: TXSlave.h 38580 2011-03-23 15:24:54Z ganis $
	/*************************************************************************	/*************************************************************************
	* 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_TXSlave	#ifndef ROOT_TXSlave
	#define ROOT_TXSlave	#define ROOT_TXSlave

	skipping to change at line 43	skipping to change at line 43
	class TXSlave : public TSlave, public TXHandler {	class TXSlave : public TSlave, public TXHandler {

	friend class TProof;	friend class TProof;
	friend class TXProofMgr;	friend class TXProofMgr;

	private:	private:
	Bool_t fValid;	Bool_t fValid;
	TSignalHandler *fIntHandler; //interrupt signal handler (ctrl-c)	TSignalHandler *fIntHandler; //interrupt signal handler (ctrl-c)

	void Init(const char *host, Int_t stype);	void Init(const char *host, Int_t stype);

		void ParseBuffer();

	// Static methods	// Static methods
	static Int_t GetProofdProtocol(TSocket *s);	static Int_t GetProofdProtocol(TSocket *s);

	protected:	protected:
	void FlushSocket();	void FlushSocket();
	void Interrupt(Int_t type);	void Interrupt(Int_t type);
	Int_t Ping();	Int_t Ping();
	TObjString SendCoordinator(Int_t kind, const char msg = 0, Int_t int2 = 0);	TObjString SendCoordinator(Int_t kind, const char msg = 0, Int_t int2 = 0);
	Int_t SendGroupPriority(const char *grp, Int_t priority);	Int_t SendGroupPriority(const char *grp, Int_t priority);

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

	TXSocket.h	TXSocket.h

	// @(#)root/proofx:$Id: TXSocket.h 34428 2010-07-15 12:35:34Z ganis $	// @(#)root/proofx:$Id: TXSocket.h 38538 2011-03-21 14:13:29Z ganis $
	/*************************************************************************	/*************************************************************************
	* 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_TXSocket	#ifndef ROOT_TXSocket
	#define ROOT_TXSocket	#define ROOT_TXSocket

	skipping to change at line 100	skipping to change at line 100

	TString fBuffer; // Container for exchanging informat ion	TString fBuffer; // Container for exchanging informat ion
	TObject *fReference; // Generic object reference of this socket	TObject *fReference; // Generic object reference of this socket
	TXHandler *fHandler; // Handler of asynchronous events (i nput, error)	TXHandler *fHandler; // Handler of asynchronous events (i nput, error)

	XrdProofConn *fConn; // instance of the underlying connec tion module	XrdProofConn *fConn; // instance of the underlying connec tion module

	// Asynchronous messages	// Asynchronous messages
	TSemaphore fASem; // Control access to conn async msg queue	TSemaphore fASem; // Control access to conn async msg queue
	TMutex *fAMtx; // To protect async msg queue	TMutex *fAMtx; // To protect async msg queue

		Bool_t fAWait; // kTRUE if waiting at the async msg queue
	std::list<TXSockBuf *> fAQue; // list of asynchronous messages	std::list<TXSockBuf *> fAQue; // list of asynchronous messages
	Int_t fByteLeft; // bytes left in the first buffer	Int_t fByteLeft; // bytes left in the first buffer
	Int_t fByteCur; // current position in the first buf fer	Int_t fByteCur; // current position in the first buf fer
	TXSockBuf *fBufCur; // current read buffer	TXSockBuf *fBufCur; // current read buffer

	TSemaphore fAsynProc; // Control actions while processing async messages	TSemaphore fAsynProc; // Control actions while processing async messages

	// Interrupts	// Interrupts
	TMutex *fIMtx; // To protect interrupt queue	TMutex *fIMtx; // To protect interrupt queue
	kXR_int32 fILev; // Highest received interrupt	kXR_int32 fILev; // Highest received interrupt

	skipping to change at line 213	skipping to change at line 214
	ESendRecvOptions opt = kDefault);	ESendRecvOptions opt = kDefault);

	// Interrupts	// Interrupts
	Int_t SendInterrupt(Int_t type);	Int_t SendInterrupt(Int_t type);
	Int_t GetInterrupt(Bool_t &forward);	Int_t GetInterrupt(Bool_t &forward);

	// Urgent message	// Urgent message
	void SendUrgent(Int_t type, Int_t int1, Int_t int2);	void SendUrgent(Int_t type, Int_t int1, Int_t int2);

	// Interrupt the low level socket	// Interrupt the low level socket

	void SetInterrupt() { fRDInterrupt = kTRUE;	inline void SetInterrupt(Bool_t i = kTRUE) { R__LOCKGUARD(fAMtx)
	if (fConn) fConn->SetInterrupt(); }	;
		fRDInterrupt = i;
		if (i && fConn) fConn->SetInterrupt
		();
		if (i && fAWait) fASem.Post(); }
		inline Bool_t IsInterrupt() { R__LOCKGUARD(fAMtx); return fRDInte
		rrupt; }
		// Set / Check async msg queue waiting status
		inline void SetAWait(Bool_t w = kTRUE) { R__LOCKGUARD(fAMtx); fA
		Wait = w; }
		inline Bool_t IsAWait() { R__LOCKGUARD(fAMtx); return fAWait; }

	// Flush the asynchronous queue	// Flush the asynchronous queue
	Int_t Flush();	Int_t Flush();

	// Ping the counterpart	// Ping the counterpart
	Bool_t Ping(const char *ord = 0);	Bool_t Ping(const char *ord = 0);

	// Request remote touch of the admin file associated with this connectio n	// Request remote touch of the admin file associated with this connectio n
	void RemoteTouch();	void RemoteTouch();
	// Propagate a Ctrl-C	// Propagate a Ctrl-C

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

	TXUnixSocket.h	TXUnixSocket.h

	// @(#)root/proofx:$Id: TXUnixSocket.h 24719 2008-07-09 07:07:25Z ganis $	// @(#)root/proofx:$Id: TXUnixSocket.h 38922 2011-04-19 13:15:05Z ganis $
	/*************************************************************************	/*************************************************************************
	* 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_TXUnixSocket	#ifndef ROOT_TXUnixSocket
	#define ROOT_TXUnixSocket	#define ROOT_TXUnixSocket

	skipping to change at line 37	skipping to change at line 37
	class TXHandler;	class TXHandler;

	class TXUnixSocket : public TXSocket {	class TXUnixSocket : public TXSocket {

	friend class TXProofServ;	friend class TXProofServ;

	private:	private:
	std::list<Int_t> fClientIDs;	std::list<Int_t> fClientIDs;

	public:	public:

	TXUnixSocket(const char *u,	TXUnixSocket(const char *u, Int_t psid = -1, Char_t ver = -1,
	Int_t psid = -1, Char_t ver = -1, TXHandler *handler = 0);	TXHandler *handler = 0, int fd = -1);
	virtual ~TXUnixSocket() { fSessionID = -1; }	virtual ~TXUnixSocket() { fSessionID = -1; }

	Int_t GetClientID() const { return (fClientIDs.size() > 0) ? fClientIDs. front() : -1; }	Int_t GetClientID() const { return (fClientIDs.size() > 0) ? fClientIDs. front() : -1; }
	Int_t GetClientIDSize() const { return fClientIDs.size(); }	Int_t GetClientIDSize() const { return fClientIDs.size(); }

	void RemoveClientID() { if (fClientIDs.size() > 1) fClientIDs.pop_front (); }	void RemoveClientID() { if (fClientIDs.size() > 1) fClientIDs.pop_front (); }
	void SetClientID(Int_t cid) { fClientIDs.push_front(cid); }	void SetClientID(Int_t cid) { fClientIDs.push_front(cid); }

	// Try reconnection after error	// Try reconnection after error
	Int_t Reconnect();	Int_t Reconnect();

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

	Tools.h	Tools.h

	// @(#)root/tmva $Id: Tools.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: Tools.h 38943 2011-04-20 08:03:25Z evt $
	// 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 *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *

		* Peter Speckmayer <peter.speckmayer@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 *
	* *	* *
	* 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 *

	skipping to change at line 68	skipping to change at line 69
	#endif	#endif

	#ifndef ROOT_TVectorDfwd	#ifndef ROOT_TVectorDfwd
	#include "TVectorDfwd.h"	#include "TVectorDfwd.h"
	#endif	#endif

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


		#ifndef ROOT_TMVA_VariableTransformBase
		#include "TMVA/VariableTransformBase.h"
		#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;
	class TSpline;	class TSpline;
	class TXMLEngine;	class TXMLEngine;

	namespace TMVA {	namespace TMVA {

	skipping to change at line 128	skipping to change at line 133

	// parse option string for ANN methods	// parse option string for ANN methods
	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,
	std::vector<Int_t>* nodes ) ;	std::vector<Int_t>* nodes ) ;

	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat
	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );

	// returns the covariance matrix of of the different classes (and the sum)	// returns the covariance matrix of of the different classes (and the sum)
	// given the event sample	// given the event sample

	std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector< Event*>& events, Int_t maxCls );	std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector< Event>& events, Int_t maxCls, VariableTransformBase transformBase=0 );

	// turns covariance into correlation matrix	// turns covariance into correlation matrix
	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );

	// check spline quality by comparison with initial histogram	// check spline quality by comparison with initial histogram
	Bool_t CheckSplines( const TH1, const TSpline );	Bool_t CheckSplines( const TH1, const TSpline );

	// normalization of variable output	// normalization of variable output
	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );


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

	ToyMCSamplerOld.h	ToyMCSamplerOld.h

	// @(#)root/roostats:$Id: ToyMCSamplerOld.h 37403 2010-12-08 15:59:22Z mone ta $	// @(#)root/roostats:$Id: ToyMCSamplerOld.h 38947 2011-04-20 08:23:25Z mone ta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	// Additions and modifications by Mario Pelliccioni	// Additions and modifications by Mario Pelliccioni
	/*************************************************************************	/*************************************************************************
	* 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. *
	*************************************************************************/	*************************************************************************/


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

	Types.h	Types.h

	// @(#)root/tmva $Id: Types.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: Types.h 38943 2011-04-20 08:03:25Z evt $
	// 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 105	skipping to change at line 105
	kCategory ,	kCategory ,
	kMaxMethod	kMaxMethod
	};	};

	// available variable transformations	// available variable transformations
	enum EVariableTransform {	enum EVariableTransform {
	kIdentity = 0,	kIdentity = 0,
	kDecorrelated,	kDecorrelated,
	kNormalized,	kNormalized,
	kPCA,	kPCA,

	kGaussDecorr,	kRearranged,
	kGauss,	kGauss,
	kUniform,	kUniform,
	kMaxVariableTransform	kMaxVariableTransform
	};	};

	// type of analysis	// type of analysis
	enum EAnalysisType {	enum EAnalysisType {
	kClassification = 0,	kClassification = 0,
	kRegression,	kRegression,
	kMulticlass,	kMulticlass,

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

	VariableDecorrTransform.h	VariableDecorrTransform.h

	// @(#)root/tmva $Id: VariableDecorrTransform.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: VariableDecorrTransform.h 38943 2011-04-20 08:03:25Z evt $
	// 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 87	skipping to change at line 87

	// provides string vector giving explicit transformation	// provides string vector giving explicit transformation
	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;

	private:	private:

	// mutable Event* fTransformedEvent; //! local event copy	// mutable Event* fTransformedEvent; //! local event copy
	std::vector<TMatrixD*> fDecorrMatrices; //! Decorrelation matrix [class0/class1/.../all classes]	std::vector<TMatrixD*> fDecorrMatrices; //! Decorrelation matrix [class0/class1/.../all classes]

	void CalcSQRMats( const std::vector<Event*>&, Int_t maxCls );	void CalcSQRMats( const std::vector<Event*>&, Int_t maxCls );

		std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector< Event*>& events, Int_t maxCls );

	ClassDef(VariableDecorrTransform,0) // Variable transformation: decor relation	ClassDef(VariableDecorrTransform,0) // Variable transformation: decor relation
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	VariableGaussTransform.h	VariableGaussTransform.h

	// @(#)root/tmva $Id: VariableGaussTransform.h 37399 2010-12-08 15:22:07Z e vt $	// @(#)root/tmva $Id: VariableGaussTransform.h 38943 2011-04-20 08:03:25Z e vt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Eckhard v. Toerne	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Eckhard v. Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 : VariableGaussTransform *	* Class : VariableGaussTransform *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Decorrelation of input variables *	* Decorrelation of input variables *

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

	VariableNormalizeTransform.h	VariableNormalizeTransform.h

	// @(#)root/tmva $Id: VariableNormalizeTransform.h 33993 2010-06-19 11:25:1 4Z stelzer $	// @(#)root/tmva $Id: VariableNormalizeTransform.h 38475 2011-03-17 10:46:0 0Z evt $
	// 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 : VariableNormalizeTransform *	* Class : VariableNormalizeTransform *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Decorrelation of input variables *	* Decorrelation of input variables *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *

		* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@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 *
	* *	* *
	* 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 *

	skipping to change at line 53	skipping to change at line 54
	#ifndef ROOT_TMVA_VariableTransformBase	#ifndef ROOT_TMVA_VariableTransformBase
	#include "TMVA/VariableTransformBase.h"	#include "TMVA/VariableTransformBase.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class VariableNormalizeTransform : public VariableTransformBase {	class VariableNormalizeTransform : public VariableTransformBase {

	public:	public:


		typedef std::vector<Float_t> FloatVector;
		typedef std::vector< FloatVector > VectorOfFloatVectors;
	VariableNormalizeTransform( DataSetInfo& dsi );	VariableNormalizeTransform( DataSetInfo& dsi );
	virtual ~VariableNormalizeTransform( void );	virtual ~VariableNormalizeTransform( 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, 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;

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

	// provides string vector giving explicit transformation	// provides string vector giving explicit transformation
	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;	std::vector<TString>* GetTransformationStrings( Int_t cls ) const;

	private:	private:

	void CalcNormalizationParams( const std::vector<Event*>& events);	void CalcNormalizationParams( const std::vector<Event*>& events);

	// mutable Event* fTransformedEvent;	// mutable Event* fTransformedEvent;


	std::vector< std::vector<Float_t> > fMin; //! Min of source	VectorOfFloatVectors fMin; //! Min of source
	range	range
	std::vector< std::vector<Float_t> > fMax; //! Max of source	VectorOfFloatVectors fMax; //! Max of source
	range	range

	ClassDef(VariableNormalizeTransform,0) // Variable transformation: no rmalization	ClassDef(VariableNormalizeTransform,0) // Variable transformation: no rmalization
	};	};

	} // namespace TMVA	} // namespace TMVA

	#endif	#endif

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

	VariablePCATransform.h	VariablePCATransform.h

	// @(#)root/tmva $Id: VariablePCATransform.h 33993 2010-06-19 11:25:14Z ste lzer $	// @(#)root/tmva $Id: VariablePCATransform.h 38475 2011-03-17 10:46:00Z evt $
	// 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 : VariablePCATransform *	* Class : VariablePCATransform *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Principal value composition of input variables *	* Principal value composition of input variables *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *

		* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@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 *
	* *	* *
	* 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 *

	skipping to change at line 74	skipping to change at line 75

	virtual void AttachXMLTo(void* parent);	virtual void AttachXMLTo(void* parent);
	virtual void ReadFromXML( void* trfnode );	virtual void ReadFromXML( void* trfnode );

	// 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 );

	private:	private:

	void CalculatePrincipalComponents( const std::vector<Event*>& );	void CalculatePrincipalComponents( const std::vector<Event*>& );

	std::vector<Float_t> X2P( const std::vector<Float_t>&, Int_t cls ) co	void X2P( std::vector<Float_t>&, const std::vector<Float_t>&, Int_t c
	nst;	ls ) const;
		void P2X( std::vector<Float_t>&, const std::vector<Float_t>&, Int_t c
	// mutable Event* fTransformedEvent;	ls ) const;

	// store relevant parts of PCA locally	// store relevant parts of PCA locally
	std::vector<TVectorD*> fMeanValues; // mean values	std::vector<TVectorD*> fMeanValues; // mean values
	std::vector<TMatrixD*> fEigenVectors; // eigenvectors	std::vector<TMatrixD*> fEigenVectors; // eigenvectors

	ClassDef(VariablePCATransform,0) // Variable transformation: Principa l Value Composition	ClassDef(VariablePCATransform,0) // Variable transformation: Principa l Value Composition
	};	};

	} // namespace TMVA	} // namespace TMVA


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

	VariableTransformBase.h	VariableTransformBase.h

	// @(#)root/tmva $Id: VariableTransformBase.h 33993 2010-06-19 11:25:14Z st elzer $	// @(#)root/tmva $Id: VariableTransformBase.h 38994 2011-04-21 09:45:51Z ev t $
	// Author: Andreas Hoecker, Peter Speckmayer,Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer,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 : VariableTransformBase *	* Class : VariableTransformBase *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Pre-transformation of input variables (base class) *	* Pre-transformation of input variables (base class) *

	skipping to change at line 71	skipping to change at line 71
	#ifndef ROOT_TMVA_DataSetInfo	#ifndef ROOT_TMVA_DataSetInfo
	#include "TMVA/DataSetInfo.h"	#include "TMVA/DataSetInfo.h"
	#endif	#endif

	namespace TMVA {	namespace TMVA {

	class VariableTransformBase : public TObject {	class VariableTransformBase : public TObject {

	public:	public:


		typedef std::vector<std::pair<Char_t,UInt_t> > VectorOfCharAndInt;
		typedef VectorOfCharAndInt::iterator ItVarTypeIdx;
		typedef VectorOfCharAndInt::const_iterator ItVarTypeIdxConst;

	VariableTransformBase( DataSetInfo& dsi, Types::EVariableTransform tf , const TString& trfName );	VariableTransformBase( DataSetInfo& dsi, Types::EVariableTransform tf , const TString& trfName );
	virtual ~VariableTransformBase( void );	virtual ~VariableTransformBase( void );

	virtual void Initialize() = 0;	virtual void Initialize() = 0;
	virtual Bool_t PrepareTransformation( const std::vector<Event*> & ) = 0;	virtual Bool_t PrepareTransformation( const std::vector<Event*> & ) = 0;
	virtual const Event* Transform ( const Event* const, Int_t cls ) const = 0;	virtual const Event* Transform ( const Event* const, Int_t cls ) const = 0;
	virtual const Event* InverseTransform( const Event* const, Int_t cls ) const = 0;	virtual const Event* InverseTransform( const Event* const, Int_t cls ) const = 0;

	// accessors	// accessors
	void SetEnabled ( Bool_t e ) { fEnabled = e; }	void SetEnabled ( Bool_t e ) { fEnabled = e; }
	void SetNormalise( Bool_t n ) { fNormalise = n; }	void SetNormalise( Bool_t n ) { fNormalise = n; }
	Bool_t IsEnabled() const { return fEnabled; }	Bool_t IsEnabled() const { return fEnabled; }
	Bool_t IsCreated() const { return fCreated; }	Bool_t IsCreated() const { return fCreated; }
	Bool_t IsNormalised() const { return fNormalise; }	Bool_t IsNormalised() const { return fNormalise; }


		// variable selection
		virtual void SelectInput( const TString& inputVariables, Bo
		ol_t putIntoVariables = kFALSE );
		virtual Bool_t GetInput ( const Event* event, std::vector<Flo
		at_t>& input, std::vector<Char_t>& mask, Bool_t backTransform = kFALSE ) c
		onst;
		virtual void SetOutput( Event* event, std::vector<Float_t>&
		output, std::vector<Char_t>& mask, const Event* oldEvent = 0, Bool_t backT
		ransform = kFALSE ) const;
		virtual void CountVariableTypes( UInt_t& nvars, UInt_t& ntg
		ts, UInt_t& nspcts ) const;

		void ToggleInputSortOrder( Bool_t sortOrder ) { fSortGet = sortOrder;
		}
		void SetOutputDataSetInfo( DataSetInfo* outputDsi ) { fDsiOutput = ou
		tputDsi; }

	void SetUseSignalTransform( Bool_t e=kTRUE) { fUseSignalTransform = e ; }	void SetUseSignalTransform( Bool_t e=kTRUE) { fUseSignalTransform = e ; }
	Bool_t UseSignalTransform() const { return fUseSignalTransform; }	Bool_t UseSignalTransform() const { return fUseSignalTransform; }

	virtual const char* GetName() const { return fTransformName.Data(); }	virtual const char* GetName() const { return fTransformName.Data(); }
	TString GetShortName() const { TString a(fTransformName); a.ReplaceAl l("Transform",""); return a; }	TString GetShortName() const { TString a(fTransformName); a.ReplaceAl l("Transform",""); return a; }

	virtual void WriteTransformationToStream ( std::ostream& o ) const = 0;	virtual void WriteTransformationToStream ( std::ostream& o ) const = 0;
	virtual void ReadTransformationFromStream( std::istream& istr, const TString& classname="" ) = 0;	virtual void ReadTransformationFromStream( std::istream& istr, const TString& classname="" ) = 0;

	virtual void AttachXMLTo(void* parent) = 0;	virtual void AttachXMLTo(void* parent) = 0;

	skipping to change at line 110	skipping to change at line 123
	// writer of function code	// writer of function code
	virtual void MakeFunction( std::ostream& fout, const TString& fncName , Int_t part,	virtual void MakeFunction( std::ostream& fout, const TString& fncName , Int_t part,
	UInt_t trCounter, Int_t cls ) = 0;	UInt_t trCounter, Int_t cls ) = 0;

	// provides string vector giving explicit transformation	// provides string vector giving explicit transformation
	virtual std::vector<TString>* GetTransformationStrings( Int_t cls ) c onst;	virtual std::vector<TString>* GetTransformationStrings( Int_t cls ) c onst;
	virtual void PrintTransformation( ostream & ) {}	virtual void PrintTransformation( ostream & ) {}

	const std::vector<TMVA::VariableInfo>& Variables() const { return fVa riables; }	const std::vector<TMVA::VariableInfo>& Variables() const { return fVa riables; }
	const std::vector<TMVA::VariableInfo>& Targets() const { return fTa rgets; }	const std::vector<TMVA::VariableInfo>& Targets() const { return fTa rgets; }

		const std::vector<TMVA::VariableInfo>& Spectators() const { return fSpectators; }

	MsgLogger& Log() const { return *fLogger; }	MsgLogger& Log() const { return *fLogger; }

	void SetTMVAVersion(TMVAVersion_t v) { fTMVAVersion = v; }	void SetTMVAVersion(TMVAVersion_t v) { fTMVAVersion = v; }

	protected:	protected:

	void CalcNorm( const std::vector<Event*>& );	void CalcNorm( const std::vector<Event*>& );

	void SetCreated( Bool_t c = kTRUE ) { fCreated = c; }	void SetCreated( Bool_t c = kTRUE ) { fCreated = c; }
	void SetNVariables( UInt_t i ) { fNVars = i; }	void SetNVariables( UInt_t i ) { fNVars = i; }
	void SetName( const TString& c ) { fTransformName = c; }	void SetName( const TString& c ) { fTransformName = c; }

	UInt_t GetNVariables() const { return fDsi.GetNVariables(); }	UInt_t GetNVariables() const { return fDsi.GetNVariables(); }
	UInt_t GetNTargets() const { return fDsi.GetNTargets(); }	UInt_t GetNTargets() const { return fDsi.GetNTargets(); }

		UInt_t GetNSpectators() const { return fDsi.GetNSpectators(); }

	DataSetInfo& fDsi;	DataSetInfo& fDsi;

		DataSetInfo* fDsiOutput;

	std::vector<TMVA::VariableInfo>& Variables() { return fVariables; }	std::vector<TMVA::VariableInfo>& Variables() { return fVariables; }
	std::vector<TMVA::VariableInfo>& Targets() { return fTargets; }	std::vector<TMVA::VariableInfo>& Targets() { return fTargets; }

		std::vector<TMVA::VariableInfo>& Spectators() { return fSpectators; }
	Int_t GetNClasses() const { return fDsi.GetNClasses(); }	Int_t GetNClasses() const { return fDsi.GetNClasses(); }

	mutable Event* fTransformedEvent; // holds the current transformed event	mutable Event* fTransformedEvent; // holds the current transformed event
	mutable Event* fBackTransformedEvent; // holds the current back-transformed event	mutable Event* fBackTransformedEvent; // holds the current back-transformed event


		// variable selection
		VectorOfCharAndInt fGet; // get variables/tar
		gets/spectators
		VectorOfCharAndInt fPut; // put variables/tar
		gets/spectators

	private:	private:

	Types::EVariableTransform fVariableTransform; // Decorrelation, PCA, etc.	Types::EVariableTransform fVariableTransform; // Decorrelation, PCA, etc.

	void UpdateNorm( Int_t ivar, Double_t x );	void UpdateNorm( Int_t ivar, Double_t x );

	Bool_t fUseSignalTransform; // true if tran sformation bases on signal data	Bool_t fUseSignalTransform; // true if tran sformation bases on signal data
	Bool_t fEnabled; // has been ena bled	Bool_t fEnabled; // has been ena bled
	Bool_t fCreated; // has been cre ated	Bool_t fCreated; // has been cre ated
	Bool_t fNormalise; // normalise in put variables	Bool_t fNormalise; // normalise in put variables
	UInt_t fNVars; // number of va riables	UInt_t fNVars; // number of va riables
	TString fTransformName; // name of tran sformation	TString fTransformName; // name of tran sformation
	std::vector<TMVA::VariableInfo> fVariables; // event variab les [saved to weight file]	std::vector<TMVA::VariableInfo> fVariables; // event variab les [saved to weight file]
	std::vector<TMVA::VariableInfo> fTargets; // event target s [saved to weight file --> TODO ]	std::vector<TMVA::VariableInfo> fTargets; // event target s [saved to weight file --> TODO ]

		std::vector<TMVA::VariableInfo> fSpectators; // event specta
		tors [saved to weight file --> TODO ]

		mutable Bool_t fVariableTypesAreCounted; // true if
		variable types have been counted already
		mutable UInt_t fNVariables; // number of va
		riables to be transformed
		mutable UInt_t fNTargets; // number of ta
		rgets to be transformed
		mutable UInt_t fNSpectators; // number of sp
		ectators to be transformed

		Bool_t fSortGet; // if true, sor
		t the variables into the order as defined by the user at the var definition
		// if false, so
		rt the variables according to the order given for the var transformation

	protected:	protected:

	TMVAVersion_t fTMVAVersion;	TMVAVersion_t fTMVAVersion;

	mutable MsgLogger* fLogger; //! message logger	mutable MsgLogger* fLogger; //! message logger

	ClassDef(VariableTransformBase,0) // Base class for variable trans formations	ClassDef(VariableTransformBase,0) // Base class for variable trans formations
	};	};


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

	Version.h	Version.h

	// @(#)root/tmva $Id: Version.h 37512 2010-12-10 14:19:02Z stelzer $	// @(#)root/tmva $Id: Version.h 38994 2011-04-21 09:45:51Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Jan Therhaag, Eckhard von Toerne, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Jan Therhaag, Eckhard von Toerne, 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 44	skipping to change at line 44
	#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.1.0"	#define TMVA_RELEASE "4.1.1"
	#define TMVA_RELEASE_DATE "Dec 10, 2010"	#define TMVA_RELEASE_DATE "Apr 21, 2011"
	#define TMVA_RELEASE_TIME "15:15:00"	#define TMVA_RELEASE_TIME "12:00:00"
	#define TMVA_VERSION_CODE 262400	#define TMVA_VERSION_CODE 262401
	#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

	cfortran.h	cfortran.h

	skipping to change at line 612	skipping to change at line 612
	( (F).dsc$l_arsize= ( (F).dsc$w_length =(ELEMLEN) ) \	( (F).dsc$l_arsize= ( (F).dsc$w_length =(ELEMLEN) ) \
	*( (F).dsc$l_m[0]=(F).dsc$bounds[0].dsc$l_u=(ELEMNO) ) , \	*( (F).dsc$l_m[0]=(F).dsc$bounds[0].dsc$l_u=(ELEMNO) ) , \
	(F).dsc$a_a0 = ( (F).dsc$a_pointer=(C) ) - (F).dsc$w_length ,(F))	(F).dsc$a_a0 = ( (F).dsc$a_pointer=(C) ) - (F).dsc$w_length ,(F))

	#endif /* PDW: 2/10/98 (CFITSIO) -- Let VMS see NUM_ELEMS definitions */	#endif /* PDW: 2/10/98 (CFITSIO) -- Let VMS see NUM_ELEMS definitions */
	#define _NUM_ELEMS -1	#define _NUM_ELEMS -1
	#define _NUM_ELEM_ARG -2	#define _NUM_ELEM_ARG -2
	#define NUM_ELEMS(A) A,_NUM_ELEMS	#define NUM_ELEMS(A) A,_NUM_ELEMS
	#define NUM_ELEM_ARG(B) *_2(A,B),_NUM_ELEM_ARG	#define NUM_ELEM_ARG(B) *_2(A,B),_NUM_ELEM_ARG
	#define TERM_CHARS(A,B) A,B	#define TERM_CHARS(A,B) A,B

		static void __cfortran__notused_dummy();
	#ifndef __CF__KnR	#ifndef __CF__KnR
	static int num_elem(char *strv, unsigned elem_len, int term_char, int num_t erm)	static int num_elem(char *strv, unsigned elem_len, int term_char, int num_t erm)
	#else	#else
	static int num_elem( strv, elem_len, term_char, num_t erm)	static int num_elem( strv, elem_len, term_char, num_t erm)
	char *strv; unsigned elem_len; int term_char; int num_t erm;	char *strv; unsigned elem_len; int term_char; int num_t erm;
	#endif	#endif
	/* elem_len is the number of characters in each element of strv, the FORTRA N	/* elem_len is the number of characters in each element of strv, the FORTRA N
	vector of strings. The last element of the vector must begin with at least	vector of strings. The last element of the vector must begin with at least
	num_term term_char characters, so that this routine can determine how	num_term term_char characters, so that this routine can determine how
	many elements are in the vector. */	many elements are in the vector. */
	{	{
	unsigned num,i;	unsigned num,i;
	if (num_term == _NUM_ELEMS \|\| num_term == _NUM_ELEM_ARG)	if (num_term == _NUM_ELEMS \|\| num_term == _NUM_ELEM_ARG)
	return term_char;	return term_char;
	if (num_term <=0) num_term = (int)elem_len;	if (num_term <=0) num_term = (int)elem_len;
	for (num=0; ; num++) {	for (num=0; ; num++) {
	for (i=0; i<(unsigned)num_term && *strv==term_char; i++,strv++){;}	for (i=0; i<(unsigned)num_term && *strv==term_char; i++,strv++){;}
	if (i==(unsigned)num_term) break;	if (i==(unsigned)num_term) break;
	else strv += elem_len-i;	else strv += elem_len-i;
	}	}

	if (0) { /* to prevent not used warnings in gcc (added by ROOT) */	if (num==0) __cfortran__notused_dummy();
	c2fstrv(0, 0, 0, 0); f2cstrv(0, 0, 0, 0); kill_trailing(0, 0);
	vkill_trailing(0, 0, 0, 0); num_elem(0, 0, 0, 0);
	}
	return (int)num;	return (int)num;
	}	}


		static void __cfortran__notused_dummy()
		{
		/* to prevent not used warnings in gcc (added by ROOT) */
		if (0) {
		c2fstrv(0, 0, 0, 0); f2cstrv(0, 0, 0, 0); kill_trailing(0, 0);
		vkill_trailing(0, 0, 0, 0); num_elem(0, 0, 0, 0);
		}
		}

	/* #endif removed 2/10/98 (CFITSIO) */	/* #endif removed 2/10/98 (CFITSIO) */

	/------------------------------------------------------------------------- /	/------------------------------------------------------------------------- /

	/* UTILITIES FOR C TO USE STRINGS IN FORTRAN COMMON BLOCKS */	/* UTILITIES FOR C TO USE STRINGS IN FORTRAN COMMON BLOCKS */

	/* C string TO Fortran Common Block STRing. */	/* C string TO Fortran Common Block STRing. */
	/* DIM is the number of DIMensions of the array in terms of strings, not	/* DIM is the number of DIMensions of the array in terms of strings, not
	characters. e.g. char a[12] has DIM = 0, char a[12][4] has DIM = 1, etc. */	characters. e.g. char a[12] has DIM = 0, char a[12][4] has DIM = 1, etc. */
	#define C2FCBSTR(CSTR,FSTR,DIM) \	#define C2FCBSTR(CSTR,FSTR,DIM) \

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

	compiledata.h	compiledata.h
	/* This is file is automatically generated */	/* This is file is automatically generated */
	#define BUILD_ARCH "linux"	#define BUILD_ARCH "linux"

	#define BUILD_NODE "Linux vm-slc5-i686 2.6.18-194.3.1.el5 #1 SMP Fri May 7 16:14:10 CEST 2010 i686 i686 i386 GNU/Linux"	#define BUILD_NODE "Linux lxbuild147.cern.ch 2.6.18-194.26.1.el5 #1 SMP Wed Nov 10 09:51:11 CET 2010 i686 i686 i386 GNU/Linux"
	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.2/i686-slc5-gcc34-opt /bin/g++"	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.2/i686-slc5-gcc34-opt /bin/g++"
	#define COMPILERVERS "gcc432"	#define COMPILERVERS "gcc432"
	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile s -shared -Wl,-soname,$LibName.so -m32 -O2 $LinkedLibs -o $SharedLib"	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile s -shared -Wl,-soname,$LibName.so -m32 -O2 $LinkedLibs -o $SharedLib"
	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2 -o $ExeName $LinkedLibs -lm -ldl -pthread -rdynamic"	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2 -o $ExeName $LinkedLibs -lm -ldl -pthread -rdynamic"
	#define CXXOPT "-O2"	#define CXXOPT "-O2"
	#define CXXDEBUG "-g"	#define CXXDEBUG "-g"
	#define ROOTBUILD ""	#define ROOTBUILD ""
	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lMathCore -lRint "	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lMathCore -lRint "
	#define INCLUDEPATH "-I$ROOTSYS/include"	#define INCLUDEPATH "-I$ROOTSYS/include"
	#define OBJEXT "o"	#define OBJEXT "o"

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

	rsalib.h	rsalib.h

	/* @(#)root/auth:$Id: rsalib.h 30749 2009-10-15 16:33:04Z brun $ */	/* @(#)root/auth:$Id: rsalib.h 37912 2011-01-31 15:36:18Z ganis $ */
	/* Author: Martin Nicolay 22/11/1988 */	/* Author: Martin Nicolay 22/11/1988 */

	/************************************************************************ **	/************************************************************************ **
	Copyright (C) 2006 Martin Nicolay <m.nicolay@osm-gmbh.de>	Copyright (C) 2006 Martin Nicolay <m.nicolay@osm-gmbh.de>

	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 Lesser General Public	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later	version 2.1 of the License, or (at your option) any later
	version.	version.

	skipping to change at line 37	skipping to change at line 37
	* Adaptation in library for ROOT by G. Ganis, July 2003 *	* Adaptation in library for ROOT by G. Ganis, July 2003 *
	* (gerardo.ganis@cern.ch) *	* (gerardo.ganis@cern.ch) *
	* *	* *
	* Header used by internal rsa functions *	* Header used by internal rsa functions *
	* *	* *
	************************************************************************* **/	************************************************************************* **/

	#ifndef _RSALIB_H	#ifndef _RSALIB_H
	#define _RSALIB_H	#define _RSALIB_H


		#ifndef _RSADEF_H
		#include "rsadef.h"
		#endif

	rsa_NUMBER rsa_genprim(int, int);	rsa_NUMBER rsa_genprim(int, int);
	int rsa_genrsa(rsa_NUMBER, rsa_NUMBER, rsa_NUMBER , rsa_NUMBER , rsa_N UMBER *);	int rsa_genrsa(rsa_NUMBER, rsa_NUMBER, rsa_NUMBER , rsa_NUMBER , rsa_N UMBER *);
	int rsa_encode(char *, int, rsa_NUMBER, rsa_NUMBER);	int rsa_encode(char *, int, rsa_NUMBER, rsa_NUMBER);
	int rsa_decode(char *, int, rsa_NUMBER, rsa_NUMBER);	int rsa_decode(char *, int, rsa_NUMBER, rsa_NUMBER);

	int rsa_encode_size(rsa_NUMBER);	int rsa_encode_size(rsa_NUMBER);

	/******************	/******************
	* nio.h *	* nio.h *
	******************/	******************/

End of changes. 2 change blocks.
	1 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/

	BinarySearchTree.h	BinarySearchTree.h

	// @(#)root/tmva $Id: BinarySearchTree.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: BinarySearchTree.h 38943 2011-04-20 08:03:25Z evt $
	// 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 122	skipping to change at line 122
	// 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 );

	// create the search tree from the events in a TTree	// create the search tree from the events in a TTree
	// using ALL the variables specified included in the Event	// using ALL the variables specified included in the Event
	Double_t Fill( const std::vector<TMVA::Event*>& events, Int_t theType = -1 );	Double_t Fill( const std::vector<TMVA::Event*>& events, Int_t theType = -1 );

	void NormalizeTree ();	void NormalizeTree ();


	void CalcStatistics( TMVA::Node* n = 0 );	void CalcStatistics( TMVA::Node* n = 0, Int_t signalClass=0 );
	void Clear ( TMVA::Node* n = 0 );	void Clear ( TMVA::Node* n = 0 );

	// access to mean for signal and background for each variable	// access to mean for signal and background for each variable
	Float_t Mean(Types::ESBType sb, UInt_t var ) { return fMeans[sb==Type s::kSignal?0:1][var]; }	Float_t Mean(Types::ESBType sb, UInt_t var ) { return fMeans[sb==Type s::kSignal?0:1][var]; }

	// access to RMS for signal and background for each variable	// access to RMS for signal and background for each variable
	Float_t RMS(Types::ESBType sb, UInt_t var ) { return fRMS[sb==Types:: kSignal?0:1][var]; }	Float_t RMS(Types::ESBType sb, UInt_t var ) { return fRMS[sb==Types:: kSignal?0:1][var]; }

	// access to Minimum for signal and background for each variable	// access to Minimum for signal and background for each variable
	Float_t Min(Types::ESBType sb, UInt_t var ) { return fMin[sb==Types:: kSignal?0:1][var]; }	Float_t Min(Types::ESBType sb, UInt_t var ) { return fMin[sb==Types:: kSignal?0:1][var]; }

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

	DataInputHandler.h	DataInputHandler.h

	// @(#)root/tmva $Id: DataInputHandler.h 33928 2010-06-15 16:19:31Z stelzer $	// @(#)root/tmva $Id: DataInputHandler.h 38475 2011-03-17 10:46:00Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, 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 : DataInputHandler *	* Class : DataInputHandler *
	* 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 69	skipping to change at line 69
	class TreeInfo {	class TreeInfo {

	public:	public:

	TreeInfo( TTree* tr, const TString& className, Double_t weight=1.0, T ypes::ETreeType tt = Types::kMaxTreeType, Bool_t own=kFALSE )	TreeInfo( TTree* tr, const TString& className, Double_t weight=1.0, T ypes::ETreeType tt = Types::kMaxTreeType, Bool_t own=kFALSE )
	: fTree(tr), fClassName(className), fWeight(weight), fTreeType(tt) , fOwner(own) {}	: fTree(tr), fClassName(className), fWeight(weight), fTreeType(tt) , fOwner(own) {}
	~TreeInfo() { if (fOwner) delete fTree; }	~TreeInfo() { if (fOwner) delete fTree; }

	TTree* GetTree() const { return fTree; }	TTree* GetTree() const { return fTree; }
	Double_t GetWeight() const { return fWeight; }	Double_t GetWeight() const { return fWeight; }

	UInt_t GetEntries() const { return fTree->GetEntries(); }	UInt_t GetEntries() const { if( !fTree ) return 0; else r eturn fTree->GetEntries(); }
	Types::ETreeType GetTreeType() const { return fTreeType; }	Types::ETreeType GetTreeType() const { return fTreeType; }
	const TString& GetClassName() const { return fClassName; }	const TString& GetClassName() const { return fClassName; }

	private:	private:

	TTree* fTree; //! pointer to the tree	TTree* fTree; //! pointer to the tree
	TString fClassName;//! name of the class the tree belongs to	TString fClassName;//! name of the class the tree belongs to
	Double_t fWeight; //! weight for the tree	Double_t fWeight; //! weight for the tree
	Types::ETreeType fTreeType; //! tree is for training/testing/both	Types::ETreeType fTreeType; //! tree is for training/testing/both
	Bool_t fOwner; //! true if created from file	Bool_t fOwner; //! true if created from file

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

	DecisionTreeNode.h	DecisionTreeNode.h

	// @(#)root/tmva $Id: DecisionTreeNode.h 37399 2010-12-08 15:22:07Z evt $	// @(#)root/tmva $Id: DecisionTreeNode.h 38943 2011-04-20 08:03:25Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard vo n Toerne	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard vo n Toerne

	/************************************************************************ ******	/************************************************************************ ******
	* 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 329	skipping to change at line 329
	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);

	static bool fgIsTraining; // static variable to flag training phase i n which we need fTrainInfo	static bool fgIsTraining; // static variable to flag training phase i n which we need fTrainInfo

	protected:	protected:

	static MsgLogger* fgLogger; // static because there is a huge numb er of nodes...	static MsgLogger* fgLogger; // static because there is a huge numb er of nodes...


	std::vector<Double_t> fFisherCoeff; // the other fisher coef f (offset at the last element	std::vector<Double_t> fFisherCoeff; // the fisher coeff (off set at the last element)

	Float_t fCutValue; // cut value appplied on this node to disc riminate bkg against sig	Float_t fCutValue; // cut value appplied on this node to disc riminate bkg against sig
	Bool_t fCutType; // true: if event variable > cutValue ==> signal , false otherwise	Bool_t fCutType; // true: if event variable > cutValue ==> signal , false otherwise
	Short_t fSelector; // index of variable used in node selectio n (decision tree)	Short_t fSelector; // index of variable used in node selectio n (decision tree)

	Float_t fResponse; // response value in case of regression	Float_t fResponse; // response value in case of regression
	Float_t fRMS; // response RMS of the regression node	Float_t fRMS; // response RMS of the regression node
	Int_t fNodeType; // Type of node: -1 == Bkg-leaf, 1 == Sign al-leaf, 0 = internal	Int_t fNodeType; // Type of node: -1 == Bkg-leaf, 1 == Sign al-leaf, 0 = internal
	Float_t fPurity; // the node purity	Float_t fPurity; // the node purity


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

	FeldmanCousins.h	FeldmanCousins.h

	// @(#)root/roostats:$Id: FeldmanCousins.h 37403 2010-12-08 15:59:22Z monet a $	// @(#)root/roostats:$Id: FeldmanCousins.h 38599 2011-03-24 08:37:05Z monet a $
	// 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_FeldmanCousins	#ifndef ROOSTATS_FeldmanCousins

	skipping to change at line 74	skipping to change at line 74
	// specify the parameters of interest in the interval	// specify the parameters of interest in the interval
	virtual void SetParameters(const RooArgSet& /set/) {	virtual void SetParameters(const RooArgSet& /set/) {
	cout << "DEPRECATED, use ModelConfig" << endl;	cout << "DEPRECATED, use ModelConfig" << endl;
	}	}

	// specify the nuisance parameters (eg. the rest of the parameters)	// specify the nuisance parameters (eg. the rest of the parameters)
	virtual void SetNuisanceParameters(const RooArgSet& /set/) {	virtual void SetNuisanceParameters(const RooArgSet& /set/) {
	cout << "DEPRECATED, use ModelConfig" << endl;	cout << "DEPRECATED, use ModelConfig" << endl;
	}	}


		// User-defined set of points to test
		void SetParameterPointsToTest(RooAbsData& pointsToTest) {
		fPointsToTest = &pointsToTest;
		}

		// User-defined set of points to test
		void SetPOIPointsToTest(RooAbsData& poiToTest) {
		fPOIToTest = &poiToTest;
		}

	// 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) {fSize = size;}	virtual void SetTestSize(Double_t size) {fSize = size;}
	// 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) {fSize = 1.-cl;}	virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl;}

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

	RooAbsData* GetPointsToScan() {	RooAbsData* GetPointsToScan() {
	if(!fPointsToTest) CreateParameterPoints();	if(!fPointsToTest) CreateParameterPoints();
	return fPointsToTest;	return fPointsToTest;

	skipping to change at line 127	skipping to change at line 137

	/*	/*
	RooAbsPdf * fPdf; // common PDF	RooAbsPdf * fPdf; // common PDF
	RooArgSet fPOI; // RooArgSet specifying parameters of interest for i nterval	RooArgSet fPOI; // RooArgSet specifying parameters of interest for i nterval
	RooArgSet fNuisParams;// RooArgSet specifying nuisance parameters fo r interval	RooArgSet fNuisParams;// RooArgSet specifying nuisance parameters fo r interval
	RooArgSet fObservables;// RooArgSet specifying nuisance parameters f or interval	RooArgSet fObservables;// RooArgSet specifying nuisance parameters f or interval
	*/	*/

	mutable ToyMCSampler* fTestStatSampler; // the test statistic sampler	mutable ToyMCSampler* fTestStatSampler; // the test statistic sampler
	mutable RooAbsData* fPointsToTest; // points to perform the construct ion	mutable RooAbsData* fPointsToTest; // points to perform the construct ion

		mutable RooAbsData* fPOIToTest; // value of POI points to perform the construction
	mutable ConfidenceBelt* fConfBelt;	mutable ConfidenceBelt* fConfBelt;
	Bool_t fAdaptiveSampling; // controls use of adaptive sampling algori thm	Bool_t fAdaptiveSampling; // controls use of adaptive sampling algori thm
	Double_t fAdditionalNToysFactor; // give user ability to ask for more toys	Double_t fAdditionalNToysFactor; // give user ability to ask for more toys
	Int_t fNbins; // number of samples per variable	Int_t fNbins; // number of samples per variable
	Bool_t fFluctuateData; // tell ToyMCSampler to fluctuate number of e ntries in dataset	Bool_t fFluctuateData; // tell ToyMCSampler to fluctuate number of e ntries in dataset
	Bool_t fDoProfileConstruction; // instead of full construction over n uisance parametrs, do profile	Bool_t fDoProfileConstruction; // instead of full construction over n uisance parametrs, do profile
	Bool_t fSaveBeltToFile; // controls use if ConfidenceBelt should be s aved to a TFile	Bool_t fSaveBeltToFile; // controls use if ConfidenceBelt should be s aved to a TFile
	Bool_t fCreateBelt; // controls use if ConfidenceBelt should be saved to a TFile	Bool_t fCreateBelt; // controls use if ConfidenceBelt should be saved to a TFile

	protected:	protected:

	ClassDef(FeldmanCousins,1) // Interface for tools setting limits (p roducing confidence intervals)	ClassDef(FeldmanCousins,2) // Interface for tools setting limits (p roducing confidence intervals)
	};	};
	}	}

	#endif	#endif

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

	HypoTestResult.h	HypoTestResult.h

	// @(#)root/roostats:$Id: HypoTestResult.h 36602 2010-11-11 16:52:13Z monet a $	// @(#)root/roostats:$Id: HypoTestResult.h 38933 2011-04-19 20:15:51Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss
	/*************************************************************************	/*************************************************************************
	* 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_HypoTestResult	#ifndef ROOSTATS_HypoTestResult

	skipping to change at line 118	skipping to change at line 118
	cout << " - CL_b: " << CLb() << " +/- " << CLbError() << std::e ndl;	cout << " - CL_b: " << CLb() << " +/- " << CLbError() << std::e ndl;
	if(HasTestStatisticData() && fAltDistr)	if(HasTestStatisticData() && fAltDistr)
	cout << " - CL_s+b: " << CLsplusb() << " +/- " << CLsplusbError () << std::endl;	cout << " - CL_s+b: " << CLsplusb() << " +/- " << CLsplusbError () << std::endl;
	if(HasTestStatisticData() && fAltDistr && fNullDistr)	if(HasTestStatisticData() && fAltDistr && fNullDistr)
	cout << " - CL_s: " << CLs() << " +/- " << CLsError() << std:: endl;	cout << " - CL_s: " << CLs() << " +/- " << CLsError() << std:: endl;

	return;	return;
	}	}

	private:	private:

	void UpdatePValue(const SamplingDistribution* distr, Double_t *pvalue , Bool_t pIsRightTail);	void UpdatePValue(const SamplingDistribution* distr, Double_t &pvalue , Double_t &perror, Bool_t pIsRightTail);

	protected:	protected:

	mutable Double_t fNullPValue; // p-value for the null hypothesis (sma ll number means disfavored)	mutable Double_t fNullPValue; // p-value for the null hypothesis (sma ll number means disfavored)
	mutable Double_t fAlternatePValue; // p-value for the alternate hypot hesis (small number means disfavored)	mutable Double_t fAlternatePValue; // p-value for the alternate hypot hesis (small number means disfavored)

		mutable Double_t fNullPValueError; // error of p-value for the null h
		ypothesis (small number means disfavored)
		mutable Double_t fAlternatePValueError; // error of p-value for the a
		lternate hypothesis (small number means disfavored)
	Double_t fTestStatisticData; // result of the test statistic evaluate d on data	Double_t fTestStatisticData; // result of the test statistic evaluate d on data
	SamplingDistribution *fNullDistr;	SamplingDistribution *fNullDistr;
	SamplingDistribution *fAltDistr;	SamplingDistribution *fAltDistr;
	Bool_t fPValueIsRightTail;	Bool_t fPValueIsRightTail;

	ClassDef(HypoTestResult,1) // Base class to represent results of a h ypothesis test	ClassDef(HypoTestResult,1) // Base class to represent results of a h ypothesis test

	};	};
	}	}


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

	MethodANNBase.h	MethodANNBase.h

	// @(#)root/tmva $Id: MethodANNBase.h 36966 2010-11-26 09:50:13Z evt $	// @(#)root/tmva $Id: MethodANNBase.h 38609 2011-03-24 16:06:32Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski	// Author: Andreas Hoecker, Peter Speckmayer, Matt Jachowski, Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* 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 *
	* from background. *	* from background. *
	* *	* *
	* Authors (alphabetical): *	* Authors (alphabetical): *
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland *
	* Matt Jachowski <jachowski@stanford.edu> - Stanford University, US A *	* Matt Jachowski <jachowski@stanford.edu> - Stanford University, US A *
	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *	* Peter Speckmayer <Peter.Speckmayer@cern.ch> - CERN, Switzerland *
	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *	* Joerg Stelzer <Joerg.Stelzer@cern.ch> - CERN, Switzerland *

		* Jan Therhaag <Jan.Therhaag@cern.ch> - U of Bonn, Germany *
	* *	* *
	* Small changes (regression): *	* Small changes (regression): *
	* 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 *
	* *	* *

	* Copyright (c) 2005: *	* Copyright (c) 2005-2011: *
	* CERN, Switzerland *	* CERN, Switzerland *
	* *	* *
	* 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_MethodANNBase	#ifndef ROOT_TMVA_MethodANNBase
	#define ROOT_TMVA_MethodANNBase	#define ROOT_TMVA_MethodANNBase


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

	ParameterSettings.h	ParameterSettings.h

	// @(#)root/mathcore:$Id: ParameterSettings.h 25486 2008-09-22 12:43:03Z mo neta $	// @(#)root/mathcore:$Id: ParameterSettings.h 37706 2011-01-05 08:54:28Z mo neta $
	// Author: L. Moneta Thu Sep 21 16:21:48 2006	// Author: L. Moneta Thu Sep 21 16:21:48 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 ParameterSettings	// Header file for class ParameterSettings

	skipping to change at line 104	skipping to change at line 104
	/// copy constructor and assignment operators (leave them to the compile r)	/// copy constructor and assignment operators (leave them to the compile r)

	public:	public:

	/// return parameter value	/// return parameter value
	double Value() const { return fValue; }	double Value() const { return fValue; }
	/// return step size	/// return step size
	double StepSize() const { return fStepSize; }	double StepSize() const { return fStepSize; }
	/// return lower limit value	/// return lower limit value
	double LowerLimit() const {return fLowerLimit;}	double LowerLimit() const {return fLowerLimit;}

	/// return lower limit value	/// return upper limit value
	double UpperLimit() const {return fUpperLimit;}	double UpperLimit() const {return fUpperLimit;}
	/// check if is fixed	/// check if is fixed
	bool IsFixed() const { return fFix; }	bool IsFixed() const { return fFix; }
	/// check if parameter has lower limit	/// check if parameter has lower limit
	bool HasLowerLimit() const {return fHasLowerLimit; }	bool HasLowerLimit() const {return fHasLowerLimit; }
	/// check if parameter has upper limit	/// check if parameter has upper limit
	bool HasUpperLimit() const {return fHasUpperLimit; }	bool HasUpperLimit() const {return fHasUpperLimit; }
	/// check if is bound	/// check if is bound
	bool IsBound() const { return fHasLowerLimit \|\| fHasUpperLimit; }	bool IsBound() const { return fHasLowerLimit \|\| fHasUpperLimit; }
	/// check if is double bound (upper AND lower limit)	/// check if is double bound (upper AND lower limit)

End of changes. 2 change blocks.
	2 lines changed or deleted	2 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.6.3/	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.6.3p
	i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5/i68	2/i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5/i
	6-slc5-gcc43-opt linux --fail-on-missing --enable-cintex --enable-explicitl	686-slc5-gcc43-opt linux --fail-on-missing --enable-builtin-pcre --enable-c
	ink --enable-gdml --enable-genvector --enable-krb5 --enable-mathmore --enab	intex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5
	le-minuit2 --enable-mysql --enable-oracle --enable-python --enable-qt --ena	--enable-mathmore --enable-minuit2 --enable-mysql --enable-oracle --enable-
	ble-qtgsi --enable-reflex --enable-roofit --enable-table --enable-unuran --	python --enable-qt --enable-qtgsi --enable-reflex --enable-roofit --enable-
	with-castor-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-g	table --enable-unuran --with-castor-incdir=/afs/cern.ch/sw/lcg/external/cas
	cc43-opt/usr/include/shift --with-castor-libdir=/afs/cern.ch/sw/lcg/externa	tor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/shift --with-castor-libdir=/af
	l/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-cern-libdir=/afs/cern.	s/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --wit
	ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/lib --with-dcap-libdir	h-cern-libdir=/afs/cern.ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-op
	=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1/i686-slc5-gcc43-opt/dca	t/lib --with-dcap-libdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1
	p/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1	/i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/extern
	/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incdir=/afs/cern.ch/sw/lcg/e	al/dcache_client/1.9.3p1/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incd
	xternal/fftw3/3.1.2/i686-slc5-gcc43-opt/include --with-fftw3-libdir=/afs/ce	ir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/include --w
	rn.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/lib --with-gccxml=/af	ith-fftw3-libdir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-o
	s/cern.ch/sw/lcg/external/gccxml/0.9.0_20100114/i686-slc5-gcc43-opt/bin --w	pt/lib --with-gccxml=/afs/cern.ch/sw/lcg/external/gccxml/0.9.0_20100114/i68
	ith-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11.8-2/i686-slc5-g	6-slc5-gcc43-opt/bin --with-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid/g
	cc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg/external/Grid/gfal/1.11	fal/1.11.8-2/i686-slc5-gcc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg
	.8-2/i686-slc5-gcc43-opt/include --with-gsl-incdir=/afs/cern.ch/sw/lcg/exte	/external/Grid/gfal/1.11.8-2/i686-slc5-gcc43-opt/include --with-gsl-incdir=
	rnal/GSL/1.10/i686-slc5-gcc43-opt/include --with-gsl-libdir=/afs/cern.ch/sw	/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/include --with-gs
	/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib --with-mysql-incdir=/afs/cer	l-libdir=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib --wi
	n.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/include/mysql --with-	th-mysql-incdir=/afs/cern.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-o
	mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.1.45/i686-slc5-gcc43-opt/	pt/include/mysql --with-mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.1
	lib/mysql --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1	.45/i686-slc5-gcc43-opt/lib/mysql --with-oracle-incdir=/afs/cern.ch/sw/lcg/
	.0p2/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern.ch/sw/lcg/e	external/oracle/11.2.0.1.0p2/i686-slc5-gcc43-opt/include --with-oracle-libd
	xternal/oracle/11.2.0.1.0p2/i686-slc5-gcc43-opt/lib --with-rfio-incdir=/afs	ir=/afs/cern.ch/sw/lcg/external/oracle/11.2.0.1.0p2/i686-slc5-gcc43-opt/lib
	/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/include/sh	--with-rfio-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-slc5-
	ift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.8-10/i686-sl	gcc43-opt/usr/include/shift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external
	c5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/sw/lcg/external/MCG	/castor/2.1.8-10/i686-slc5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cer
	enerators/pythia6/421.2/i686-slc5-gcc43-opt/lib --with-pythia8-incdir=/afs/	n.ch/sw/lcg/external/MCGenerators/pythia6/424.2/i686-slc5-gcc43-opt/lib --w
	cern.ch/sw/lcg/external/MCGenerators/pythia8/130/i686-slc5-gcc43-opt/includ	ith-pythia8-incdir=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/145/i6
	e --with-pythia8-libdir=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/1	86-slc5-gcc43-opt/include --with-pythia8-libdir=/afs/cern.ch/sw/lcg/externa
	30/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/cern.ch/sw/lcg/external/	l/MCGenerators/pythia8/145/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/
	graphviz/2.24.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz-libdir=/af	cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5-gcc43-opt/include/graphvi
	s/cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5-gcc43-opt/lib"	z --with-gviz-libdir=/afs/cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5
	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft	-gcc43-opt/lib"
	gl builtin_glew builtin_pcre castor cintex editline dcache exceptions expli	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft
	citlink fftw3 gviz gdml genvector gfal krb5 ldap mathmore memstat minuit2 m	gl builtin_glew builtin_pcre castor cintex editline dcache exceptions expli
	ysql opengl oracle pgsql pythia8 python qt qtgsi reflex roofit rfio shadowp	citlink fftw3 gviz gdml genvector gfal krb5 ldap mathmore memstat minuit2 m
	w shared ssl table tmva unuran x11 xft xml xrootd thread"	ysql opengl oracle pythia8 python qt qtgsi reflex roofit rfio shadowpw shar
		ed ssl table tmva unuran x11 xft xml xrootd thread"

	#endif	#endif

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

	RooAbsPdf.h	RooAbsPdf.h

	skipping to change at line 97	skipping to change at line 97

	RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, const RooCmdArg& arg1,	RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, const RooCmdArg& arg1,
	const RooCmdArg& arg2=RooCmdArg::none(), const RooCmdArg& arg3=RooCmdArg::none(),	const RooCmdArg& arg2=RooCmdArg::none(), const RooCmdArg& arg3=RooCmdArg::none(),
	const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none()) ;	const RooCmdArg& arg4=RooCmdArg::none(), const RooCmdArg& arg5=RooCmdArg::none()) ;
	RooDataHist *generateBinned(const RooArgSet &whatVars,	RooDataHist *generateBinned(const RooArgSet &whatVars,
	const RooCmdArg& arg1=RooCmdArg::none(),const RooCmdArg& arg2=RooCmdArg::none(),	const RooCmdArg& arg1=RooCmdArg::none(),const RooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& arg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmdArg& arg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none()) ;	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmdArg& arg6=RooCmdArg::none()) ;
	RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, Bool_t expectedData=kFALSE, Bool_t extended=kFALSE) const;	RooDataHist *generateBinned(const RooArgSet &whatVars, Double_t nEvents, Bool_t expectedData=kFALSE, Bool_t extended=kFALSE) const;


		virtual RooDataSet* generateSimGlobal(const RooArgSet& whatVars, Int_t nE
		vents) ;

	virtual RooPlot* plotOn(RooPlot* frame,	virtual RooPlot* plotOn(RooPlot* frame,
	const RooCmdArg& arg1=RooCmdArg::none(), const Roo CmdArg& arg2=RooCmdArg::none(),	const RooCmdArg& arg1=RooCmdArg::none(), const Roo CmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(), const Roo CmdArg& arg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(), const Roo CmdArg& arg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(), const Roo CmdArg& arg6=RooCmdArg::none(),	const RooCmdArg& arg5=RooCmdArg::none(), const Roo CmdArg& arg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(), const Roo CmdArg& arg8=RooCmdArg::none(),	const RooCmdArg& arg7=RooCmdArg::none(), const Roo CmdArg& arg8=RooCmdArg::none(),
	const RooCmdArg& arg9=RooCmdArg::none(), const Roo CmdArg& arg10=RooCmdArg::none()	const RooCmdArg& arg9=RooCmdArg::none(), const Roo CmdArg& arg10=RooCmdArg::none()
	) const {	) const {
	return RooAbsReal::plotOn(frame,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8 ,arg9,arg10) ;	return RooAbsReal::plotOn(frame,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8 ,arg9,arg10) ;
	}	}


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

	RooSimultaneous.h	RooSimultaneous.h

	skipping to change at line 81	skipping to change at line 81

	// Backward compatibility function	// Backward compatibility function
	virtual RooPlot plotOn(RooPlot frame, Option_t* drawOptions, Double_t s caleFactor=1.0,	virtual RooPlot plotOn(RooPlot frame, Option_t* drawOptions, Double_t s caleFactor=1.0,
	ScaleType stype=Relative, const RooAbsData* projDa ta=0, const RooArgSet* projSet=0,	ScaleType stype=Relative, const RooAbsData* projDa ta=0, const RooArgSet* projSet=0,
	Double_t precision=1e-3, Bool_t shiftToZero=kFALSE , const RooArgSet* projDataSet=0,	Double_t precision=1e-3, Bool_t shiftToZero=kFALSE , const RooArgSet* projDataSet=0,
	Double_t rangeLo=0, Double_t rangeHi=0, RooCurve:: WingMode wmode=RooCurve::Extended) const;	Double_t rangeLo=0, Double_t rangeHi=0, RooCurve:: WingMode wmode=RooCurve::Extended) const;

	RooAbsPdf* getPdf(const char* catName) const ;	RooAbsPdf* getPdf(const char* catName) const ;
	const RooAbsCategoryLValue& indexCat() const { return (RooAbsCategoryLVal ue&) _indexCat.arg() ; }	const RooAbsCategoryLValue& indexCat() const { return (RooAbsCategoryLVal ue&) _indexCat.arg() ; }


		virtual RooDataSet* generateSimGlobal(const RooArgSet& whatVars, Int_t nE
		vents) ;

	protected:	protected:

	void initialize(RooAbsCategoryLValue& inIndexCat, std::map<std::string,Ro oAbsPdf*> pdfMap) ;	void initialize(RooAbsCategoryLValue& inIndexCat, std::map<std::string,Ro oAbsPdf*> pdfMap) ;
	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;

	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;
	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;
	mutable RooSetProxy _plotCoefNormSet ;	mutable RooSetProxy _plotCoefNormSet ;
	const TNamed* _plotCoefNormRange ;	const TNamed* _plotCoefNormRange ;


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

	G__ci_fproto.h		G__ci_fproto.h

	skipping to change at line 80		skipping to change at line 80
	*************************************************************************/		*************************************************************************/

	/*************************************************************************		/*************************************************************************
	* interface method setup functions		* interface method setup functions
	*************************************************************************/		*************************************************************************/

	G__DECL_API(25, int, G__defined_tagname, (G__CONST char* tagname,int noerro r))		G__DECL_API(25, int, G__defined_tagname, (G__CONST char* tagname,int noerro r))
	G__DECL_API(26, struct G__Definedtemplateclass ,G__defined_templateclass, (G__CONST char name))		G__DECL_API(26, struct G__Definedtemplateclass ,G__defined_templateclass, (G__CONST char name))

	G__DECL_API(27, int, G__deleteglobal, (void* p))		G__DECL_API(27, int, G__deleteglobal, (void* p))

			G__DECL_API(269, int, G__resetglobalvar, (void* p))
	G__DECL_API(28, int, G__deletevariable, (G__CONST char* varname))		G__DECL_API(28, int, G__deletevariable, (G__CONST char* varname))
	G__DECL_API(29, int, G__optimizemode, (int optimizemode))		G__DECL_API(29, int, G__optimizemode, (int optimizemode))
	G__DECL_API(30, int, G__getoptimizemode, (void))		G__DECL_API(30, int, G__getoptimizemode, (void))
	G__DECL_API(31, G__value, G__string2type_body, (G__CONST char *typenamin,in t noerror))		G__DECL_API(31, G__value, G__string2type_body, (G__CONST char *typenamin,in t noerror))
	G__DECL_API(32, G__value, G__string2type, (G__CONST char *typenamin))		G__DECL_API(32, G__value, G__string2type, (G__CONST char *typenamin))
	G__DECL_API(33, void, G__findsym, (G__CONST char fname))		G__DECL_API(33, void, G__findsym, (G__CONST char fname))

	G__DECL_API(34, int, G__IsInMacro, (void))		G__DECL_API(34, int, G__IsInMacro, (void))
	G__DECL_API(35, void, G__storerewindposition, (void))		G__DECL_API(35, void, G__storerewindposition, (void))
	G__DECL_API(36, void, G__rewinddictionary, (void))		G__DECL_API(36, void, G__rewinddictionary, (void))

	skipping to change at line 158		skipping to change at line 159
	G__DECL_API(65, int, G__gettempfilenum, (void))		G__DECL_API(65, int, G__gettempfilenum, (void))
	G__DECL_API(66, void, G__LockCpp, (void))		G__DECL_API(66, void, G__LockCpp, (void))
	G__DECL_API(67, void, G__set_sym_underscore, (int x))		G__DECL_API(67, void, G__set_sym_underscore, (int x))
	G__DECL_API(68, int, G__get_sym_underscore, (void))		G__DECL_API(68, int, G__get_sym_underscore, (void))
	G__DECL_API(69, void*, G__get_errmsgcallback, (void))		G__DECL_API(69, void*, G__get_errmsgcallback, (void))
	G__DECL_API(70, void, G__mask_errmsg, (char* msg))		G__DECL_API(70, void, G__mask_errmsg, (char* msg))
	G__DECL_API(71, int, G__main, (int argc,char **argv))		G__DECL_API(71, int, G__main, (int argc,char **argv))
	G__DECL_API(72, void, G__setothermain, (int othermain))		G__DECL_API(72, void, G__setothermain, (int othermain))
	G__DECL_API(73, void, G__exit, (int rtn))		G__DECL_API(73, void, G__exit, (int rtn))
	G__DECL_API(74, int, G__getnumbaseclass, (int tagnum))		G__DECL_API(74, int, G__getnumbaseclass, (int tagnum))

	G__DECL_API(75, void, G__setnewtype, (int globalcomp,G__CONST char* comment ,int nindex))		G__DECL_API(75, void, G__setnewtype, (char globalcomp,G__CONST char* commen t,int nindex))
	G__DECL_API(76, void, G__setnewtypeindex, (int j,int type_index))		G__DECL_API(76, void, G__setnewtypeindex, (int j,int type_index))
	G__DECL_API(77, void, G__resetplocal, (void))		G__DECL_API(77, void, G__resetplocal, (void))

	TBranch.h	TBranch.h

	// @(#)root/tree:$Id: TBranch.h 37168 2010-12-02 02:34:55Z pcanal $	// @(#)root/tree:$Id: TBranch.h 38801 2011-04-11 20:10:24Z pcanal $
	// 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 37	skipping to change at line 37
	#endif	#endif

	#ifndef ROOT_TObjArray	#ifndef ROOT_TObjArray
	#include "TObjArray.h"	#include "TObjArray.h"
	#endif	#endif

	#ifndef ROOT_TAttFill	#ifndef ROOT_TAttFill
	#include "TAttFill.h"	#include "TAttFill.h"
	#endif	#endif


		#ifndef ROOT_TDataType
		#include "TDataType.h"
		#endif

	class TTree;	class TTree;
	class TBasket;	class TBasket;
	class TLeaf;	class TLeaf;
	class TBrowser;	class TBrowser;
	class TDirectory;	class TDirectory;
	class TFile;	class TFile;
	class TClonesArray;	class TClonesArray;

	const Int_t kDoNotProcess = BIT(10); // Active bit for branches	const Int_t kDoNotProcess = BIT(10); // Active bit for branches
	const Int_t kIsClone = BIT(11); // to indicate a TBranchClones	const Int_t kIsClone = BIT(11); // to indicate a TBranchClones
	const Int_t kBranchObject = BIT(12); // branch is a TObject*	const Int_t kBranchObject = BIT(12); // branch is a TObject*
	const Int_t kBranchAny = BIT(17); // branch is an object*	const Int_t kBranchAny = BIT(17); // branch is an object*
	const Int_t kMapObject = kBranchObject \| kBranchAny;	const Int_t kMapObject = kBranchObject \| kBranchAny;

	class TBranch : public TNamed , public TAttFill {	class TBranch : public TNamed , public TAttFill {

	protected:	protected:
	// TBranch status bits	// TBranch status bits

	enum { kAutoDelete = BIT(15) };	enum EStatusBits {
		kAutoDelete = BIT(15),
		kDoNotUseBufferMap = BIT(22) // If set, at least one of the entry in
		the branch will use the buffer's map of classname and objects.
		};

	static Int_t fgCount; //! branch counter	static Int_t fgCount; //! branch counter
	Int_t fCompress; // (=1 branch is compressed, 0 otherwise)	Int_t fCompress; // (=1 branch is compressed, 0 otherwise)
	Int_t fBasketSize; // Initial Size of Basket Buffer	Int_t fBasketSize; // Initial Size of Basket Buffer
	Int_t fEntryOffsetLen; // Initial Length of fEntryOffset table i n the basket buffers	Int_t fEntryOffsetLen; // Initial Length of fEntryOffset table i n the basket buffers
	Int_t fWriteBasket; // Last basket number written	Int_t fWriteBasket; // Last basket number written
	Long64_t fEntryNumber; // Current entry number (last one filled in this branch)	Long64_t fEntryNumber; // Current entry number (last one filled in this branch)
	Int_t fOffset; // Offset of this branch	Int_t fOffset; // Offset of this branch
	Int_t fMaxBaskets; // Maximum number of Baskets so far	Int_t fMaxBaskets; // Maximum number of Baskets so far
	Int_t fNBaskets; //! Number of baskets in memory	Int_t fNBaskets; //! Number of baskets in memory
	Int_t fSplitLevel; // Branch split level	Int_t fSplitLevel; // Branch split level
	Int_t fNleaves; //! Number of leaves	Int_t fNleaves; //! Number of leaves
	Int_t fReadBasket; //! Current basket number when reading	Int_t fReadBasket; //! Current basket number when reading
	Long64_t fReadEntry; //! Current entry number when reading	Long64_t fReadEntry; //! Current entry number when reading

		Long64_t fFirstBasketEntry;//! First entry in the current basket.
		Long64_t fNextBasketEntry; //! Next entry that will requires us to go
		to the next basket
		TBasket *fCurrentBasket; //! Pointer to the current basket.
	Long64_t fEntries; // Number of entries	Long64_t fEntries; // Number of entries
	Long64_t fFirstEntry; // Number of the first entry in this bran ch	Long64_t fFirstEntry; // Number of the first entry in this bran ch
	Long64_t fTotBytes; // Total number of bytes in all leaves be fore compression	Long64_t fTotBytes; // Total number of bytes in all leaves be fore compression
	Long64_t fZipBytes; // Total number of bytes in all leaves af ter compression	Long64_t fZipBytes; // Total number of bytes in all leaves af ter compression
	TObjArray fBranches; //-> List of Branches of this branch	TObjArray fBranches; //-> List of Branches of this branch
	TObjArray fLeaves; //-> List of leaves of this branch	TObjArray fLeaves; //-> List of leaves of this branch
	TObjArray fBaskets; //-> List of baskets of this branch	TObjArray fBaskets; //-> List of baskets of this branch
	Int_t *fBasketBytes; //[fMaxBaskets] Lenght of baskets on file	Int_t *fBasketBytes; //[fMaxBaskets] Lenght of baskets on file
	Long64_t *fBasketEntry; //[fMaxBaskets] Table of first entry in ea ck basket	Long64_t *fBasketEntry; //[fMaxBaskets] Table of first entry in ea ck basket
	Long64_t *fBasketSeek; //[fMaxBaskets] Addresses of baskets on fi le	Long64_t *fBasketSeek; //[fMaxBaskets] Addresses of baskets on fi le

	skipping to change at line 94	skipping to change at line 104
	TDirectory *fDirectory; //! Pointer to directory where this branch buffers are stored	TDirectory *fDirectory; //! Pointer to directory where this branch buffers are stored
	TString fFileName; // Name of file where buffers are stored ("" if in same file as Tree header)	TString fFileName; // Name of file where buffers are stored ("" if in same file as Tree header)
	TBuffer *fEntryBuffer; //! Buffer used to directly pass the conte nt without streaming	TBuffer *fEntryBuffer; //! Buffer used to directly pass the conte nt without streaming
	TList *fBrowsables; //! List of TVirtualBranchBrowsables used for Browse()	TList *fBrowsables; //! List of TVirtualBranchBrowsables used for Browse()

	Bool_t fSkipZip; //! After being read, the buffer will not be unziped.	Bool_t fSkipZip; //! After being read, the buffer will not be unziped.

	typedef void (TBranch::*ReadLeaves_t)(TBuffer &b);	typedef void (TBranch::*ReadLeaves_t)(TBuffer &b);
	ReadLeaves_t fReadLeaves; //! Pointer to the ReadLeaves implementati on to use.	ReadLeaves_t fReadLeaves; //! Pointer to the ReadLeaves implementati on to use.
	void ReadLeavesImpl(TBuffer &b);	void ReadLeavesImpl(TBuffer &b);

		void ReadLeaves0Impl(TBuffer &b);
		void ReadLeaves1Impl(TBuffer &b);
		void ReadLeaves2Impl(TBuffer &b);

	void SetSkipZip(Bool_t skip = kTRUE) { fSkipZip = skip; }	void SetSkipZip(Bool_t skip = kTRUE) { fSkipZip = skip; }
	void Init(const char name, const char leaflist, Int_t compress);	void Init(const char name, const char leaflist, Int_t compress);

	TBasket *GetFreshBasket();	TBasket *GetFreshBasket();
	Int_t WriteBasket(TBasket* basket, Int_t where);	Int_t WriteBasket(TBasket* basket, Int_t where);

	TString GetRealFileName() const;	TString GetRealFileName() const;

	private:	private:

	skipping to change at line 141	skipping to change at line 154
	virtual Int_t GetBasketSize() const {return fBasketSize;}	virtual Int_t GetBasketSize() const {return fBasketSize;}
	virtual TList *GetBrowsables();	virtual TList *GetBrowsables();
	virtual const char* GetClassName() const;	virtual const char* GetClassName() const;
	virtual Int_t GetCompressionLevel() const {return fCompress;}	virtual Int_t GetCompressionLevel() const {return fCompress;}
	TDirectory *GetDirectory() const {return fDirectory;}	TDirectory *GetDirectory() const {return fDirectory;}
	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);
	virtual Int_t GetEntryExport(Long64_t entry, Int_t getall, TClonesAr ray *list, Int_t n);	virtual Int_t GetEntryExport(Long64_t entry, Int_t getall, TClonesAr ray *list, Int_t n);
	Int_t GetEntryOffsetLen() const { return fEntryOffsetLen; }	Int_t GetEntryOffsetLen() const { return fEntryOffsetLen; }
	Int_t GetEvent(Long64_t entry=0) {return GetEntry(entry);}	Int_t GetEvent(Long64_t entry=0) {return GetEntry(entry);}
	const char *GetIconName() const;	const char *GetIconName() const;

		virtual Int_t GetExpectedType(TClass *&clptr,EDataType &type);
	virtual TLeaf GetLeaf(const char name) const;	virtual TLeaf GetLeaf(const char name) const;
	virtual TFile *GetFile(Int_t mode=0);	virtual TFile *GetFile(Int_t mode=0);
	const char *GetFileName() const {return fFileName.Data();}	const char *GetFileName() const {return fFileName.Data();}
	Int_t GetOffset() const {return fOffset;}	Int_t GetOffset() const {return fOffset;}
	Int_t GetReadBasket() const {return fReadBasket;}	Int_t GetReadBasket() const {return fReadBasket;}
	Long64_t GetReadEntry() const {return fReadEntry;}	Long64_t GetReadEntry() const {return fReadEntry;}
	Int_t GetWriteBasket() const {return fWriteBasket;}	Int_t GetWriteBasket() const {return fWriteBasket;}
	Long64_t GetTotalSize(Option_t *option="") const;	Long64_t GetTotalSize(Option_t *option="") const;
	Long64_t GetTotBytes(Option_t *option="") const;	Long64_t GetTotBytes(Option_t *option="") const;
	Long64_t GetZipBytes(Option_t *option="") const;	Long64_t GetZipBytes(Option_t *option="") const;

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

	TBranchElement.h	TBranchElement.h

	// @(#)root/tree:$Id: TBranchElement.h 36061 2010-10-04 16:05:51Z pcanal $	// @(#)root/tree:$Id: TBranchElement.h 38757 2011-04-07 04:22:58Z pcanal $
	// Author: Rene Brun 14/01/2001	// Author: Rene Brun 14/01/2001

	/*************************************************************************	/*************************************************************************
	* 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 30	skipping to change at line 30
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TBranch	#ifndef ROOT_TBranch
	#include "TBranch.h"	#include "TBranch.h"
	#endif	#endif

	#ifndef ROOT_TClassRef	#ifndef ROOT_TClassRef
	#include "TClassRef.h"	#include "TClassRef.h"
	#endif	#endif


		#ifndef ROOT_TTree
		#include "TTree.h"
		#endif

		#ifndef ROOT_TError
		#include "TError.h"
		#endif

	#include <vector>	#include <vector>

	class TFolder;	class TFolder;
	class TStreamerInfo;	class TStreamerInfo;
	class TVirtualCollectionProxy;	class TVirtualCollectionProxy;
	class TVirtualCollectionIterators;	class TVirtualCollectionIterators;
	class TVirtualCollectionPtrIterators;	class TVirtualCollectionPtrIterators;
	class TVirtualArray;	class TVirtualArray;

	namespace TStreamerInfoActions { class TActionSequence; }	namespace TStreamerInfoActions { class TActionSequence; }

	skipping to change at line 61	skipping to change at line 69
	kCache = BIT(18), // Need to pushd/pop fOnfileObject.	kCache = BIT(18), // Need to pushd/pop fOnfileObject.
	kOwnOnfileObj = BIT(19), // We are the owner of fOnfileObject.	kOwnOnfileObj = BIT(19), // We are the owner of fOnfileObject.
	kAddressSet = BIT(20), // The addressing set have been called for this branch	kAddressSet = BIT(20), // The addressing set have been called for this branch
	kMakeClass = BIT(21), // This branch has been switched to using the MakeClass Mode	kMakeClass = BIT(21), // This branch has been switched to using the MakeClass Mode
	kDecomposedObj= BIT(21) // More explicit alias for kMakeClass.	kDecomposedObj= BIT(21) // More explicit alias for kMakeClass.
	};	};

	// Data Members	// Data Members
	protected:	protected:
	TString fClassName; // Class name of referenced ob ject	TString fClassName; // Class name of referenced ob ject

	TString fTargetClassName; //! Name of the target in-mem ory class
	TString fParentName; // Name of parent class	TString fParentName; // Name of parent class
	TString fClonesName; // Name of class in TClonesArr ay (if any)	TString fClonesName; // Name of class in TClonesArr ay (if any)
	TVirtualCollectionProxy *fCollProxy; //! collection interface (if an y)	TVirtualCollectionProxy *fCollProxy; //! collection interface (if an y)
	UInt_t fCheckSum; // CheckSum of class	UInt_t fCheckSum; // CheckSum of class
	Int_t fClassVersion; // Version number of class	Int_t fClassVersion; // Version number of class
	Int_t fID; // element serial number in fI nfo	Int_t fID; // element serial number in fI nfo
	Int_t fType; // branch type	Int_t fType; // branch type
	Int_t fStreamerType; // branch streamer type	Int_t fStreamerType; // branch streamer type
	Int_t fMaximum; // Maximum entries for a TClon esArray or variable array	Int_t fMaximum; // Maximum entries for a TClon esArray or variable array
	Int_t fSTLtype; //! STL container type	Int_t fSTLtype; //! STL container type
	Int_t fNdata; //! Number of data in this bran ch	Int_t fNdata; //! Number of data in this bran ch
	TBranchElement *fBranchCount; // pointer to primary branchco unt branch	TBranchElement *fBranchCount; // pointer to primary branchco unt branch
	TBranchElement *fBranchCount2; // pointer to secondary branch count branch	TBranchElement *fBranchCount2; // pointer to secondary branch count branch
	TStreamerInfo *fInfo; //! Pointer to StreamerInfo	TStreamerInfo *fInfo; //! Pointer to StreamerInfo
	char fObject; //! Pointer to object at fAddr ess	char fObject; //! Pointer to object at fAddr ess
	TVirtualArray *fOnfileObject; //! Place holder for the onfile representation of data members.	TVirtualArray *fOnfileObject; //! Place holder for the onfile representation of data members.
	Bool_t fInit; //! Initialization flag for bra nch assignment	Bool_t fInit; //! Initialization flag for bra nch assignment
	Bool_t fInitOffsets; //! Initialization flag to not endlessly recalculate offsets	Bool_t fInitOffsets; //! Initialization flag to not endlessly recalculate offsets

		TClassRef fTargetClass; //! Reference to the target in- memory class
	TClassRef fCurrentClass; //! Reference to current (trans ient) class definition	TClassRef fCurrentClass; //! Reference to current (trans ient) class definition
	TClassRef fParentClass; //! Reference to class definiti on in fParentName	TClassRef fParentClass; //! Reference to class definiti on in fParentName
	TClassRef fBranchClass; //! Reference to class definiti on in fClassName	TClassRef fBranchClass; //! Reference to class definiti on in fClassName

		TClassRef fClonesClass; //! Reference to class definiti on in fClonesName
	Int_t *fBranchOffset; //! Sub-Branch offsets with res pect to current transient class	Int_t *fBranchOffset; //! Sub-Branch offsets with res pect to current transient class
	Int_t fBranchID; //! ID number assigned by a TRe fTable.	Int_t fBranchID; //! ID number assigned by a TRe fTable.
	std::vector<Int_t> fIDs; //! List of the serial number o f all the StreamerInfo to be used.	std::vector<Int_t> fIDs; //! List of the serial number o f all the StreamerInfo to be used.
	TStreamerInfoActions::TActionSequence *fReadActionSequence; //! Set of actions to be executed to extract the data from the basket.	TStreamerInfoActions::TActionSequence *fReadActionSequence; //! Set of actions to be executed to extract the data from the basket.
	TVirtualCollectionIterators *fIterators; //! holds the ite rators when the branch is of fType==4.	TVirtualCollectionIterators *fIterators; //! holds the ite rators when the branch is of fType==4.
	TVirtualCollectionPtrIterators *fPtrIterators; //! holds the ite rators when the branch is of fType==4 and it is a split collection of point ers.	TVirtualCollectionPtrIterators *fPtrIterators; //! holds the ite rators when the branch is of fType==4 and it is a split collection of point ers.

	// Not implemented	// Not implemented
	private:	private:
	TBranchElement(const TBranchElement&); // not implemented	TBranchElement(const TBranchElement&); // not implemented

	skipping to change at line 105	skipping to change at line 114
	static void SwitchContainer(TObjArray *);	static void SwitchContainer(TObjArray *);

	// Implementation use only functions.	// Implementation use only functions.
	protected:	protected:
	void BuildTitle(const char* name);	void BuildTitle(const char* name);
	virtual void InitializeOffsets();	virtual void InitializeOffsets();
	virtual void InitInfo();	virtual void InitInfo();
	Bool_t IsMissingCollection() const;	Bool_t IsMissingCollection() const;
	TClass *GetCurrentClass(); // Class referenced by trans ient description	TClass *GetCurrentClass(); // Class referenced by trans ient description
	TClass *GetParentClass(); // Class referenced by fParen tName	TClass *GetParentClass(); // Class referenced by fParen tName

		TStreamerInfo *GetInfoImp() const;
	void ReleaseObject();	void ReleaseObject();
	void SetBranchCount(TBranchElement* bre);	void SetBranchCount(TBranchElement* bre);
	void SetBranchCount2(TBranchElement* bre) { fBranchC ount2 = bre; }	void SetBranchCount2(TBranchElement* bre) { fBranchC ount2 = bre; }
	Int_t Unroll(const char* name, TClass* cltop, TClass* cl, char* ptr, Int_t basketsize, Int_t splitlevel, Int_t btype);	Int_t Unroll(const char* name, TClass* cltop, TClass* cl, char* ptr, Int_t basketsize, Int_t splitlevel, Int_t btype);

	void ValidateAddress() const;	inline void ValidateAddress() const;

	void Init(TTree tree, TBranch parent, const char* name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);	void Init(TTree tree, TBranch parent, const char* name, TStreamerInfo* sinfo, Int_t id, char* pointer, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t btype = 0);
	void Init(TTree tree, TBranch parent, const char* name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1 );	void Init(TTree tree, TBranch parent, const char* name, TClonesArray* clones, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t compress = -1 );
	void Init(TTree tree, TBranch parent, const char* name, TVirtualCollec tionProxy* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t comp ress = -1);	void Init(TTree tree, TBranch parent, const char* name, TVirtualCollec tionProxy* cont, Int_t basketsize = 32000, Int_t splitlevel = 0, Int_t comp ress = -1);

	void ReadLeavesImpl(TBuffer& b);	void ReadLeavesImpl(TBuffer& b);
	void ReadLeavesMakeClass(TBuffer& b);	void ReadLeavesMakeClass(TBuffer& b);
	void ReadLeavesCollection(TBuffer& b);	void ReadLeavesCollection(TBuffer& b);
	void ReadLeavesCollectionSplitPtrMember(TBuffer& b);	void ReadLeavesCollectionSplitPtrMember(TBuffer& b);
	void ReadLeavesCollectionSplitVectorPtrMember(TBuffer& b);	void ReadLeavesCollectionSplitVectorPtrMember(TBuffer& b);

	skipping to change at line 153	skipping to change at line 163
	virtual Int_t Fill();	virtual Int_t Fill();
	virtual void FillLeaves(TBuffer& b);	virtual void FillLeaves(TBuffer& b);
	virtual TBranch FindBranch(const char name);	virtual TBranch FindBranch(const char name);
	virtual TLeaf FindLeaf(const char name);	virtual TLeaf FindLeaf(const char name);
	virtual char *GetAddress() const;	virtual char *GetAddress() const;
	TBranchElement *GetBranchCount() const { return fBranchCount; }	TBranchElement *GetBranchCount() const { return fBranchCount; }
	TBranchElement *GetBranchCount2() const { return fBranchCount2; }	TBranchElement *GetBranchCount2() const { return fBranchCount2; }
	Int_t *GetBranchOffset() const { return fBranchOffset; }	Int_t *GetBranchOffset() const { return fBranchOffset; }
	UInt_t GetCheckSum() { return fCheckSum; }	UInt_t GetCheckSum() { return fCheckSum; }
	virtual const char *GetClassName() const { return fClassName.Data() ; }	virtual const char *GetClassName() const { return fClassName.Data() ; }

		virtual TClass *GetClass() const { return fBranchClass; }
	virtual const char *GetClonesName() const { return fClonesName.Data (); }	virtual const char *GetClonesName() const { return fClonesName.Data (); }
	TVirtualCollectionProxy *GetCollectionProxy();	TVirtualCollectionProxy *GetCollectionProxy();
	virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0);	virtual Int_t GetEntry(Long64_t entry = 0, Int_t getall = 0);

		virtual Int_t GetExpectedType(TClass *&clptr,EDataType &type) ;
	const char *GetIconName() const;	const char *GetIconName() const;
	Int_t GetID() const { return fID; }	Int_t GetID() const { return fID; }
	TStreamerInfo *GetInfo() const;	TStreamerInfo *GetInfo() const;
	Bool_t GetMakeClass() const;	Bool_t GetMakeClass() const;
	char *GetObject() const;	char *GetObject() const;
	virtual const char *GetParentName() const { return fParentName.Data (); }	virtual const char *GetParentName() const { return fParentName.Data (); }
	virtual Int_t GetMaximum() const;	virtual Int_t GetMaximum() const;
	Int_t GetNdata() const { return fNdata; }	Int_t GetNdata() const { return fNdata; }
	Int_t GetType() const { return fType; }	Int_t GetType() const { return fType; }
	Int_t GetStreamerType() const { return fStreamerType; }	Int_t GetStreamerType() const { return fStreamerType; }

	virtual TString GetTargetClassName() { return fTargetClassName; }	virtual TClass *GetTargetClass() { return fTargetClass; }
	virtual const char *GetTypeName() const;	virtual const char *GetTypeName() const;
	Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kF ALSE) const;	Double_t GetValue(Int_t i, Int_t len, Bool_t subarr = kF ALSE) const;
	virtual void *GetValuePointer() const;	virtual void *GetValuePointer() const;
	Int_t GetClassVersion() { return fClassVersion; }	Int_t GetClassVersion() { return fClassVersion; }
	Bool_t IsBranchFolder() const { return TestBit(kBranch Folder); }	Bool_t IsBranchFolder() const { return TestBit(kBranch Folder); }
	Bool_t IsFolder() const;	Bool_t IsFolder() const;
	virtual Bool_t IsObjectOwner() const { return TestBit(kDeleteO bject); }	virtual Bool_t IsObjectOwner() const { return TestBit(kDeleteO bject); }
	virtual Bool_t Notify() { if (fAddress) { ResetAddress(); } re turn 1; }	virtual Bool_t Notify() { if (fAddress) { ResetAddress(); } re turn 1; }
	virtual void Print(Option_t* option = "") const;	virtual void Print(Option_t* option = "") const;
	void PrintValue(Int_t i) const;	void PrintValue(Int_t i) const;

	skipping to change at line 189	skipping to change at line 201
	virtual void ResetDeleteObject();	virtual void ResetDeleteObject();
	virtual void SetAddress(void* addobj);	virtual void SetAddress(void* addobj);
	virtual Bool_t SetMakeClass(Bool_t decomposeObj = kTRUE);	virtual Bool_t SetMakeClass(Bool_t decomposeObj = kTRUE);
	virtual void SetObject(void *objadd);	virtual void SetObject(void *objadd);
	virtual void SetBasketSize(Int_t buffsize);	virtual void SetBasketSize(Int_t buffsize);
	virtual void SetBranchFolder() { SetBit(kBranchFolder); }	virtual void SetBranchFolder() { SetBit(kBranchFolder); }
	virtual void SetClassName(const char* name) { fClassName = n ame; }	virtual void SetClassName(const char* name) { fClassName = n ame; }
	virtual void SetOffset(Int_t offset);	virtual void SetOffset(Int_t offset);
	inline void SetParentClass(TClass* clparent);	inline void SetParentClass(TClass* clparent);
	virtual void SetParentName(const char* name) { fParentName = name; }	virtual void SetParentName(const char* name) { fParentName = name; }

	virtual void SetTargetClassName(const char *name);	virtual void SetTargetClass(const char *name);
	virtual void SetupAddresses();	virtual void SetupAddresses();
	virtual void SetType(Int_t btype) { fType = btype; }	virtual void SetType(Int_t btype) { fType = btype; }
	virtual void UpdateFile();	virtual void UpdateFile();

	ClassDef(TBranchElement,9) // Branch in case of an object	ClassDef(TBranchElement,9) // Branch in case of an object
	};	};

	inline void TBranchElement::SetParentClass(TClass* clparent)	inline void TBranchElement::SetParentClass(TClass* clparent)
	{	{
	fParentClass = clparent;	fParentClass = clparent;
	fParentName = clparent ? clparent->GetName() : "";	fParentName = clparent ? clparent->GetName() : "";
	}	}


		inline void TBranchElement::ValidateAddress() const
		{
		// Check to see if the user changed the object pointer without telling u
		s.

		if (fID < 0) {
		// We are a top-level branch.
		if (!fTree->GetMakeClass() && fAddress && (((char*) fAddress) != fO
		bject)) {
		// The semantics of fAddress and fObject are violated.
		// Assume the user changed the pointer on us.
		// Note: The cast is here because we want to be able to
		// be called from the constant get functions.

		// FIXME: Disable the check/warning TTree until we add a missing i
		nterface.
		if (TestBit(kDeleteObject)) {
		// This should never happen!
		Error("ValidateAddress", "We owned an object whose address chan
		ged! our ptr: %p new ptr: %p", fObject, ((char*) fAddress));
		const_cast<TBranchElement*>(this)->ResetBit(kDeleteObject);
		}
		const_cast<TBranchElement*>(this)->SetAddress(fAddress);
		}
		}
		}

	#endif // ROOT_TBranchElement	#endif // ROOT_TBranchElement

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

	TBranchObject.h	TBranchObject.h

	// @(#)root/tree:$Id: TBranchObject.h 37168 2010-12-02 02:34:55Z pcanal $	// @(#)root/tree:$Id: TBranchObject.h 38059 2011-02-13 21:12:16Z pcanal $
	// Author: Rene Brun 11/02/96	// Author: Rene Brun 11/02/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 47	skipping to change at line 47
	TBranchObject();	TBranchObject();
	TBranchObject(TBranch parent, const char name, const char classname, void addobj, Int_t basketsize=32000, Int_t splitlevel = 0, Int_t compress= -1, Bool_t isptrptr = kTRUE);	TBranchObject(TBranch parent, const char name, const char classname, void addobj, Int_t basketsize=32000, Int_t splitlevel = 0, Int_t compress= -1, Bool_t isptrptr = kTRUE);
	TBranchObject(TTree tree, const char name, const char classname, void addobj, Int_t basketsize=32000, Int_t splitlevel = 0, Int_t compress=-1, Bool_t isptrptr = kTRUE);	TBranchObject(TTree tree, const char name, const char classname, void addobj, Int_t basketsize=32000, Int_t splitlevel = 0, Int_t compress=-1, Bool_t isptrptr = kTRUE);
	virtual ~TBranchObject();	virtual ~TBranchObject();

	virtual void Browse(TBrowser *b);	virtual void Browse(TBrowser *b);
	virtual Int_t Fill();	virtual Int_t Fill();
	virtual const char* GetClassName() const { return fClassName.Data(); };	virtual const char* GetClassName() const { return fClassName.Data(); };
	virtual const char* GetObjClassName() { return fClassName.Data(); };	virtual const char* GetObjClassName() { return fClassName.Data(); };
	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);	virtual Int_t GetEntry(Long64_t entry=0, Int_t getall = 0);

		virtual Int_t GetExpectedType(TClass *&clptr,EDataType &type);
	Bool_t IsFolder() const;	Bool_t IsFolder() const;
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual void SetAddress(void *addobj);	virtual void SetAddress(void *addobj);
	virtual void SetAutoDelete(Bool_t autodel=kTRUE);	virtual void SetAutoDelete(Bool_t autodel=kTRUE);
	virtual void SetBasketSize(Int_t buffsize);	virtual void SetBasketSize(Int_t buffsize);
	virtual void SetupAddresses();	virtual void SetupAddresses();
	virtual void UpdateAddress();	virtual void UpdateAddress();

	ClassDef(TBranchObject,1); //Branch in case of an object	ClassDef(TBranchObject,1); //Branch in case of an object

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

	TBrowserImp.h	TBrowserImp.h

	// @(#)root/base:$Id: TBrowserImp.h 30884 2009-10-27 12:26:33Z rdm $	// @(#)root/base:$Id: TBrowserImp.h 37996 2011-02-07 15:33:10Z rdm $
	// Author: Fons Rademakers 15/11/95	// Author: Fons Rademakers 15/11/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 54	skipping to change at line 54
	TBrowserImp(TBrowser b, const char title, UInt_t width, UInt_t height, Option_t *opt = "");	TBrowserImp(TBrowser b, const char title, UInt_t width, UInt_t height, Option_t *opt = "");
	TBrowserImp(TBrowser b, const char title, Int_t x, Int_t y, UInt_t wid th, UInt_t height, Option_t *opt = "");	TBrowserImp(TBrowser b, const char title, Int_t x, Int_t y, UInt_t wid th, UInt_t height, Option_t *opt = "");
	virtual ~TBrowserImp() { }	virtual ~TBrowserImp() { }

	virtual void Add(TObject , const char , Int_t) { }	virtual void Add(TObject , const char , Int_t) { }
	virtual void AddCheckBox(TObject *, Bool_t = kFALSE) { }	virtual void AddCheckBox(TObject *, Bool_t = kFALSE) { }
	virtual void CheckObjectItem(TObject *, Bool_t = kFALSE) { }	virtual void CheckObjectItem(TObject *, Bool_t = kFALSE) { }
	virtual void RemoveCheckBox(TObject *) { }	virtual void RemoveCheckBox(TObject *) { }
	virtual void BrowseObj(TObject *) { }	virtual void BrowseObj(TObject *) { }
	TBrowser *Browser() const { return fBrowser; }	TBrowser *Browser() const { return fBrowser; }

		virtual void CloseTabs() { }
	virtual void ExecuteDefaultAction(TObject *) { }	virtual void ExecuteDefaultAction(TObject *) { }
	virtual void Iconify() { }	virtual void Iconify() { }
	virtual void RecursiveRemove(TObject *) { }	virtual void RecursiveRemove(TObject *) { }
	virtual void Refresh(Bool_t = kFALSE) { }	virtual void Refresh(Bool_t = kFALSE) { }
	virtual void Show() { }	virtual void Show() { }
	virtual void SetDrawOption(Option_t *option="");	virtual void SetDrawOption(Option_t *option="");
	virtual Option_t *GetDrawOption() const { return 0; }	virtual Option_t *GetDrawOption() const { return 0; }

	virtual Long_t ExecPlugin(const char , const char , const char *, I nt_t, Int_t) { return 0; }	virtual Long_t ExecPlugin(const char , const char , const char *, I nt_t, Int_t) { return 0; }
	virtual void SetStatusText(const char *, Int_t) { }	virtual void SetStatusText(const char *, Int_t) { }

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

	TBuffer.h	TBuffer.h

	// @(#)root/base:$Id: TBuffer.h 36061 2010-10-04 16:05:51Z pcanal $	// @(#)root/base:$Id: TBuffer.h 37809 2011-01-19 11:07:41Z rdm $
	// Author: Rene Brun, Philippe Canal, Fons Rademakers 04/05/96	// Author: Rene Brun, Philippe Canal, Fons Rademakers 04/05/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 56	skipping to change at line 56
	Int_t fBufSize; //Size of buffer	Int_t fBufSize; //Size of buffer
	char *fBuffer; //Buffer used to store objects	char *fBuffer; //Buffer used to store objects
	char *fBufCur; //Current position in buffer	char *fBufCur; //Current position in buffer
	char *fBufMax; //End of buffer	char *fBufMax; //End of buffer
	TObject *fParent; //Pointer to parent object owning this buffer	TObject *fParent; //Pointer to parent object owning this buffer
	ReAllocCharFun_t fReAllocFunc; //! Realloc function to be used when ex tending the buffer.	ReAllocCharFun_t fReAllocFunc; //! Realloc function to be used when ex tending the buffer.
	CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members	CacheList_t fCacheStack; //Stack of pointers to the cache where to temporarily store the value of 'missing' data members

	// Default ctor	// Default ctor
	TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0),	TBuffer() : TObject(), fMode(0), fVersion(0), fBufSize(0), fBuffer(0),

	fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0) {}	fBufCur(0), fBufMax(0), fParent(0), fReAllocFunc(0), fCacheStack(0,(TV irtualArray*)0) {}

	// TBuffer objects cannot be copied or assigned	// TBuffer objects cannot be copied or assigned
	TBuffer(const TBuffer &); // not implemented	TBuffer(const TBuffer &); // not implemented
	void operator=(const TBuffer &); // not implemented	void operator=(const TBuffer &); // not implemented

	Int_t Read(const char *name) { return TObject::Read(name); }	Int_t Read(const char *name) { return TObject::Read(name); }
	Int_t Write(const char *name, Int_t opt, Int_t bufs)	Int_t Write(const char *name, Int_t opt, Int_t bufs)
	{ return TObject::Write(name, opt, bufs); }	{ return TObject::Write(name, opt, bufs); }
	Int_t Write(const char *name, Int_t opt, Int_t bufs) const	Int_t Write(const char *name, Int_t opt, Int_t bufs) const
	{ return TObject::Write(name, opt, bufs); }	{ return TObject::Write(name, opt, bufs); }

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

	TChain.h	TChain.h

	// @(#)root/tree:$Id: TChain.h 33354 2010-05-03 19:46:03Z pcanal $	// @(#)root/tree:$Id: TChain.h 37957 2011-02-02 21:17:37Z pcanal $
	// Author: Rene Brun 03/02/97	// Author: Rene Brun 03/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 124	skipping to change at line 124
	virtual Int_t LoadBaskets(Long64_t maxmemory);	virtual Int_t LoadBaskets(Long64_t maxmemory);
	virtual Long64_t LoadTree(Long64_t entry);	virtual Long64_t LoadTree(Long64_t entry);
	void Lookup(Bool_t force = kFALSE);	void Lookup(Bool_t force = kFALSE);
	virtual void Loop(Option_t option="", Long64_t nentries=kBigNumber , Long64_t firstentry=0); // MENU*	virtual void Loop(Option_t option="", Long64_t nentries=kBigNumber , Long64_t firstentry=0); // MENU*
	virtual void ls(Option_t *option="") const;	virtual void ls(Option_t *option="") const;
	virtual Long64_t Merge(const char name, Option_t option = "");	virtual Long64_t Merge(const char name, Option_t option = "");
	virtual Long64_t Merge(TCollection list, Option_t option = "");	virtual Long64_t Merge(TCollection list, Option_t option = "");
	virtual Long64_t Merge(TFile file, Int_t basketsize, Option_t option= "");	virtual Long64_t Merge(TFile file, Int_t basketsize, Option_t option= "");
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	virtual Long64_t Process(const char filename, Option_t option="", Lon g64_t nentries=kBigNumber, Long64_t firstentry=0); // MENU	virtual Long64_t Process(const char filename, Option_t option="", Lon g64_t nentries=kBigNumber, Long64_t firstentry=0); // MENU

	#ifndef __CINT__	#if defined(__CINT__)
	virtual Long64_t Process(TSelector selector, Option_t option="", Lon	#if defined(R__MANUAL_DICT)
	g64_t nentries=kBigNumber, Long64_t firstentry=0);	virtual Long64_t Process(void* selector, Option_t* option = "", Long64_
		t nentries = kBigNumber, Long64_t firstentry = 0);
		#endif
		#else
		virtual Long64_t Process(TSelector* selector, Option_t* option = "", Lo
		ng64_t nentries = kBigNumber, Long64_t firstentry = 0);
	#endif	#endif
	virtual void RecursiveRemove(TObject *obj);	virtual void RecursiveRemove(TObject *obj);
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual void ResetBranchAddress(TBranch *);	virtual void ResetBranchAddress(TBranch *);
	virtual void ResetBranchAddresses();	virtual void ResetBranchAddresses();
	virtual Long64_t Scan(const char varexp="", const char selection="", Option_t option="", Long64_t nentries=1000000000, Long64_t firstentry=0); // MENU*	virtual Long64_t Scan(const char varexp="", const char selection="", Option_t option="", Long64_t nentries=1000000000, Long64_t firstentry=0); // MENU*
	virtual void SetAutoDelete(Bool_t autodel=kTRUE);	virtual void SetAutoDelete(Bool_t autodel=kTRUE);
	virtual Int_t SetBranchAddress(const char bname,void add, TBranch **ptr = 0);	virtual Int_t SetBranchAddress(const char bname,void add, TBranch **ptr = 0);
	virtual Int_t SetBranchAddress(const char bname,void add, TBranch *ptr, TClass realClass, EDataType datatype, Bool_t isptr);	virtual Int_t SetBranchAddress(const char bname,void add, TBranch *ptr, TClass realClass, EDataType datatype, Bool_t isptr);
	virtual Int_t SetBranchAddress(const char bname,void add, TClass * realClass, EDataType datatype, Bool_t isptr);	virtual Int_t SetBranchAddress(const char bname,void add, TClass * realClass, EDataType datatype, Bool_t isptr);

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

	TChainIndex.h	TChainIndex.h

	// @(#)root/treeplayer:$Id: TChainIndex.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/treeplayer:$Id: TChainIndex.h 38496 2011-03-18 10:04:01Z pcanal $
	// Author: Marek Biskup 07/06/2005	// Author: Marek Biskup 07/06/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 68	skipping to change at line 68

	std::pair<TVirtualIndex*, Int_t> GetSubTreeIndex(Int_t major, Int_t mino r) const;	std::pair<TVirtualIndex*, Int_t> GetSubTreeIndex(Int_t major, Int_t mino r) const;
	void ReleaseSubTreeIndex(TVirtualIndex* index, Int_t treeNo) const;	void ReleaseSubTreeIndex(TVirtualIndex* index, Int_t treeNo) const;
	void DeleteIndices();	void DeleteIndices();

	public:	public:
	TChainIndex();	TChainIndex();
	TChainIndex(const TTree T, const char majorname, const char *minorname );	TChainIndex(const TTree T, const char majorname, const char *minorname );
	virtual ~TChainIndex();	virtual ~TChainIndex();
	virtual void Append(const TVirtualIndex *, Bool_t delaySort = kFALSE);	virtual void Append(const TVirtualIndex *, Bool_t delaySort = kFALSE);

	virtual Int_t GetEntryNumberFriend(const TTree *T);	virtual Long64_t GetEntryNumberFriend(const TTree *parent);
	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const;	virtual Long64_t GetEntryNumberWithIndex(Int_t major, Int_t minor) const;
	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t mi nor) const;	virtual Long64_t GetEntryNumberWithBestIndex(Int_t major, Int_t mi nor) const;
	const char *GetMajorName() const {return fMajorName.Data() ;}	const char *GetMajorName() const {return fMajorName.Data() ;}
	const char *GetMinorName() const {return fMinorName.Data() ;}	const char *GetMinorName() const {return fMinorName.Data() ;}
	virtual Long64_t GetN() const {return fEntries.size();}	virtual Long64_t GetN() const {return fEntries.size();}

	virtual TTreeFormula GetMajorFormulaParent(const TTree T);	virtual TTreeFormula GetMajorFormulaParent(const TTree parent);
	virtual TTreeFormula GetMinorFormulaParent(const TTree T);	virtual TTreeFormula GetMinorFormulaParent(const TTree parent);
	virtual void UpdateFormulaLeaves(const TTree *parent);	virtual void UpdateFormulaLeaves(const TTree *parent);
	virtual void SetTree(const TTree *T);	virtual void SetTree(const TTree *T);

	ClassDef(TChainIndex,1) //A Tree Index with majorname and minorname.	ClassDef(TChainIndex,1) //A Tree Index with majorname and minorname.
	};	};

	#endif	#endif

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

	TClass.h	TClass.h

	// @(#)root/meta:$Id: TClass.h 37287 2010-12-05 04:14:11Z pcanal $	// @(#)root/meta:$Id: TClass.h 37702 2011-01-04 17:07:52Z 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 159	skipping to change at line 159

	// Various implementation for TClass::Stramer	// Various implementation for TClass::Stramer
	void StreamerExternal(void object, TBuffer &b, const TClass onfile_cla ss) const;	void StreamerExternal(void object, TBuffer &b, const TClass onfile_cla ss) const;
	void StreamerTObject(void object, TBuffer &b, const TClass onfile_clas s) const;	void StreamerTObject(void object, TBuffer &b, const TClass onfile_clas s) const;
	void StreamerTObjectInitialized(void object, TBuffer &b, const TClass onfile_class) const;	void StreamerTObjectInitialized(void object, TBuffer &b, const TClass onfile_class) const;
	void StreamerTObjectEmulated(void object, TBuffer &b, const TClass onf ile_class) const;	void StreamerTObjectEmulated(void object, TBuffer &b, const TClass onf ile_class) const;
	void StreamerInstrumented(void object, TBuffer &b, const TClass onfile _class) const;	void StreamerInstrumented(void object, TBuffer &b, const TClass onfile _class) const;
	void StreamerStreamerInfo(void object, TBuffer &b, const TClass onfile _class) const;	void StreamerStreamerInfo(void object, TBuffer &b, const TClass onfile _class) const;
	void StreamerDefault(void object, TBuffer &b, const TClass onfile_clas s) const;	void StreamerDefault(void object, TBuffer &b, const TClass onfile_clas s) const;


	static IdMap_t *fgIdMap; //Map from typeid to TClass pointer	static IdMap_t *GetIdMap(); //Map from typeid to TClass pointer
	static ENewType fgCallingNew; //Intent of why/how TClass::New() i s called	static ENewType fgCallingNew; //Intent of why/how TClass::New() i s called
	static Int_t fgClassCount; //provides unique id for a each cla ss	static Int_t fgClassCount; //provides unique id for a each cla ss
	//stored in TObject::fUniqueID	//stored in TObject::fUniqueID
	// Internal status bits	// Internal status bits
	enum { kLoading = BIT(14) };	enum { kLoading = BIT(14) };
	// Internal streamer type.	// Internal streamer type.
	enum {kDefault=0, kEmulated=1, kTObject=2, kInstrumented=4, kForeign=8, kExternal=16};	enum {kDefault=0, kEmulated=1, kTObject=2, kInstrumented=4, kForeign=8, kExternal=16};

	// When a new class is created, we need to be able to find	// When a new class is created, we need to be able to find
	// if there are any existing classes that have the same name	// if there are any existing classes that have the same name

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

	TClonesArray.h	TClonesArray.h

	// @(#)root/cont:$Id: TClonesArray.h 33807 2010-06-10 07:23:32Z brun $	// @(#)root/cont:$Id: TClonesArray.h 38515 2011-03-18 16:57:21Z rdm $
	// Author: Rene Brun 11/02/96	// Author: Rene Brun 11/02/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 70	skipping to change at line 70
	void AddAt(TObject *, Int_t) { MayNotUse("AddAt"); }	void AddAt(TObject *, Int_t) { MayNotUse("AddAt"); }
	void AddAtAndExpand(TObject *, Int_t) { MayNotUse("AddAtAndE xpand"); }	void AddAtAndExpand(TObject *, Int_t) { MayNotUse("AddAtAndE xpand"); }
	Int_t AddAtFree(TObject *) { MayNotUse("AddAtFree"); return 0 ; }	Int_t AddAtFree(TObject *) { MayNotUse("AddAtFree"); return 0 ; }
	void AddAfter(const TObject , TObject ) { MayNotUse("AddAf ter"); }	void AddAfter(const TObject , TObject ) { MayNotUse("AddAf ter"); }
	void AddBefore(const TObject , TObject ) { MayNotUse("AddB efore"); }	void AddBefore(const TObject , TObject ) { MayNotUse("AddB efore"); }
	void BypassStreamer(Bool_t bypass=kTRUE);	void BypassStreamer(Bool_t bypass=kTRUE);
	Bool_t CanBypassStreamer() const { return TestBit(kBypassStrea mer); }	Bool_t CanBypassStreamer() const { return TestBit(kBypassStrea mer); }
	void SetClass(const char *classname,Int_t size=1000);	void SetClass(const char *classname,Int_t size=1000);
	void SetClass(const TClass *cl,Int_t size=1000);	void SetClass(const TClass *cl,Int_t size=1000);


	void AbsorbObjects(TClonesArray* tc);	void AbsorbObjects(TClonesArray *tc);
		void AbsorbObjects(TClonesArray *tc, Int_t idx1, Int_t idx2)
		;
	void MultiSort(Int_t nTCs, TClonesArray** tcs, Int_t upto = kMaxInt);	void MultiSort(Int_t nTCs, TClonesArray** tcs, Int_t upto = kMaxInt);
	virtual TObject *RemoveAt(Int_t idx);	virtual TObject *RemoveAt(Int_t idx);
	virtual TObject Remove(TObject obj);	virtual TObject Remove(TObject obj);
	virtual void RemoveRange(Int_t idx1, Int_t idx2);	virtual void RemoveRange(Int_t idx1, Int_t idx2);
	virtual void Sort(Int_t upto = kMaxInt);	virtual void Sort(Int_t upto = kMaxInt);

	TObject *New(Int_t idx);	TObject *New(Int_t idx);
	TObject *AddrAt(Int_t idx);	TObject *AddrAt(Int_t idx);
	TObject *&operator[](Int_t idx);	TObject *&operator[](Int_t idx);
	TObject *operator[](Int_t idx) const;	TObject *operator[](Int_t idx) const;

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

	TEveCalo.h	TEveCalo.h

	// @(#)root/eve:$Id: TEveCalo.h 35074 2010-08-30 15:18:02Z matevz $	// @(#)root/eve:$Id: TEveCalo.h 38721 2011-04-04 13:37:12Z 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 194	skipping to change at line 194
	};	};

	/************************************************************************** /	/************************************************************************** /
	/************************************************************************** /	/************************************************************************** /

	class TEveCalo2D : public TEveCaloViz,	class TEveCalo2D : public TEveCaloViz,
	public TEveProjected	public TEveProjected
	{	{
	friend class TEveCalo2DGL;	friend class TEveCalo2DGL;


		public:
	typedef std::vector<TEveCaloData::vCellId_t*> vBinCells_t;	typedef std::vector<TEveCaloData::vCellId_t*> vBinCells_t;
	typedef std::vector<TEveCaloData::vCellId_t*>::iterator vBinCells_i;	typedef std::vector<TEveCaloData::vCellId_t*>::iterator vBinCells_i;

	private:	private:
	TEveCalo2D(const TEveCalo2D&); // Not implemented	TEveCalo2D(const TEveCalo2D&); // Not implemented
	TEveCalo2D& operator=(const TEveCalo2D&); // Not implemented	TEveCalo2D& operator=(const TEveCalo2D&); // Not implemented

	TEveProjection::EPType_e fOldProjectionType;	TEveProjection::EPType_e fOldProjectionType;
	void CellSelectionChangedInternal(TEveCaloData::vCellId_t& cells, std::v ector<TEveCaloData::vCellId_t*>& cellLists);	void CellSelectionChangedInternal(TEveCaloData::vCellId_t& cells, std::v ector<TEveCaloData::vCellId_t*>& cellLists);


	skipping to change at line 231	skipping to change at line 232
	virtual void SetProjection(TEveProjectionManager* proj, TEveProjectable* model);	virtual void SetProjection(TEveProjectionManager* proj, TEveProjectable* model);
	virtual void UpdateProjection();	virtual void UpdateProjection();
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void CellSelectionChanged();	virtual void CellSelectionChanged();

	virtual void SetScaleAbs(Bool_t);	virtual void SetScaleAbs(Bool_t);

	virtual Float_t GetValToHeight() const;	virtual Float_t GetValToHeight() const;


		const TEveCalo2D::vBinCells_t& GetBinLists() const { return fCellLists;
		}

	ClassDef(TEveCalo2D, 0); // Class for visualization of projected calorim eter event data.	ClassDef(TEveCalo2D, 0); // Class for visualization of projected calorim eter event data.
	};	};
	/************************************************************************** /	/************************************************************************** /
	/************************************************************************** /	/************************************************************************** /

	class TEveCaloLego : public TEveCaloViz	class TEveCaloLego : public TEveCaloViz
	{	{
	friend class TEveCaloLegoGL;	friend class TEveCaloLegoGL;
	friend class TEveCaloLegoOverlay;	friend class TEveCaloLegoOverlay;


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

	TEveProjections.h	TEveProjections.h

	// @(#)root/eve:$Id: TEveProjections.h 35221 2010-09-10 11:46:37Z matevz $	// @(#)root/eve:$Id: TEveProjections.h 38721 2011-04-04 13:37:12Z 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 57	skipping to change at line 57
	};	};

	typedef std::vector<PreScaleEntry_t> vPreScale_t;	typedef std::vector<PreScaleEntry_t> vPreScale_t;
	typedef std::vector<PreScaleEntry_t>::iterator vPreScale_i;	typedef std::vector<PreScaleEntry_t>::iterator vPreScale_i;

	protected:	protected:
	EPType_e fType; // type	EPType_e fType; // type
	EGeoMode_e fGeoMode; // strategy of polygon projection (w hat to try first)	EGeoMode_e fGeoMode; // strategy of polygon projection (w hat to try first)
	TString fName; // name	TString fName; // name


	TEveVector fCenter; // center of distortion	TEveVector fCenter; // center of distortionprivate:
	TEveVector fZeroPosVal; // projected origin (0, 0, 0)
		bool fDisplaceOrigin; // displace point before projection

	Bool_t fUsePreScale; // use pre-scaling	Bool_t fUsePreScale; // use pre-scaling
	vPreScale_t fPreScales[3]; // scaling before the distortion	vPreScale_t fPreScales[3]; // scaling before the distortion

	Float_t fDistortion; // distortion	Float_t fDistortion; // distortion
	Float_t fFixR; // radius from which scaling remains constant	Float_t fFixR; // radius from which scaling remains constant
	Float_t fFixZ; // z-coordinate from which scaling r emains constant	Float_t fFixZ; // z-coordinate from which scaling r emains constant
	Float_t fPastFixRFac; // relative scaling factor beyond fF ixR as 10^x	Float_t fPastFixRFac; // relative scaling factor beyond fF ixR as 10^x
	Float_t fPastFixZFac; // relative scaling factor beyond fF ixZ as 10^x	Float_t fPastFixZFac; // relative scaling factor beyond fF ixZ as 10^x
	Float_t fScaleR; // scale factor to keep projected ra dius at fFixR fixed	Float_t fScaleR; // scale factor to keep projected ra dius at fFixR fixed
	Float_t fScaleZ; // scale factor to keep projected z- coordinate at fFixZ fixed	Float_t fScaleZ; // scale factor to keep projected z- coordinate at fFixZ fixed
	Float_t fPastFixRScale; // relative scaling beyond fFixR	Float_t fPastFixRScale; // relative scaling beyond fFixR
	Float_t fPastFixZScale; // relative scaling beyond fFixZ	Float_t fPastFixZScale; // relative scaling beyond fFixZ
	Float_t fMaxTrackStep; // maximum distance between two poin ts on a track	Float_t fMaxTrackStep; // maximum distance between two poin ts on a track


	TEveVector fLowLimit; // convergence of point +infinity
	TEveVector fUpLimit; // convergence of point -infinity

	void PreScaleVariable(Int_t dim, Float_t& v);	void PreScaleVariable(Int_t dim, Float_t& v);

	public:	public:
	TEveProjection();	TEveProjection();
	virtual ~TEveProjection() {}	virtual ~TEveProjection() {}

	virtual Bool_t Is2D() const = 0;	virtual Bool_t Is2D() const = 0;
	virtual Bool_t Is3D() const = 0;	virtual Bool_t Is3D() const = 0;

	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Flo at_t d, EPProc_e p = kPP_Full) = 0;	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Flo at_t d, EPProc_e p = kPP_Full) = 0;

	skipping to change at line 99	skipping to change at line 97
	void ProjectPointdv(Double_t* v, Float_t d);	void ProjectPointdv(Double_t* v, Float_t d);
	void ProjectVector(TEveVector& v, Float_t d);	void ProjectVector(TEveVector& v, Float_t d);

	void ProjectPointfv(const TEveTrans* t, const Float_t* p , Float_t* v, Float_t d);	void ProjectPointfv(const TEveTrans* t, const Float_t* p , Float_t* v, Float_t d);
	void ProjectPointdv(const TEveTrans* t, const Double_t* p , Double_t* v, Float_t d);	void ProjectPointdv(const TEveTrans* t, const Double_t* p , Double_t* v, Float_t d);
	void ProjectVector(const TEveTrans* t, TEveVector& v, Flo at_t d);	void ProjectVector(const TEveTrans* t, TEveVector& v, Flo at_t d);

	const Char_t* GetName() const { return fName.Data(); }	const Char_t* GetName() const { return fName.Data(); }
	void SetName(const Char_t* txt) { fName = txt; }	void SetName(const Char_t* txt) { fName = txt; }


	virtual void SetCenter(TEveVector& v) { fCenter = v; UpdateLimi	virtual void SetCenter(TEveVector& v) { fCenter = v; }
	t(); }	virtual Float_t* GetProjectedCenter();
	virtual Float_t* GetProjectedCenter() { return fCenter.Arr(); }
		void SetDisplaceOrigin(bool);
		Bool_t GetDisplaceOrigin() const { return fDisplaceOrigin;
		}

	void SetType(EPType_e t) { fType = t; }	void SetType(EPType_e t) { fType = t; }
	EPType_e GetType() const { return fType; }	EPType_e GetType() const { return fType; }

	void SetGeoMode(EGeoMode_e m) { fGeoMode = m; }	void SetGeoMode(EGeoMode_e m) { fGeoMode = m; }
	EGeoMode_e GetGeoMode() const { return fGeoMode; }	EGeoMode_e GetGeoMode() const { return fGeoMode; }


	virtual void UpdateLimit();

	Bool_t GetUsePreScale() const { return fUsePreScale; }	Bool_t GetUsePreScale() const { return fUsePreScale; }
	void SetUsePreScale(Bool_t x) { fUsePreScale = x; }	void SetUsePreScale(Bool_t x) { fUsePreScale = x; }

	void PreScalePoint(Float_t& x, Float_t& y);	void PreScalePoint(Float_t& x, Float_t& y);
	void PreScalePoint(Float_t& x, Float_t& y, Float_t& z);	void PreScalePoint(Float_t& x, Float_t& y, Float_t& z);
	void AddPreScaleEntry(Int_t coord, Float_t max_val, Float_t scale);	void AddPreScaleEntry(Int_t coord, Float_t max_val, Float_t scale);
	void ChangePreScaleEntry(Int_t coord, Int_t entry, Float_t new_scale );	void ChangePreScaleEntry(Int_t coord, Int_t entry, Float_t new_scale );
	void ClearPreScales();	void ClearPreScales();

	void SetDistortion(Float_t d);	void SetDistortion(Float_t d);

	skipping to change at line 140	skipping to change at line 139
	void SetMaxTrackStep(Float_t x) { fMaxTrackStep = TMath::Max(x, 1.0f ); }	void SetMaxTrackStep(Float_t x) { fMaxTrackStep = TMath::Max(x, 1.0f ); }

	virtual Bool_t HasSeveralSubSpaces() const { return kFALSE; }	virtual Bool_t HasSeveralSubSpaces() const { return kFALSE; }
	virtual Bool_t AcceptSegment(TEveVector&, TEveVector&, Float_t /to lerance/) const { return kTRUE; }	virtual Bool_t AcceptSegment(TEveVector&, TEveVector&, Float_t /to lerance/) const { return kTRUE; }
	virtual Int_t SubSpaceId(const TEveVector&) const { return 0; }	virtual Int_t SubSpaceId(const TEveVector&) const { return 0; }
	virtual Bool_t IsOnSubSpaceBoundrary(const TEveVector&) const { ret urn kFALSE; }	virtual Bool_t IsOnSubSpaceBoundrary(const TEveVector&) const { ret urn kFALSE; }
	virtual void BisectBreakPoint(TEveVector& vL, TEveVector& vR, Flo at_t eps_sqr=1e-10f);	virtual void BisectBreakPoint(TEveVector& vL, TEveVector& vR, Flo at_t eps_sqr=1e-10f);
	virtual void SetDirectionalVector(Int_t screenAxis, TEveVector& v ec);	virtual void SetDirectionalVector(Int_t screenAxis, TEveVector& v ec);

	// utils to draw axis	// utils to draw axis

		TEveVector GetOrthogonalCenter(int idx, TEveVector& out);
	virtual Float_t GetValForScreenPos(Int_t ax, Float_t value);	virtual Float_t GetValForScreenPos(Int_t ax, Float_t value);
	virtual Float_t GetScreenVal(Int_t ax, Float_t value);	virtual Float_t GetScreenVal(Int_t ax, Float_t value);

	Float_t GetLimit(Int_t i, Bool_t pos) { return pos ? fUpLimi	Float_t GetScreenVal(Int_t i, Float_t x, TEveVector& dirVec,
	t[i] : fLowLimit[i]; }	TEveVector& oCenter);
		Float_t GetLimit(Int_t i, Bool_t pos);

	static Float_t fgEps; // resolution of projected points	static Float_t fgEps; // resolution of projected points
	static Float_t fgEpsSqr; // square of resolution of projected point s	static Float_t fgEpsSqr; // square of resolution of projected point s

	ClassDef(TEveProjection, 0); // Base for specific classes that implement non-linear projections.	ClassDef(TEveProjection, 0); // Base for specific classes that implement non-linear projections.
	};	};

	//========================================================================= =====	//========================================================================= =====
	// TEveRhoZProjection	// TEveRhoZProjection
	//========================================================================= =====	//========================================================================= =====

	skipping to change at line 168	skipping to change at line 169

	public:	public:
	TEveRhoZProjection();	TEveRhoZProjection();
	virtual ~TEveRhoZProjection() {}	virtual ~TEveRhoZProjection() {}

	virtual Bool_t Is2D() const { return kTRUE; }	virtual Bool_t Is2D() const { return kTRUE; }
	virtual Bool_t Is3D() const { return kFALSE; }	virtual Bool_t Is3D() const { return kFALSE; }

	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Flo at_t d, EPProc_e proc = kPP_Full);	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Flo at_t d, EPProc_e proc = kPP_Full);


	virtual void SetCenter(TEveVector& center);	virtual void SetCenter(TEveVector& v);
	virtual Float_t* GetProjectedCenter() { return fProjectedCenter.Arr() ; }	virtual Float_t* GetProjectedCenter() { return fProjectedCenter.Arr() ; }


	virtual void UpdateLimit();

	virtual Bool_t HasSeveralSubSpaces() const { return kTRUE; }	virtual Bool_t HasSeveralSubSpaces() const { return kTRUE; }
	virtual Bool_t AcceptSegment(TEveVector& v1, TEveVector& v2, Float_ t tolerance) const;	virtual Bool_t AcceptSegment(TEveVector& v1, TEveVector& v2, Float_ t tolerance) const;
	virtual Int_t SubSpaceId(const TEveVector& v) const;	virtual Int_t SubSpaceId(const TEveVector& v) const;
	virtual Bool_t IsOnSubSpaceBoundrary(const TEveVector& v) const;	virtual Bool_t IsOnSubSpaceBoundrary(const TEveVector& v) const;
	virtual void SetDirectionalVector(Int_t screenAxis, TEveVector& v ec);	virtual void SetDirectionalVector(Int_t screenAxis, TEveVector& v ec);

	ClassDef(TEveRhoZProjection, 0); // Rho/Z non-linear projection.	ClassDef(TEveRhoZProjection, 0); // Rho/Z non-linear projection.
	};	};

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

	skipping to change at line 218	skipping to change at line 217
	virtual ~TEve3DProjection() {}	virtual ~TEve3DProjection() {}

	virtual Bool_t Is2D() const { return kFALSE; }	virtual Bool_t Is2D() const { return kFALSE; }
	virtual Bool_t Is3D() const { return kTRUE; }	virtual Bool_t Is3D() const { return kTRUE; }

	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Float_t d, EPProc_e proc = kPP_Full);	virtual void ProjectPoint(Float_t& x, Float_t& y, Float_t& z, Float_t d, EPProc_e proc = kPP_Full);

	ClassDef(TEve3DProjection, 0); // 3D scaling "projection"	ClassDef(TEve3DProjection, 0); // 3D scaling "projection"
	};	};


		// AMT: temporary workaround till root pactches are integrated in CMSSW
		#define TEVEPROJECTIONS_DISPLACE_ORIGIN_MODE

	#endif	#endif

End of changes. 10 change blocks.
	16 lines changed or deleted	18 lines changed or added

	TEventIter.h	TEventIter.h

	// @(#)root/proofplayer:$Id: TEventIter.h 30859 2009-10-24 14:53:07Z ganis $	// @(#)root/proofplayer:$Id: TEventIter.h 38810 2011-04-12 16:22:59Z ganis $
	// Author: Maarten Ballintijn 07/01/02	// Author: Maarten Ballintijn 07/01/02
	// Modified: Long Tran-Thanh 04/09/07 (Addition of TEventIterUnit)	// Modified: Long Tran-Thanh 04/09/07 (Addition of TEventIterUnit)

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2001, 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 82	skipping to change at line 82
	Int_t LoadDir(); // Load the directory pointed to by fElem	Int_t LoadDir(); // Load the directory pointed to by fElem

	public:	public:
	TEventIter();	TEventIter();
	TEventIter(TDSet dset, TSelector sel, Long64_t first, Long64_t num);	TEventIter(TDSet dset, TSelector sel, Long64_t first, Long64_t num);
	virtual ~TEventIter();	virtual ~TEventIter();

	virtual Long64_t GetCacheSize() = 0;	virtual Long64_t GetCacheSize() = 0;
	virtual Int_t GetLearnEntries() = 0;	virtual Int_t GetLearnEntries() = 0;
	virtual Long64_t GetNextEvent() = 0;	virtual Long64_t GetNextEvent() = 0;

		virtual void InvalidatePacket();
	virtual void StopProcess(Bool_t abort);	virtual void StopProcess(Bool_t abort);

	static TEventIter Create(TDSet dset, TSelector *sel, Long64_t first, L ong64_t num);	static TEventIter Create(TDSet dset, TSelector *sel, Long64_t first, L ong64_t num);

	ClassDef(TEventIter,0) // Event iterator used by TProofPlayer's	ClassDef(TEventIter,0) // Event iterator used by TProofPlayer's
	};	};

	//------------------------------------------------------------------------	//------------------------------------------------------------------------

	class TEventIterUnit : public TEventIter {	class TEventIterUnit : public TEventIter {

	skipping to change at line 142	skipping to change at line 143
	class TEventIterTree : public TEventIter {	class TEventIterTree : public TEventIter {

	private:	private:
	TString fTreeName; // name of the tree object to iterate over	TString fTreeName; // name of the tree object to iterate over
	TTree *fTree; // tree we are iterating over	TTree *fTree; // tree we are iterating over
	TTreeCache *fTreeCache; // instance of the tree cache for the tree	TTreeCache *fTreeCache; // instance of the tree cache for the tree
	Bool_t fTreeCacheIsLearning; // Whether cache is in learning phase	Bool_t fTreeCacheIsLearning; // Whether cache is in learning phase
	Bool_t fUseTreeCache; // Control usage of the tree cache	Bool_t fUseTreeCache; // Control usage of the tree cache
	Long64_t fCacheSize; // Cache size	Long64_t fCacheSize; // Cache size
	Bool_t fUseParallelUnzip; // Control usage of parallel unzip	Bool_t fUseParallelUnzip; // Control usage of parallel unzip

		Bool_t fDontCacheFiles; // Control OS caching of read files (Mac Os X only)
	TList *fFileTrees; // Files && Trees currently open	TList *fFileTrees; // Files && Trees currently open

	// Auxilliary class to keep track open files and loaded trees	// Auxilliary class to keep track open files and loaded trees
	class TFileTree : public TNamed {	class TFileTree : public TNamed {
	public:	public:
	Bool_t fUsed;	Bool_t fUsed;
	Bool_t fIsLocal;	Bool_t fIsLocal;
	TFile *fFile;	TFile *fFile;
	TList *fTrees;	TList *fTrees;
	TFileTree(const char name, TFile f, Bool_t islocal);	TFileTree(const char name, TFile f, Bool_t islocal);

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

	TFileCollection.h	TFileCollection.h

	// @(#)root/base:$Id: TFileCollection.h 36629 2010-11-12 14:46:35Z brun $	// @(#)root/base:$Id: TFileCollection.h 38735 2011-04-05 09:41:14Z rdm $
	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07

	/*************************************************************************	/*************************************************************************
	* 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 106	skipping to change at line 106
	Long64_t GetTotalEntries(const char *tree) const;	Long64_t GetTotalEntries(const char *tree) const;

	TFileInfoMeta GetMetaData(const char meta = 0) const;	TFileInfoMeta GetMetaData(const char meta = 0) const;
	void SetDefaultMetaData(const char *meta);	void SetDefaultMetaData(const char *meta);
	Bool_t AddMetaData(TObject *meta);	Bool_t AddMetaData(TObject *meta);
	void RemoveMetaData(const char *meta = 0);	void RemoveMetaData(const char *meta = 0);

	TFileCollection *GetStagedSubset();	TFileCollection *GetStagedSubset();

	TFileCollection GetFilesOnServer(const char server);	TFileCollection GetFilesOnServer(const char server);

	TMap GetFilesPerServer(const char exclude = 0);	TMap GetFilesPerServer(const char exclude = 0, Bool_t curro nly = kFALSE);

	ClassDef(TFileCollection, 3) // Collection of TFileInfo objects	ClassDef(TFileCollection, 3) // Collection of TFileInfo objects
	};	};

	#endif	#endif

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

	TGButton.h	TGButton.h

	// @(#)root/gui:$Id: TGButton.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGButton.h 38844 2011-04-14 12:35:01Z bellenot $
	// Author: Fons Rademakers 06/01/98	// Author: Fons Rademakers 06/01/98

	/*************************************************************************	/*************************************************************************
	* 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_TGButton	#ifndef ROOT_TGButton
	#define ROOT_TGButton	#define ROOT_TGButton

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

	// TGButton, TGTextButton, TGPictureButton, TGCheckButton and //	// TGButton, TGTextButton, TGPictureButton, TGCheckButton TGRadioButton //
	// TGRadioButton //	// and TGSplitButton //
	// //	// //
	// This header defines all GUI button widgets. //	// This header defines all GUI button widgets. //
	// //	// //
	// TGButton is a button abstract base class. It defines general button //	// TGButton is a button abstract base class. It defines general button //
	// behaviour. //	// behaviour. //
	// //	// //
	// Selecting a text or picture button will generate the event: //	// Selecting a text or picture button will generate the event: //
	// kC_COMMAND, kCM_BUTTON, button id, user data. //	// kC_COMMAND, kCM_BUTTON, button id, user data. //
	// //	// //
	// Selecting a check button will generate the event: //	// Selecting a check button will generate the event: //

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

	protected:	protected:
	UInt_t fTWidth; // button width	UInt_t fTWidth; // button width
	UInt_t fTHeight; // button height	UInt_t fTHeight; // button height
	EButtonState fState; // button state	EButtonState fState; // button state
	Bool_t fStayDown; // true if button has to stay down	Bool_t fStayDown; // true if button has to stay down
	GContext_t fNormGC; // graphics context used for drawing button	GContext_t fNormGC; // graphics context used for drawing button
	void *fUserData; // pointer to user data structure	void *fUserData; // pointer to user data structure
	TGToolTip *fTip; // tool tip associated with button	TGToolTip *fTip; // tool tip associated with button
	TGButtonGroup *fGroup; // button group this button belongs to	TGButtonGroup *fGroup; // button group this button belongs to

		Pixel_t fBgndColor; // actual background color
		Pixel_t fHighColor; // highlight color
		UInt_t fStyle; // button style (modern or classic)

	virtual void SetToggleButton(Bool_t) { }	virtual void SetToggleButton(Bool_t) { }
	virtual void EmitSignals(Bool_t wasUp);	virtual void EmitSignals(Bool_t wasUp);

	static const TGGC *fgDefaultGC;	static const TGGC *fgDefaultGC;
	static const TGGC *fgHibckgndGC;	static const TGGC *fgHibckgndGC;

	static Window_t fgReleaseBtn; // the last released button	static Window_t fgReleaseBtn; // the last released button

	private:	private:

	skipping to change at line 116	skipping to change at line 119
	virtual void SetUserData(void *userData) { fUserData = userData; }	virtual void SetUserData(void *userData) { fUserData = userData; }
	virtual void *GetUserData() const { return fUserData; }	virtual void *GetUserData() const { return fUserData; }
	virtual void SetToolTipText(const char text, Long_t delayms = 4 00); //MENU*	virtual void SetToolTipText(const char text, Long_t delayms = 4 00); //MENU*
	virtual TGToolTip *GetToolTip() const { return fTip; }	virtual TGToolTip *GetToolTip() const { return fTip; }
	virtual void SetState(EButtonState state, Bool_t emit = kFALSE);	virtual void SetState(EButtonState state, Bool_t emit = kFALSE);
	virtual EButtonState GetState() const { return fState; }	virtual EButtonState GetState() const { return fState; }
	virtual void AllowStayDown(Bool_t a) { fStayDown = a; }	virtual void AllowStayDown(Bool_t a) { fStayDown = a; }
	virtual void SetGroup(TGButtonGroup *gr);	virtual void SetGroup(TGButtonGroup *gr);
	TGButtonGroup *GetGroup() const { return fGroup; }	TGButtonGroup *GetGroup() const { return fGroup; }


	virtual Bool_t IsDown() const { return !(fOptions & kRaisedFrame); }	virtual Bool_t IsDown() const;// { return !(fOptions & kRaisedFram e); }
	virtual void SetDown(Bool_t on = kTRUE, Bool_t emit = kFALSE);	virtual void SetDown(Bool_t on = kTRUE, Bool_t emit = kFALSE);
	virtual Bool_t IsOn() const { return IsDown(); }	virtual Bool_t IsOn() const { return IsDown(); }
	virtual void SetOn(Bool_t on = kTRUE, Bool_t emit = kFALSE) { S etDown(on, emit); }	virtual void SetOn(Bool_t on = kTRUE, Bool_t emit = kFALSE) { S etDown(on, emit); }
	virtual Bool_t IsToggleButton() const { return kFALSE; }	virtual Bool_t IsToggleButton() const { return kFALSE; }
	virtual Bool_t IsExclusiveToggle() const { return kFALSE; }	virtual Bool_t IsExclusiveToggle() const { return kFALSE; }
	virtual void Toggle(Bool_t emit = kFALSE) { SetDown(IsDown() ? k FALSE : kTRUE, emit); }	virtual void Toggle(Bool_t emit = kFALSE) { SetDown(IsDown() ? k FALSE : kTRUE, emit); }
	virtual void SetEnabled(Bool_t e = kTRUE); //TOGGLE *GETTER=Is Enabled	virtual void SetEnabled(Bool_t e = kTRUE); //TOGGLE *GETTER=Is Enabled

		virtual UInt_t GetStyle() const { return fStyle; }
		virtual void SetStyle(UInt_t newstyle);
		virtual void SetStyle(const char *style);

	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");

	GContext_t GetNormGC() const { return fNormGC; }	GContext_t GetNormGC() const { return fNormGC; }

	virtual void Pressed() { Emit("Pressed()"); } // SIGNAL	virtual void Pressed() { Emit("Pressed()"); } // SIGNAL
	virtual void Released() { Emit("Released()"); } // SIGNAL	virtual void Released() { Emit("Released()"); } // SIGNAL
	virtual void Clicked() { Emit("Clicked()"); } // SIGNAL	virtual void Clicked() { Emit("Clicked()"); } // SIGNAL
	virtual void Toggled(Bool_t on) { Emit("Toggled(Bool_t)", on); } // SI GNAL	virtual void Toggled(Bool_t on) { Emit("Toggled(Bool_t)", on); } // SI GNAL


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

	TGClient.h	TGClient.h

	// @(#)root/gui:$Id: TGClient.h 25391 2008-09-12 12:40:48Z rdm $	// @(#)root/gui:$Id: TGClient.h 38843 2011-04-14 12:13:31Z bellenot $
	// Author: Fons Rademakers 27/12/97	// Author: Fons Rademakers 27/12/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 79	skipping to change at line 79
	TGMimeTypes *fMimeTypeList; // mimetype list	TGMimeTypes *fMimeTypeList; // mimetype list
	Colormap_t fDefaultColormap; // default colormap	Colormap_t fDefaultColormap; // default colormap
	Bool_t fGlobalNeedRedraw; // true if at least one window needs to be redrawn	Bool_t fGlobalNeedRedraw; // true if at least one window needs to be redrawn
	Bool_t fForceRedraw; // redraw widgets as soon as possible	Bool_t fForceRedraw; // redraw widgets as soon as possible
	THashList *fWlist; // list of frames	THashList *fWlist; // list of frames
	TList *fPlist; // list of popup windows used in Hand leMaskEvent()	TList *fPlist; // list of popup windows used in Hand leMaskEvent()
	TList *fUWHandlers; // list of event handlers for unknown windows	TList *fUWHandlers; // list of event handlers for unknown windows
	TList *fIdleHandlers; // list of idle handlers	TList *fIdleHandlers; // list of idle handlers
	EGEventType fWaitForEvent; // event to wait for	EGEventType fWaitForEvent; // event to wait for
	Window_t fWaitForWindow; // window in which to wait for event	Window_t fWaitForWindow; // window in which to wait for event

		UInt_t fStyle; // GUI style (modern or classic)

	TGClient(const TGClient&); // not implemented	TGClient(const TGClient&); // not implemented
	TGClient& operator=(const TGClient&); // not implemented	TGClient& operator=(const TGClient&); // not implemented

	Bool_t ProcessOneEvent();	Bool_t ProcessOneEvent();
	Bool_t ProcessIdleEvent();	Bool_t ProcessIdleEvent();
	Bool_t DoRedraw();	Bool_t DoRedraw();

	public:	public:
	TGClient(const char *dpyName = 0);	TGClient(const char *dpyName = 0);

	skipping to change at line 150	skipping to change at line 151
	TGGCPool *GetGCPool() const { return fGCPool; }	TGGCPool *GetGCPool() const { return fGCPool; }
	TGGC GetGC(GCValues_t values, Bool_t rw = kFALSE);	TGGC GetGC(GCValues_t values, Bool_t rw = kFALSE);
	void FreeGC(const TGGC *gc);	void FreeGC(const TGGC *gc);
	void FreeGC(GContext_t gc);	void FreeGC(GContext_t gc);

	TGFontPool *GetFontPool() const { return fFontPool; }	TGFontPool *GetFontPool() const { return fFontPool; }
	TGFont GetFont(const char font, Bool_t fixedDefault = kTRUE);	TGFont GetFont(const char font, Bool_t fixedDefault = kTRUE);
	TGFont GetFont(const TGFont font);	TGFont GetFont(const TGFont font);
	void FreeFont(const TGFont *font);	void FreeFont(const TGFont *font);


		UInt_t GetStyle() const { return fStyle; }
		void SetStyle(UInt_t newstyle) { fStyle = newstyle; }
		void SetStyle(const char *style);

	Colormap_t GetDefaultColormap() const { return fDefaultColormap; }	Colormap_t GetDefaultColormap() const { return fDefaultColormap; }
	TGMimeTypes *GetMimeTypeList() const { return fMimeTypeList; }	TGMimeTypes *GetMimeTypeList() const { return fMimeTypeList; }

	THashList *GetListOfWindows() const { return fWlist; }	THashList *GetListOfWindows() const { return fWlist; }
	TList *GetListOfPopups() const { return fPlist; }	TList *GetListOfPopups() const { return fPlist; }

	ClassDef(TGClient,0) // Class making connection to display server	ClassDef(TGClient,0) // Class making connection to display server
	};	};

	R__EXTERN TGClient *gClient;	R__EXTERN TGClient *gClient;

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

	TGFrame.h	TGFrame.h

	// @(#)root/gui:$Id: TGFrame.h 25391 2008-09-12 12:40:48Z rdm $	// @(#)root/gui:$Id: TGFrame.h 38064 2011-02-14 13:54:40Z bellenot $
	// Author: Fons Rademakers 03/01/98	// Author: Fons Rademakers 03/01/98

	/*************************************************************************	/*************************************************************************
	* 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 533	skipping to change at line 533
	TGMainFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,	TGMainFrame(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
	UInt_t options = kVerticalFrame);	UInt_t options = kVerticalFrame);
	virtual ~TGMainFrame();	virtual ~TGMainFrame();

	virtual Bool_t HandleKey(Event_t *event);	virtual Bool_t HandleKey(Event_t *event);
	virtual Bool_t HandleClientMessage(Event_t *event);	virtual Bool_t HandleClientMessage(Event_t *event);
	virtual Bool_t HandleSelection(Event_t *event);	virtual Bool_t HandleSelection(Event_t *event);
	virtual Bool_t HandleSelectionRequest(Event_t *event);	virtual Bool_t HandleSelectionRequest(Event_t *event);
	virtual Bool_t HandleButton(Event_t *event);	virtual Bool_t HandleButton(Event_t *event);
	virtual Bool_t HandleMotion(Event_t *event);	virtual Bool_t HandleMotion(Event_t *event);

		virtual Bool_t SaveFrameAsCodeOrImage();
	virtual void SendCloseMessage();	virtual void SendCloseMessage();
	virtual void CloseWindow(); //SIGNAL	virtual void CloseWindow(); //SIGNAL

	void DontCallClose();	void DontCallClose();
	void SetWindowName(const char *name = 0);	void SetWindowName(const char *name = 0);
	void SetIconName(const char *name);	void SetIconName(const char *name);
	const TGPicture SetIconPixmap(const char iconName);	const TGPicture SetIconPixmap(const char iconName);
	void SetIconPixmap(char **xpm_array);	void SetIconPixmap(char **xpm_array);
	void SetClassHints(const char className, const char resourceName);	void SetClassHints(const char className, const char resourceName);
	void SetMWMHints(UInt_t value, UInt_t funcs, UInt_t input);	void SetMWMHints(UInt_t value, UInt_t funcs, UInt_t input);

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

	TGListTree.h	TGListTree.h

	// @(#)root/gui:$Id: TGListTree.h 25229 2008-08-25 15:14:34Z bellenot $	// @(#)root/gui:$Id: TGListTree.h 38753 2011-04-06 13:14:08Z bellenot $
	// Author: Fons Rademakers 25/02/98	// Author: Fons Rademakers 25/02/98

	/*************************************************************************	/*************************************************************************
	* 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 238	skipping to change at line 238
	TGListTreeItem *fFirst; // pointer to first item in list	TGListTreeItem *fFirst; // pointer to first item in list
	TGListTreeItem *fLast; // pointer to last item in list	TGListTreeItem *fLast; // pointer to last item in list
	TGListTreeItem *fSelected; // pointer to selected item in list	TGListTreeItem *fSelected; // pointer to selected item in list
	TGListTreeItem *fCurrent; // pointer to current item in list	TGListTreeItem *fCurrent; // pointer to current item in list
	TGListTreeItem *fBelowMouse; // pointer to item below mouses cursor	TGListTreeItem *fBelowMouse; // pointer to item below mouses cursor
	Int_t fHspacing; // horizontal spacing between items	Int_t fHspacing; // horizontal spacing between items
	Int_t fVspacing; // vertical spacing between items	Int_t fVspacing; // vertical spacing between items
	Int_t fIndent; // number of pixels indentation	Int_t fIndent; // number of pixels indentation
	Int_t fMargin; // number of pixels margin from left s ide	Int_t fMargin; // number of pixels margin from left s ide
	Pixel_t fGrayPixel; // gray draw color	Pixel_t fGrayPixel; // gray draw color

		GContext_t fActiveGC; // activated (selected) drawing contex t
	GContext_t fDrawGC; // icon drawing context	GContext_t fDrawGC; // icon drawing context
	GContext_t fLineGC; // dashed line drawing context	GContext_t fLineGC; // dashed line drawing context
	GContext_t fHighlightGC; // highlighted icon drawing context	GContext_t fHighlightGC; // highlighted icon drawing context
	FontStruct_t fFont; // font used to draw item text	FontStruct_t fFont; // font used to draw item text
	UInt_t fDefw; // default list width	UInt_t fDefw; // default list width
	UInt_t fDefh; // default list height	UInt_t fDefh; // default list height
	Int_t fExposeTop; // top y postion of visible region	Int_t fExposeTop; // top y postion of visible region
	Int_t fExposeBottom; // bottom y position of visible region	Int_t fExposeBottom; // bottom y position of visible region
	TGToolTip *fTip; // tooltip shown when moving over list items	TGToolTip *fTip; // tooltip shown when moving over list items
	TGListTreeItem *fTipItem; // item for which tooltip is set	TGListTreeItem *fTipItem; // item for which tooltip is set

	skipping to change at line 265	skipping to change at line 266
	Bool_t fUserControlled; // let user decides what is the behavi our on events	Bool_t fUserControlled; // let user decides what is the behavi our on events
	Bool_t fEventHandled; // flag used from user code to bypass standard event handling	Bool_t fEventHandled; // flag used from user code to bypass standard event handling
	UInt_t fLastEventState; // modifier state of the last keyboard event	UInt_t fLastEventState; // modifier state of the last keyboard event

	EColorMarkupMode fColorMode; // if/how to render item's main color	EColorMarkupMode fColorMode; // if/how to render item's main color
	ECheckMode fCheckMode; // how to propagate check properties t hrough the tree	ECheckMode fCheckMode; // how to propagate check properties t hrough the tree
	GContext_t fColorGC; // drawing context for main item color	GContext_t fColorGC; // drawing context for main item color

	static Pixel_t fgGrayPixel;	static Pixel_t fgGrayPixel;
	static const TGFont *fgDefaultFont;	static const TGFont *fgDefaultFont;

		static TGGC *fgActiveGC;
	static TGGC *fgDrawGC;	static TGGC *fgDrawGC;
	static TGGC *fgLineGC;	static TGGC *fgLineGC;
	static TGGC *fgHighlightGC;	static TGGC *fgHighlightGC;
	static TGGC *fgColorGC;	static TGGC *fgColorGC;
	static const TGPicture *fgOpenPic; // icon for open item	static const TGPicture *fgOpenPic; // icon for open item
	static const TGPicture *fgClosedPic; // icon for closed item	static const TGPicture *fgClosedPic; // icon for closed item
	static const TGPicture *fgCheckedPic; // icon for checked item	static const TGPicture *fgCheckedPic; // icon for checked item
	static const TGPicture *fgUncheckedPic; // icon for unchecked item	static const TGPicture *fgUncheckedPic; // icon for unchecked item

	static Pixel_t GetGrayPixel();	static Pixel_t GetGrayPixel();
	static FontStruct_t GetDefaultFontStruct();	static FontStruct_t GetDefaultFontStruct();

		static const TGGC &GetActiveGC();
	static const TGGC &GetDrawGC();	static const TGGC &GetDrawGC();
	static const TGGC &GetLineGC();	static const TGGC &GetLineGC();
	static const TGGC &GetHighlightGC();	static const TGGC &GetHighlightGC();
	static const TGGC &GetColorGC();	static const TGGC &GetColorGC();

	void Draw(Handle_t id, Int_t yevent, Int_t hevent);	void Draw(Handle_t id, Int_t yevent, Int_t hevent);
	void Draw(Option_t * ="") { MayNotUse("Draw(Option_t*)"); }	void Draw(Option_t * ="") { MayNotUse("Draw(Option_t*)"); }
	Int_t DrawChildren(Handle_t id, TGListTreeItem *item, Int_t x, Int_t y, Int_t xroot);	Int_t DrawChildren(Handle_t id, TGListTreeItem *item, Int_t x, Int_t y, Int_t xroot);
	void DrawItem(Handle_t id, TGListTreeItem item, Int_t x, Int_t y, Int_ t xroot,	void DrawItem(Handle_t id, TGListTreeItem item, Int_t x, Int_t y, Int_ t xroot,
	UInt_t retwidth, UInt_t retheight);	UInt_t retwidth, UInt_t retheight);

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

	TGResourcePool.h	TGResourcePool.h

	// @(#)root/gui:$Id: TGResourcePool.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGResourcePool.h 38843 2011-04-14 12:13:31Z bellenot $
	// Author: Fons Rademakers 19/5/2003	// Author: Fons Rademakers 19/5/2003

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, 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 44	skipping to change at line 44
	class TGPicture;	class TGPicture;
	class TGMimeTypes;	class TGMimeTypes;

	class TGResourcePool : public TGObject {	class TGResourcePool : public TGObject {

	private:	private:
	Pixel_t fBackColor; // default background color	Pixel_t fBackColor; // default background color
	Pixel_t fForeColor; // default foreground color	Pixel_t fForeColor; // default foreground color
	Pixel_t fHilite; // default hilite color	Pixel_t fHilite; // default hilite color
	Pixel_t fShadow; // default shadow color	Pixel_t fShadow; // default shadow color

		Pixel_t fHighLightColor; // highlight color
	Pixel_t fSelBackColor; // default selection background colo r	Pixel_t fSelBackColor; // default selection background colo r
	Pixel_t fSelForeColor; // default selection foreground colo r	Pixel_t fSelForeColor; // default selection foreground colo r
	Pixel_t fDocBackColor; // default document background color	Pixel_t fDocBackColor; // default document background color
	Pixel_t fDocForeColor; // default document foreground color	Pixel_t fDocForeColor; // default document foreground color
	Pixel_t fTipBackColor; // default tip background color	Pixel_t fTipBackColor; // default tip background color
	Pixel_t fTipForeColor; // default tip foreground color	Pixel_t fTipForeColor; // default tip foreground color
	Pixel_t fWhite; // white color index	Pixel_t fWhite; // white color index
	Pixel_t fBlack; // black color index	Pixel_t fBlack; // black color index

	TGFontPool *fFontPool; // font pool manager	TGFontPool *fFontPool; // font pool manager

	skipping to change at line 117	skipping to change at line 118
	// Color values...	// Color values...

	Pixel_t GetWhiteColor() const { return fWhite; }	Pixel_t GetWhiteColor() const { return fWhite; }
	Pixel_t GetBlackColor() const { return fBlack; }	Pixel_t GetBlackColor() const { return fBlack; }

	Pixel_t GetFrameFgndColor() const { return fForeColor; }	Pixel_t GetFrameFgndColor() const { return fForeColor; }
	Pixel_t GetFrameBgndColor() const { return fBackColor; }	Pixel_t GetFrameBgndColor() const { return fBackColor; }
	Pixel_t GetFrameHiliteColor() const { return fHilite; }	Pixel_t GetFrameHiliteColor() const { return fHilite; }
	Pixel_t GetFrameShadowColor() const { return fShadow; }	Pixel_t GetFrameShadowColor() const { return fShadow; }


		Pixel_t GetHighLightColor() const { return fHighLightColor; }

	Pixel_t GetDocumentFgndColor() const { return fDocForeColor; }	Pixel_t GetDocumentFgndColor() const { return fDocForeColor; }
	Pixel_t GetDocumentBgndColor() const { return fDocBackColor; }	Pixel_t GetDocumentBgndColor() const { return fDocBackColor; }

	Pixel_t GetSelectedFgndColor() const { return fSelForeColor; }	Pixel_t GetSelectedFgndColor() const { return fSelForeColor; }
	Pixel_t GetSelectedBgndColor() const { return fSelBackColor; }	Pixel_t GetSelectedBgndColor() const { return fSelBackColor; }

	Pixel_t GetTipFgndColor() const { return fTipForeColor; }	Pixel_t GetTipFgndColor() const { return fTipForeColor; }
	Pixel_t GetTipBgndColor() const { return fTipBackColor; }	Pixel_t GetTipBgndColor() const { return fTipBackColor; }

	// Fonts...	// Fonts...

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

	TGScrollBar.h	TGScrollBar.h

	// @(#)root/gui:$Id: TGScrollBar.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGScrollBar.h 38845 2011-04-14 12:47:50Z bellenot $
	// Author: Fons Rademakers 10/01/98	// Author: Fons Rademakers 10/01/98

	/*************************************************************************	/*************************************************************************
	* 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

	class TTimer;	class TTimer;

	class TGScrollBarElement : public TGFrame {	class TGScrollBarElement : public TGFrame {

	private:	private:
	TGScrollBarElement(const TGScrollBarElement&); // Not implemented	TGScrollBarElement(const TGScrollBarElement&); // Not implemented
	TGScrollBarElement& operator=(const TGScrollBarElement&); // Not impleme nted	TGScrollBarElement& operator=(const TGScrollBarElement&); // Not impleme nted

	protected:	protected:

	Int_t fState; // state of scrollbar element (button up or do	Int_t fState; // state of scrollbar element (button up o
	wn)	r down)
	const TGPicture *fPic; // picture in scrollbar element	const TGPicture *fPic; // picture in scrollbar element
	const TGPicture *fPicN; // picture for normal state of scrollbar eleme	const TGPicture *fPicN; // picture for normal state of scrollbar e
	nt	lement
	const TGPicture *fPicD; // picture for disabled state of scrollbar ele	const TGPicture *fPicD; // picture for disabled state of scrollbar
	ment	element
		Pixel_t fBgndColor; // background color
		Pixel_t fHighColor; // highlight color
		Int_t fStyle; // modern or classic style

	public:	public:
	TGScrollBarElement(const TGWindow p = 0, const TGPicture pic = 0,	TGScrollBarElement(const TGWindow p = 0, const TGPicture pic = 0,
	UInt_t w = 1, UInt_t h = 1,	UInt_t w = 1, UInt_t h = 1,
	UInt_t options = kRaisedFrame \| kDoubleBorder,	UInt_t options = kRaisedFrame \| kDoubleBorder,
	Pixel_t back = GetDefaultFrameBackground());	Pixel_t back = GetDefaultFrameBackground());
	virtual ~TGScrollBarElement();	virtual ~TGScrollBarElement();

	virtual void SetState(Int_t state);	virtual void SetState(Int_t state);
	virtual void DrawBorder();	virtual void DrawBorder();
	virtual void SetEnabled(Bool_t on = kTRUE);	virtual void SetEnabled(Bool_t on = kTRUE);
	virtual Bool_t IsEnabled() const { return !(fState & kButtonDisabled); }	virtual Bool_t IsEnabled() const { return !(fState & kButtonDisabled); }

		virtual Bool_t HandleCrossing(Event_t *event);

	ClassDef(TGScrollBarElement,0) // Scrollbar element (head, tail, slider )	ClassDef(TGScrollBarElement,0) // Scrollbar element (head, tail, slider )
	};	};

	class TGScrollBar : public TGFrame, public TGWidget {	class TGScrollBar : public TGFrame, public TGWidget {

	private:	private:
	TGScrollBar(const TGScrollBar&); // Not implemented	TGScrollBar(const TGScrollBar&); // Not implemented
	TGScrollBar& operator=(const TGScrollBar&); // Not implemented	TGScrollBar& operator=(const TGScrollBar&); // Not implemented


	skipping to change at line 99	skipping to change at line 103
	Int_t fSliderRange; // logical slider range	Int_t fSliderRange; // logical slider range
	Int_t fSmallInc; // Small Increment in the sliding al gorithm	Int_t fSmallInc; // Small Increment in the sliding al gorithm
	TGScrollBarElement *fHead; // head button of scrollbar	TGScrollBarElement *fHead; // head button of scrollbar
	TGScrollBarElement *fTail; // tail button of scrollbar	TGScrollBarElement *fTail; // tail button of scrollbar
	TGScrollBarElement *fSlider; // slider	TGScrollBarElement *fSlider; // slider
	const TGPicture *fHeadPic; // picture in head (up or left arrow )	const TGPicture *fHeadPic; // picture in head (up or left arrow )
	const TGPicture *fTailPic; // picture in tail (down or right ar row)	const TGPicture *fTailPic; // picture in tail (down or right ar row)
	TTimer *fRepeat; // repeat rate timer (when mouse sta ys pressed)	TTimer *fRepeat; // repeat rate timer (when mouse sta ys pressed)
	Window_t fSubw; // sub window in which mouse is pres sed	Window_t fSubw; // sub window in which mouse is pres sed
	Bool_t fAccelerated; // kFALSE - normal, kTRUE - accelera ted	Bool_t fAccelerated; // kFALSE - normal, kTRUE - accelera ted

		Pixel_t fBgndColor; // background color
		Pixel_t fHighColor; // highlight color

	static Pixmap_t fgBckgndPixmap;	static Pixmap_t fgBckgndPixmap;
	static Int_t fgScrollBarWidth;	static Int_t fgScrollBarWidth;

	public:	public:
	static Pixmap_t GetBckgndPixmap();	static Pixmap_t GetBckgndPixmap();
	static Int_t GetScrollBarWidth();	static Int_t GetScrollBarWidth();

	TGScrollBar(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,	TGScrollBar(const TGWindow *p = 0, UInt_t w = 1, UInt_t h = 1,
	UInt_t options = kChildFrame,	UInt_t options = kChildFrame,
	Pixel_t back = GetDefaultFrameBackground());	Pixel_t back = GetDefaultFrameBackground());
	virtual ~TGScrollBar();	virtual ~TGScrollBar();

	void GrabPointer(Bool_t grab) { fGrabPointer = grab; }	void GrabPointer(Bool_t grab) { fGrabPointer = grab; }

	virtual void DrawBorder() { }	virtual void DrawBorder() { }
	virtual Bool_t HandleButton(Event_t *event) = 0;	virtual Bool_t HandleButton(Event_t *event) = 0;

		virtual Bool_t HandleCrossing(Event_t *event);
	virtual Bool_t HandleMotion(Event_t *event) = 0;	virtual Bool_t HandleMotion(Event_t *event) = 0;
	virtual Bool_t HandleTimer(TTimer *t);	virtual Bool_t HandleTimer(TTimer *t);
	virtual void Layout() = 0;	virtual void Layout() = 0;

	virtual void SetRange(Int_t range, Int_t page_size) = 0;	virtual void SetRange(Int_t range, Int_t page_size) = 0;
	virtual void SetPosition(Int_t pos) = 0;	virtual void SetPosition(Int_t pos) = 0;
	virtual Int_t GetPosition() const { return fPos; }	virtual Int_t GetPosition() const { return fPos; }
	virtual Int_t GetPageSize() const { return fPsize; }	virtual Int_t GetPageSize() const { return fPsize; }
	virtual Int_t GetRange() const { return fRange; }	virtual Int_t GetRange() const { return fRange; }
	virtual void Resize(UInt_t w = 0, UInt_t h = 0) { TGFrame::Resize(w, h) ; SetRange(fRange, fPsize); }	virtual void Resize(UInt_t w = 0, UInt_t h = 0) { TGFrame::Resize(w, h) ; SetRange(fRange, fPsize); }

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

	TGeoNavigator.h	TGeoNavigator.h

	// @(#)root/geom:$Id: TGeoNavigator.h 31002 2009-11-06 09:27:30Z brun $	// @(#)root/geom:$Id: TGeoNavigator.h 38790 2011-04-10 07:55:05Z agheata $
	// Author: Mihaela Gheata 30/05/07	// Author: Mihaela Gheata 30/05/07

	/*************************************************************************	/*************************************************************************
	* 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 151	skipping to change at line 151
	Bool_t IsStepExiting() const {return fIsStepExiti ng;}	Bool_t IsStepExiting() const {return fIsStepExiti ng;}
	Bool_t IsOutside() const {return fIsOutside;}	Bool_t IsOutside() const {return fIsOutside;}
	Bool_t IsOnBoundary() const {return fIsOnBoundar y;}	Bool_t IsOnBoundary() const {return fIsOnBoundar y;}
	Bool_t IsNullStep() const {return fIsNullStep; }	Bool_t IsNullStep() const {return fIsNullStep; }
	void SetCheckingOverlaps(Bool_t flag=kTRUE) {fSearchOv erlaps = flag;}	void SetCheckingOverlaps(Bool_t flag=kTRUE) {fSearchOv erlaps = flag;}
	void SetOutside(Bool_t flag=kTRUE) {fIsOutside = flag; }	void SetOutside(Bool_t flag=kTRUE) {fIsOutside = flag; }
	//--- modeler state getters/setters	//--- modeler state getters/setters
	void DoBackupState();	void DoBackupState();
	void DoRestoreState();	void DoRestoreState();
	Int_t GetNodeId() const {return fCache->GetNo deId();}	Int_t GetNodeId() const {return fCache->GetNo deId();}

		Int_t GetNextDaughterIndex() const {return fNextDaughte rIndex;}
	TGeoNode *GetNextNode() const {return fNextNode;}	TGeoNode *GetNextNode() const {return fNextNode;}
	TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMo ther(up);}	TGeoNode *GetMother(Int_t up=1) const {return fCache->GetMo ther(up);}
	TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return fCache- >GetMotherMatrix(up);}	TGeoHMatrix *GetMotherMatrix(Int_t up=1) const {return fCache- >GetMotherMatrix(up);}
	TGeoHMatrix *GetHMatrix();	TGeoHMatrix *GetHMatrix();
	TGeoHMatrix *GetCurrentMatrix() const {return fCache->GetCu rrentMatrix();}	TGeoHMatrix *GetCurrentMatrix() const {return fCache->GetCu rrentMatrix();}
	TGeoNode *GetCurrentNode() const {return fCurrentNode; }	TGeoNode *GetCurrentNode() const {return fCurrentNode; }
	Int_t GetCurrentNodeId() const {return fCache->GetCu rrentNodeId();}	Int_t GetCurrentNodeId() const {return fCache->GetCu rrentNodeId();}
	const Double_t *GetCurrentPoint() const {return fPoint;}	const Double_t *GetCurrentPoint() const {return fPoint;}
	const Double_t *GetCurrentDirection() const {return fDirection;}	const Double_t *GetCurrentDirection() const {return fDirection;}
	TGeoVolume *GetCurrentVolume() const {return fCurrentNode->Ge tVolume();}	TGeoVolume *GetCurrentVolume() const {return fCurrentNode->Ge tVolume();}

	skipping to change at line 178	skipping to change at line 179
	void SetCurrentPoint(const Double_t point) {memcpy(fP oint,point,3sizeof(Double_t));}	void SetCurrentPoint(const Double_t point) {memcpy(fP oint,point,3sizeof(Double_t));}
	void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {	void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {
	fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}	fPoint[0]=x; fPoint[1]=y; fPoint[2]=z;}
	void SetLastPoint(Double_t x, Double_t y, Double_t z) {	void SetLastPoint(Double_t x, Double_t y, Double_t z) {
	fLastPoint[0]=x; fLastPoint[1]=y; fLast Point[2]=z;}	fLastPoint[0]=x; fLastPoint[1]=y; fLast Point[2]=z;}
	void SetCurrentDirection(const Double_t dir) {memcpy( fDirection,dir,3sizeof(Double_t));}	void SetCurrentDirection(const Double_t dir) {memcpy( fDirection,dir,3sizeof(Double_t));}
	void SetCurrentDirection(Double_t nx, Double_t ny, Dou ble_t nz) {	void SetCurrentDirection(Double_t nx, Double_t ny, Dou ble_t nz) {
	fDirection[0]=nx; fDirection[1]=ny; fDi rection[2]=nz;}	fDirection[0]=nx; fDirection[1]=ny; fDi rection[2]=nz;}
	// void SetNormalChecked(Double_t norm) {fNormalChecked =norm;}	// void SetNormalChecked(Double_t norm) {fNormalChecked =norm;}
	void SetCldirChecked(Double_t dir) {memcpy(fCldirChec ked, dir, 3sizeof(Double_t));}	void SetCldirChecked(Double_t dir) {memcpy(fCldirChec ked, dir, 3sizeof(Double_t));}

		void SetLastSafetyForPoint(Double_t safe, const Double _t point) {fLastSafety=safe; memcpy(fLastPoint,point,3sizeof(Double_t));}

	//--- point/vector reference frame conversion	//--- point/vector reference frame conversion
	void LocalToMaster(const Double_t local, Double_t ma ster) const {fCache->LocalToMaster(local, master);}	void LocalToMaster(const Double_t local, Double_t ma ster) const {fCache->LocalToMaster(local, master);}
	void LocalToMasterVect(const Double_t local, Double_t master) const {fCache->LocalToMasterVect(local, master);}	void LocalToMasterVect(const Double_t local, Double_t master) const {fCache->LocalToMasterVect(local, master);}
	void LocalToMasterBomb(const Double_t local, Double_t master) const {fCache->LocalToMasterBomb(local, master);}	void LocalToMasterBomb(const Double_t local, Double_t master) const {fCache->LocalToMasterBomb(local, master);}
	void MasterToLocal(const Double_t master, Double_t l ocal) const {fCache->MasterToLocal(master, local);}	void MasterToLocal(const Double_t master, Double_t l ocal) const {fCache->MasterToLocal(master, local);}
	void MasterToLocalVect(const Double_t master, Double_ t local) const {fCache->MasterToLocalVect(master, local);}	void MasterToLocalVect(const Double_t master, Double_ t local) const {fCache->MasterToLocalVect(master, local);}
	void MasterToLocalBomb(const Double_t master, Double_ t local) const {fCache->MasterToLocalBomb(master, local);}	void MasterToLocalBomb(const Double_t master, Double_ t local) const {fCache->MasterToLocalBomb(master, local);}
	void MasterToTop(const Double_t master, Double_t top ) const;	void MasterToTop(const Double_t master, Double_t top ) const;
	void TopToMaster(const Double_t top, Double_t master ) const;	void TopToMaster(const Double_t top, Double_t master ) const;

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