ROOT: headers diff between 5.34.09 and 5.34.10 versions

	Channel.h	Channel.h

	skipping to change at line 33	skipping to change at line 33
	namespace HistFactory {	namespace HistFactory {

	class Channel {	class Channel {

	public:	public:
	friend class Measurement;	friend class Measurement;

	Channel();	Channel();
	Channel(std::string Name, std::string InputFile="");	Channel(std::string Name, std::string InputFile="");


		// set name of channel
	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }

		// get name of channel
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

		// set name of input file containing histograms
	void SetInputFile( const std::string& file ) { fInputFile = file; }	void SetInputFile( const std::string& file ) { fInputFile = file; }

		// get name of input file
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

		// set path for histograms in input file
	void SetHistoPath( const std::string& file ) { fHistoPath = file; }	void SetHistoPath( const std::string& file ) { fHistoPath = file; }

		// get path to histograms in input file
	std::string GetHistoPath() { return fHistoPath; }	std::string GetHistoPath() { return fHistoPath; }


		// set data object
	void SetData( const RooStats::HistFactory::Data& data ) { fData = data; }	void SetData( const RooStats::HistFactory::Data& data ) { fData = data; }
	void SetData( std::string HistoName, std::string InputFile, std::string H istoPath="" );	void SetData( std::string HistoName, std::string InputFile, std::string H istoPath="" );
	void SetData( double Val );	void SetData( double Val );
	void SetData( TH1* hData );	void SetData( TH1* hData );

		// get data object
	RooStats::HistFactory::Data& GetData() { return fData; }	RooStats::HistFactory::Data& GetData() { return fData; }


		// add additional data object
	void AddAdditionalData( const RooStats::HistFactory::Data& data ) { fAddi tionalData.push_back(data); }	void AddAdditionalData( const RooStats::HistFactory::Data& data ) { fAddi tionalData.push_back(data); }

		// retrieve vector of additional data objects
	std::vector<RooStats::HistFactory::Data>& GetAdditionalData() { return fA dditionalData; }	std::vector<RooStats::HistFactory::Data>& GetAdditionalData() { return fA dditionalData; }

	void SetStatErrorConfig( double RelErrorThreshold, Constraint::Type Const raintType );	void SetStatErrorConfig( double RelErrorThreshold, Constraint::Type Const raintType );
	void SetStatErrorConfig( double RelErrorThreshold, std::string Constraint Type );	void SetStatErrorConfig( double RelErrorThreshold, std::string Constraint Type );

		// define treatment of statistical uncertainties
	void SetStatErrorConfig( RooStats::HistFactory::StatErrorConfig Config ) { fStatErrorConfig = Config; }	void SetStatErrorConfig( RooStats::HistFactory::StatErrorConfig Config ) { fStatErrorConfig = Config; }

		// get information about threshold for statistical uncertainties and cons traint term
	HistFactory::StatErrorConfig& GetStatErrorConfig() { return fStatErrorCon fig; }	HistFactory::StatErrorConfig& GetStatErrorConfig() { return fStatErrorCon fig; }

	void AddSample( RooStats::HistFactory::Sample sample );	void AddSample( RooStats::HistFactory::Sample sample );

		// get vector of samples for this channel
	std::vector< RooStats::HistFactory::Sample >& GetSamples() { return fSamp les; }	std::vector< RooStats::HistFactory::Sample >& GetSamples() { return fSamp les; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);
	void PrintXML( std::string Directory, std::string Prefix="" );	void PrintXML( std::string Directory, std::string Prefix="" );

	void CollectHistograms();	void CollectHistograms();
	bool CheckHistograms();	bool CheckHistograms();

	protected:	protected:


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

	CholeskyDecomp.h	CholeskyDecomp.h

	skipping to change at line 19	skipping to change at line 19
	* routines for use with ROOT's SMatrix classes (symmetric positive	* routines for use with ROOT's SMatrix classes (symmetric positive
	* definite case)	* definite case)
	*	*
	* @author Manuel Schiller	* @author Manuel Schiller
	* @date Aug 29 2008	* @date Aug 29 2008
	* initial release inside LHCb	* initial release inside LHCb
	* @date May 7 2009	* @date May 7 2009
	* factored code to provide a nice Cholesky decomposition class, along	* factored code to provide a nice Cholesky decomposition class, along
	* with separate methods for solving a single linear system and to	* with separate methods for solving a single linear system and to
	* obtain the inverse matrix from the decomposition	* obtain the inverse matrix from the decomposition

		* @data July 15th 2013
		* provide a version of that class which works if the dimension of the
		* problem is only known at run time
	*/	*/

	#include <cmath>	#include <cmath>
	#include <algorithm>	#include <algorithm>

	namespace ROOT {	namespace ROOT {

	namespace Math {	namespace Math {

	/// helpers for CholeskyDecomp	/// helpers for CholeskyDecomp
	namespace CholeskyDecompHelpers {	namespace CholeskyDecompHelpers {
	// forward decls	// forward decls

		template<class F, class M> struct _decomposerGenDim;
	template<class F, unsigned N, class M> struct _decomposer;	template<class F, unsigned N, class M> struct _decomposer;

		template<class F, class M> struct _inverterGenDim;
	template<class F, unsigned N, class M> struct _inverter;	template<class F, unsigned N, class M> struct _inverter;

		template<class F, class V> struct _solverGenDim;
	template<class F, unsigned N, class V> struct _solver;	template<class F, unsigned N, class V> struct _solver;

		template<typename G> class PackedArrayAdapter;
	}	}

	/// class to compute the Cholesky decomposition of a matrix	/// class to compute the Cholesky decomposition of a matrix
	/** class to compute the Cholesky decomposition of a symmetric	/** class to compute the Cholesky decomposition of a symmetric
	* positive definite matrix	* positive definite matrix
	*	*
	* provides routines to check if the decomposition succeeded (i.e. if	* provides routines to check if the decomposition succeeded (i.e. if
	* matrix is positive definite and non-singular), to solve a linear	* matrix is positive definite and non-singular), to solve a linear
	* system for the given matrix and to obtain its inverse	* system for the given matrix and to obtain its inverse
	*	*

	skipping to change at line 75	skipping to change at line 82
	*/	*/
	template<class F, unsigned N> class CholeskyDecomp	template<class F, unsigned N> class CholeskyDecomp
	{	{
	private:	private:
	/// lower triangular matrix L	/// lower triangular matrix L
	/** lower triangular matrix L, packed storage, with diagonal	/** lower triangular matrix L, packed storage, with diagonal
	* elements pre-inverted */	* elements pre-inverted */
	F fL[N * (N + 1) / 2];	F fL[N * (N + 1) / 2];
	/// flag indicating a successful decomposition	/// flag indicating a successful decomposition
	bool fOk;	bool fOk;

	/// adapter for packed arrays (to SMatrix indexing conventions)
	template<typename G> class PackedArrayAdapter
	{
	private:
	G* fArr; ///< pointer to first array element
	public:
	/// constructor
	PackedArrayAdapter(G* arr) : fArr(arr) {}
	/// read access to elements (make sure that j <= i)
	const G operator()(unsigned i, unsigned j) const
	{ return fArr[((i * (i + 1)) / 2) + j]; }
	/// write access to elements (make sure that j <= i)
	G& operator()(unsigned i, unsigned j)
	{ return fArr[((i * (i + 1)) / 2) + j]; }
	};
	public:	public:
	/// perform a Cholesky decomposition	/// perform a Cholesky decomposition
	/** perfrom a Cholesky decomposition of a symmetric positive	/** perfrom a Cholesky decomposition of a symmetric positive
	* definite matrix m	* definite matrix m
	*	*
	* this is the constructor to uses with an SMatrix (and objects	* this is the constructor to uses with an SMatrix (and objects
	* that behave like an SMatrix in terms of using	* that behave like an SMatrix in terms of using
	* operator()(int i, int j) for access to elements)	* operator()(int i, int j) for access to elements)
	*/	*/
	template<class M> CholeskyDecomp(const M& m) :	template<class M> CholeskyDecomp(const M& m) :

	skipping to change at line 121	skipping to change at line 113
	* plain arrays are used	* plain arrays are used
	*	*
	* NOTE: the matrix is given in packed representation, matrix	* NOTE: the matrix is given in packed representation, matrix
	* element m(i,j) (j <= i) is supposed to be in array element	* element m(i,j) (j <= i) is supposed to be in array element
	* (i * (i + 1)) / 2 + j	* (i * (i + 1)) / 2 + j
	*/	*/
	template<typename G> CholeskyDecomp(G* m) :	template<typename G> CholeskyDecomp(G* m) :
	fL(), fOk(false)	fL(), fOk(false)
	{	{
	using CholeskyDecompHelpers::_decomposer;	using CholeskyDecompHelpers::_decomposer;

		using CholeskyDecompHelpers::PackedArrayAdapter;
	fOk = _decomposer<F, N, PackedArrayAdapter<G> >()(	fOk = _decomposer<F, N, PackedArrayAdapter<G> >()(
	fL, PackedArrayAdapter<G>(m));	fL, PackedArrayAdapter<G>(m));
	}	}

	/// returns true if decomposition was successful	/// returns true if decomposition was successful
	/** @returns true if decomposition was successful */	/** @returns true if decomposition was successful */
	bool ok() const { return fOk; }	bool ok() const { return fOk; }
	/// returns true if decomposition was successful	/// returns true if decomposition was successful
	/** @returns true if decomposition was successful */	/** @returns true if decomposition was successful */
	operator bool() const { return fOk; }	operator bool() const { return fOk; }

	skipping to change at line 174	skipping to change at line 167
	*	*
	* @returns if the decomposition was successful	* @returns if the decomposition was successful
	*	*
	* NOTE: the matrix is given in packed representation, matrix	* NOTE: the matrix is given in packed representation, matrix
	* element m(i,j) (j <= i) is supposed to be in array element	* element m(i,j) (j <= i) is supposed to be in array element
	* (i * (i + 1)) / 2 + j	* (i * (i + 1)) / 2 + j
	*/	*/
	template<typename G> bool Invert(G* m) const	template<typename G> bool Invert(G* m) const
	{	{
	using CholeskyDecompHelpers::_inverter;	using CholeskyDecompHelpers::_inverter;

		using CholeskyDecompHelpers::PackedArrayAdapter;
	if (fOk) {	if (fOk) {
	PackedArrayAdapter<G> adapted(m);	PackedArrayAdapter<G> adapted(m);
	_inverter<F,N,PackedArrayAdapter<G> >()(adapted, fL);	_inverter<F,N,PackedArrayAdapter<G> >()(adapted, fL);
	}	}
	return fOk;	return fOk;
	}	}
	};	};


		/// class to compute the Cholesky decomposition of a matrix
		/** class to compute the Cholesky decomposition of a symmetric
		* positive definite matrix when the dimensionality of the problem is not k
		nown
		* at compile time
		*
		* provides routines to check if the decomposition succeeded (i.e. if
		* matrix is positive definite and non-singular), to solve a linear
		* system for the given matrix and to obtain its inverse
		*
		* the actual functionality is implemented in templated helper
		* classes which have specializations for dimensions N = 1 to 6
		* to achieve a gain in speed for common matrix sizes
		*
		* usage example:
		* @code
		* // let m be a symmetric positive definite SMatrix (use type float
		* // for internal computations, matrix size is 4x4)
		* CholeskyDecomp<float, 4> decomp(m);
		* // check if the decomposition succeeded
		* if (!decomp) {
		* std::cerr << "decomposition failed!" << std::endl;
		* } else {
		* // let rhs be a vector; we seek a vector x such that m * x = rhs
		* decomp.Solve(rhs);
		* // rhs now contains the solution we are looking for
		*
		* // obtain the inverse of m, put it into m itself
		* decomp.Invert(m);
		* }
		* @endcode
		*/
		template<class F> class CholeskyDecompGenDim
		{
		private:
		/** @brief dimensionality
		* dimensionality of the problem */
		unsigned fN;
		/// lower triangular matrix L
		/** lower triangular matrix L, packed storage, with diagonal
		* elements pre-inverted */
		F *fL;
		/// flag indicating a successful decomposition
		bool fOk;
		public:
		/// perform a Cholesky decomposition
		/** perfrom a Cholesky decomposition of a symmetric positive
		* definite matrix m
		*
		* this is the constructor to uses with an SMatrix (and objects
		* that behave like an SMatrix in terms of using
		* operator()(int i, int j) for access to elements)
		*/
		template<class M> CholeskyDecompGenDim(unsigned N, const M& m) :
		fN(N), fL(new F[(fN * (fN + 1)) / 2]), fOk(false)
		{
		using CholeskyDecompHelpers::_decomposerGenDim;
		fOk = _decomposerGenDim<F, M>()(fL, m, fN);
		}

		/// perform a Cholesky decomposition
		/** perfrom a Cholesky decomposition of a symmetric positive
		* definite matrix m
		*
		* this is the constructor to use in special applications where
		* plain arrays are used
		*
		* NOTE: the matrix is given in packed representation, matrix
		* element m(i,j) (j <= i) is supposed to be in array element
		* (i * (i + 1)) / 2 + j
		*/
		template<typename G> CholeskyDecompGenDim(unsigned N, G* m) :
		fN(N), fL(new F[(fN * (fN + 1)) / 2]), fOk(false)
		{
		using CholeskyDecompHelpers::_decomposerGenDim;
		using CholeskyDecompHelpers::PackedArrayAdapter;
		fOk = _decomposerGenDim<F, PackedArrayAdapter<G> >()(
		fL, PackedArrayAdapter<G>(m), fN);
		}

		/// destructor
		~CholeskyDecompGenDim() { delete[] fL; }

		/// returns true if decomposition was successful
		/** @returns true if decomposition was successful */
		bool ok() const { return fOk; }
		/// returns true if decomposition was successful
		/** @returns true if decomposition was successful */
		operator bool() const { return fOk; }

		/// solves a linear system for the given right hand side
		/** solves a linear system for the given right hand side
		*
		* Note that you can use both SVector classes and plain arrays for
		* rhs. (Make sure that the sizes match!). It will work with any vector
		* implementing the operator [i]
		*
		* @returns if the decomposition was successful
		*/
		template<class V> bool Solve(V& rhs) const
		{
		using CholeskyDecompHelpers::_solverGenDim;
		if (fOk) _solverGenDim<F,V>()(rhs, fL, fN); return fOk;
		}

		/// place the inverse into m
		/** place the inverse into m
		*
		* This is the method to use with an SMatrix.
		*
		* @returns if the decomposition was successful
		*/
		template<class M> bool Invert(M& m) const
		{
		using CholeskyDecompHelpers::_inverterGenDim;
		if (fOk) _inverterGenDim<F,M>()(m, fL, fN); return fOk;
		}

		/// place the inverse into m
		/** place the inverse into m
		*
		* This is the method to use with a plain array.
		*
		* @returns if the decomposition was successful
		*
		* NOTE: the matrix is given in packed representation, matrix
		* element m(i,j) (j <= i) is supposed to be in array element
		* (i * (i + 1)) / 2 + j
		*/
		template<typename G> bool Invert(G* m) const
		{
		using CholeskyDecompHelpers::_inverterGenDim;
		using CholeskyDecompHelpers::PackedArrayAdapter;
		if (fOk) {
		PackedArrayAdapter<G> adapted(m);
		_inverterGenDim<F,PackedArrayAdapter<G> >()(adapted, fL, fN);
		}
		return fOk;
		}
		};

	namespace CholeskyDecompHelpers {	namespace CholeskyDecompHelpers {

	/// struct to do a Cholesky decomposition	/// adapter for packed arrays (to SMatrix indexing conventions)
	template<class F, unsigned N, class M> struct _decomposer	template<typename G> class PackedArrayAdapter
		{
		private:
		G* fArr; ///< pointer to first array element
		public:
		/// constructor
		PackedArrayAdapter(G* arr) : fArr(arr) {}
		/// read access to elements (make sure that j <= i)
		const G operator()(unsigned i, unsigned j) const
		{ return fArr[((i * (i + 1)) / 2) + j]; }
		/// write access to elements (make sure that j <= i)
		G& operator()(unsigned i, unsigned j)
		{ return fArr[((i * (i + 1)) / 2) + j]; }
		};
		/// struct to do a Cholesky decomposition (general dimensionality)
		template<class F, class M> struct _decomposerGenDim
	{	{
	/// method to do the decomposition	/// method to do the decomposition
	/** @returns if the decomposition was successful */	/** @returns if the decomposition was successful */

	bool operator()(F* dst, const M& src) const	bool operator()(F* dst, const M& src, unsigned N) const
	{	{
	// perform Cholesky decomposition of matrix: M = L L^T	// perform Cholesky decomposition of matrix: M = L L^T
	// only thing that can go wrong: trying to take square	// only thing that can go wrong: trying to take square
	// root of negative number or zero (matrix is	// root of negative number or zero (matrix is
	// ill-conditioned or singular in these cases)	// ill-conditioned or singular in these cases)

	// element L(i,j) is at array position (i * (i+1)) / 2 + j	// element L(i,j) is at array position (i * (i+1)) / 2 + j

	// quirk: we may need to invert L later anyway, so we can	// quirk: we may need to invert L later anyway, so we can
	// invert elements on diagonale straight away (we only	// invert elements on diagonale straight away (we only

	skipping to change at line 225	skipping to change at line 374
	// keep truncation error small	// keep truncation error small
	tmpdiag = src(i, i) - tmpdiag;	tmpdiag = src(i, i) - tmpdiag;
	// check if positive definite	// check if positive definite
	if (tmpdiag <= F(0)) return false;	if (tmpdiag <= F(0)) return false;
	else base1[i] = std::sqrt(F(1) / tmpdiag);	else base1[i] = std::sqrt(F(1) / tmpdiag);
	}	}
	return true;	return true;
	}	}
	};	};


	/// struct to obtain the inverse from a Cholesky decomposition	/// struct to do a Cholesky decomposition
	template<class F, unsigned N, class M> struct _inverter	template<class F, unsigned N, class M> struct _decomposer
		{
		/// method to do the decomposition
		/** @returns if the decomposition was successful */
		bool operator()(F* dst, const M& src) const
		{ return _decomposerGenDim<F, M>()(dst, src, N); }
		};

		/// struct to obtain the inverse from a Cholesky decomposition (general
		dimensionality)
		template<class F, class M> struct _inverterGenDim
	{	{
	/// method to do the inversion	/// method to do the inversion

	void operator()(M& dst, const F* src) const	void operator()(M& dst, const F* src, unsigned N) const
	{	{
	// make working copy	// make working copy

	F l[N * (N + 1) / 2];	F * l = new F[N * (N + 1) / 2];
	std::copy(src, src + ((N * (N + 1)) / 2), l);	std::copy(src, src + ((N * (N + 1)) / 2), l);
	// ok, next step: invert off-diagonal part of matrix	// ok, next step: invert off-diagonal part of matrix
	F* base1 = &l[1];	F* base1 = &l[1];
	for (unsigned i = 1; i < N; base1 += ++i) {	for (unsigned i = 1; i < N; base1 += ++i) {
	for (unsigned j = 0; j < i; ++j) {	for (unsigned j = 0; j < i; ++j) {
	F tmp = F(0);	F tmp = F(0);
	const F base2 = &l[(i (i - 1)) / 2];	const F base2 = &l[(i (i - 1)) / 2];
	for (unsigned k = i; k-- > j; base2 -= k)	for (unsigned k = i; k-- > j; base2 -= k)
	tmp -= base1[k] * base2[j];	tmp -= base1[k] * base2[j];
	base1[j] = tmp * base1[i];	base1[j] = tmp * base1[i];

	skipping to change at line 256	skipping to change at line 414
	// Li = L^(-1) formed, now calculate M^(-1) = Li^T Li	// Li = L^(-1) formed, now calculate M^(-1) = Li^T Li
	for (unsigned i = N; i--; ) {	for (unsigned i = N; i--; ) {
	for (unsigned j = i + 1; j--; ) {	for (unsigned j = i + 1; j--; ) {
	F tmp = F(0);	F tmp = F(0);
	base1 = &l[(N * (N - 1)) / 2];	base1 = &l[(N * (N - 1)) / 2];
	for (unsigned k = N; k-- > i; base1 -= k)	for (unsigned k = N; k-- > i; base1 -= k)
	tmp += base1[i] * base1[j];	tmp += base1[i] * base1[j];
	dst(i, j) = tmp;	dst(i, j) = tmp;
	}	}
	}	}

		delete [] l;
	}	}
	};	};


	/// struct to solve a linear system using its Cholesky decomposition	/// struct to obtain the inverse from a Cholesky decomposition
	template<class F, unsigned N, class V> struct _solver	template<class F, unsigned N, class M> struct _inverter
		{
		/// method to do the inversion
		void operator()(M& dst, const F* src) const
		{ return _inverterGenDim<F, M>()(dst, src, N); }
		};

		/// struct to solve a linear system using its Cholesky decomposition (ge
		neralised dimensionality)
		template<class F, class V> struct _solverGenDim
	{	{
	/// method to solve the linear system	/// method to solve the linear system

	void operator()(V& rhs, const F* l) const	void operator()(V& rhs, const F* l, unsigned N) const
	{	{
	// solve Ly = rhs	// solve Ly = rhs
	for (unsigned k = 0; k < N; ++k) {	for (unsigned k = 0; k < N; ++k) {
	const unsigned base = (k * (k + 1)) / 2;	const unsigned base = (k * (k + 1)) / 2;
	F sum = F(0);	F sum = F(0);
	for (unsigned i = k; i--; )	for (unsigned i = k; i--; )
	sum += rhs[i] * l[base + i];	sum += rhs[i] * l[base + i];
	// elements on diagonale are pre-inverted!	// elements on diagonale are pre-inverted!
	rhs[k] = (rhs[k] - sum) * l[base + k];	rhs[k] = (rhs[k] - sum) * l[base + k];
	}	}

	skipping to change at line 285	skipping to change at line 452
	for (unsigned k = N; k--; ) {	for (unsigned k = N; k--; ) {
	F sum = F(0);	F sum = F(0);
	for (unsigned i = N; --i > k; )	for (unsigned i = N; --i > k; )
	sum += rhs[i] * l[(i * (i + 1)) / 2 + k];	sum += rhs[i] * l[(i * (i + 1)) / 2 + k];
	// elements on diagonale are pre-inverted!	// elements on diagonale are pre-inverted!
	rhs[k] = (rhs[k] - sum) * l[(k * (k + 1)) / 2 + k];	rhs[k] = (rhs[k] - sum) * l[(k * (k + 1)) / 2 + k];
	}	}
	}	}
	};	};


		/// struct to solve a linear system using its Cholesky decomposition
		template<class F, unsigned N, class V> struct _solver
		{
		/// method to solve the linear system
		void operator()(V& rhs, const F* l) const
		{ _solverGenDim<F, V>()(rhs, l, N); }
		};

	/// struct to do a Cholesky decomposition (specialized, N = 6)	/// struct to do a Cholesky decomposition (specialized, N = 6)
	template<class F, class M> struct _decomposer<F, 6, M>	template<class F, class M> struct _decomposer<F, 6, M>
	{	{
	/// method to do the decomposition	/// method to do the decomposition
	bool operator()(F* dst, const M& src) const	bool operator()(F* dst, const M& src) const
	{	{
	if (src(0,0) <= F(0)) return false;	if (src(0,0) <= F(0)) return false;
	dst[0] = std::sqrt(F(1) / src(0,0));	dst[0] = std::sqrt(F(1) / src(0,0));
	dst[1] = src(1,0) * dst[0];	dst[1] = src(1,0) * dst[0];
	dst[2] = src(1,1) - dst[1] * dst[1];	dst[2] = src(1,1) - dst[1] * dst[1];

End of changes. 18 change blocks.
	25 lines changed or deleted	203 lines changed or added

	Data.h	Data.h

	skipping to change at line 45	skipping to change at line 45
	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }
	std::string GetHistoName() { return fHistoName; }	std::string GetHistoName() { return fHistoName; }

	void SetHistoPath(const std::string& HistoPath) { fHistoPath = HistoPath; }	void SetHistoPath(const std::string& HistoPath) { fHistoPath = HistoPath; }
	std::string GetHistoPath() { return fHistoPath; }	std::string GetHistoPath() { return fHistoPath; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML( std::ostream& );
	void writeToFile( std::string FileName, std::string DirName );	void writeToFile( std::string FileName, std::string DirName );

	TH1* GetHisto();	TH1* GetHisto();
	void SetHisto(TH1* Hist) { fhData = Hist; fHistoName=Hist->GetName(); }	void SetHisto(TH1* Hist) { fhData = Hist; fHistoName=Hist->GetName(); }

	protected:	protected:

	std::string fName;	std::string fName;

	std::string fInputFile;	std::string fInputFile;

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

	Factory.h	Factory.h

	// @(#)root/tmva $Id$	// @(#)root/mathcore:$Id$
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka	// Author: L. Moneta Fri Dec 22 14:43:33 2006
	i Voss, Eckhard von Toerne, Jan Therhaag


	/**************************************************************************	/**********************************************************************
	********	* *
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis	* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
	*	* *
	* Package: TMVA	* *
	*	**********************************************************************/
	* Class : Factory
	*	// Header file for class Factory
	* Web : http://tmva.sourceforge.net
	*	#ifndef ROOT_Math_Factory
	*	#define ROOT_Math_Factory
	*
	* Description:
	*
	* This is the main MVA steering class: it creates (books) all MVA met
	hods, *
	* and guides them through the training, testing and evaluation phases
	. *
	*
	*
	* Authors (alphabetical):
	*
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland
	*
	* Joerg Stelzer <stelzer@cern.ch> - DESY, Germany
	*
	* 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 *
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada
	*
	*
	*
	* Copyright (c) 2005-2011:
	*
	* CERN, Switzerland
	*
	* U. of Victoria, Canada
	*
	* MPI-K Heidelberg, Germany
	*
	* U. of Bonn, Germany
	*
	*
	*
	* Redistribution and use in source and binary forms, with or without
	*
	* modification, are permitted according to the terms listed in LICENSE
	*
	* (http://tmva.sourceforge.net/LICENSE)
	*
	**************************************************************************
	********/

	#ifndef ROOT_TMVA_Factory
	#define ROOT_TMVA_Factory

	//////////////////////////////////////////////////////////////////////////
	// //
	// Factory //
	// //
	// This is the main MVA steering class: it creates all MVA methods, //
	// and guides them through the training, testing and evaluation //
	// phases //
	// //
	//////////////////////////////////////////////////////////////////////////

	#include <string>	#include <string>

	#include <vector>
	#include <map>
	#ifndef ROOT_TCut
	#include "TCut.h"
	#endif

	#ifndef ROOT_TMVA_Configurable
	#include "TMVA/Configurable.h"
	#endif
	#ifndef ROOT_TMVA_Types
	#include "TMVA/Types.h"
	#endif
	#ifndef ROOT_TMVA_DataSet
	#include "TMVA/DataSet.h"
	#endif

	class TFile;
	class TTree;
	class TDirectory;

	namespace TMVA {

	class IMethod;
	class MethodBase;
	class DataInputHandler;
	class DataSetInfo;
	class DataSetManager;
	class VariableTransformBase;

	class Factory : public Configurable {
	public:

	typedef std::vector<IMethod*> MVector;

	// no default constructor
	Factory( TString theJobName, TFile* theTargetFile, TString theOption
	= "" );

	// default destructor
	virtual ~Factory();

	virtual const char* GetName() const { return "Factory"; }

	// add events to training and testing trees
	void AddSignalTrainingEvent ( const std::vector<Double_t>& event,
	Double_t weight = 1.0 );
	void AddBackgroundTrainingEvent( const std::vector<Double_t>& event,
	Double_t weight = 1.0 );
	void AddSignalTestEvent ( const std::vector<Double_t>& event,
	Double_t weight = 1.0 );
	void AddBackgroundTestEvent ( const std::vector<Double_t>& event,
	Double_t weight = 1.0 );
	void AddTrainingEvent( const TString& className, const std::vector<Do
	uble_t>& event, Double_t weight );
	void AddTestEvent ( const TString& className, const std::vector<Do
	uble_t>& event, Double_t weight );
	void AddEvent ( const TString& className, Types::ETreeType tt,
	const std::vector<Double_t>& event, Double_t weight );
	Bool_t UserAssignEvents(UInt_t clIndex);
	TTree* CreateEventAssignTrees( const TString& name );

	DataSetInfo& AddDataSet( DataSetInfo& );
	DataSetInfo& AddDataSet( const TString& );

	// special case: signal/background

	// Data input related
	void SetInputTrees( const TString& signalFileName, const TString& bac
	kgroundFileName,
	Double_t signalWeight=1.0, Double_t backgroundWei
	ght=1.0 );
	void SetInputTrees( TTree* inputTree, const TCut& SigCut, const TCut&
	BgCut );
	// Set input trees at once
	void SetInputTrees( TTree* signal, TTree* background,
	Double_t signalWeight=1.0, Double_t backgroundWei
	ght=1.0) ;

	void AddSignalTree( TTree* signal, Double_t weight=1.0, Types::ETr
	eeType treetype = Types::kMaxTreeType );
	void AddSignalTree( TString datFileS, Double_t weight=1.0, Types::ETr
	eeType treetype = Types::kMaxTreeType );
	void AddSignalTree( TTree* signal, Double_t weight, const TString& tr
	eetype );

	// ... depreciated, kept for backwards compatibility
	void SetSignalTree( TTree* signal, Double_t weight=1.0);

	void AddBackgroundTree( TTree* background, Double_t weight=1.0, Types
	::ETreeType treetype = Types::kMaxTreeType );
	void AddBackgroundTree( TString datFileB, Double_t weight=1.0, Types
	::ETreeType treetype = Types::kMaxTreeType );
	void AddBackgroundTree( TTree* background, Double_t weight, const TSt
	ring & treetype );

	// ... depreciated, kept for backwards compatibility
	void SetBackgroundTree( TTree* background, Double_t weight=1.0 );

	void SetSignalWeightExpression( const TString& variable );
	void SetBackgroundWeightExpression( const TString& variable );

	// special case: regression
	void AddRegressionTree( TTree* tree, Double_t weight = 1.0,
	Types::ETreeType treetype = Types::kMaxTreeTy
	pe ) {
	AddTree( tree, "Regression", weight, "", treetype );
	}

	// general

	// Data input related
	void SetTree( TTree* tree, const TString& className, Double_t weight
	); // depreciated
	void AddTree( TTree* tree, const TString& className, Double_t weight=
	1.0,
	const TCut& cut = "",
	Types::ETreeType tt = Types::kMaxTreeType );
	void AddTree( TTree* tree, const TString& className, Double_t weight,
	const TCut& cut, const TString& treeType );

	// set input variable
	void SetInputVariables ( std::vector<TString>* theVariables ); // de
	preciated
	void AddVariable ( const TString& expression, const TString& t
	itle, const TString& unit,
	char type='F', Double_t min = 0, Double_t m
	ax = 0 );
	void AddVariable ( const TString& expression, char type='F',
	Double_t min = 0, Double_t max = 0 );
	void AddTarget ( const TString& expression, const TString& t
	itle = "", const TString& unit = "",
	Double_t min = 0, Double_t max = 0 );
	void AddRegressionTarget( const TString& expression, const TString& t
	itle = "", const TString& unit = "",
	Double_t min = 0, Double_t max = 0 )
	{
	AddTarget( expression, title, unit, min, max );
	}
	void AddSpectator ( const TString& expression, const TString&
	title = "", const TString& unit = "",
	Double_t min = 0, Double_t max = 0 );

	// set weight for class
	void SetWeightExpression( const TString& variable, const TString& cla
	ssName = "" );

	// set cut for class
	void SetCut( const TString& cut, const TString& className = "" );
	void SetCut( const TCut& cut, const TString& className = "" );
	void AddCut( const TString& cut, const TString& className = "" );
	void AddCut( const TCut& cut, const TString& className = "" );

	// prepare input tree for training
	void PrepareTrainingAndTestTree( const TCut& cut, const TString& spli
	tOpt );
	void PrepareTrainingAndTestTree( TCut sigcut, TCut bkgcut, const TStr
	ing& splitOpt );

	// ... deprecated, kept for backwards compatibility
	void PrepareTrainingAndTestTree( const TCut& cut, Int_t Ntrain, Int_t
	Ntest = -1 );

	void PrepareTrainingAndTestTree( const TCut& cut, Int_t NsigTrain, In
	t_t NbkgTrain, Int_t NsigTest, Int_t NbkgTest,
	const TString& otherOpt="SplitMode=R
	andom:!V" );

	MethodBase* BookMethod( TString theMethodName, TString methodTitle, T
	String theOption = "" );
	MethodBase* BookMethod( Types::EMVA theMethod, TString methodTitle,
	TString theOption = "" );
	MethodBase* BookMethod( TMVA::Types::EMVA /theMethod/,
	TString /methodTitle/,
	TString /methodOption/,
	TMVA::Types::EMVA /theCommittee/,
	TString /committeeOption = ""/ ) { return 0
	; }

	// optimize all booked methods (well, if desired by the method)
	void OptimizeAllMethods (TString fomType="ROCIntegral
	", TString fitType="FitGA");
	void OptimizeAllMethodsForClassification(TString fomType="ROCIntegral
	", TString fitType="FitGA") { OptimizeAllMethods(fomType,fitType); }
	void OptimizeAllMethodsForRegression (TString fomType="ROCIntegral
	", TString fitType="FitGA") { OptimizeAllMethods(fomType,fitType); }

	// training for all booked methods
	void TrainAllMethods ();
	void TrainAllMethodsForClassification( void ) { TrainAllMethods(); }
	void TrainAllMethodsForRegression ( void ) { TrainAllMethods(); }

	// testing
	void TestAllMethods();

	// performance evaluation
	void EvaluateAllMethods( void );
	void EvaluateAllVariables( TString options = "" );

	// delete all methods and reset the method vector
	void DeleteAllMethods( void );

	// accessors
	IMethod* GetMethod( const TString& title ) const;

	Bool_t Verbose( void ) const { return fVerbose; }
	void SetVerbose( Bool_t v=kTRUE );

	// make ROOT-independent C++ class for classifier response
	// (classifier-specific implementation)
	// If no classifier name is given, help messages for all booked
	// classifiers are printed
	virtual void MakeClass( const TString& methodTitle = "" ) const;

	// prints classifier-specific hepl messages, dedicated to
	// help with the optimisation and configuration options tuning.
	// If no classifier name is given, help messages for all booked
	// classifiers are printed
	void PrintHelpMessage( const TString& methodTitle = "" ) const;

	static TDirectory* RootBaseDir() { return (TDirectory*)fgTargetFile;
	}

	private:

	// the beautiful greeting message
	void Greetings();

	void WriteDataInformation();

	DataInputHandler& DataInput() { return *fDataInputHandler; }
	DataSetInfo& DefaultDataSetInfo();
	void SetInputTreesFromEventAssignTrees();

	private:

	// data members

	DataSetManager* fDataSetManager; // DSMTEST

	static TFile* fgTargetFile; //! ROOT
	output file

	DataInputHandler* fDataInputHandler;

	std::vector<TMVA::VariableTransformBase*> fDefaultTrfs; //! list
	of transformations on default DataSet

	// cd to local directory
	TString fOptions; //! optio
	n string given by construction (presently only "V")
	TString fTransformations; //! List
	of transformations to test
	Bool_t fVerbose; //! verbo
	se mode

	MVector fMethods; //! all M
	VA methods
	TString fJobName; //! jobna
	me, used as extension in weight file names

	// flag determining the way training and test data are assigned to Fa
	ctory
	enum DataAssignType { kUndefined = 0,
	kAssignTrees,
	kAssignEvents };
	DataAssignType fDataAssignType; //! flags
	for data assigning
	std::vector<TTree*> fTrainAssignTree; //! for e
	ach class: tmp tree if user wants to assign the events directly
	std::vector<TTree*> fTestAssignTree; //! for e
	ach class: tmp tree if user wants to assign the events directly

	Int_t fATreeType; // typ
	e of event (=classIndex)
	Float_t fATreeWeight; // wei
	ght of the event
	Float_t* fATreeEvent; // eve
	nt variables

	Types::EAnalysisType fAnalysisType; //! the t
	raining type


	protected:	namespace ROOT {

		namespace Math {

		class Minimizer;
		class DistSampler;

		//_________________________________________________________________________
		__
		/**
		Factory class holding static functions to create the interfaces like RO
		OT::Math::Minimizer
		via the Plugin Manager
		*/
		class Factory {
		public:

		/**
		static method to create the corrisponding Minimizer given the string
		Supported Minimizers types are:
		Minuit (TMinuit), Minuit2, GSLMultiMin, GSLMultiFit, GSLSimAn, Linear
		, Fumili, Genetic
		If no name is given use default values defined in MinimizerOptions
		*/
		static ROOT::Math::Minimizer * CreateMinimizer(const std::string & minim
		izerType = "", const std::string & algoType = "");

		/**
		static method to create the distribution sampler class given a string
		specifying the type
		Supported sampler types are:
		Unuran, Foam
		If no name is given use default values defined in DistSamplerOptions
		*/
		static ROOT::Math::DistSampler * CreateDistSampler(const std::string & s
		amplerType ="");

		};


	ClassDef(Factory,0) // The factory creates all MVA methods, and perf	} // end namespace Fit
	orms their training and testing
	};


	} // namespace TMVA	} // end namespace ROOT


	#endif	#endif /* ROOT_Fit_MinimizerFactory */

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

	HistFactoryNavigation.h	HistFactoryNavigation.h

	#include <map>	#include <map>


	#include "TFile.h"
	#include "TH1.h"	#include "TH1.h"

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

	#include "TCanvas.h"
	#include "THStack.h"	#include "THStack.h"

	#include "TLegend.h"

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

	#include "RooWorkspace.h"
	#include "RooSimultaneous.h"
	#include "RooCategory.h"
	#include "RooProduct.h"	#include "RooProduct.h"

	#include "RooRealSumPdf.h"
	#include "RooStats/HistFactory/Measurement.h"	#include "RooStats/HistFactory/Measurement.h"


	#include "RooStats/ModelConfig.h"	#include "RooStats/ModelConfig.h"

	namespace RooStats {	namespace RooStats {
	namespace HistFactory {	namespace HistFactory {

	class HistFactoryNavigation {	class HistFactoryNavigation {

	public:	public:

	// Initialze based on an already-created HistFactory Model	// Initialze based on an already-created HistFactory Model

	skipping to change at line 61	skipping to change at line 50

	// Print parameters that effect a particular sample	// Print parameters that effect a particular sample
	void PrintSampleParameters(const std::string& channel, const std::str ing& sample,	void PrintSampleParameters(const std::string& channel, const std::str ing& sample,
	bool IncludeConstantParams=false);	bool IncludeConstantParams=false);

	// Print the different components that make up a sample	// Print the different components that make up a sample
	// (NormFactors, Statistical Uncertainties, Interpolation, etc)	// (NormFactors, Statistical Uncertainties, Interpolation, etc)
	void PrintSampleComponents(const std::string& channel, const std::str ing& sample);	void PrintSampleComponents(const std::string& channel, const std::str ing& sample);

	// Print a "HistFactory style" RooDataSet in a readable way	// Print a "HistFactory style" RooDataSet in a readable way

	static void PrintDataSet(RooDataSet* data, const std::string& channel ="", int max=-1);	void PrintDataSet(RooDataSet* data, const std::string& channel="");

	// Print the model and the data, comparing channel by channel	// Print the model and the data, comparing channel by channel
	void PrintModelAndData(RooDataSet* data);	void PrintModelAndData(RooDataSet* data);

	// The value of the ith bin for the total in that channel	// The value of the ith bin for the total in that channel
	double GetBinValue(int bin, const std::string& channel);	double GetBinValue(int bin, const std::string& channel);
	// The value of the ith bin for that sample and channel	// The value of the ith bin for that sample and channel
	double GetBinValue(int bin, const std::string& channel, const std::st ring& sample);	double GetBinValue(int bin, const std::string& channel, const std::st ring& sample);

	// The (current) histogram for that sample	// The (current) histogram for that sample
	// This includes all parameters and interpolation	// This includes all parameters and interpolation
	TH1* GetSampleHist(const std::string& channel,	TH1* GetSampleHist(const std::string& channel,
	const std::string& sample, const std::string& name= "");	const std::string& sample, const std::string& name= "");

	// Get the total channel histogram for this channel	// Get the total channel histogram for this channel
	TH1* GetChannelHist(const std::string& channel, const std::string& na me="");	TH1* GetChannelHist(const std::string& channel, const std::string& na me="");


		// Get a histogram from the dataset for this channel
		TH1* GetDataHist(RooDataSet* data, const std::string& channel, const
		std::string& name="");

		// Get a stack of all samples in a channel
		THStack* GetChannelStack(const std::string& channel, const std::strin
		g& name="");

		// Draw a stack of the channel, and include data if the pointer is su
		pplied
		void DrawChannel(const std::string& channel, RooDataSet* data=NULL);

	// Get the RooAbsReal function for a given sample in a given channel	// Get the RooAbsReal function for a given sample in a given channel
	RooAbsReal* SampleFunction(const std::string& channel, const std::str ing& sample);	RooAbsReal* SampleFunction(const std::string& channel, const std::str ing& sample);

	// Get the set of observables for a given channel	// Get the set of observables for a given channel
	RooArgSet* GetObservableSet(const std::string& channel);	RooArgSet* GetObservableSet(const std::string& channel);

	// Get the constraint term for a given systematic (alpha or gamma)	// Get the constraint term for a given systematic (alpha or gamma)
	RooAbsReal* GetConstraintTerm(const std::string& parameter);	RooAbsReal* GetConstraintTerm(const std::string& parameter);

	// Get the uncertainty based on the constraint term for a given syste matic	// Get the uncertainty based on the constraint term for a given syste matic

	skipping to change at line 100	skipping to change at line 98

	// Find a node in the pdf and replace it with a new node	// Find a node in the pdf and replace it with a new node
	// These nodes can be functions, pdf's, RooRealVar's, etc	// These nodes can be functions, pdf's, RooRealVar's, etc
	// Will do minimial checking to make sure the replacement makes sense	// Will do minimial checking to make sure the replacement makes sense
	void ReplaceNode(const std::string& ToReplace, RooAbsArg* ReplaceWith );	void ReplaceNode(const std::string& ToReplace, RooAbsArg* ReplaceWith );

	// Set any RooRealVar's const (or not const) if they match	// Set any RooRealVar's const (or not const) if they match
	// the supplied regular expression	// the supplied regular expression
	void SetConstant(const std::string& regExpr=".*", bool constant=true) ;	void SetConstant(const std::string& regExpr=".*", bool constant=true) ;


	void SetNumBinsToPrint(int num) { _numBinsToPrint = num; }	void SetMaxBinToPrint(int max) { _maxBinToPrint = max; }
	int GetNumBinsToPrint() const { return _numBinsToPrint; }	int GetMaxBinToPrint() const { return _maxBinToPrint; }

		void SetMinBinToPrint(int min) { _minBinToPrint = min; }
		int GetMinBinToPrint() const { return _minBinToPrint; }

	// Get the model for this channel	// Get the model for this channel
	RooAbsPdf* GetModel() const { return fModel; }	RooAbsPdf* GetModel() const { return fModel; }

	//	//
	RooAbsPdf* GetChannelPdf(const std::string& channel);	RooAbsPdf* GetChannelPdf(const std::string& channel);


		std::vector< std::string > GetChannelSampleList(const std::string& ch
		annel);

	// Return the RooRealVar by the same name used in the model	// Return the RooRealVar by the same name used in the model
	// If not found, return NULL	// If not found, return NULL
	RooRealVar* var(const std::string& varName) const;	RooRealVar* var(const std::string& varName) const;

	/*	/*
	// Add a channel to the pdf	// Add a channel to the pdf
	// Combine the data if it is provided	// Combine the data if it is provided
	void AddChannel(const std::string& channel, RooAbsPdf* pdf, RooDataSe t* data=NULL);	void AddChannel(const std::string& channel, RooAbsPdf* pdf, RooDataSe t* data=NULL);
	*/	*/


	skipping to change at line 132	skipping to change at line 135
	void AddConstraintTerm(RooAbsArg* constraintTerm);	void AddConstraintTerm(RooAbsArg* constraintTerm);

	// Add a constraint term to the pdf of a particular channel	// Add a constraint term to the pdf of a particular channel
	// This method requires that the pdf be simultaneous	// This method requires that the pdf be simultaneous
	// OR that the channel string match the channel that the pdf represen ts	// OR that the channel string match the channel that the pdf represen ts
	void AddConstraintTerm(RooAbsArg* constraintTerm, const std::string& channel);	void AddConstraintTerm(RooAbsArg* constraintTerm, const std::string& channel);
	*/	*/

	protected:	protected:


		// Set the title and bin widths
		void SetPrintWidths(const std::string& channel);

	// Fetch the node information for the pdf in question, and	// Fetch the node information for the pdf in question, and
	// save it in the varous collections in this class	// save it in the varous collections in this class
	void _GetNodes(ModelConfig* mc);	void _GetNodes(ModelConfig* mc);
	void _GetNodes(RooAbsPdf* model, const RooArgSet* observables);	void _GetNodes(RooAbsPdf* model, const RooArgSet* observables);

	// Print a histogram's contents to the screen	// Print a histogram's contents to the screen
	// void PrettyPrintHistogram(TH1* hist);	// void PrettyPrintHistogram(TH1* hist);

		void PrintMultiDimHist(TH1* hist, int bin_print_width);

	// Make a histogram from a funciton	// Make a histogram from a funciton
	// Edit so it can take a RooArgSet of parameters	// Edit so it can take a RooArgSet of parameters
	TH1* MakeHistFromRooFunction( RooAbsReal* func, RooArgList vars, std: :string name="Hist" );	TH1* MakeHistFromRooFunction( RooAbsReal* func, RooArgList vars, std: :string name="Hist" );

	// Get a map of sample names to their functions for a particular chan nel	// Get a map of sample names to their functions for a particular chan nel
	std::map< std::string, RooAbsReal*> GetSampleFunctionMap(const std::s tring& channel);	std::map< std::string, RooAbsReal*> GetSampleFunctionMap(const std::s tring& channel);

	private:	private:

	// The HistFactory Pdf Pointer	// The HistFactory Pdf Pointer
	RooAbsPdf* fModel;	RooAbsPdf* fModel;

	// The observables	// The observables
	RooArgSet* fObservables;	RooArgSet* fObservables;


	int _numBinsToPrint;	int _minBinToPrint;
		int _maxBinToPrint;

		int _label_print_width;
		int _bin_print_width;

	// The list of channels	// The list of channels
	std::vector<std::string> fChannelNameVec;	std::vector<std::string> fChannelNameVec;

	// Map of channel names to their full pdf's	// Map of channel names to their full pdf's
	std::map< std::string, RooAbsPdf* > fChannelPdfMap;	std::map< std::string, RooAbsPdf* > fChannelPdfMap;

	// Map of channel names to pdf without constraint	// Map of channel names to pdf without constraint
	std::map< std::string, RooAbsPdf* > fChannelSumNodeMap;	std::map< std::string, RooAbsPdf* > fChannelSumNodeMap;


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

	MakeModelAndMeasurementsFast.h	MakeModelAndMeasurementsFast.h

	skipping to change at line 16	skipping to change at line 16
	#include <vector>	#include <vector>

	#include "RooStats/HistFactory/Measurement.h"	#include "RooStats/HistFactory/Measurement.h"
	#include "RooStats/HistFactory/Channel.h"	#include "RooStats/HistFactory/Channel.h"
	#include "RooStats/HistFactory/EstimateSummary.h"	#include "RooStats/HistFactory/EstimateSummary.h"

	#include "RooWorkspace.h"	#include "RooWorkspace.h"
	#include "RooPlot.h"	#include "RooPlot.h"
	#include "TFile.h"	#include "TFile.h"


	void fastDriver(std::string input);

	namespace RooStats{	namespace RooStats{
	namespace HistFactory{	namespace HistFactory{


		//void fastDriver(std::string input);

	RooWorkspace* MakeModelAndMeasurementFast( RooStats::HistFactory::Measu rement& measurement );	RooWorkspace* MakeModelAndMeasurementFast( RooStats::HistFactory::Measu rement& measurement );
	//RooWorkspace* MakeModelFast( RooStats::HistFactory::Measurement& meas urement );	//RooWorkspace* MakeModelFast( RooStats::HistFactory::Measurement& meas urement );

	std::vector<RooStats::HistFactory::EstimateSummary> GetChannelEstimateS ummaries(RooStats::HistFactory::Measurement& measurement, RooStats::HistFac tory::Channel& channel);	std::vector<RooStats::HistFactory::EstimateSummary> GetChannelEstimateS ummaries(RooStats::HistFactory::Measurement& measurement, RooStats::HistFac tory::Channel& channel);
	// void ConfigureWorkspaceForMeasurement( const std::string&, RooWorksp ace*, RooStats::HistFactory::Measurement&);	// void ConfigureWorkspaceForMeasurement( const std::string&, RooWorksp ace*, RooStats::HistFactory::Measurement&);

	void FormatFrameForLikelihood(RooPlot* frame, std::string xTitle=std::s tring("#sigma / #sigma_{SM}"), std::string yTitle=std::string("-log likelih ood"));	void FormatFrameForLikelihood(RooPlot* frame, std::string xTitle=std::s tring("#sigma / #sigma_{SM}"), std::string yTitle=std::string("-log likelih ood"));
	void FitModel(RooWorkspace *, std::string data_name="obsData");	void FitModel(RooWorkspace *, std::string data_name="obsData");
	void FitModelAndPlot(const std::string& measurementName, const std::str ing& fileNamePrefix, RooWorkspace , std::string, std::string, TFile, FILE *);	void FitModelAndPlot(const std::string& measurementName, const std::str ing& fileNamePrefix, RooWorkspace , std::string, std::string, TFile, FILE *);
	}	}

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

	OneDimFunctionAdapter.h	OneDimFunctionAdapter.h

	skipping to change at line 101	skipping to change at line 101

	/**	/**
	Destructor (no operations)	Destructor (no operations)
	*/	*/
	virtual ~OneDimMultiFunctionAdapter () { if (fOwn && fX) delete [] fX; }	virtual ~OneDimMultiFunctionAdapter () { if (fOwn && fX) delete [] fX; }

	/**	/**
	clone	clone
	*/	*/
	virtual OneDimMultiFunctionAdapter * Clone( ) const {	virtual OneDimMultiFunctionAdapter * Clone( ) const {

	if (fOwn)	if (fOwn) {
	return new OneDimMultiFunctionAdapter( fFunc, fDim, fCoord, fParam	OneDimMultiFunctionAdapter * f = new OneDimMultiFunctionAdapter(
	s);	fFunc, fDim, fCoord, fParams);
		std::copy(fX, fX+fDim, f->fX);
		return f;
		}
	else	else
	return new OneDimMultiFunctionAdapter( fFunc, fX, fCoord, fParams) ;	return new OneDimMultiFunctionAdapter( fFunc, fX, fCoord, fParams) ;
	}	}

	public:	public:

	/**	/**
	Set X values in case vector is own, iterator size must match previou s	Set X values in case vector is own, iterator size must match previou s
	set dimension	set dimension
	*/	*/

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

	ParamHistFunc.h	ParamHistFunc.h

	skipping to change at line 33	skipping to change at line 33
	class RooArgList ;	class RooArgList ;
	class RooWorkspace;	class RooWorkspace;
	class RooBinning;	class RooBinning;

	class ParamHistFunc : public RooAbsReal {	class ParamHistFunc : public RooAbsReal {
	public:	public:

	ParamHistFunc() ;	ParamHistFunc() ;
	ParamHistFunc(const char name, const char title, const RooArgList& vars , const RooArgList& paramSet );	ParamHistFunc(const char name, const char title, const RooArgList& vars , const RooArgList& paramSet );
	ParamHistFunc(const char name, const char title, const RooArgList& vars , const RooArgList& paramSet, const TH1* hist );	ParamHistFunc(const char name, const char title, const RooArgList& vars , const RooArgList& paramSet, const TH1* hist );

	// Not yet fully implemented:
	//ParamHistFunc(const char name, const char title, const RooRealVar& va
	r, const RooArgList& paramSet, const RooAbsReal& nominal );
	virtual ~ParamHistFunc() ;	virtual ~ParamHistFunc() ;

	ParamHistFunc(const ParamHistFunc& other, const char* name = 0);	ParamHistFunc(const ParamHistFunc& other, const char* name = 0);
	virtual TObject* clone(const char* newname) const { return new ParamHistF unc(*this, newname); }	virtual TObject* clone(const char* newname) const { return new ParamHistF unc(*this, newname); }


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

	const RooArgList& paramList() const { return _paramSet ; }	const RooArgList& paramList() const { return _paramSet ; }

	Int_t numBins() const { return _dataSet.numEntries(); } // Number of bins (called numEntries in RooDataHist)	Int_t numBins() const { return _dataSet.numEntries(); } // Number of bins (called numEntries in RooDataHist)

	void setParamConst( Int_t, Bool_t=kTRUE );	void setParamConst( Int_t, Bool_t=kTRUE );

		void setConstant(bool constant);

		void setShape(TH1* shape);

	RooRealVar& getParameter() const ;	RooRealVar& getParameter() const ;
	RooRealVar& getParameter( Int_t masterIdx ) const ;	RooRealVar& getParameter( Int_t masterIdx ) const ;

	const RooArgSet* get(Int_t masterIdx) const { return _dataSet.get( master Idx ) ; }	const RooArgSet* get(Int_t masterIdx) const { return _dataSet.get( master Idx ) ; }
	const RooArgSet* get(const RooArgSet& coord) const { return _dataSet.get( coord ) ; }	const RooArgSet* get(const RooArgSet& coord) const { return _dataSet.get( coord ) ; }

	double binVolume() const { return _dataSet.binVolume(); }	double binVolume() const { return _dataSet.binVolume(); }

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

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

	PreprocessFunction.h	PreprocessFunction.h

	skipping to change at line 20	skipping to change at line 20

	class PreprocessFunction {	class PreprocessFunction {
	public:	public:

	PreprocessFunction();	PreprocessFunction();

	PreprocessFunction(std::string Name, std::string Expression, std::strin g Dependents);	PreprocessFunction(std::string Name, std::string Expression, std::strin g Dependents);
	std::string GetCommand(std::string Name, std::string Expression, std::s tring Dependents);	std::string GetCommand(std::string Name, std::string Expression, std::s tring Dependents);

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML(std::ostream& );

	void SetName( const std::string& Name) { fName = Name; }	void SetName( const std::string& Name) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void SetExpression( const std::string& Expression) { fExpression = Expr ession; }	void SetExpression( const std::string& Expression) { fExpression = Expr ession; }
	std::string GetExpression() { return fExpression; }	std::string GetExpression() { return fExpression; }

	void SetDependents( const std::string& Dependents) { fDependents = Depe ndents; }	void SetDependents( const std::string& Dependents) { fDependents = Depe ndents; }
	std::string GetDependents() { return fDependents; }	std::string GetDependents() { return fDependents; }


End of changes. 1 change blocks.
	0 lines changed or deleted	1 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.8.4/ i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.7.3/i68 6-slc5-gcc43-opt linux --fail-on-missing --enable-builtin-pcre --enable-cin tex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5 -- enable-mathmore --enable-minuit2 --enable-mysql --enable-oracle --enable-py thon --enable-qt --enable-qtgsi --enable-reflex --enable-roofit --enable-ta ble --enable-unuran --with-castor-incdir=/afs/cern.ch/sw/lcg/external/casto r/2.1.13-6/i686-slc5-gcc43-opt/usr/include/shift --with-castor-libdir=/afs/ cern.ch/sw/lcg/external/castor/2.1.13-6/i686-slc5-gcc43-opt/usr/lib --with- cern-libdir=/afs/cern.ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/ lib --with-dcap-libdir=/afs/cern.ch/sw/lcg/external/dcache_client/2.47.5-0/ i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/externa l/dcache_client/2.47.5-0/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incd ir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/include --w ith-fftw3-libdir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-o pt/lib --with-gccxml=/afs/cern.ch/sw/lcg/external/gccxml/0.9.0_20120309p2/i 686-slc5-gcc43-opt/bin --with-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid /gfal/1.13.0-0/i686-slc5-gcc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/l cg/external/Grid/gfal/1.13.0-0/i686-slc5-gcc43-opt/include --with-gsl-incdi r=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/include --with- gsl-libdir=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib -- with-mysql-incdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i686-slc5-gcc43 -opt/include --with-mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/ i686-slc5-gcc43-opt/lib --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/o racle/11.2.0.3.0/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern .ch/sw/lcg/external/oracle/11.2.0.3.0/i686-slc5-gcc43-opt/lib --with-rfio-i ncdir=/afs/cern.ch/sw/lcg/external/castor/2.1.13-6/i686-slc5-gcc43-opt/usr/ include/shift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.13 -6/i686-slc5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/sw/lcg/ex ternal/MCGenerators/pythia6/426.2/i686-slc5-gcc43-opt/lib --with-pythia8-in cdir=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/160/i686-slc5-gcc43- opt/include --with-pythia8-libdir=/afs/cern.ch/sw/lcg/external/MCGenerators /pythia8/160/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/cern.ch/sw/lcg /external/graphviz/2.28.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz- libdir=/afs/cern.ch/sw/lcg/external/graphviz/2.28.0/i686-slc5-gcc43-opt/lib --with-xrootd=/afs/cern.ch/sw/lcg/external/xrootd/3.2.7/i686-slc5-gcc43-op t --with-srm-ifce-incdir=/afs/cern.ch/sw/lcg/external/Grid/srm-ifce/1.13.0- 0/i686-slc5-gcc43-opt/include"	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.8.4/ i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.7.3/i68 6-slc5-gcc43-opt linux --fail-on-missing --enable-builtin-pcre --enable-cin tex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5 -- enable-mathmore --enable-minuit2 --enable-mysql --enable-oracle --enable-py thon --enable-qt --enable-qtgsi --enable-reflex --enable-roofit --enable-ta ble --enable-unuran --with-castor-incdir=/afs/cern.ch/sw/lcg/external/casto r/2.1.13-6/i686-slc5-gcc43-opt/usr/include/shift --with-castor-libdir=/afs/ cern.ch/sw/lcg/external/castor/2.1.13-6/i686-slc5-gcc43-opt/usr/lib --with- cern-libdir=/afs/cern.ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/ lib --with-dcap-libdir=/afs/cern.ch/sw/lcg/external/dcache_client/2.47.5-0/ i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/externa l/dcache_client/2.47.5-0/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incd ir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-opt/include --w ith-fftw3-libdir=/afs/cern.ch/sw/lcg/external/fftw3/3.1.2/i686-slc5-gcc43-o pt/lib --with-gccxml=/afs/cern.ch/sw/lcg/external/gccxml/0.9.0_20120309p2/i 686-slc5-gcc43-opt/bin --with-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid /gfal/1.13.0-0/i686-slc5-gcc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/l cg/external/Grid/gfal/1.13.0-0/i686-slc5-gcc43-opt/include --with-gsl-incdi r=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/include --with- gsl-libdir=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib -- with-mysql-incdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i686-slc5-gcc43 -opt/include --with-mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/ i686-slc5-gcc43-opt/lib --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/o racle/11.2.0.3.0/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern .ch/sw/lcg/external/oracle/11.2.0.3.0/i686-slc5-gcc43-opt/lib --with-rfio-i ncdir=/afs/cern.ch/sw/lcg/external/castor/2.1.13-6/i686-slc5-gcc43-opt/usr/ include/shift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.13 -6/i686-slc5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/sw/lcg/ex ternal/MCGenerators/pythia6/426.2/i686-slc5-gcc43-opt/lib --with-pythia8-in cdir=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/160/i686-slc5-gcc43- opt/include --with-pythia8-libdir=/afs/cern.ch/sw/lcg/external/MCGenerators /pythia8/160/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/cern.ch/sw/lcg /external/graphviz/2.28.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz- libdir=/afs/cern.ch/sw/lcg/external/graphviz/2.28.0/i686-slc5-gcc43-opt/lib --with-xrootd=/afs/cern.ch/sw/lcg/external/xrootd/3.2.7/i686-slc5-gcc43-op t --with-srm-ifce-incdir=/afs/cern.ch/sw/lcg/external/Grid/srm-ifce/1.13.0- 0/i686-slc5-gcc43-opt/include"

	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft gl builtin_glew builtin_pcre builtin_lzma castor cintex dcache explicitlink fftw3 gdml genvector gfal krb5 ldap mathmore memstat minuit2 mysql opengl oracle pythia8 python qt qtgsi reflex roofit rfio shadowpw shared ssl table tmva unuran x11 xft xml xrootd thread"	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft gl builtin_glew builtin_pcre builtin_lzma castor cintex dcache explicitlink fftw3 gdml genvector gfal krb5 ldap mathmore memstat minuit2 mysql opengl oracle pythia8 python qt qtgsi reflex roofit rfio shadowpw shared sqlite ss l table tmva unuran x11 xft xml xrootd thread"

	#endif	#endif

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

	RVersion.h	RVersion.h

	skipping to change at line 17	skipping to change at line 17
	* These macros can be used in the following way:	* These macros can be used in the following way:
	*	*
	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)	* #if ROOT_VERSION_CODE >= ROOT_VERSION(2,23,4)
	* #include <newheader.h>	* #include <newheader.h>
	* #else	* #else
	* #include <oldheader.h>	* #include <oldheader.h>
	* #endif	* #endif
	*	*
	*/	*/


	#define ROOT_RELEASE "5.34/09"	#define ROOT_RELEASE "5.34/10"
	#define ROOT_RELEASE_DATE "Jun 26 2013"	#define ROOT_RELEASE_DATE "Aug 29 2013"
	#define ROOT_RELEASE_TIME "16:38:19"	#define ROOT_RELEASE_TIME "16:17:59"
	#define ROOT_SVN_REVISION 49361	#define ROOT_SVN_REVISION 49361

	#define ROOT_GIT_COMMIT "v5-34-08-80-g1323c6f"	#define ROOT_GIT_COMMIT "v5-34-09-278-gdd55a0f"
	#define ROOT_GIT_BRANCH "heads/v5-34-00-patches"	#define ROOT_GIT_BRANCH "heads/v5-34-00-patches"

	#define ROOT_VERSION_CODE 336393	#define ROOT_VERSION_CODE 336394
	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

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

	RooAbsArg.h	RooAbsArg.h

	skipping to change at line 390	skipping to change at line 390
	// Cache management	// Cache management
	void registerCache(RooAbsCache& cache) ;	void registerCache(RooAbsCache& cache) ;
	void unRegisterCache(RooAbsCache& cache) ;	void unRegisterCache(RooAbsCache& cache) ;
	Int_t numCaches() const ;	Int_t numCaches() const ;
	RooAbsCache* getCache(Int_t index) const ;	RooAbsCache* getCache(Int_t index) const ;

	enum OperMode { Auto=0, AClean=1, ADirty=2 } ;	enum OperMode { Auto=0, AClean=1, ADirty=2 } ;
	inline OperMode operMode() const { return _operMode ; }	inline OperMode operMode() const { return _operMode ; }
	void setOperMode(OperMode mode, Bool_t recurseADirty=kTRUE) ;	void setOperMode(OperMode mode, Bool_t recurseADirty=kTRUE) ;


	static UInt_t crc32(const char* data) ;	static UInt_t crc32(const char* data);
		static UInt_t crc32(const char* data, ULong_t sz, UInt_t crc = 0);

		static const UInt_t fnv1a32start = 2166136261u;
		static UInt_t fnv1a32(const char* data);
		static UInt_t fnv1a32(const char* data, ULong_t sz, UInt_t hash = fnv1a32
		start);

		static const ULong64_t fnv1a64start = (ULong64_t(3421674724u) << 32) \| UL
		ong64_t(2216829733u);
		static ULong64_t fnv1a64(const char* data);
		static ULong64_t fnv1a64(const char* data, ULong_t sz, ULong64_t hash = f
		nv1a64start);

	Bool_t addOwnedComponents(const RooArgSet& comps) ;	Bool_t addOwnedComponents(const RooArgSet& comps) ;
	const RooArgSet* ownedComponents() const { return _ownedComponents ; }	const RooArgSet* ownedComponents() const { return _ownedComponents ; }

	void setProhibitServerRedirect(Bool_t flag) { _prohibitServerRedirect = f lag ; }	void setProhibitServerRedirect(Bool_t flag) { _prohibitServerRedirect = f lag ; }

	protected:	protected:

	void graphVizAddConnections(std::set<std::pair<RooAbsArg,RooAbsArg> >&) ;	void graphVizAddConnections(std::set<std::pair<RooAbsArg,RooAbsArg> >&) ;


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

	RooAbsReal.h	RooAbsReal.h

	skipping to change at line 247	skipping to change at line 247

	// Printing interface (human readable)	// Printing interface (human readable)
	virtual void printValue(std::ostream& os) const ;	virtual void printValue(std::ostream& os) const ;
	virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verb ose=kFALSE, TString indent="") const ;	virtual void printMultiline(std::ostream& os, Int_t contents, Bool_t verb ose=kFALSE, TString indent="") const ;

	static void setCacheCheck(Bool_t flag) ;	static void setCacheCheck(Bool_t flag) ;

	// Evaluation error logging	// Evaluation error logging
	class EvalError {	class EvalError {
	public:	public:

	EvalError() { _msg[0] = 0 ; _srvval[0] = 0 ; }	EvalError() { }
	EvalError(const EvalError& other) { strlcpy(_msg,other._msg,1024) ; str	EvalError(const EvalError& other) : _msg(other._msg), _srvval(other._sr
	lcpy(_srvval,other._srvval,1024) ; } ;	vval) { }
	void setMessage(const char* tmp) ;	void setMessage(const char* tmp) { std::string s(tmp); s.swap(_msg); }
	void setServerValues(const char* tmp) ;	void setServerValues(const char* tmp) { std::string s(tmp); s.swap(_srv
	char _msg[1024] ;	val); }
	char _srvval[1024] ;	std::string _msg;
		std::string _srvval;
	} ;	} ;

	enum ErrorLoggingMode { PrintErrors, CollectErrors, CountErrors, Ignore } ;	enum ErrorLoggingMode { PrintErrors, CollectErrors, CountErrors, Ignore } ;
	static ErrorLoggingMode evalErrorLoggingMode() ;	static ErrorLoggingMode evalErrorLoggingMode() ;
	static void setEvalErrorLoggingMode(ErrorLoggingMode m) ;	static void setEvalErrorLoggingMode(ErrorLoggingMode m) ;
	void logEvalError(const char* message, const char* serverValueString=0) c onst ;	void logEvalError(const char* message, const char* serverValueString=0) c onst ;
	static void logEvalError(const RooAbsReal* originator, const char* origNa me, const char* message, const char* serverValueString=0) ;	static void logEvalError(const RooAbsReal* originator, const char* origNa me, const char* message, const char* serverValueString=0) ;
	static void printEvalErrors(std::ostream&os=std::cout, Int_t maxPerNode=1 0000000) ;	static void printEvalErrors(std::ostream&os=std::cout, Int_t maxPerNode=1 0000000) ;
	static Int_t numEvalErrors() ;	static Int_t numEvalErrors() ;
	static Int_t numEvalErrorItems() ;	static Int_t numEvalErrorItems() ;

	skipping to change at line 306	skipping to change at line 306
	virtual Bool_t setData(RooAbsData& /data/, Bool_t /cloneData/=kTRUE) { return kTRUE ; }	virtual Bool_t setData(RooAbsData& /data/, Bool_t /cloneData/=kTRUE) { return kTRUE ; }

	virtual void enableOffsetting(Bool_t) {} ;	virtual void enableOffsetting(Bool_t) {} ;
	virtual Bool_t isOffsetting() const { return kFALSE ; }	virtual Bool_t isOffsetting() const { return kFALSE ; }
	virtual Double_t offset() const { return 0 ; }	virtual Double_t offset() const { return 0 ; }

	static void setHideOffset(Bool_t flag);	static void setHideOffset(Bool_t flag);
	static Bool_t hideOffset() ;	static Bool_t hideOffset() ;

	protected:	protected:


	// PlotOn with command list
	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;

	// Hook for objects with normalization-dependent parameters interperetati on	// Hook for objects with normalization-dependent parameters interperetati on
	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) ;

	// Helper functions for plotting	// Helper functions for plotting
	Bool_t plotSanityChecks(RooPlot* frame) const ;	Bool_t plotSanityChecks(RooPlot* frame) const ;
	void makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars ,	void makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars ,
	RooArgSet& projectedVars, Bool_t silent) const ;	RooArgSet& projectedVars, Bool_t silent) const ;

	TString integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset=0 , const char* rangeName=0, Bool_t omitEmpty=kFALSE) const ;	TString integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset=0 , const char* rangeName=0, Bool_t omitEmpty=kFALSE) const ;

	skipping to change at line 440	skipping to change at line 436
	RooFit::MPSplit interleave ;	RooFit::MPSplit interleave ;
	const char* curveNameSuffix ;	const char* curveNameSuffix ;
	Int_t numee ;	Int_t numee ;
	Double_t eeval ;	Double_t eeval ;
	Bool_t doeeval ;	Bool_t doeeval ;
	Bool_t progress ;	Bool_t progress ;
	} ;	} ;

	// Plot implementation functions	// Plot implementation functions
	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;

		// PlotOn with command list
		virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;

	virtual RooPlot plotAsymOn(RooPlot frame, const RooAbsCategoryLValue& a symCat, PlotOpt o) const;	virtual RooPlot plotAsymOn(RooPlot frame, const RooAbsCategoryLValue& a symCat, PlotOpt o) const;

	private:	private:

	static ErrorLoggingMode _evalErrorMode ;	static ErrorLoggingMode _evalErrorMode ;
	static std::map<const RooAbsArg*,std::pair<std::string,std::list<EvalErro r> > > _evalErrorList ;	static std::map<const RooAbsArg*,std::pair<std::string,std::list<EvalErro r> > > _evalErrorList ;
	static Int_t _evalErrorCount ;	static Int_t _evalErrorCount ;

	Bool_t matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs, const TList &nameList) const;	Bool_t matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs, const TList &nameList) const;


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

	RooBinning.h	RooBinning.h

	skipping to change at line 24	skipping to change at line 24
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_BINNING	#ifndef ROO_BINNING
	#define ROO_BINNING	#define ROO_BINNING

	#include "Rtypes.h"	#include "Rtypes.h"
	#include "TList.h"	#include "TList.h"
	#include "RooDouble.h"	#include "RooDouble.h"
	#include "RooAbsBinning.h"	#include "RooAbsBinning.h"
	#include "RooNumber.h"	#include "RooNumber.h"

	#include <set>	#include <vector>
	class RooAbsPdf ;	class RooAbsPdf;
	class RooRealVar ;	class RooRealVar;

	class RooBinning : public RooAbsBinning {	class RooBinning : public RooAbsBinning {
	public:	public:


	RooBinning(Double_t xlo=-RooNumber::infinity(), Double_t xhi=RooNumber::i	RooBinning(Double_t xlo = -RooNumber::infinity(), Double_t xhi = RooNumbe
	nfinity(), const char* name=0) ;	r::infinity(), const char* name = 0);
	RooBinning(Int_t nBins, Double_t xlo, Double_t xhi, const char* name=0) ;	RooBinning(Int_t nBins, Double_t xlo, Double_t xhi, const char* name = 0)
	RooBinning(Int_t nBins, const Double_t* boundaries, const char* name=0) ;	;
	RooBinning(const RooBinning& other, const char* name=0) ;	RooBinning(Int_t nBins, const Double_t* boundaries, const char* name = 0)
	RooAbsBinning* clone(const char* name=0) const { return new RooBinning(*t	;
	his,name?name:GetName()) ; }	RooBinning(const RooBinning& other, const char* name = 0);
	~RooBinning() ;	RooAbsBinning* clone(const char* name = 0) const { return new RooBinning(
		*this,name?name:GetName()); }
		~RooBinning();

	virtual Int_t numBoundaries() const {	virtual Int_t numBoundaries() const {
	// Return the number boundaries	// Return the number boundaries

	return _nbins+1 ;	return _nbins+1;
	}	}

	virtual Int_t binNumber(Double_t x) const ;	virtual Int_t binNumber(Double_t x) const;
	virtual Int_t rawBinNumber(Double_t x) const ;	virtual Int_t rawBinNumber(Double_t x) const;
	virtual Double_t nearestBoundary(Double_t x) const ;	virtual Double_t nearestBoundary(Double_t x) const;


	virtual void setRange(Double_t xlo, Double_t xhi) ;	virtual void setRange(Double_t xlo, Double_t xhi);

	virtual Double_t lowBound() const {	virtual Double_t lowBound() const {
	// Return the lower bound value	// Return the lower bound value

	return _xlo ;	return _xlo;
	}	}
	virtual Double_t highBound() const {	virtual Double_t highBound() const {
	// Return the upper bound value	// Return the upper bound value

	return _xhi ;	return _xhi;
	}	}
	virtual Double_t averageBinWidth() const {	virtual Double_t averageBinWidth() const {
	// Return the average bin width	// Return the average bin width

	return (highBound()-lowBound())/numBins() ;	return (highBound() - lowBound()) / numBins();
	}	}

	virtual Double_t* array() const ;	virtual Double_t* array() const;


	virtual Double_t binCenter(Int_t bin) const ;	virtual Double_t binCenter(Int_t bin) const;
	virtual Double_t binWidth(Int_t bin) const ;	virtual Double_t binWidth(Int_t bin) const;
	virtual Double_t binLow(Int_t bin) const ;	virtual Double_t binLow(Int_t bin) const;
	virtual Double_t binHigh(Int_t bin) const ;	virtual Double_t binHigh(Int_t bin) const;

	Bool_t addBoundary(Double_t boundary) ;	Bool_t addBoundary(Double_t boundary);
	void addBoundaryPair(Double_t boundary, Double_t mirrorPoint=0) ;	void addBoundaryPair(Double_t boundary, Double_t mirrorPoint = 0);
	void addUniform(Int_t nBins, Double_t xlo, Double_t xhi) ;	void addUniform(Int_t nBins, Double_t xlo, Double_t xhi);
	Bool_t removeBoundary(Double_t boundary) ;	Bool_t removeBoundary(Double_t boundary);


	Bool_t hasBoundary(Double_t boundary) ;	Bool_t hasBoundary(Double_t boundary);

	protected:	protected:


	Bool_t binEdges(Int_t bin, Double_t& xlo, Double_t& xhi) const ;	Bool_t binEdges(Int_t bin, Double_t& xlo, Double_t& xhi) const;
	void updateBinCount() ;	void updateBinCount();


	Double_t _xlo ; // Lower bound	Double_t _xlo; // Lower bound
	Double_t _xhi ; // Upper bound	Double_t _xhi; // Upper bound
	Bool_t _ownBoundLo ; // Does the lower bound coincide with a bin boun	Bool_t _ownBoundLo; // Does the lower bound coincide with a bin bound
	dary	ary
	Bool_t _ownBoundHi ; // Does the upper bound coincide with a bin boun	Bool_t _ownBoundHi; // Does the upper bound coincide with a bin bound
	dary	ary
	Int_t _nbins ; // Numer of bins	Int_t _nbins; // Numer of bins

		std::vector<Double_t> _boundaries; // Boundaries
		mutable Double_t* _array; //! Array of boundaries
		mutable Int_t _blo; //! bin number for _xlo


	std::set<Double_t> _boundaries ; // Boundaries	ClassDef(RooBinning,3) // Generic binning specification
	mutable Double_t* _array ; //! Array of boundaries

	ClassDef(RooBinning,2) // Generic binning specification
	};	};

	#endif	#endif

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

	RooChebychev.h	RooChebychev.h

	skipping to change at line 45	skipping to change at line 45

	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 ;

	private:	private:

	RooRealProxy _x;	RooRealProxy _x;
	RooListProxy _coefList ;	RooListProxy _coefList ;

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

		Double_t evalAnaInt(const Double_t x) const;

	ClassDef(RooChebychev,1) // Chebychev polynomial PDF	ClassDef(RooChebychev,1) // Chebychev polynomial PDF
	};	};

	#endif	#endif

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

	RooComplex.h	RooComplex.h

	skipping to change at line 19	skipping to change at line 19
	* 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_COMPLEX	#ifndef ROO_COMPLEX
	#define ROO_COMPLEX	#define ROO_COMPLEX


		#if !defined(ROO_MATH) && !defined(ROO_COMPLEX_CXX) && !defined(__CINT__) &
		& \
		!defined(R__DICTIONARY_FILENAME)
		#warning "RooComplex is deprecated, use std::complex instead!"
		#endif

	#include <math.h>	#include <math.h>
	#include "Rtypes.h"	#include "Rtypes.h"
	#include "Riosfwd.h"	#include "Riosfwd.h"

		#include <complex>

	// This is a bare-bones complex class adapted from the CINT complex.h heade r,	// This is a bare-bones complex class adapted from the CINT complex.h heade r,
	// and introduced to support the complex error function in RooMath. The mai n	// and introduced to support the complex error function in RooMath. The mai n
	// changes with respect to the CINT header are to avoid defining global	// changes with respect to the CINT header are to avoid defining global
	// functions (at the cost of not supporting implicit casts on the first	// functions (at the cost of not supporting implicit casts on the first
	// argument) and adding const declarations where appropriate.	// argument) and adding const declarations where appropriate.

	class RooComplex {	class RooComplex {
	public:	public:

	inline RooComplex(Double_t a=0, Double_t b=0) : _re(a), _im(b) { }
	virtual ~RooComplex() {} ;	inline RooComplex(std::complex<Double_t> c) : _re(c.real()), _im(c.imag()
		) { }

		inline RooComplex(Double_t a=0, Double_t b=0) : _re(a), _im(b) { warn();
		}
		virtual ~RooComplex() { }
	inline RooComplex& operator=(const RooComplex& other) {	inline RooComplex& operator=(const RooComplex& other) {

		warn();
	if (&other==this) return *this ;	if (&other==this) return *this ;
	this->_re= other._re;	this->_re= other._re;
	this->_im= other._im;	this->_im= other._im;
	return(*this);	return(*this);
	}	}
	// unary operators	// unary operators
	inline RooComplex operator-() const {	inline RooComplex operator-() const {
	return RooComplex(-_re,-_im);	return RooComplex(-_re,-_im);
	}	}
	// binary operators	// binary operators

	skipping to change at line 96	skipping to change at line 106
	}	}
	inline RooComplex sqrt() const {	inline RooComplex sqrt() const {
	Double_t arg=atan2(_im,_re)*0.5;	Double_t arg=atan2(_im,_re)*0.5;
	Double_t mag=::sqrt(::sqrt(_re_re + _im_im));	Double_t mag=::sqrt(::sqrt(_re_re + _im_im));
	return RooComplex(magcos(arg),magsin(arg));	return RooComplex(magcos(arg),magsin(arg));
	}	}
	// ouptput formatting	// ouptput formatting
	void Print() const;	void Print() const;
	private:	private:
	Double_t _re,_im;	Double_t _re,_im;


		void warn() const;

	ClassDef(RooComplex,0) // a non-persistent bare-bones complex class	ClassDef(RooComplex,0) // a non-persistent bare-bones complex class
	};	};

	// output formatting	// output formatting
	std::ostream& operator<<(std::ostream& os, const RooComplex& z);	std::ostream& operator<<(std::ostream& os, const RooComplex& z);

	#endif	#endif

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

	RooGExpModel.h	RooGExpModel.h

	skipping to change at line 19	skipping to change at line 19
	* 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_GEXP_MODEL	#ifndef ROO_GEXP_MODEL
	#define ROO_GEXP_MODEL	#define ROO_GEXP_MODEL


		#include <cmath>
		#include <complex>

		#include "Rtypes.h"
	#include "RooResolutionModel.h"	#include "RooResolutionModel.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"

	#include "RooComplex.h"
	#include "RooMath.h"	#include "RooMath.h"

	class RooGExpModel : public RooResolutionModel {	class RooGExpModel : public RooResolutionModel {
	public:	public:

	enum RooGExpBasis { noBasis=0, expBasisMinus= 1, expBasisSum= 2, expBasis Plus= 3,	enum RooGExpBasis { noBasis=0, expBasisMinus= 1, expBasisSum= 2, expBasis Plus= 3,
	sinBasisMinus=11, sinBasisSum=12, sinBasisP lus=13,	sinBasisMinus=11, sinBasisSum=12, sinBasisP lus=13,
	cosBasisMinus=21, cosBasisSum=22, cosBasis Plus=23,	cosBasisMinus=21, cosBasisSum=22, cosBasis Plus=23,
	sinhBasisMinus=31,sinhBasisSum=32,sinhBasis Plus=33,	sinhBasisMinus=31,sinhBasisSum=32,sinhBasis Plus=33,
	coshBasisMinus=41,coshBasisSum=42,coshBasis Plus=43} ;	coshBasisMinus=41,coshBasisSum=42,coshBasis Plus=43} ;

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

	void advertiseAsymptoticIntegral(Bool_t flag) { _asympInt = flag ; } // added FMV,07/24/03	void advertiseAsymptoticIntegral(Bool_t flag) { _asympInt = flag ; } // added FMV,07/24/03

	protected:	protected:

	Double_t logErfC(Double_t x) const ;	Double_t logErfC(Double_t x) const ;

	//Double_t calcDecayConv(Double_t sign, Double_t tau, Double_t sig, Doubl e_t rtau) const ;	//Double_t calcDecayConv(Double_t sign, Double_t tau, Double_t sig, Doubl e_t rtau) const ;
	Double_t calcDecayConv(Double_t sign, Double_t tau, Double_t sig, Double_ t rtau, Double_t fsign) const ;	Double_t calcDecayConv(Double_t sign, Double_t tau, Double_t sig, Double_ t rtau, Double_t fsign) const ;
	// modified FMV,08/13/03	// modified FMV,08/13/03

	RooComplex calcSinConv(Double_t sign, Double_t sig, Double_t tau, Double_ t omega, Double_t rtau, Double_t fsign) const ;	std::complex<Double_t> calcSinConv(Double_t sign, Double_t sig, Double_t tau, Double_t omega, Double_t rtau, Double_t fsign) const ;
	Double_t calcSinConv(Double_t sign, Double_t sig, Double_t tau, Double_t rtau, Double_t fsign) const ;	Double_t calcSinConv(Double_t sign, Double_t sig, Double_t tau, Double_t rtau, Double_t fsign) const ;

	RooComplex calcSinConvNorm(Double_t sign, Double_t tau, Double_t omega,	std::complex<Double_t> calcSinConvNorm(Double_t sign, Double_t tau, Doubl e_t omega,
	Double_t sig, Double_t rtau, Double_t fsign, co nst char* rangeName) const ; // modified FMV,07/24/03	Double_t sig, Double_t rtau, Double_t fsign, co nst char* rangeName) const ; // modified FMV,07/24/03
	Double_t calcSinConvNorm(Double_t sign, Double_t tau,	Double_t calcSinConvNorm(Double_t sign, Double_t tau,
	Double_t sig, Double_t rtau, Double_t fsign, const char* rangeName) const ; // added FMV,08/18/03	Double_t sig, Double_t rtau, Double_t fsign, const char* rangeName) const ; // added FMV,08/18/03
	//Double_t calcSinhConv(Double_t sign, Double_t sign1, Double_t sign2, Do uble_t tau, Double_t dgamma, Double_t sig, Double_t rtau, Double_t fsign) c onst ;	//Double_t calcSinhConv(Double_t sign, Double_t sign1, Double_t sign2, Do uble_t tau, Double_t dgamma, Double_t sig, Double_t rtau, Double_t fsign) c onst ;
	//Double_t calcCoshConv(Double_t sign, Double_t tau, Double_t dgamma, Dou ble_t sig, Double_t rtau, Double_t fsign) const ;	//Double_t calcCoshConv(Double_t sign, Double_t tau, Double_t dgamma, Dou ble_t sig, Double_t rtau, Double_t fsign) const ;
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;

	RooComplex evalCerfApprox(Double_t swt, Double_t u, Double_t c) const ;	static std::complex<Double_t> evalCerfApprox(Double_t swt, Double_t u, Do uble_t c);

	// Calculate exp(-u^2) cwerf(swt*c + i(u+c)), taking care of numerical in stabilities	// Calculate exp(-u^2) cwerf(swt*c + i(u+c)), taking care of numerical in stabilities

	inline RooComplex evalCerf(Double_t swt, Double_t u, Double_t c) const {	static inline std::complex<Double_t> evalCerf(Double_t swt, Double_t u, D
	RooComplex z(swt*c,u+c);	ouble_t c)
	return (z.im()>-4.0) ? RooMath::FastComplexErrFunc(z)exp(-uu) : evalC	{
	erfApprox(swt,u,c) ;	std::complex<Double_t> z(swt*c,u+c);
	}	return (z.imag()>-4.0) ? RooMath::faddeeva_fast(z)std::exp(-uu) : eva
		lCerfApprox(swt,u,c) ;
	// Calculate Re(exp(-u^2) cwerf(swt*c + i(u+c))), taking care of numerica
	l instabilities
	inline Double_t evalCerfRe(Double_t swt, Double_t u, Double_t c) const {
	RooComplex z(swt*c,u+c);
	return (z.im()>-4.0) ? RooMath::FastComplexErrFuncRe(z)exp(-uu) : eva
	lCerfApprox(swt,u,c).re() ;
	}

	// Calculate Im(exp(-u^2) cwerf(swt*c + i(u+c))), taking care of numerica
	l instabilities
	inline Double_t evalCerfIm(Double_t swt, Double_t u, Double_t c) const {
	RooComplex z(swt*c,u+c);
	return (z.im()>-4.0) ? RooMath::FastComplexErrFuncIm(z)exp(-uu) : eva
	lCerfApprox(swt,u,c).im() ;
	}	}

	// Calculate Re(exp(-u^2) cwerf(i(u+c)))	// Calculate Re(exp(-u^2) cwerf(i(u+c)))
	// added FMV, 08/17/03	// added FMV, 08/17/03
	inline Double_t evalCerfRe(Double_t u, Double_t c) const {	inline Double_t evalCerfRe(Double_t u, Double_t c) const {
	Double_t expArg = u2c+c*c ;	Double_t expArg = u2c+c*c ;
	if (expArg<300) {	if (expArg<300) {
	return exp(expArg) * RooMath::erfc(u+c);	return exp(expArg) * RooMath::erfc(u+c);
	} else {	} else {
	return exp(expArg+logErfC(u+c));	return exp(expArg+logErfC(u+c));
	}	}
	}	}

	// Calculate common normalization factors	// Calculate common normalization factors
	// added FMV,07/24/03	// added FMV,07/24/03

	RooComplex evalCerfInt(Double_t sign, Double_t wt, Double_t tau, Double_t umin, Double_t umax, Double_t c) const ;	std::complex<Double_t> evalCerfInt(Double_t sign, Double_t wt, Double_t t au, Double_t umin, Double_t umax, Double_t c) const ;
	Double_t evalCerfInt(Double_t sign, Double_t tau, Double_t umin, Double_t umax, Double_t c) const ;	Double_t evalCerfInt(Double_t sign, Double_t tau, Double_t umin, Double_t umax, Double_t c) const ;

	RooRealProxy sigma ;	RooRealProxy sigma ;
	RooRealProxy rlife ;	RooRealProxy rlife ;
	RooRealProxy ssf ;	RooRealProxy ssf ;
	RooRealProxy rsf ;	RooRealProxy rsf ;
	Bool_t _flip ;	Bool_t _flip ;
	Bool_t _nlo ;	Bool_t _nlo ;
	Bool_t _flatSFInt ;	Bool_t _flatSFInt ;
	Bool_t _asympInt ; // added FMV,07/24/03	Bool_t _asympInt ; // added FMV,07/24/03

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

	RooGaussModel.h	RooGaussModel.h

	skipping to change at line 19	skipping to change at line 19
	* 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_GAUSS_MODEL	#ifndef ROO_GAUSS_MODEL
	#define ROO_GAUSS_MODEL	#define ROO_GAUSS_MODEL


		#include <cmath>
		#include <complex>

	#include "RooResolutionModel.h"	#include "RooResolutionModel.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"

	#include "RooComplex.h"
	#include "RooMath.h"	#include "RooMath.h"

	class RooGaussModel : public RooResolutionModel {	class RooGaussModel : public RooResolutionModel {
	public:	public:

	enum RooGaussBasis { noBasis=0, expBasisMinus= 1, expBasisSum= 2, expBasi sPlus= 3,	enum RooGaussBasis { noBasis=0, expBasisMinus= 1, expBasisSum= 2, expBasi sPlus= 3,
	sinBasisMinus=11, sinBasisSum=12, sinBasi sPlus=13,	sinBasisMinus=11, sinBasisSum=12, sinBasi sPlus=13,
	cosBasisMinus=21, cosBasisSum=22, cosBasi sPlus=23,	cosBasisMinus=21, cosBasisSum=22, cosBasi sPlus=23,
	linBasi sPlus=33,	linBasi sPlus=33,
	quadBasi sPlus=43,	quadBasi sPlus=43,

	skipping to change at line 64	skipping to change at line 66
	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 advertiseFlatScaleFactorIntegral(Bool_t flag) { _flatSFInt = flag ; }	void advertiseFlatScaleFactorIntegral(Bool_t flag) { _flatSFInt = flag ; }

	void advertiseAymptoticIntegral(Bool_t flag) { _asympInt = flag ; } // a dded FMV,07/24/03	void advertiseAymptoticIntegral(Bool_t flag) { _asympInt = flag ; } // a dded FMV,07/24/03

	protected:	protected:

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

	RooComplex evalCerfApprox(Double_t swt, Double_t u, Double_t c) const ;	static std::complex<Double_t> evalCerfApprox(Double_t swt, Double_t u, Do uble_t c);

	// Calculate exp(-u^2) cwerf(swt*c + i(u+c)), taking care of numerical in stabilities	// Calculate exp(-u^2) cwerf(swt*c + i(u+c)), taking care of numerical in stabilities

	inline RooComplex evalCerf(Double_t swt, Double_t u, Double_t c) const {	static inline std::complex<Double_t> evalCerf(Double_t swt, Double_t u, D
	RooComplex z(swt*c,u+c);	ouble_t c)
	return (z.im()>-4.0) ? RooMath::FastComplexErrFunc(z)exp(-uu) : evalC	{
	erfApprox(swt,u,c) ;	std::complex<Double_t> z(swt*c,u+c);
	}	return (z.imag()>-4.0) ? (std::exp(-uu)RooMath::faddeeva_fast(z)) : e
		valCerfApprox(swt,u,c);
	// Calculate Re(exp(-u^2) cwerf(swt*c + i(u+c))), taking care of numerica
	l instabilities
	inline Double_t evalCerfRe(Double_t swt, Double_t u, Double_t c) const {
	RooComplex z(swt*c,u+c);
	return (z.im()>-4.0) ? RooMath::FastComplexErrFuncRe(z)exp(-uu) : eva
	lCerfApprox(swt,u,c).re() ;
	}

	// Calculate Im(exp(-u^2) cwerf(swt*c + i(u+c))), taking care of numerica
	l instabilities
	inline Double_t evalCerfIm(Double_t swt, Double_t u, Double_t c) const {
	RooComplex z(swt*c,u+c);
	return (z.im()>-4.0) ? RooMath::FastComplexErrFuncIm(z)exp(-uu) : eva
	lCerfApprox(swt,u,c).im() ;
	}	}

	// Calculate common normalization factors	// Calculate common normalization factors

	RooComplex evalCerfInt(Double_t sign, Double_t wt, Double_t tau, Double_t umin, Double_t umax, Double_t c) const ;	std::complex<Double_t> evalCerfInt(Double_t sign, Double_t wt, Double_t t au, Double_t umin, Double_t umax, Double_t c) const;

	Bool_t _flatSFInt ;	Bool_t _flatSFInt ;

	Bool_t _asympInt ; // added FMV,07/24/03	Bool_t _asympInt ; // added FMV,07/24/03

	RooRealProxy mean ;	RooRealProxy mean ;
	RooRealProxy sigma ;	RooRealProxy sigma ;
	RooRealProxy msf ;	RooRealProxy msf ;
	RooRealProxy ssf ;	RooRealProxy ssf ;


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

	RooKeysPdf.h	RooKeysPdf.h

	skipping to change at line 39	skipping to change at line 39
	MirrorAsymRight, MirrorLeftAsymRight,	MirrorAsymRight, MirrorLeftAsymRight,
	MirrorAsymBoth };	MirrorAsymBoth };
	RooKeysPdf() ;	RooKeysPdf() ;
	RooKeysPdf(const char name, const char title,	RooKeysPdf(const char name, const char title,
	RooAbsReal& x, RooDataSet& data, Mirror mirror= NoMirror,	RooAbsReal& x, RooDataSet& data, Mirror mirror= NoMirror,
	Double_t rho=1);	Double_t rho=1);
	RooKeysPdf(const RooKeysPdf& other, const char* name=0);	RooKeysPdf(const RooKeysPdf& other, const char* name=0);
	virtual TObject* clone(const char* newname) const {return new RooKeysPdf( *this,newname); }	virtual TObject* clone(const char* newname) const {return new RooKeysPdf( *this,newname); }
	virtual ~RooKeysPdf();	virtual ~RooKeysPdf();


		virtual Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& analVa
		rs,
		const char* rangeName = 0) const;
		virtual Double_t analyticalIntegral(Int_t code, const char* rangeName = 0
		) const;
		virtual Int_t getMaxVal(const RooArgSet& vars) const;
		virtual Double_t maxVal(Int_t code) const;

	void LoadDataSet( RooDataSet& data);	void LoadDataSet( RooDataSet& data);

	protected:	protected:

	RooRealProxy _x ;	RooRealProxy _x ;
	Double_t evaluate() const;	Double_t evaluate() const;

	private:	private:

	Double_t evaluateFull(Double_t x) const;	Double_t evaluateFull(Double_t x) const;

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

	RooMath.h	RooMath.h

	skipping to change at line 22	skipping to change at line 22
	* 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_MATH	#ifndef ROO_MATH
	#define ROO_MATH	#define ROO_MATH

	#include <cmath>	#include <cmath>
	#include <complex>	#include <complex>


		#include "Rtypes.h"
		#include "TMath.h"
	#include "RooComplex.h"	#include "RooComplex.h"


	#include <fstream>	#if defined(__my_func__)
		#undef __my_func__
		#endif
		#if defined(WIN32)
		#define __my_func__ __FUNCTION__
		#else
		#define __my_func__ __func__
		#endif


	typedef RooComplex* pRooComplex ;	typedef Double_t* pDouble_t;
	typedef Double_t* pDouble_t ;

	class RooMath {	class RooMath {
	public:	public:


	virtual ~RooMath() {} ;	virtual ~RooMath() {};

	/** @brief evaluate Faddeeva function for complex argument	/** @brief evaluate Faddeeva function for complex argument
	*	*
	* @author Manuel Schiller <manuel.schiller@nikhef.nl>	* @author Manuel Schiller <manuel.schiller@nikhef.nl>
	* @date 2013-02-21	* @date 2013-02-21
	*	*
	* Calculate the value of the Faddeeva function @f$w(z) = \exp(-z^2)	* Calculate the value of the Faddeeva function @f$w(z) = \exp(-z^2)
	* \mathrm{erfc}(-i z)@f$.	* \mathrm{erfc}(-i z)@f$.
	*	*
	* The method described in	* The method described in

	skipping to change at line 89	skipping to change at line 97
	* points, Taylor expansions are used to overcome that difficulty.	* points, Taylor expansions are used to overcome that difficulty.
	*	*
	* This routine precomputes everything it can, and tries to write out com plex	* This routine precomputes everything it can, and tries to write out com plex
	* operations to minimise subroutine calls, e.g. for the multiplication o f	* operations to minimise subroutine calls, e.g. for the multiplication o f
	* complex numbers.	* complex numbers.
	*	*
	* In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accur ate	* In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accur ate
	* to better than 4e-13 relative, the average relative error is better th an	* to better than 4e-13 relative, the average relative error is better th an
	* 7e-16. On a modern x86_64 machine, the routine is roughly three times as	* 7e-16. On a modern x86_64 machine, the routine is roughly three times as
	* fast than the old CERNLIB implementation and offers better accuracy.	* fast than the old CERNLIB implementation and offers better accuracy.

		*
		* For large @f$\|z\|@f$, the familiar continued fraction approximation
		*
		* @f[ w(z)=\frac{-iz/\sqrt{\pi}}{-z^2+\frac{1/2}{1+\frac{2/2}{-z^2 +
		* \frac{3/2}{1+\frac{4/2}{-z^2+\frac{5/2}{1+\frac{6/2}{-z^2+\frac{7/2
		* }{1+\frac{8/2}{-z^2+\frac{9/2}{1+\ldots}}}}}}}}}} @f]
		*
		* is used, truncated at the ellipsis ("...") in the formula; for @f$\|z\|
		>
		* 12@f$, @f$Im(z)>0@f$ it will give full double precision at a smaller
		* computational cost than the method described above. (For @f$\|z\|>12@f$,
		* @f$Im(z)<0@f$, the symmetry property @f$w(x-iy)=2e^{-(x+iy)^2-w(x+iy)}
		@f$
		* is used.
	*/	*/
	static std::complex<double> faddeeva(std::complex<double> z);	static std::complex<double> faddeeva(std::complex<double> z);
	/** @brief evaluate Faddeeva function for complex argument (fast version)	/** @brief evaluate Faddeeva function for complex argument (fast version)
	*	*
	* @author Manuel Schiller <manuel.schiller@nikhef.nl>	* @author Manuel Schiller <manuel.schiller@nikhef.nl>
	* @date 2013-02-21	* @date 2013-02-21
	*	*
	* Calculate the value of the Faddeeva function @f$w(z) = \exp(-z^2)	* Calculate the value of the Faddeeva function @f$w(z) = \exp(-z^2)
	* \mathrm{erfc}(-i z)@f$.	* \mathrm{erfc}(-i z)@f$.
	*	*

	skipping to change at line 113	skipping to change at line 133
	* To be fast, chose @f$t_m=8@f$ and @f$N=11@f$ which should give accurac ies	* To be fast, chose @f$t_m=8@f$ and @f$N=11@f$ which should give accurac ies
	* around 1e-7.	* around 1e-7.
	*	*
	* In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accur ate	* In the square -8 <= Re(z) <= 8, -8 <= Im(z) <= 8, the routine is accur ate
	* to better than 4e-7 relative, the average relative error is better tha n	* to better than 4e-7 relative, the average relative error is better tha n
	* 5e-9. On a modern x86_64 machine, the routine is roughly five times as	* 5e-9. On a modern x86_64 machine, the routine is roughly five times as
	* fast than the old CERNLIB implementation, or about 30% faster than the	* fast than the old CERNLIB implementation, or about 30% faster than the
	* interpolation/lookup table based fast method used previously in RooFit ,	* interpolation/lookup table based fast method used previously in RooFit ,
	* and offers better accuracy than the latter (the relative error is roug hly	* and offers better accuracy than the latter (the relative error is roug hly
	* a factor 280 smaller than the old interpolation/table lookup routine).	* a factor 280 smaller than the old interpolation/table lookup routine).

		*
		* For large @f$\|z\|@f$, the familiar continued fraction approximation
		*
		* @f[ w(z)=\frac{-iz/\sqrt{\pi}}{-z^2+\frac{1/2}{1+\frac{2/2}{-z^2 +
		* \frac{3/2}{1+\ldots}}}} @f]
		*
		* is used, truncated at the ellipsis ("...") in the formula; for @f$\|z\|
		>
		* 8@f$, @f$Im(z)>0@f$ it will give full float precision at a smaller
		* computational cost than the method described above. (For @f$\|z\|>8@f$,
		* @f$Im(z)<0@f$, the symmetry property @f$w(x-iy)=2e^{-(x+iy)^2-w(x+iy)}
		@f$
		* is used.
	*/	*/
	static std::complex<double> faddeeva_fast(std::complex<double> z);	static std::complex<double> faddeeva_fast(std::complex<double> z);

	/** @brief complex erf function	/** @brief complex erf function
	*	*
	* @author Manuel Schiller <manuel.schiller@nikhef.nl>	* @author Manuel Schiller <manuel.schiller@nikhef.nl>
	* @date 2013-02-21	* @date 2013-02-21
	*	*
	* Calculate erf(z) for complex z.	* Calculate erf(z) for complex z.
	*/	*/

	skipping to change at line 150	skipping to change at line 181
	static std::complex<double> erfc(const std::complex<double> z);	static std::complex<double> erfc(const std::complex<double> z);
	/** @brief complex erfc function (fast version)	/** @brief complex erfc function (fast version)
	*	*
	* @author Manuel Schiller <manuel.schiller@nikhef.nl>	* @author Manuel Schiller <manuel.schiller@nikhef.nl>
	* @date 2013-02-21	* @date 2013-02-21
	*	*
	* Calculate erfc(z) for complex z. Use the code in faddeeva_fast to save some time.	* Calculate erfc(z) for complex z. Use the code in faddeeva_fast to save some time.
	*/	*/
	static std::complex<double> erfc_fast(const std::complex<double> z);	static std::complex<double> erfc_fast(const std::complex<double> z);


	// CERNLIB complex error function
	static RooComplex ComplexErrFunc(Double_t re, Double_t im= 0);
	static RooComplex ComplexErrFunc(const RooComplex& z);

	// Interpolated CERF with automatic interpolation order selection
	static RooComplex FastComplexErrFunc(const RooComplex& z) ;

	// Interpolated Re(CERF) with automatic interpolation order selection
	static Double_t FastComplexErrFuncRe(const RooComplex& z) ;

	// Interpolated Im(CERF) with automatic interpolation order selection
	static Double_t FastComplexErrFuncIm(const RooComplex& z) ;

	// Interpolated complex error function at specified interpolation order
	static RooComplex ITPComplexErrFunc(const RooComplex& z, Int_t nOrder) ;
	static Double_t ITPComplexErrFuncRe(const RooComplex& z, Int_t nOrder) ;
	static Double_t ITPComplexErrFuncIm(const RooComplex& z, Int_t nOrder) ;

	// Switch to use file cache for CERF lookup table
	static void cacheCERF(Bool_t flag=kTRUE) ;

	// 1-D nth order polynomial interpolation routines	// 1-D nth order polynomial interpolation routines
	static Double_t interpolate(Double_t yArr[],Int_t nOrder, Double_t x) ;	static Double_t interpolate(Double_t yArr[],Int_t nOrder, Double_t x) ;
	static Double_t interpolate(Double_t xa[], Double_t ya[], Int_t n, Double _t x) ;	static Double_t interpolate(Double_t xa[], Double_t ya[], Int_t n, Double _t x) ;


	static Double_t erf(Double_t x) ;	static inline Double_t erf(Double_t x)
	static Double_t erfc(Double_t x) ;	{ return TMath::Erf(x); }


	static void cleanup() ;	static inline Double_t erfc(Double_t x)
		{ return TMath::Erfc(x); }


	// Allocate and initialize CERF lookup grid	/// deprecated function
	static void initFastCERF(Int_t reBins= 800, Double_t reMin=-4.0, Double_t	static RooComplex ComplexErrFunc(Double_t re, Double_t im = 0.)
	reMax=4.0,	{ warn(__my_func__, "RooMath::faddeeva"); std::complex<Double_t> z = fadd
	Int_t imBins=1000, Double_t imMin=-4.0, Double_t	eeva(std::complex<Double_t>(re, im)); return RooComplex(z.real(), z.imag())
	imMax=6.0) ;	; }
		/// deprecated function
		static RooComplex ComplexErrFunc(const RooComplex& zz)
		{ warn(__my_func__, "RooMath::faddeeva"); std::complex<Double_t> z = fadd
		eeva(std::complex<Double_t>(zz.re(), zz.im())); return RooComplex(z.real(),
		z.imag()); }
		/// deprecated function
		static RooComplex ComplexErrFuncFast(const RooComplex& zz)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return RooComplex
		(z.real(), z.imag()); }
		/// deprecated function
		static Double_t ComplexErrFuncFastRe(const RooComplex& zz)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return z.real();
		}
		/// deprecated function
		static Double_t ComplexErrFuncFastIm(const RooComplex& zz)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return z.imag();
		}
		/// deprecated function
		static RooComplex ITPComplexErrFuncFast(const RooComplex& zz, Int_t)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return RooComplex
		(z.real(), z.imag()); }
		/// deprecated function
		static Double_t ITPComplexErrFuncFastRe(const RooComplex& zz, Int_t)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return z.real();
		}
		/// deprecated function
		static Double_t ITPComplexErrFuncFastIm(const RooComplex& zz, Int_t)
		{ warn(__my_func__, "RooMath::faddeeva_fast"); std::complex<Double_t> z =
		faddeeva_fast(std::complex<Double_t>(zz.re(), zz.im())); return z.imag();
		}
		/// deprecated function
		static void cacheCERF(Bool_t) { warn(__my_func__); }
		/// deprecated function
		static void cleanup() { warn(__my_func__); }
		/// deprecated function
		static void initFastCERF(Int_t /reBins = 800/, Double_t /*reMin = -4.0
		/, Double_t /reMax = 4.0*/,
		Int_t /imBins = 1000/, Double_t /imMin = -4.0
		/, Double_t /imMax = 6.0/)
		{
		warn(__my_func__);
		}

	private:	private:

		// deprecation warnings
		static void warn(const char* oldfun, const char* newfun = 0);

	ClassDef(RooMath,0) // math utility routines	ClassDef(RooMath,0) // math utility routines
	};	};


		#undef __my_func__

	#endif	#endif

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

	RooMinimizer.h	RooMinimizer.h

	skipping to change at line 49	skipping to change at line 49

	RooMinimizer(RooAbsReal& function) ;	RooMinimizer(RooAbsReal& function) ;
	virtual ~RooMinimizer() ;	virtual ~RooMinimizer() ;

	enum Strategy { Speed=0, Balance=1, Robustness=2 } ;	enum Strategy { Speed=0, Balance=1, Robustness=2 } ;
	enum PrintLevel { None=-1, Reduced=0, Normal=1, ExtraForProblem=2, Maximu m=3 } ;	enum PrintLevel { None=-1, Reduced=0, Normal=1, ExtraForProblem=2, Maximu m=3 } ;
	void setStrategy(Int_t strat) ;	void setStrategy(Int_t strat) ;
	void setErrorLevel(Double_t level) ;	void setErrorLevel(Double_t level) ;
	void setEps(Double_t eps) ;	void setEps(Double_t eps) ;
	void optimizeConst(Int_t flag) ;	void optimizeConst(Int_t flag) ;

	void setEvalErrorWall(Bool_t flag) { _fcn->SetEvalErrorWall(flag); }	void setEvalErrorWall(Bool_t flag) { fitterFcn()->SetEvalErrorWall(flag); }
	void setOffsetting(Bool_t flag) ;	void setOffsetting(Bool_t flag) ;

		void setMaxIterations(Int_t n) ;
		void setMaxFunctionCalls(Int_t n) ;

	RooFitResult* fit(const char* options) ;	RooFitResult* fit(const char* options) ;

	Int_t migrad() ;	Int_t migrad() ;
	Int_t hesse() ;	Int_t hesse() ;
	Int_t minos() ;	Int_t minos() ;
	Int_t minos(const RooArgSet& minosParamList) ;	Int_t minos(const RooArgSet& minosParamList) ;
	Int_t seek() ;	Int_t seek() ;
	Int_t simplex() ;	Int_t simplex() ;
	Int_t improve() ;	Int_t improve() ;

	Int_t minimize(const char* type, const char* alg=0) ;	Int_t minimize(const char* type, const char* alg=0) ;

	RooFitResult* save(const char* name=0, const char* title=0) ;	RooFitResult* save(const char* name=0, const char* title=0) ;
	RooPlot* contour(RooRealVar& var1, RooRealVar& var2,	RooPlot* contour(RooRealVar& var1, RooRealVar& var2,
	Double_t n1=1, Double_t n2=2, Double_t n3=0,	Double_t n1=1, Double_t n2=2, Double_t n3=0,
	Double_t n4=0, Double_t n5=0, Double_t n6=0) ;	Double_t n4=0, Double_t n5=0, Double_t n6=0) ;

	Int_t setPrintLevel(Int_t newLevel) ;	Int_t setPrintLevel(Int_t newLevel) ;

	void setPrintEvalErrors(Int_t numEvalErrors) { _fcn->SetPrintEvalErrors(n	void setPrintEvalErrors(Int_t numEvalErrors) { fitterFcn()->SetPrintEvalE
	umEvalErrors); }	rrors(numEvalErrors); }
	void setVerbose(Bool_t flag=kTRUE) { _verbose = flag ; _fcn->SetVerbose(f	void setVerbose(Bool_t flag=kTRUE) { _verbose = flag ; fitterFcn()->SetVe
	lag); }	rbose(flag); }
	void setProfile(Bool_t flag=kTRUE) { _profile = flag ; }	void setProfile(Bool_t flag=kTRUE) { _profile = flag ; }

	Bool_t setLogFile(const char* logf=0) { return _fcn->SetLogFile(logf); }	Bool_t setLogFile(const char* logf=0) { return fitterFcn()->SetLogFile(lo gf); }

	void setMinimizerType(const char* type) ;	void setMinimizerType(const char* type) ;

	static void cleanup() ;	static void cleanup() ;
	static RooFitResult* lastMinuitFit(const RooArgList& varList=RooArgList() ) ;	static RooFitResult* lastMinuitFit(const RooArgList& varList=RooArgList() ) ;

	void saveStatus(const char* label, Int_t status) { _statusHistory.push_ba ck(std::pair<std::string,int>(label,status)) ; }	void saveStatus(const char* label, Int_t status) { _statusHistory.push_ba ck(std::pair<std::string,int>(label,status)) ; }


	Int_t evalCounter() const { return _fcn->evalCounter() ; }	Int_t evalCounter() const { return fitterFcn()->evalCounter() ; }
	void zeroEvalCount() { _fcn->zeroEvalCount() ; }	void zeroEvalCount() { fitterFcn()->zeroEvalCount() ; }

		ROOT::Fit::Fitter* fitter() ;
		const ROOT::Fit::Fitter* fitter() const ;

	protected:	protected:

	friend class RooAbsPdf ;	friend class RooAbsPdf ;
	void applyCovarianceMatrix(TMatrixDSym& V) ;	void applyCovarianceMatrix(TMatrixDSym& V) ;

	void profileStart() ;	void profileStart() ;
	void profileStop() ;	void profileStop() ;


	inline Int_t getNPar() const { return _fcn->NDim() ; }	inline Int_t getNPar() const { return fitterFcn()->NDim() ; }
	inline std::ofstream* logfile() const { return _fcn->GetLogFile(); }	inline std::ofstream* logfile() { return fitterFcn()->GetLogFile(); }
	inline Double_t& maxFCN() { return _fcn->GetMaxFCN() ; }	inline Double_t& maxFCN() { return fitterFcn()->GetMaxFCN() ; }

		const RooMinimizerFcn* fitterFcn() const { return ( fitter()->GetFCN() ?
		((RooMinimizerFcn*) fitter()->GetFCN()) : _fcn ) ; }
		RooMinimizerFcn* fitterFcn() { return ( fitter()->GetFCN() ? ((RooMinimiz
		erFcn*) fitter()->GetFCN()) : _fcn ) ; }

	private:	private:

	Int_t _printLevel ;	Int_t _printLevel ;
	Int_t _status ;	Int_t _status ;
	Bool_t _optConst ;	Bool_t _optConst ;
	Bool_t _profile ;	Bool_t _profile ;
	RooAbsReal* _func ;	RooAbsReal* _func ;

	Bool_t _verbose ;	Bool_t _verbose ;

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

	RooNLLVar.h	RooNLLVar.h

	skipping to change at line 66	skipping to change at line 66
	protected:	protected:

	virtual Bool_t processEmptyDataSets() const { return _extended ; }	virtual Bool_t processEmptyDataSets() const { return _extended ; }

	static RooArgSet _emptySet ; // Supports named argument constructor	static RooArgSet _emptySet ; // Supports named argument constructor

	Bool_t _extended ;	Bool_t _extended ;
	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const ;	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const ;
	Bool_t _weightSq ; // Apply weights squared?	Bool_t _weightSq ; // Apply weights squared?
	mutable Bool_t _first ; //!	mutable Bool_t _first ; //!

		Double_t _offsetSaveW2; //!
		Double_t _offsetCarrySaveW2; //!


	ClassDef(RooNLLVar,1) // Function representing (extended) -log(L) of p.d. f and dataset	ClassDef(RooNLLVar,2) // Function representing (extended) -log(L) of p.d. f and dataset
	};	};

	#endif	#endif

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

	RooRealMPFE.h	RooRealMPFE.h

	skipping to change at line 28	skipping to change at line 28

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"
	#include "RooArgList.h"	#include "RooArgList.h"
	#include "RooMPSentinel.h"	#include "RooMPSentinel.h"
	#include "TStopwatch.h"	#include "TStopwatch.h"
	#include <vector>	#include <vector>

	class RooArgSet ;	class RooArgSet ;

		namespace RooFit { class BidirMMapPipe; }

	class RooRealMPFE : public RooAbsReal {	class RooRealMPFE : public RooAbsReal {
	public:	public:
	// Constructors, assignment etc	// Constructors, assignment etc
	RooRealMPFE(const char name, const char title, RooAbsReal& arg, Bool_t calcInline=kFALSE) ;	RooRealMPFE(const char name, const char title, RooAbsReal& arg, Bool_t calcInline=kFALSE) ;
	RooRealMPFE(const RooRealMPFE& other, const char* name=0);	RooRealMPFE(const RooRealMPFE& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooRealMPF E(*this,newname); }	virtual TObject* clone(const char* newname) const { return new RooRealMPF E(*this,newname); }
	virtual ~RooRealMPFE();	virtual ~RooRealMPFE();

	void calculate() const ;	void calculate() const ;

	skipping to change at line 55	skipping to change at line 56
	void enableOffsetting(Bool_t flag) ;	void enableOffsetting(Bool_t flag) ;

	void followAsSlave(RooRealMPFE& master) { _updateMaster = &master ; }	void followAsSlave(RooRealMPFE& master) { _updateMaster = &master ; }

	protected:	protected:

	// Function evaluation	// Function evaluation
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;
	friend class RooAbsTestStatistic ;	friend class RooAbsTestStatistic ;
	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso Tracking=kTRUE) ;	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso Tracking=kTRUE) ;

		virtual Double_t getCarry() const;

	enum State { Initialize,Client,Server,Inline } ;	enum State { Initialize,Client,Server,Inline } ;
	State _state ;	State _state ;


	enum Message { SendReal=0, SendCat=1, Calculate=2, Retrieve=3, ReturnValu	enum Message { SendReal=0, SendCat, Calculate, Retrieve, ReturnValue, Ter
	e=4, Terminate=5,	minate,
	ConstOpt=6, Verbose=7, RetrieveErrors=8, SendError=9, LogEv	ConstOpt, Verbose, LogEvalError, ApplyNLLW2, EnableOffset,
	alError=10, ApplyNLLW2=11, EnableOffset=12, CalculateNoOffset=13 } ;	CalculateNoOffset } ;

	void initialize() ;	void initialize() ;
	void initVars() ;	void initVars() ;
	void serverLoop() ;	void serverLoop() ;

	void doApplyNLLW2(Bool_t flag) ;	void doApplyNLLW2(Bool_t flag) ;

	RooRealProxy _arg ; // Function to calculate in parallel process	RooRealProxy _arg ; // Function to calculate in parallel process
	RooListProxy _vars ; // Variables	RooListProxy _vars ; // Variables
	RooArgList _saveVars ; // Copy of variables	RooArgList _saveVars ; // Copy of variables
	mutable Bool_t _calcInProgress ;	mutable Bool_t _calcInProgress ;
	Bool_t _verboseClient ;	Bool_t _verboseClient ;
	Bool_t _verboseServer ;	Bool_t _verboseServer ;
	Bool_t _inlineMode ;	Bool_t _inlineMode ;
	mutable Bool_t _forceCalc ;	mutable Bool_t _forceCalc ;
	mutable RooAbsReal::ErrorLoggingMode _remoteEvalErrorLoggingState ;	mutable RooAbsReal::ErrorLoggingMode _remoteEvalErrorLoggingState ;

	Int_t _pid ; // PID of child process


	Int_t _pipeToClient[2] ; // Pipe to client process	RooFit::BidirMMapPipe *_pipe; //! connection to child
	Int_t _pipeToServer[2] ; // Pipe to server process

	mutable std::vector<Bool_t> _valueChanged ; //! Flags if variable needs u pdate on server-side	mutable std::vector<Bool_t> _valueChanged ; //! Flags if variable needs u pdate on server-side
	mutable std::vector<Bool_t> _constChanged ; //! Flags if variable needs u pdate on server-side	mutable std::vector<Bool_t> _constChanged ; //! Flags if variable needs u pdate on server-side
	RooRealMPFE* _updateMaster ; //! Update master	RooRealMPFE* _updateMaster ; //! Update master
	mutable Bool_t _retrieveDispatched ; //!	mutable Bool_t _retrieveDispatched ; //!

		mutable Double_t _evalCarry; //!

	static RooMPSentinel _sentinel ;	static RooMPSentinel _sentinel ;


	ClassDef(RooRealMPFE,1) // Multi-process front-end for parallel calculati on of a real valued function	ClassDef(RooRealMPFE,2) // Multi-process front-end for parallel calculati on of a real valued function
	};	};

	#endif	#endif

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

	Sample.h	Sample.h

	skipping to change at line 20	skipping to change at line 20

	#ifndef HISTFACTORY_SAMPLE_H	#ifndef HISTFACTORY_SAMPLE_H
	#define HISTFACTORY_SAMPLE_H	#define HISTFACTORY_SAMPLE_H

	#include <string>	#include <string>
	#include <fstream>	#include <fstream>
	#include <vector>	#include <vector>
	#include <iostream>	#include <iostream>

	#include "TRef.h"	#include "TRef.h"

		class TH1;
	#include "RooStats/HistFactory/Systematics.h"	#include "RooStats/HistFactory/Systematics.h"

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	class Sample {	class Sample {

	public:	public:

	Sample();	Sample();
	Sample(std::string Name);	Sample(std::string Name);
	Sample(std::string Name, std::string HistoName, std::string InputFile, st d::string HistoPath="");	Sample(std::string Name, std::string HistoName, std::string InputFile, st d::string HistoPath="");

		~Sample();

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);
	void PrintXML( std::ofstream& xml );	void PrintXML( std::ofstream& xml );
	void writeToFile( std::string FileName, std::string DirName );	void writeToFile( std::string FileName, std::string DirName );

	TH1* GetHisto();	TH1* GetHisto();

		// set histogram for this sample
	void SetHisto( TH1* histo ) { fhNominal = histo; fHistoName=histo->GetNam e(); }	void SetHisto( TH1* histo ) { fhNominal = histo; fHistoName=histo->GetNam e(); }
	void SetValue( Double_t Val );	void SetValue( Double_t Val );

	// Some helper functions	// Some helper functions

	void ActivateStatError();	void ActivateStatError();
	void ActivateStatError( std::string HistoName, std::string InputFile, std ::string HistoPath="" );	void ActivateStatError( std::string HistoName, std::string InputFile, std ::string HistoPath="" );

	void AddOverallSys( std::string Name, Double_t Low, Double_t High );	void AddOverallSys( std::string Name, Double_t Low, Double_t High );
	void AddOverallSys( const OverallSys& Sys );	void AddOverallSys( const OverallSys& Sys );

	skipping to change at line 66	skipping to change at line 69
	void AddHistoFactor( std::string Name, std::string HistoNameLow, std::st ring HistoFileLow, std::string HistoPathLow,	void AddHistoFactor( std::string Name, std::string HistoNameLow, std::st ring HistoFileLow, std::string HistoPathLow,
	std::string HistoNameHigh, std::string HistoFileHigh, std::string HistoPathHigh );	std::string HistoNameHigh, std::string HistoFileHigh, std::string HistoPathHigh );
	void AddHistoFactor( const HistoFactor& Factor );	void AddHistoFactor( const HistoFactor& Factor );

	void AddShapeFactor( std::string Name );	void AddShapeFactor( std::string Name );
	void AddShapeFactor( const ShapeFactor& Factor );	void AddShapeFactor( const ShapeFactor& Factor );

	void AddShapeSys( std::string Name, Constraint::Type ConstraintType, s td::string HistoName, std::string HistoFile, std::string HistoPath="" );	void AddShapeSys( std::string Name, Constraint::Type ConstraintType, s td::string HistoName, std::string HistoFile, std::string HistoPath="" );
	void AddShapeSys( const ShapeSys& Sys );	void AddShapeSys( const ShapeSys& Sys );


		// defines whether the normalization scale with luminosity
	void SetNormalizeByTheory( bool norm ) { fNormalizeByTheory = norm; }	void SetNormalizeByTheory( bool norm ) { fNormalizeByTheory = norm; }

		// does the normalization scale with luminosity
	bool GetNormalizeByTheory() { return fNormalizeByTheory; }	bool GetNormalizeByTheory() { return fNormalizeByTheory; }


		// get name of sample
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

		// set name of sample
	void SetName(const std::string& Name) { fName = Name; }	void SetName(const std::string& Name) { fName = Name; }


		// get input ROOT file
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

		// set input ROOT file
	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }	void SetInputFile(const std::string& InputFile) { fInputFile = InputFile; }


		// get histogram name
	std::string GetHistoName() { return fHistoName; }	std::string GetHistoName() { return fHistoName; }

		// set histogram name
	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }	void SetHistoName(const std::string& HistoName) { fHistoName = HistoName; }


		// get histogram path
	std::string GetHistoPath() { return fHistoPath; }	std::string GetHistoPath() { return fHistoPath; }

		// set histogram path
	void SetHistoPath(const std::string& HistoPath) { fHistoPath = HistoPath; }	void SetHistoPath(const std::string& HistoPath) { fHistoPath = HistoPath; }


		// get name of associated channel
	std::string GetChannelName() { return fChannelName; }	std::string GetChannelName() { return fChannelName; }

		// set name of associated channel
	void SetChannelName(const std::string& ChannelName) { fChannelName = Chan nelName; }	void SetChannelName(const std::string& ChannelName) { fChannelName = Chan nelName; }

	std::vector< RooStats::HistFactory::OverallSys >& GetOverallSysList() { r eturn fOverallSysList; }	std::vector< RooStats::HistFactory::OverallSys >& GetOverallSysList() { r eturn fOverallSysList; }
	std::vector< RooStats::HistFactory::NormFactor >& GetNormFactorList() { r eturn fNormFactorList; }	std::vector< RooStats::HistFactory::NormFactor >& GetNormFactorList() { r eturn fNormFactorList; }

	std::vector< RooStats::HistFactory::HistoSys >& GetHistoSysList() { return fHistoSysList; }	std::vector< RooStats::HistFactory::HistoSys >& GetHistoSysList() { return fHistoSysList; }
	std::vector< RooStats::HistFactory::HistoFactor >& GetHistoFactorList() { return fHistoFactorList; }	std::vector< RooStats::HistFactory::HistoFactor >& GetHistoFactorList() { return fHistoFactorList; }

	std::vector< RooStats::HistFactory::ShapeSys >& GetShapeSysList() { return fShapeSysList; }	std::vector< RooStats::HistFactory::ShapeSys >& GetShapeSysList() { return fShapeSysList; }
	std::vector< RooStats::HistFactory::ShapeFactor >& GetShapeFactorList() { return fShapeFactorList; }	std::vector< RooStats::HistFactory::ShapeFactor >& GetShapeFactorList() { return fShapeFactorList; }

	skipping to change at line 127	skipping to change at line 142
	std::vector< RooStats::HistFactory::ShapeFactor > fShapeFactorList;	std::vector< RooStats::HistFactory::ShapeFactor > fShapeFactorList;

	// Properties	// Properties
	RooStats::HistFactory::StatError fStatError;	RooStats::HistFactory::StatError fStatError;

	bool fNormalizeByTheory;	bool fNormalizeByTheory;
	bool fStatErrorActivate;	bool fStatErrorActivate;

	// The Nominal Shape	// The Nominal Shape
	TRef fhNominal;	TRef fhNominal;

		TH1* fhCountingHist;

	};	};

	} // namespace HistFactory	} // namespace HistFactory
	} // namespace RooStats	} // namespace RooStats

	#endif	#endif

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

	Systematics.h	Systematics.h

	skipping to change at line 21	skipping to change at line 21
	#ifndef HISTFACTORY_SYSTEMATICS_H	#ifndef HISTFACTORY_SYSTEMATICS_H
	#define HISTFACTORY_SYSTEMATICS_H	#define HISTFACTORY_SYSTEMATICS_H

	#include <string>	#include <string>
	#include <fstream>	#include <fstream>
	#include <iostream>	#include <iostream>

	#include "TH1.h"	#include "TH1.h"
	#include "TRef.h"	#include "TRef.h"


	//#include "RooStats/HistFactory/HistCollector.h"

	namespace RooStats{	namespace RooStats{
	namespace HistFactory {	namespace HistFactory {

	namespace Constraint {	namespace Constraint {
	enum Type{ Gaussian, Poisson };	enum Type{ Gaussian, Poisson };
	std::string Name( Type type );	std::string Name( Type type );

	Type GetType( std::string Name );	Type GetType( const std::string& Name );
	}	}


		// Base class for common functions
		/*
		class Systematic {

		public:

		virtual void Print(std::ostream& = std::cout);
		virtual void writeToFile(const std::string& FileName,
		const std::string& Directory);

		};
		*/

	class OverallSys {	class OverallSys {

	public:	public:

	//friend class Channel;

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void SetLow( double Low ) { fLow = Low; }	void SetLow( double Low ) { fLow = Low; }
	void SetHigh( double High ) { fHigh = High; }	void SetHigh( double High ) { fHigh = High; }
	double GetLow() { return fLow; }	double GetLow() { return fLow; }
	double GetHigh() { return fHigh; }	double GetHigh() { return fHigh; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML(std::ostream&);

	protected:	protected:
	std::string fName;	std::string fName;
	double fLow;	double fLow;
	double fHigh;	double fHigh;

	};	};

	class NormFactor {	class NormFactor {

	public:	public:

	//friend class Channel;

	NormFactor();	NormFactor();

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void SetVal( double Val ) { fVal = Val; }	void SetVal( double Val ) { fVal = Val; }
	double GetVal() { return fVal; }	double GetVal() { return fVal; }

	void SetConst( bool Const=true ) { fConst = Const; }	void SetConst( bool Const=true ) { fConst = Const; }
	bool GetConst() { return fConst; }	bool GetConst() { return fConst; }

	void SetLow( double Low ) { fLow = Low; }	void SetLow( double Low ) { fLow = Low; }
	void SetHigh( double High ) { fHigh = High; }	void SetHigh( double High ) { fHigh = High; }
	double GetLow() { return fLow; }	double GetLow() { return fLow; }
	double GetHigh() { return fHigh; }	double GetHigh() { return fHigh; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML(std::ostream&);

	protected:	protected:

	std::string fName;	std::string fName;
	double fVal;	double fVal;
	double fLow;	double fLow;
	double fHigh;	double fHigh;
	bool fConst;	bool fConst;

	};	};

	class HistoSys {	class HistoSys {

	public:	public:

	//friend class Channel;

	HistoSys() : fhLow(NULL), fhHigh(NULL) {;}	HistoSys() : fhLow(NULL), fhHigh(NULL) {;}
	HistoSys(const std::string& Name) : fName(Name), fhLow(NULL), fhHigh(NU LL) {;}	HistoSys(const std::string& Name) : fName(Name), fhLow(NULL), fhHigh(NU LL) {;}

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

	void writeToFile( std::string FileName, std::string DirName );	void PrintXML(std::ostream&);
		void writeToFile( const std::string& FileName, const std::string& DirNa
		me );

	void SetHistoLow( TH1* Low ) { fhLow = Low; }	void SetHistoLow( TH1* Low ) { fhLow = Low; }
	void SetHistoHigh( TH1* High ) { fhHigh = High; }	void SetHistoHigh( TH1* High ) { fhHigh = High; }

	TH1* GetHistoLow();	TH1* GetHistoLow();
	TH1* GetHistoHigh();	TH1* GetHistoHigh();

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }


	skipping to change at line 146	skipping to change at line 157

	// The Low and High Histograms	// The Low and High Histograms
	TRef fhLow;	TRef fhLow;
	TRef fhHigh;	TRef fhHigh;

	};	};

	class HistoFactor {	class HistoFactor {

	public:	public:

	//friend class Channel;

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void SetInputFileLow( const std::string& InputFileLow ) { fInputFileLow = InputFileLow; }	void SetInputFileLow( const std::string& InputFileLow ) { fInputFileLow = InputFileLow; }
	void SetInputFileHigh( const std::string& InputFileHigh ) { fInputFileH igh = InputFileHigh; }	void SetInputFileHigh( const std::string& InputFileHigh ) { fInputFileH igh = InputFileHigh; }

	std::string GetInputFileLow() { return fInputFileLow; }	std::string GetInputFileLow() { return fInputFileLow; }
	std::string GetInputFileHigh() { return fInputFileHigh; }	std::string GetInputFileHigh() { return fInputFileHigh; }


	skipping to change at line 170	skipping to change at line 180
	std::string GetHistoNameLow() { return fHistoNameLow; }	std::string GetHistoNameLow() { return fHistoNameLow; }
	std::string GetHistoNameHigh() { return fHistoNameHigh; }	std::string GetHistoNameHigh() { return fHistoNameHigh; }

	void SetHistoPathLow( const std::string& HistoPathLow ) { fHistoPathLow = HistoPathLow; }	void SetHistoPathLow( const std::string& HistoPathLow ) { fHistoPathLow = HistoPathLow; }
	void SetHistoPathHigh( const std::string& HistoPathHigh ) { fHistoPathH igh = HistoPathHigh; }	void SetHistoPathHigh( const std::string& HistoPathHigh ) { fHistoPathH igh = HistoPathHigh; }

	std::string GetHistoPathLow() { return fHistoPathLow; }	std::string GetHistoPathLow() { return fHistoPathLow; }
	std::string GetHistoPathHigh() { return fHistoPathHigh; }	std::string GetHistoPathHigh() { return fHistoPathHigh; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

	void writeToFile( std::string FileName, std::string DirName );	void writeToFile( const std::string& FileName, const std::string& DirNa
		me );
		void PrintXML(std::ostream&);

	TH1* GetHistoLow();	TH1* GetHistoLow();
	TH1* GetHistoHigh();	TH1* GetHistoHigh();
	void SetHistoLow( TH1* Low ) { fhLow = Low; }	void SetHistoLow( TH1* Low ) { fhLow = Low; }
	void SetHistoHigh( TH1* High ) { fhHigh = High; }	void SetHistoHigh( TH1* High ) { fhHigh = High; }

	protected:	protected:

	std::string fName;	std::string fName;


	skipping to change at line 198	skipping to change at line 209

	// The Low and High Histograms	// The Low and High Histograms
	TRef fhLow;	TRef fhLow;
	TRef fhHigh;	TRef fhHigh;

	};	};

	class ShapeSys {	class ShapeSys {

	public:	public:

	//friend class Channel;

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void SetInputFile( const std::string& InputFile ) { fInputFile = InputF ile; }	void SetInputFile( const std::string& InputFile ) { fInputFile = InputF ile; }
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }

	void SetHistoName( const std::string& HistoName ) { fHistoName = HistoN ame; }	void SetHistoName( const std::string& HistoName ) { fHistoName = HistoN ame; }
	std::string GetHistoName() { return fHistoName; }	std::string GetHistoName() { return fHistoName; }

	void SetHistoPath( const std::string& HistoPath ) { fHistoPath = HistoP ath; }	void SetHistoPath( const std::string& HistoPath ) { fHistoPath = HistoP ath; }
	std::string GetHistoPath() { return fHistoPath; }	std::string GetHistoPath() { return fHistoPath; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

	void writeToFile( std::string FileName, std::string DirName );	void PrintXML(std::ostream&);
		void writeToFile( const std::string& FileName, const std::string& DirNa
		me );

	TH1* GetErrorHist();	TH1* GetErrorHist();
	void SetErrorHist(TH1* hError) { fhError = hError; }	void SetErrorHist(TH1* hError) { fhError = hError; }

	void SetConstraintType( Constraint::Type ConstrType ) { fConstraintType = ConstrType; }	void SetConstraintType( Constraint::Type ConstrType ) { fConstraintType = ConstrType; }
	Constraint::Type GetConstraintType() { return fConstraintType; }	Constraint::Type GetConstraintType() { return fConstraintType; }

	protected:	protected:

	std::string fName;	std::string fName;

	skipping to change at line 237	skipping to change at line 248
	Constraint::Type fConstraintType;	Constraint::Type fConstraintType;

	// The histogram holding the error	// The histogram holding the error
	TRef fhError;	TRef fhError;

	};	};

	class ShapeFactor {	class ShapeFactor {

	public:	public:

	//friend class Channel;
		ShapeFactor();

	void SetName( const std::string& Name ) { fName = Name; }	void SetName( const std::string& Name ) { fName = Name; }
	std::string GetName() { return fName; }	std::string GetName() { return fName; }

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML(std::ostream&);
		void writeToFile( const std::string& FileName, const std::string& DirNa
		me);

		void SetInitialShape(TH1* shape) { fhInitialShape = shape; }
		TH1* GetInitialShape() { return fhInitialShape; }

		void SetConstant(bool constant) { fConstant = constant; }
		bool IsConstant() { return fConstant; }

		bool HasInitialShape() { return fHasInitialShape; }

		void SetInputFile( const std::string& InputFile ) {
		fInputFile = InputFile;
		fHasInitialShape=true;
		}
		std::string GetInputFile() { return fInputFile; }

		void SetHistoName( const std::string& HistoName ) {
		fHistoName = HistoName;
		fHasInitialShape=true;
		}
		std::string GetHistoName() { return fHistoName; }

		void SetHistoPath( const std::string& HistoPath ) {
		fHistoPath = HistoPath;
		fHasInitialShape=true;
		}
		std::string GetHistoPath() { return fHistoPath; }

	protected:	protected:
	std::string fName;	std::string fName;


		bool fConstant;

		// A histogram representing
		// the initial shape
		bool fHasInitialShape;
		std::string fHistoName;
		std::string fHistoPath;
		std::string fInputFile;
		TH1* fhInitialShape;

	};	};

	class StatError {	class StatError {

	public:	public:

	//friend class Channel;

	StatError() : fActivate(false), fUseHisto(false), fhError(NULL) {;}	StatError() : fActivate(false), fUseHisto(false), fhError(NULL) {;}

	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

	void writeToFile( std::string FileName, std::string DirName );	void PrintXML(std::ostream&);
		void writeToFile( const std::string& FileName, const std::string& DirNa
		me );

	void Activate( bool IsActive=true ) { fActivate = IsActive; }	void Activate( bool IsActive=true ) { fActivate = IsActive; }
	bool GetActivate() { return fActivate; }	bool GetActivate() { return fActivate; }

	void SetUseHisto( bool UseHisto=true ) { fUseHisto = UseHisto; }	void SetUseHisto( bool UseHisto=true ) { fUseHisto = UseHisto; }
	bool GetUseHisto() { return fUseHisto; }	bool GetUseHisto() { return fUseHisto; }

	void SetInputFile( const std::string& InputFile ) { fInputFile = InputF ile; }	void SetInputFile( const std::string& InputFile ) { fInputFile = InputF ile; }
	std::string GetInputFile() { return fInputFile; }	std::string GetInputFile() { return fInputFile; }


	skipping to change at line 293	skipping to change at line 343
	std::string fHistoPath;	std::string fHistoPath;

	// The histogram holding the error	// The histogram holding the error
	TRef fhError;	TRef fhError;

	};	};

	class StatErrorConfig {	class StatErrorConfig {

	public:	public:

	//friend class Channel;

	StatErrorConfig() : fRelErrorThreshold( .05 ), fConstraintType( Constra int::Gaussian ) {;}	StatErrorConfig() : fRelErrorThreshold( .05 ), fConstraintType( Constra int::Gaussian ) {;}
	void Print(std::ostream& = std::cout);	void Print(std::ostream& = std::cout);

		void PrintXML(std::ostream&);

	void SetRelErrorThreshold( double Threshold ) { fRelErrorThreshold = Th reshold; }	void SetRelErrorThreshold( double Threshold ) { fRelErrorThreshold = Th reshold; }
	double GetRelErrorThreshold() { return fRelErrorThreshold; }	double GetRelErrorThreshold() { return fRelErrorThreshold; }

	void SetConstraintType( Constraint::Type ConstrType ) { fConstraintType = ConstrType; }	void SetConstraintType( Constraint::Type ConstrType ) { fConstraintType = ConstrType; }
	Constraint::Type GetConstraintType() { return fConstraintType; }	Constraint::Type GetConstraintType() { return fConstraintType; }

	protected:	protected:

	double fRelErrorThreshold;	double fRelErrorThreshold;

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

	TAttFill.h	TAttFill.h

	skipping to change at line 57	skipping to change at line 57
	virtual void SetFillAttributes(); // MENU	virtual void SetFillAttributes(); // MENU
	virtual void SetFillColor(Color_t fcolor) { fFillColor = fcolor; }	virtual void SetFillColor(Color_t fcolor) { fFillColor = fcolor; }
	virtual void SetFillStyle(Style_t fstyle) { fFillStyle = fstyle; }	virtual void SetFillStyle(Style_t fstyle) { fFillStyle = fstyle; }

	ClassDef(TAttFill,1) //Fill area attributes	ClassDef(TAttFill,1) //Fill area attributes
	};	};

	inline Bool_t TAttFill::IsTransparent() const	inline Bool_t TAttFill::IsTransparent() const
	{ return fFillStyle >= 4000 && fFillStyle <= 4100 ? kTRUE : kFALSE; }	{ return fFillStyle >= 4000 && fFillStyle <= 4100 ? kTRUE : kFALSE; }


		enum EFillStyle {kFDotted1 = 3001, kFDotted2 = 3002, kFDotted3 = 30
		03,
		kFHatched1 = 3004, kHatched2 = 3005, kFHatched3 = 30
		06,
		kFHatched4 = 3007, kFWicker = 3008, kFScales = 30
		09,
		kFBricks = 3010, kFSnowflakes = 3011, kFCircles = 30
		12,
		kFTiles = 3013, kFMondrian = 3014, kFDiamonds = 30
		15,
		kFWaves1 = 3016, kFDashed1 = 3017, kFDashed2 = 30
		18,
		kFAlhambra = 3019, kFWaves2 = 3020, kFStars1 = 30
		21,
		kFStars2 = 3022, kFPyramids = 3023, kFFrieze = 30
		24,
		kFMetopes = 3025, kFEmpty = 0 , kFSolid = 1}
		;

	#endif	#endif

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

	TAttText.h	TAttText.h

	skipping to change at line 63	skipping to change at line 63
	virtual void SetTextAlign(Short_t align=11) { fTextAlign = align;}	virtual void SetTextAlign(Short_t align=11) { fTextAlign = align;}
	virtual void SetTextAngle(Float_t tangle=0) { fTextAngle = tangle;} // MENU	virtual void SetTextAngle(Float_t tangle=0) { fTextAngle = tangle;} // MENU
	virtual void SetTextColor(Color_t tcolor=1) { fTextColor = tcolor;}	virtual void SetTextColor(Color_t tcolor=1) { fTextColor = tcolor;}
	virtual void SetTextFont(Font_t tfont=62) { fTextFont = tfont;}	virtual void SetTextFont(Font_t tfont=62) { fTextFont = tfont;}
	virtual void SetTextSize(Float_t tsize=1) { fTextSize = tsize;}	virtual void SetTextSize(Float_t tsize=1) { fTextSize = tsize;}
	virtual void SetTextSizePixels(Int_t npixels);	virtual void SetTextSizePixels(Int_t npixels);

	ClassDef(TAttText,1) //Text attributes	ClassDef(TAttText,1) //Text attributes
	};	};


		enum ETextAlign {kHAlignLeft=10, kHAlignCenter=20, kHAlignRight=30,
		kVAlignBottom=1, kVAlignCenter=2, kVAlignTop=3};

	#endif	#endif

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

	TClass.h	TClass.h

	skipping to change at line 41	skipping to change at line 41
	#endif	#endif
	#ifndef ROOT_TObjString	#ifndef ROOT_TObjString
	#include "TObjString.h"	#include "TObjString.h"
	#endif	#endif
	#include <map>	#include <map>
	#include <string>	#include <string>

	class TBaseClass;	class TBaseClass;
	class TBrowser;	class TBrowser;
	class TDataMember;	class TDataMember;

		class TClassAttributeMap;
	class TClassRef;	class TClassRef;
	class TMethod;	class TMethod;
	class TRealData;	class TRealData;
	class TCint;	class TCint;
	class TBuffer;	class TBuffer;
	class TVirtualStreamerInfo;	class TVirtualStreamerInfo;
	class TVirtualCollectionProxy;	class TVirtualCollectionProxy;
	class TMethodCall;	class TMethodCall;
	class TVirtualIsAProxy;	class TVirtualIsAProxy;
	class TVirtualRefProxy;	class TVirtualRefProxy;

	skipping to change at line 141	skipping to change at line 142
	mutable Long_t fProperty; //!Property	mutable Long_t fProperty; //!Property
	mutable Bool_t fVersionUsed; //!Indicates whether GetClassVersio n has been called	mutable Bool_t fVersionUsed; //!Indicates whether GetClassVersio n has been called

	mutable Bool_t fIsOffsetStreamerSet; //!saved remember if fOffsetStr eamer has been set.	mutable Bool_t fIsOffsetStreamerSet; //!saved remember if fOffsetStr eamer has been set.
	mutable Long_t fOffsetStreamer; //!saved info to call Streamer	mutable Long_t fOffsetStreamer; //!saved info to call Streamer
	Int_t fStreamerType; //!cached of the streaming method t o use	Int_t fStreamerType; //!cached of the streaming method t o use
	mutable TVirtualStreamerInfo *fCurrentInfo; //!cached current st reamer info.	mutable TVirtualStreamerInfo *fCurrentInfo; //!cached current st reamer info.
	TClassRef *fRefStart; //!List of references to this objec t	TClassRef *fRefStart; //!List of references to this objec t
	TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if th is class represents a reference	TVirtualRefProxy *fRefProxy; //!Pointer to reference proxy if th is class represents a reference
	ROOT::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules	ROOT::TSchemaRuleSet *fSchemaRules; //! Schema evolution rules

		TClassAttributeMap *fAttributeMap; //pointer to a class attribute map

	typedef void (TClass::StreamerImpl_t)(void obj, TBuffer &b, const TCla ss *onfile_class) const;	typedef void (TClass::StreamerImpl_t)(void obj, TBuffer &b, const TCla ss *onfile_class) const;
	mutable StreamerImpl_t fStreamerImpl;//! Pointer to the function impleme nting the right streaming behavior for the class represented by this object .	mutable StreamerImpl_t fStreamerImpl;//! Pointer to the function impleme nting the right streaming behavior for the class represented by this object .

	TMethod *GetClassMethod(Long_t faddr);	TMethod *GetClassMethod(Long_t faddr);
	TMethod GetClassMethod(const char name, const char *signatur e);	TMethod GetClassMethod(const char name, const char *signatur e);
	Int_t GetBaseClassOffsetRecurse(const TClass *base);	Int_t GetBaseClassOffsetRecurse(const TClass *base);
	void Init(const char name, Version_t cversion, const type_info info,	void Init(const char name, Version_t cversion, const type_info info,
	TVirtualIsAProxy *isa, ShowMembersFunc_t showmember,	TVirtualIsAProxy *isa, ShowMembersFunc_t showmember,
	const char dfil, const char ifil,	const char dfil, const char ifil,

	skipping to change at line 257	skipping to change at line 259
	TVirtualStreamerInfo *FindStreamerInfo(UInt_t checksum) const;	TVirtualStreamerInfo *FindStreamerInfo(UInt_t checksum) const;
	TVirtualStreamerInfo GetConversionStreamerInfo( const char onfile_ classname, Int_t version ) const;	TVirtualStreamerInfo GetConversionStreamerInfo( const char onfile_ classname, Int_t version ) const;
	TVirtualStreamerInfo FindConversionStreamerInfo( const char onfile _classname, UInt_t checksum ) const;	TVirtualStreamerInfo FindConversionStreamerInfo( const char onfile _classname, UInt_t checksum ) const;
	TVirtualStreamerInfo GetConversionStreamerInfo( const TClass onfil e_cl, Int_t version ) const;	TVirtualStreamerInfo GetConversionStreamerInfo( const TClass onfil e_cl, Int_t version ) const;
	TVirtualStreamerInfo FindConversionStreamerInfo( const TClass onfi le_cl, UInt_t checksum ) const;	TVirtualStreamerInfo FindConversionStreamerInfo( const TClass onfi le_cl, UInt_t checksum ) const;
	Bool_t HasDefaultConstructor() const;	Bool_t HasDefaultConstructor() const;
	UInt_t GetCheckSum(UInt_t code=0) const;	UInt_t GetCheckSum(UInt_t code=0) const;
	TVirtualCollectionProxy *GetCollectionProxy() const;	TVirtualCollectionProxy *GetCollectionProxy() const;
	TVirtualIsAProxy *GetIsAProxy() const;	TVirtualIsAProxy *GetIsAProxy() const;
	Version_t GetClassVersion() const { fVersionUsed = kTRUE; retur n fClassVersion; }	Version_t GetClassVersion() const { fVersionUsed = kTRUE; retur n fClassVersion; }

		Int_t GetClassSize() const { return Size(); }
	TDataMember GetDataMember(const char datamember) const;	TDataMember GetDataMember(const char datamember) const;
	Long_t GetDataMemberOffset(const char *membername) const;	Long_t GetDataMemberOffset(const char *membername) const;
	const char *GetDeclFileName() const { return fDeclFileName; }	const char *GetDeclFileName() const { return fDeclFileName; }
	Short_t GetDeclFileLine() const { return fDeclFileLine; }	Short_t GetDeclFileLine() const { return fDeclFileLine; }
	ROOT::DelFunc_t GetDelete() const;	ROOT::DelFunc_t GetDelete() const;
	ROOT::DesFunc_t GetDestructor() const;	ROOT::DesFunc_t GetDestructor() const;
	ROOT::DelArrFunc_t GetDeleteArray() const;	ROOT::DelArrFunc_t GetDeleteArray() const;
	ClassInfo_t *GetClassInfo() const { return fClassInfo; }	ClassInfo_t *GetClassInfo() const { return fClassInfo; }
	const char *GetContextMenuTitle() const { return fContextMenuTitl e; }	const char *GetContextMenuTitle() const { return fContextMenuTitl e; }
	TVirtualStreamerInfo *GetCurrentStreamerInfo() {	TVirtualStreamerInfo *GetCurrentStreamerInfo() {

	skipping to change at line 382	skipping to change at line 385
	void Store(TBuffer &b) const;	void Store(TBuffer &b) const;

	// Pseudo-method apply to the 'obj'. In particular those are used to	// Pseudo-method apply to the 'obj'. In particular those are used to
	// implement TObject like methods for non-TObject classes	// implement TObject like methods for non-TObject classes

	Int_t Browse(void obj, TBrowser b) const;	Int_t Browse(void obj, TBrowser b) const;
	void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);	void DeleteArray(void *ary, Bool_t dtorOnly = kFALSE);
	void Destructor(void *obj, Bool_t dtorOnly = kFALSE);	void Destructor(void *obj, Bool_t dtorOnly = kFALSE);
	void DynamicCast(const TClass base, void *obj, Bool_t up = kTRUE);	void DynamicCast(const TClass base, void *obj, Bool_t up = kTRUE);
	Bool_t IsFolder(void *obj) const;	Bool_t IsFolder(void *obj) const;

		void CreateAttributeMap();
		TClassAttributeMap *GetAttributeMap() const
		{
		//Get the TClassAttributeMap pointer to be able to add attribute
		//pairs key-value to the TClass.

		return fAttributeMap;
		}
	inline void Streamer(void obj, TBuffer &b, const TClass onfile_ class = 0) const	inline void Streamer(void obj, TBuffer &b, const TClass onfile_ class = 0) const
	{	{
	// Inline for performance, skipping one function call.	// Inline for performance, skipping one function call.
	(this->*fStreamerImpl)(obj,b,onfile_class);	(this->*fStreamerImpl)(obj,b,onfile_class);
	}	}

	ClassDef(TClass,0) //Dictionary containing class information	ClassDef(TClass,0) //Dictionary containing class information
	};	};

	namespace ROOT {	namespace ROOT {

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

	TDSet.h	TDSet.h

	skipping to change at line 95	skipping to change at line 95
	Long64_t fTDSetOffset;// the global offset in the TDSet of the f irst	Long64_t fTDSetOffset;// the global offset in the TDSet of the f irst
	// entry in this element	// entry in this element
	TObject *fEntryList; // entry (or event) list to be used in pro cessing	TObject *fEntryList; // entry (or event) list to be used in pro cessing
	Bool_t fValid; // whether or not the input values are val id	Bool_t fValid; // whether or not the input values are val id
	Long64_t fEntries; // total number of possible entries in fil e	Long64_t fEntries; // total number of possible entries in fil e
	TList *fFriends; // friend elements	TList *fFriends; // friend elements

	TString fDataSet; // Name of the dataset of which this eleme nt is part	TString fDataSet; // Name of the dataset of which this eleme nt is part
	TList *fAssocObjList; // List of objects associated to this e lement	TList *fAssocObjList; // List of objects associated to this e lement
	// (e.g. TObjString describing associate d files)	// (e.g. TObjString describing associate d files)

		Float_t fMaxProcTime; // Max processing time in secs; -1 no lim it

	Bool_t HasBeenLookedUp() const { return TestBit(kHasBeenLooked Up); }	Bool_t HasBeenLookedUp() const { return TestBit(kHasBeenLooked Up); }

	TDSetElement& operator=(const TDSetElement &); // Not implemented	TDSetElement& operator=(const TDSetElement &); // Not implemented

	public:	public:
	TDSetElement();	TDSetElement();
	TDSetElement(const char file, const char objname = 0,	TDSetElement(const char file, const char objname = 0,
	const char *dir = 0, Long64_t first = 0, Long64_t num = -1,	const char *dir = 0, Long64_t first = 0, Long64_t num = -1,
	const char msd = 0, const char dataset = 0);	const char msd = 0, const char dataset = 0);

	skipping to change at line 142	skipping to change at line 143
	void Validate(Bool_t isTree);	void Validate(Bool_t isTree);
	void Validate(TDSetElement *elem);	void Validate(TDSetElement *elem);
	void Invalidate() { fValid = kFALSE; }	void Invalidate() { fValid = kFALSE; }
	void SetValid() { fValid = kTRUE; }	void SetValid() { fValid = kTRUE; }
	Int_t Compare(const TObject *obj) const;	Int_t Compare(const TObject *obj) const;
	Bool_t IsSortable() const { return kTRUE; }	Bool_t IsSortable() const { return kTRUE; }
	Int_t Lookup(Bool_t force = kFALSE);	Int_t Lookup(Bool_t force = kFALSE);
	void SetLookedUp() { SetBit(kHasBeenLookedUp); }	void SetLookedUp() { SetBit(kHasBeenLookedUp); }
	TFileInfo GetFileInfo(const char type = "TTree");	TFileInfo GetFileInfo(const char type = "TTree");


		Float_t GetMaxProcTime() const { return fMaxProcTime; }
		void SetMaxProcTime(Float_t mpt) { fMaxProcTime = mpt; }

	Int_t MergeElement(TDSetElement *elem);	Int_t MergeElement(TDSetElement *elem);


	ClassDef(TDSetElement,8) // A TDSet element	ClassDef(TDSetElement,9) // A TDSet element
	};	};

	class TDSet : public TNamed {	class TDSet : public TNamed {

	public:	public:
	// TDSet status bits	// TDSet status bits
	enum EStatusBits {	enum EStatusBits {
	kWriteV3 = BIT(16),	kWriteV3 = BIT(16),
	kEmpty = BIT(17),	kEmpty = BIT(17),
	kValidityChecked = BIT(18), // Set if elements validiy has been chec ked	kValidityChecked = BIT(18), // Set if elements validiy has been chec ked

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

	TEveBrowser.h	TEveBrowser.h

	skipping to change at line 150	skipping to change at line 150
	public:	public:
	TEveBrowser(UInt_t w, UInt_t h);	TEveBrowser(UInt_t w, UInt_t h);
	virtual ~TEveBrowser() {}	virtual ~TEveBrowser() {}

	virtual void ReallyDelete();	virtual void ReallyDelete();
	virtual void CloseTab(Int_t id);	virtual void CloseTab(Int_t id);
	virtual void CloseWindow();	virtual void CloseWindow();

	void InitPlugins(Option_t *opt="FI");	void InitPlugins(Option_t *opt="FI");


	TGFileBrowser* MakeFileBrowser();	TGFileBrowser* MakeFileBrowser(Bool_t make_default=kFALSE);
	TGFileBrowser* GetFileBrowser() const { return fFileBrowser; }	TGFileBrowser* GetFileBrowser() const;
		void SetFileBrowser(TGFileBrowser* b);

	void EveMenu(Int_t id);	void EveMenu(Int_t id);

	// Some getters missing in TRootBrowser	// Some getters missing in TRootBrowser
	TGMenuBar* GetMenuBar() const { return fMenuBar; }	TGMenuBar* GetMenuBar() const { return fMenuBar; }
	TGHorizontalFrame* GetTopMenuFrame() const { return fTopMenuFrame; }	TGHorizontalFrame* GetTopMenuFrame() const { return fTopMenuFrame; }

	void HideBottomTab();	void HideBottomTab();

	void SanitizeTabCounts();	void SanitizeTabCounts();

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

	TGeoArb8.h	TGeoArb8.h

	skipping to change at line 70	skipping to change at line 70
	public:	public:
	// constructors	// constructors
	TGeoArb8();	TGeoArb8();
	TGeoArb8(Double_t dz, Double_t *vertices=0);	TGeoArb8(Double_t dz, Double_t *vertices=0);
	TGeoArb8(const char name, Double_t dz, Double_t vertices=0);	TGeoArb8(const char name, Double_t dz, Double_t vertices=0);
	// destructor	// destructor
	virtual ~TGeoArb8();	virtual ~TGeoArb8();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
		virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
	void ComputeTwist();	void ComputeTwist();

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
	Double_t DistToPlane(Double_t point, Double_t dir, Int_t	virtual void Contains_v(const Double_t points, Bool_t inside,
	ipl, Bool_t in) const;	Int_t vecsize) const;
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	Double_t DistToPlane(const Double_t *point, const Double_t
	_t iact=1,	*dir, Int_t ipl, Bool_t in) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual Int_t GetByteCount() const {return 100;}	virtual Int_t GetByteCount() const {return 100;}

	Double_t GetClosestEdge(Double_t point, Double_t vert, In t_t &isegment) const;	Double_t GetClosestEdge(const Double_t point, Double_t ve rt, Int_t &isegment) const;
	virtual Bool_t GetPointsOnFacet(Int_t /index/, Int_t /npoints /, Double_t * /array/) const;	virtual Bool_t GetPointsOnFacet(Int_t /index/, Int_t /npoints /, Double_t * /array/) const;
	Double_t GetDz() const {return fDz;}	Double_t GetDz() const {return fDz;}
	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	static void GetPlaneNormal(Double_t p1, Double_t p2, Double_ t p3, Double_t norm);	static void GetPlaneNormal(Double_t p1, Double_t p2, Double_ t p3, Double_t norm);
	Double_t *GetVertices() {return &fXY[0][0];}	Double_t *GetVertices() {return &fXY[0][0];}
	Double_t GetTwist(Int_t iseg) const;	Double_t GetTwist(Int_t iseg) const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	static Bool_t IsSamePoint(Double_t p1, Double_t p2) {return (T Math::Abs(p1[0]-p2[0])<1.E-16 && TMath::Abs(p1[1]-p2[1])<1.E-16)?kTRUE:kFAL SE;}	static Bool_t IsSamePoint(const Double_t p1, const Double_t p2 ) {return (TMath::Abs(p1[0]-p2[0])<1.E-16 && TMath::Abs(p1[1]-p2[1])<1.E-16 )?kTRUE:kFALSE;}
	static Bool_t InsidePolygon(Double_t x, Double_t y, Double_t *pt s);	static Bool_t InsidePolygon(Double_t x, Double_t y, Double_t *pt s);
	virtual void InspectShape() const;	virtual void InspectShape() const;
	Bool_t IsTwisted() const {return (fTwist==0)?kFALSE:kTRUE ;}	Bool_t IsTwisted() const {return (fTwist==0)?kFALSE:kTRUE ;}

	Double_t SafetyToFace(Double_t *point, Int_t iseg, Bool_t i	Double_t SafetyToFace(const Double_t *point, Int_t iseg, Bo
	n) const;	ol_t in) const;
	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetPlaneVertices(Double_t zpl, Double_t *vertices) const;	void SetPlaneVertices(Double_t zpl, Double_t *vertices) const;
	virtual void SetVertex(Int_t vnum, Double_t x, Double_t y);	virtual void SetVertex(Int_t vnum, Double_t x, Double_t y);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	void SetDz(Double_t dz) {fDz = dz;}	void SetDz(Double_t dz) {fDz = dz;}
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoArb8, 1) // arbitrary trapezoid with 8 vertices	ClassDef(TGeoArb8, 1) // arbitrary trapezoid with 8 vertices

	skipping to change at line 152	skipping to change at line 157
	TGeoTrap();	TGeoTrap();
	TGeoTrap(Double_t dz, Double_t theta, Double_t phi);	TGeoTrap(Double_t dz, Double_t theta, Double_t phi);
	TGeoTrap(Double_t dz, Double_t theta, Double_t phi, Double_t h1,	TGeoTrap(Double_t dz, Double_t theta, Double_t phi, Double_t h1,
	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,
	Double_t tl2, Double_t alpha2);	Double_t tl2, Double_t alpha2);
	TGeoTrap(const char *name, Double_t dz, Double_t theta, Double_t phi, Do uble_t h1,	TGeoTrap(const char *name, Double_t dz, Double_t theta, Double_t phi, Do uble_t h1,
	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,
	Double_t tl2, Double_t alpha2);	Double_t tl2, Double_t alpha2);
	// destructor	// destructor
	virtual ~TGeoTrap();	virtual ~TGeoTrap();

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	Double_t GetTheta() const {return fTheta;}	Double_t GetTheta() const {return fTheta;}
	Double_t GetPhi() const {return fPhi;}	Double_t GetPhi() const {return fPhi;}
	Double_t GetH1() const {return fH1;}	Double_t GetH1() const {return fH1;}
	Double_t GetBl1() const {return fBl1;}	Double_t GetBl1() const {return fBl1;}
	Double_t GetTl1() const {return fTl1;}	Double_t GetTl1() const {return fTl1;}
	Double_t GetAlpha1() const {return fAlpha1;}	Double_t GetAlpha1() const {return fAlpha1;}
	Double_t GetH2() const {return fH2;}	Double_t GetH2() const {return fH2;}
	Double_t GetBl2() const {return fBl2;}	Double_t GetBl2() const {return fBl2;}
	Double_t GetTl2() const {return fTl2;}	Double_t GetTl2() const {return fTl2;}
	Double_t GetAlpha2() const {return fAlpha2;}	Double_t GetAlpha2() const {return fAlpha2;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");

	ClassDef(TGeoTrap, 1) // G3 TRAP shape	ClassDef(TGeoTrap, 1) // G3 TRAP shape
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /
	// TGeoGtra / /	// TGeoGtra / /
	// / /	// / /
	// Gtra is a twisted general trapezoid, i.e. one for which the faces perpen dicular//	// Gtra is a twisted general trapezoid, i.e. one for which the faces perpen dicular//

	skipping to change at line 207	skipping to change at line 215
	// constructors	// constructors
	TGeoGtra();	TGeoGtra();
	TGeoGtra(Double_t dz, Double_t theta, Double_t phi, Double_t twist, Doub le_t h1,	TGeoGtra(Double_t dz, Double_t theta, Double_t phi, Double_t twist, Doub le_t h1,
	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,
	Double_t tl2, Double_t alpha2);	Double_t tl2, Double_t alpha2);
	TGeoGtra(const char *name, Double_t dz, Double_t theta, Double_t phi, Do uble_t twist, Double_t h1,	TGeoGtra(const char *name, Double_t dz, Double_t theta, Double_t phi, Do uble_t twist, Double_t h1,
	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,	Double_t bl1, Double_t tl1, Double_t alpha1, Double_t h2, Doubl e_t bl2,
	Double_t tl2, Double_t alpha2);	Double_t tl2, Double_t alpha2);
	// destructor	// destructor
	virtual ~TGeoGtra();	virtual ~TGeoGtra();

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	Double_t GetTwistAngle() const {return fTwistAngle;}	Double_t GetTwistAngle() const {return fTwistAngle;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");

	ClassDef(TGeoGtra, 1) // G3 GTRA shape	ClassDef(TGeoGtra, 1) // G3 GTRA shape
	};	};

	#endif	#endif

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

	TGeoBoolNode.h	TGeoBoolNode.h

	skipping to change at line 77	skipping to change at line 77
	public:	public:
	// constructors	// constructors
	TGeoBoolNode();	TGeoBoolNode();
	TGeoBoolNode(const char expr1, const char expr2);	TGeoBoolNode(const char expr1, const char expr2);
	TGeoBoolNode(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeo Matrix rmat=0);	TGeoBoolNode(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeo Matrix rmat=0);

	// destructor	// destructor
	virtual ~TGeoBoolNode();	virtual ~TGeoBoolNode();
	// methods	// methods
	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin) = 0;	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin) = 0;

	virtual void ComputeNormal(Double_t point, Double_t dir, Double_t	virtual void ComputeNormal(const Double_t point, const Double_t d
	*norm) = 0;	ir, Double_t *norm) = 0;
	virtual Bool_t Contains(Double_t *point) const = 0;	virtual Bool_t Contains(const Double_t *point) const = 0;
	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py) = 0;	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py) = 0;

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int_t i act=1,	virtual Double_t DistFromInside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const = 0 ;	Double_t step=0, Double_t *safe=0) const = 0 ;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, Int_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const = 0 ;	Double_t step=0, Double_t *safe=0) const = 0 ;
	virtual EGeoBoolType GetBooleanOperator() const = 0;	virtual EGeoBoolType GetBooleanOperator() const = 0;
	virtual Int_t GetNpoints() = 0;	virtual Int_t GetNpoints() = 0;
	TGeoMatrix *GetLeftMatrix() const {return fLeftMat;}	TGeoMatrix *GetLeftMatrix() const {return fLeftMat;}
	TGeoMatrix *GetRightMatrix() const {return fRightMat;}	TGeoMatrix *GetRightMatrix() const {return fRightMat;}
	TGeoShape *GetLeftShape() const {return fLeft;}	TGeoShape *GetLeftShape() const {return fLeft;}
	TGeoShape *GetRightShape() const {return fRight;}	TGeoShape *GetRightShape() const {return fRight;}
	virtual TGeoBoolNode *MakeClone() const = 0;	virtual TGeoBoolNode *MakeClone() const = 0;
	virtual void Paint(Option_t *option);	virtual void Paint(Option_t *option);
	void RegisterMatrices();	void RegisterMatrices();
	Bool_t ReplaceMatrix(TGeoMatrix mat, TGeoMatrix newmat);	Bool_t ReplaceMatrix(TGeoMatrix mat, TGeoMatrix newmat);

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const = 0;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const = 0;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	void SetSelected(Int_t sel);	void SetSelected(Int_t sel);
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoBoolNode, 1) // a boolean node	ClassDef(TGeoBoolNode, 1) // a boolean node
	};	};

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

	skipping to change at line 122	skipping to change at line 122
	public:	public:
	// constructors	// constructors
	TGeoUnion();	TGeoUnion();
	TGeoUnion(const char expr1, const char expr2);	TGeoUnion(const char expr1, const char expr2);
	TGeoUnion(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeoMat rix rmat=0);	TGeoUnion(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeoMat rix rmat=0);

	// destructor	// destructor
	virtual ~TGeoUnion();	virtual ~TGeoUnion();
	// methods	// methods
	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);

	virtual void ComputeNormal(Double_t point, Double_t dir, Double_t	virtual void ComputeNormal(const Double_t point, const Double_t d
	*norm);	ir, Double_t *norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int_t i act=1,	virtual Double_t DistFromInside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, Int_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;
	virtual EGeoBoolType GetBooleanOperator() const {return kGeoUnion;}	virtual EGeoBoolType GetBooleanOperator() const {return kGeoUnion;}
	virtual Int_t GetNpoints();	virtual Int_t GetNpoints();

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	//CS specific	//CS specific
	virtual TGeoBoolNode *MakeClone() const;	virtual TGeoBoolNode *MakeClone() const;
	virtual void Paint(Option_t *option);	virtual void Paint(Option_t *option);

	ClassDef(TGeoUnion, 1) // union node	ClassDef(TGeoUnion, 1) // union node
	};	};


	skipping to change at line 161	skipping to change at line 161
	public:	public:
	// constructors	// constructors
	TGeoIntersection();	TGeoIntersection();
	TGeoIntersection(const char expr1, const char expr2);	TGeoIntersection(const char expr1, const char expr2);
	TGeoIntersection(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeoMatrix rmat=0);	TGeoIntersection(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, TGeoMatrix rmat=0);

	// destructor	// destructor
	virtual ~TGeoIntersection();	virtual ~TGeoIntersection();
	// methods	// methods
	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);

	virtual void ComputeNormal(Double_t point, Double_t dir, Double_t	virtual void ComputeNormal(const Double_t point, const Double_t d
	*norm);	ir, Double_t *norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int_t i act=1,	virtual Double_t DistFromInside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, Int_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;
	virtual EGeoBoolType GetBooleanOperator() const {return kGeoIntersection ;}	virtual EGeoBoolType GetBooleanOperator() const {return kGeoIntersection ;}
	virtual Int_t GetNpoints();	virtual Int_t GetNpoints();

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	//CS specific	//CS specific
	virtual TGeoBoolNode *MakeClone() const;	virtual TGeoBoolNode *MakeClone() const;
	virtual void Paint(Option_t *option);	virtual void Paint(Option_t *option);

	ClassDef(TGeoIntersection, 1) // intersection node	ClassDef(TGeoIntersection, 1) // intersection node
	};	};


	skipping to change at line 199	skipping to change at line 199
	public:	public:
	// constructors	// constructors
	TGeoSubtraction();	TGeoSubtraction();
	TGeoSubtraction(const char expr1, const char expr2);	TGeoSubtraction(const char expr1, const char expr2);
	TGeoSubtraction(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, T GeoMatrix rmat=0);	TGeoSubtraction(TGeoShape left, TGeoShape right, TGeoMatrix lmat=0, T GeoMatrix rmat=0);

	// destructor	// destructor
	virtual ~TGeoSubtraction();	virtual ~TGeoSubtraction();
	// methods	// methods
	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);	virtual void ComputeBBox(Double_t &dx, Double_t &dy, Double_t &dz, Double_t *origin);

	virtual void ComputeNormal(Double_t point, Double_t dir, Double_t	virtual void ComputeNormal(const Double_t point, const Double_t d
	*norm);	ir, Double_t *norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);	virtual Int_t DistanceToPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int_t i act=1,	virtual Double_t DistFromInside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, Int_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Double_t dir, Int_t iact=1,
	Double_t step=0, Double_t *safe=0) const;	Double_t step=0, Double_t *safe=0) const;
	virtual EGeoBoolType GetBooleanOperator() const {return kGeoSubtraction; }	virtual EGeoBoolType GetBooleanOperator() const {return kGeoSubtraction; }
	virtual Int_t GetNpoints();	virtual Int_t GetNpoints();

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );	virtual void SavePrimitive(std::ostream &out, Option_t *option = "" );
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	//CS specific	//CS specific
	virtual TGeoBoolNode *MakeClone() const;	virtual TGeoBoolNode *MakeClone() const;
	virtual void Paint(Option_t *option);	virtual void Paint(Option_t *option);

	ClassDef(TGeoSubtraction, 1) // subtraction node	ClassDef(TGeoSubtraction, 1) // subtraction node
	};	};
	#endif	#endif

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

	TGeoCompositeShape.h	TGeoCompositeShape.h

	skipping to change at line 54	skipping to change at line 54
	TGeoCompositeShape(const char name, const char expression);	TGeoCompositeShape(const char name, const char expression);
	TGeoCompositeShape(const char *expression);	TGeoCompositeShape(const char *expression);
	TGeoCompositeShape(const char name, TGeoBoolNode node);	TGeoCompositeShape(const char name, TGeoBoolNode node);
	// destructor	// destructor
	virtual ~TGeoCompositeShape();	virtual ~TGeoCompositeShape();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ClearThreadData() const;	virtual void ClearThreadData() const;
	virtual void CreateThreadData(Int_t nthreads);	virtual void CreateThreadData(Int_t nthreads);
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	TGeoBoolNode *GetBoolNode() const {return fNode;}	TGeoBoolNode *GetBoolNode() const {return fNode;}
	virtual void GetBoundingCylinder(Double_t * /param/) const {; }	virtual void GetBoundingCylinder(Double_t * /param/) const {; }
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsComposite() const {return kTRUE;}	virtual Bool_t IsComposite() const {return kTRUE;}
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}
	void MakeNode(const char *expression);	void MakeNode(const char *expression);
	virtual Bool_t PaintComposite(Option_t *option = "") const;	virtual Bool_t PaintComposite(Option_t *option = "") const;
	void RegisterYourself();	void RegisterYourself();

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t * /param/) {;}	virtual void SetDimensions(Double_t * /param/) {;}
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoCompositeShape, 1) // boolean composite shape	ClassDef(TGeoCompositeShape, 1) // boolean composite shape
	};	};

	#endif	#endif

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

	TGeoCone.h	TGeoCone.h

	skipping to change at line 53	skipping to change at line 53
	TGeoCone(const char *name, Double_t dz, Double_t rmin1, Double_t rmax1,	TGeoCone(const char *name, Double_t dz, Double_t rmin1, Double_t rmax1,
	Double_t rmin2, Double_t rmax2);	Double_t rmin2, Double_t rmax2);
	TGeoCone(Double_t *params);	TGeoCone(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoCone();	virtual ~TGeoCone();
	// methods	// methods

	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	static Double_t Capacity(Double_t dz, Double_t rmin1, Double_t rma x1, Double_t rmin2, Double_t rmax2);	static Double_t Capacity(Double_t dz, Double_t rmin1, Double_t rma x1, Double_t rmin2, Double_t rmax2);
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	static void ComputeNormalS(Double_t point, Double_t dir, Dou	virtual void ComputeNormal_v(const Double_t *points, const Doub
	ble_t *norm,	le_t dirs, Double_t norms, Int_t vecsize);
		static void ComputeNormalS(const Double_t *point, const Double
		_t dir, Double_t norm,
	Double_t dz, Double_t rmin1, Double _t rmax1, Double_t rmin2, Double_t rmax2);	Double_t dz, Double_t rmin1, Double _t rmax1, Double_t rmin2, Double_t rmax2);

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	static void DistToCone(Double_t point, Double_t dir, Double_	static void DistToCone(const Double_t point, const Double_t
	t dz, Double_t r1, Double_t r2, Double_t &b, Double_t &delta);	dir, Double_t dz, Double_t r1, Double_t r2, Double_t &b, Double_t &delta);
	static Double_t DistFromInsideS(Double_t point, Double_t dir, Do	static Double_t DistFromInsideS(const Double_t *point, const Doubl
	uble_t dz,	e_t *dir, Double_t dz,
	Double_t rmin1, Double_t rmax1, Double_ t rmin2, Double_t rmax2);	Double_t rmin1, Double_t rmax1, Double_ t rmin2, Double_t rmax2);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	static Double_t DistFromOutsideS(Double_t point, Double_t dir, D	virtual void DistFromInside_v(const Double_t *points, const Dou
	ouble_t dz,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		static Double_t DistFromOutsideS(const Double_t *point, const Doub
		le_t *dir, Double_t dz,
	Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2);	Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2);

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Doubl e_t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);

	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual Int_t GetByteCount() const {return 56;}	virtual Int_t GetByteCount() const {return 56;}
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Double_t GetDz() const {return fDz;}	virtual Double_t GetDz() const {return fDz;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;

	skipping to change at line 88	skipping to change at line 92
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;
	virtual Double_t GetRmin1() const {return fRmin1;}	virtual Double_t GetRmin1() const {return fRmin1;}
	virtual Double_t GetRmax1() const {return fRmax1;}	virtual Double_t GetRmax1() const {return fRmax1;}
	virtual Double_t GetRmin2() const {return fRmin2;}	virtual Double_t GetRmin2() const {return fRmin2;}
	virtual Double_t GetRmax2() const {return fRmax2;}	virtual Double_t GetRmax2() const {return fRmax2;}

	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	static Double_t SafetyS(Double_t *point, Bool_t in, Double_t dz, D	st;
	ouble_t rmin1, Double_t rmax1,	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		static Double_t SafetyS(const Double_t *point, Bool_t in, Double_t
		dz, Double_t rmin1, Double_t rmax1,
	Double_t rmin2, Double_t rmax2, Int_t skip z=0);	Double_t rmin2, Double_t rmax2, Int_t skip z=0);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetConeDimensions(Double_t dz, Double_t rmin1, Dou ble_t rmax1,	void SetConeDimensions(Double_t dz, Double_t rmin1, Dou ble_t rmax1,
	Double_t rmin2, Double_t rmax2);	Double_t rmin2, Double_t rmax2);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buffer) const;	virtual void SetSegsAndPols(TBuffer3D &buffer) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;


	skipping to change at line 134	skipping to change at line 139
	Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2 );	Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2 );
	TGeoConeSeg(const char *name, Double_t dz, Double_t rmin1, Double_t rmax 1,	TGeoConeSeg(const char *name, Double_t dz, Double_t rmin1, Double_t rmax 1,
	Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2 );	Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2 );
	TGeoConeSeg(Double_t *params);	TGeoConeSeg(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoConeSeg();	virtual ~TGeoConeSeg();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	static Double_t Capacity(Double_t dz, Double_t rmin1, Double_t rma x1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2);	static Double_t Capacity(Double_t dz, Double_t rmin1, Double_t rma x1, Double_t rmin2, Double_t rmax2, Double_t phi1, Double_t phi2);
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	static void ComputeNormalS(Double_t point, Double_t dir, Dou	virtual void ComputeNormal_v(const Double_t *points, const Doub
	ble_t *norm,	le_t dirs, Double_t norms, Int_t vecsize);
		static void ComputeNormalS(const Double_t *point, const Double
		_t dir, Double_t norm,
	Double_t dz, Double_t rmin1, Double _t rmax1, Double_t rmin2, Double_t rmax2,	Double_t dz, Double_t rmin1, Double _t rmax1, Double_t rmin2, Double_t rmax2,
	Double_t c1, Double_t s1, Double_t c2, Double_t s2);	Double_t c1, Double_t s1, Double_t c2, Double_t s2);

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;

	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	static Double_t DistToCons(Double_t point, Double_t dir, Double_	static Double_t DistToCons(const Double_t point, const Double_t
	t r1, Double_t z1, Double_t r2, Double_t z2, Double_t phi1, Double_t phi2);	dir, Double_t r1, Double_t z1, Double_t r2, Double_t z2, Double_t phi1, Dou
	static Double_t DistFromInsideS(Double_t point, Double_t dir, Do	ble_t phi2);
	uble_t dz, Double_t rmin1, Double_t rmax1,	static Double_t DistFromInsideS(const Double_t *point, const Doubl
		e_t *dir, Double_t dz, Double_t rmin1, Double_t rmax1,
	Double_t rmin2, Double_t rmax2, Double_t c1, Double_t s1, Double_t c2, Double_t s2, Double_t cm, Double_t sm, Doubl e_t cdfi);	Double_t rmin2, Double_t rmax2, Double_t c1, Double_t s1, Double_t c2, Double_t s2, Double_t cm, Double_t sm, Doubl e_t cdfi);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	static Double_t DistFromOutsideS(Double_t point, Double_t dir, D	virtual void DistFromInside_v(const Double_t *points, const Dou
	ouble_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Double_t rmax2,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		static Double_t DistFromOutsideS(const Double_t *point, const Doub
		le_t *dir, Double_t dz, Double_t rmin1, Double_t rmax1, Double_t rmin2, Dou
		ble_t rmax2,
	Double_t c1, Double_t s1, Double_t c2, D ouble_t s2, Double_t cm, Double_t sm, Double_t cdfi);	Double_t c1, Double_t s1, Double_t c2, D ouble_t s2, Double_t cm, Double_t sm, Double_t cdfi);

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Doubl e_t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 64;}	virtual Int_t GetByteCount() const {return 64;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetPhi2() const {return fPhi2;}	Double_t GetPhi2() const {return fPhi2;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	static Double_t SafetyS(Double_t *point, Bool_t in, Double_t dz, D	st;
	ouble_t rmin1, Double_t rmax1,	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		static Double_t SafetyS(const Double_t *point, Bool_t in, Double_t
		dz, Double_t rmin1, Double_t rmax1,
	Double_t rmin2, Double_t rmax2, Double_t p hi1, Double_t phi2, Int_t skipz=0);	Double_t rmin2, Double_t rmax2, Double_t p hi1, Double_t phi2, Int_t skipz=0);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetConsDimensions(Double_t dz, Double_t rmin1, Dou ble_t rmax1,	void SetConsDimensions(Double_t dz, Double_t rmin1, Dou ble_t rmax1,
	Double_t rmin2, Double_t rmax2, Doub le_t phi1, Double_t phi2);	Double_t rmin2, Double_t rmax2, Doub le_t phi1, Double_t phi2);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buffer) const;	virtual void SetSegsAndPols(TBuffer3D &buffer) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;


End of changes. 16 change blocks.
	32 lines changed or deleted	54 lines changed or added

	TGeoEltu.h	TGeoEltu.h

	skipping to change at line 41	skipping to change at line 41
	// constructors	// constructors
	TGeoEltu();	TGeoEltu();
	TGeoEltu(Double_t a, Double_t b, Double_t dz);	TGeoEltu(Double_t a, Double_t b, Double_t dz);
	TGeoEltu(const char *name, Double_t a, Double_t b, Double_t dz);	TGeoEltu(const char *name, Double_t a, Double_t b, Double_t dz);
	TGeoEltu(Double_t *params);	TGeoEltu(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoEltu();	virtual ~TGeoEltu();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetA() const {return fRmin;}	virtual Double_t GetA() const {return fRmin;}
	virtual Double_t GetB() const {return fRmax;}	virtual Double_t GetB() const {return fRmax;}
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetEltuDimensions(Double_t a, Double_t b, Double_t dz);	void SetEltuDimensions(Double_t a, Double_t b, Double_t dz);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;

	ClassDef(TGeoEltu, 1) // elliptical tube class	ClassDef(TGeoEltu, 1) // elliptical tube class

	};	};


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

	TGeoHalfSpace.h	TGeoHalfSpace.h

	skipping to change at line 44	skipping to change at line 44
	public:	public:
	// constructors	// constructors
	TGeoHalfSpace();	TGeoHalfSpace();
	TGeoHalfSpace(const char name, Double_t p, Double_t *n);	TGeoHalfSpace(const char name, Double_t p, Double_t *n);
	TGeoHalfSpace(Double_t *params);	TGeoHalfSpace(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoHalfSpace();	virtual ~TGeoHalfSpace();
	// methods	// methods
	virtual Double_t Capacity() const {return 0.;}	virtual Double_t Capacity() const {return 0.;}
	virtual void ComputeBBox() {;}	virtual void ComputeBBox() {;}

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t *GetPoint() {return fP;}	virtual Double_t *GetPoint() {return fP;}
	virtual Double_t *GetNorm() {return fN;}	virtual Double_t *GetNorm() {return fN;}
	virtual void GetBoundingCylinder(Double_t * /param/) const {; }	virtual void GetBoundingCylinder(Double_t * /param/) const {; }
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const {return 0;}	virtual Int_t GetNmeshVertices() const {return 0;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t * /points/) const {;}	virtual void SetPoints(Double_t * /points/) const {;}
	virtual void SetPoints(Float_t * /points/) const {;}	virtual void SetPoints(Float_t * /points/) const {;}
	virtual void Sizeof3D() const {;}	virtual void Sizeof3D() const {;}

	ClassDef(TGeoHalfSpace, 1) // half-space class	ClassDef(TGeoHalfSpace, 1) // half-space class
	};	};

	#endif	#endif

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

	TGeoHype.h	TGeoHype.h

	skipping to change at line 75	skipping to change at line 75
	TGeoHype();	TGeoHype();
	TGeoHype(Double_t rin, Double_t stin, Double_t rout, Double_t stout, Dou ble_t dz);	TGeoHype(Double_t rin, Double_t stin, Double_t rout, Double_t stout, Dou ble_t dz);
	TGeoHype(const char *name, Double_t rin, Double_t stin, Double_t rout, D ouble_t stout, Double_t dz);	TGeoHype(const char *name, Double_t rin, Double_t stin, Double_t rout, D ouble_t stout, Double_t dz);
	TGeoHype(Double_t *params);	TGeoHype(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoHype();	virtual ~TGeoHype();
	// methods	// methods

	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	Int_t DistToHype(Double_t point, Double_t dir, Double_	virtual void DistFromOutside_v(const Double_t *points, const Do
	t *s, Bool_t inner, Bool_t in) const;	uble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		Int_t DistToHype(const Double_t point, const Double_t
		dir, Double_t *s, Bool_t inner, Bool_t in) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 64;}	virtual Int_t GetByteCount() const {return 64;}
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	Double_t GetStIn() const {return fStIn;}	Double_t GetStIn() const {return fStIn;}
	Double_t GetStOut() const {return fStOut;}	Double_t GetStOut() const {return fStOut;}
	Bool_t HasInner() const {return !TestShapeBit(kGeoRSeg);}	Bool_t HasInner() const {return !TestShapeBit(kGeoRSeg);}
	Double_t RadiusHypeSq(Double_t z, Bool_t inner) const;	Double_t RadiusHypeSq(Double_t z, Bool_t inner) const;
	Double_t ZHypeSq(Double_t r, Bool_t inner) const;	Double_t ZHypeSq(Double_t r, Bool_t inner) const;
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;
	//virtual void Paint(Option_t *option);	//virtual void Paint(Option_t *option);

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	Double_t SafetyToHype(Double_t *point, Bool_t inner, Bool_t	st;
	in) const;	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		Double_t SafetyToHype(const Double_t *point, Bool_t inner,
		Bool_t in) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetHypeDimensions(Double_t rin, Double_t stin, Dou ble_t rout, Double_t stout, Double_t dz);	void SetHypeDimensions(Double_t rin, Double_t stin, Dou ble_t rout, Double_t stout, Double_t dz);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoHype, 1) // hyperboloid class	ClassDef(TGeoHype, 1) // hyperboloid class


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

	TGeoPara.h	TGeoPara.h

	skipping to change at line 56	skipping to change at line 56
	// constructors	// constructors
	TGeoPara();	TGeoPara();
	TGeoPara(Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi);	TGeoPara(Double_t dx, Double_t dy, Double_t dz, Double_t alpha, Double_t theta, Double_t phi);
	TGeoPara(const char *name, Double_t dx, Double_t dy, Double_t dz, Double _t alpha, Double_t theta, Double_t phi);	TGeoPara(const char *name, Double_t dx, Double_t dy, Double_t dz, Double _t alpha, Double_t theta, Double_t phi);
	TGeoPara(Double_t *param);	TGeoPara(Double_t *param);
	// destructor	// destructor
	virtual ~TGeoPara();	virtual ~TGeoPara();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual Int_t GetByteCount() const {return 48;}	virtual Int_t GetByteCount() const {return 48;}
	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual Int_t GetNmeshVertices() const {return 8;}	virtual Int_t GetNmeshVertices() const {return 8;}
	Double_t GetX() const {return fX;}	Double_t GetX() const {return fX;}
	Double_t GetY() const {return fY;}	Double_t GetY() const {return fY;}
	Double_t GetZ() const {return fZ;}	Double_t GetZ() const {return fZ;}
	Double_t GetAlpha() const {return fAlpha;}	Double_t GetAlpha() const {return fAlpha;}
	Double_t GetTheta() const {return fTheta;}	Double_t GetTheta() const {return fTheta;}
	Double_t GetPhi() const {return fPhi;}	Double_t GetPhi() const {return fPhi;}
	Double_t GetTxy() const {return fTxy;}	Double_t GetTxy() const {return fTxy;}
	Double_t GetTxz() const {return fTxz;}	Double_t GetTxz() const {return fTxz;}
	Double_t GetTyz() const {return fTyz;}	Double_t GetTyz() const {return fTyz;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoPara, 1) // box primitive	ClassDef(TGeoPara, 1) // box primitive
	};	};

	#endif	#endif

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

	TGeoParaboloid.h	TGeoParaboloid.h

	skipping to change at line 55	skipping to change at line 55
	// constructors	// constructors
	TGeoParaboloid();	TGeoParaboloid();
	TGeoParaboloid(Double_t rlo, Double_t rhi, Double_t dz);	TGeoParaboloid(Double_t rlo, Double_t rhi, Double_t dz);
	TGeoParaboloid(const char *name, Double_t rlo, Double_t rhi, Double_t dz );	TGeoParaboloid(const char *name, Double_t rlo, Double_t rhi, Double_t dz );
	TGeoParaboloid(Double_t *params);	TGeoParaboloid(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoParaboloid();	virtual ~TGeoParaboloid();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	Double_t DistToParaboloid(Double_t point, Double_t dir, B	Double_t DistToParaboloid(const Double_t *point, const Doub
	ool_t in) const;	le_t *dir, Bool_t in) const;
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	virtual Double_t DistFromInside(const Double_t *point, const Double
	_t iact=1,	_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	Double_t GetRlo() const {return fRlo;}	Double_t GetRlo() const {return fRlo;}
	Double_t GetRhi() const {return fRhi;}	Double_t GetRhi() const {return fRhi;}
	Double_t GetDz() const {return fDz;}	Double_t GetDz() const {return fDz;}

	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetParaboloidDimensions(Double_t rlo, Double_t rhi , Double_t dz);	void SetParaboloidDimensions(Double_t rlo, Double_t rhi , Double_t dz);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoParaboloid, 1) // paraboloid class	ClassDef(TGeoParaboloid, 1) // paraboloid class


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

	TGeoPatternFinder.h	TGeoPatternFinder.h

	skipping to change at line 43	skipping to change at line 43
	{	{
	public:	public:
	struct ThreadData_t	struct ThreadData_t
	{	{
	TGeoMatrix *fMatrix; //! generic matrix	TGeoMatrix *fMatrix; //! generic matrix
	Int_t fCurrent; //! current division element	Int_t fCurrent; //! current division element
	Int_t fNextIndex; //! index of next node	Int_t fNextIndex; //! index of next node

	ThreadData_t();	ThreadData_t();
	~ThreadData_t();	~ThreadData_t();

		private:
		ThreadData_t(const ThreadData_t&); // Not implemented
		ThreadData_t& operator=(const ThreadData_t&); // Not implemented
	};	};
	ThreadData_t& GetThreadData() const;	ThreadData_t& GetThreadData() const;
	void ClearThreadData() const;	void ClearThreadData() const;
	void CreateThreadData(Int_t nthreads);	void CreateThreadData(Int_t nthreads);

	protected :	protected :
	enum EGeoPatternFlags {	enum EGeoPatternFlags {
	kPatternReflected = BIT(14),	kPatternReflected = BIT(14),
	kPatternSpacedOut = BIT(15)	kPatternSpacedOut = BIT(15)
	};	};

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

	TGeoPcon.h	TGeoPcon.h

	skipping to change at line 64	skipping to change at line 64
	// constructors	// constructors
	TGeoPcon();	TGeoPcon();
	TGeoPcon(Double_t phi, Double_t dphi, Int_t nz);	TGeoPcon(Double_t phi, Double_t dphi, Int_t nz);
	TGeoPcon(const char *name, Double_t phi, Double_t dphi, Int_t nz);	TGeoPcon(const char *name, Double_t phi, Double_t dphi, Int_t nz);
	TGeoPcon(Double_t *params);	TGeoPcon(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoPcon();	virtual ~TGeoPcon();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual void DefineSection(Int_t snum, Double_t z, Double_t rmi n, Double_t rmax);	virtual void DefineSection(Int_t snum, Double_t z, Double_t rmi n, Double_t rmax);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	Double_t DistToSegZ(Double_t point, Double_t dir, Int_t &	virtual void DistFromOutside_v(const Double_t *points, const Do
	iz) const;	uble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		Double_t DistToSegZ(const Double_t point, const Double_t
		dir, Int_t &iz) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 60+12*fNz;}	virtual Int_t GetByteCount() const {return 60+12*fNz;}
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetDphi() const {return fDphi;}	Double_t GetDphi() const {return fDphi;}

	skipping to change at line 102	skipping to change at line 106
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;
	Double_t &Phi1() {return fPhi1;}	Double_t &Phi1() {return fPhi1;}
	Double_t &Dphi() {return fDphi;}	Double_t &Dphi() {return fDphi;}
	Double_t &Rmin(Int_t ipl) {return fRmin[ipl];}	Double_t &Rmin(Int_t ipl) {return fRmin[ipl];}
	Double_t &Rmax(Int_t ipl) {return fRmax[ipl];}	Double_t &Rmax(Int_t ipl) {return fRmax[ipl];}
	Double_t &Z(Int_t ipl) {return fZ[ipl];}	Double_t &Z(Int_t ipl) {return fZ[ipl];}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	Double_t SafetyToSegment(Double_t *point, Int_t ipl, Bool_t	st;
	in=kTRUE, Double_t safmin=TGeoShape::Big()) const;	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		Double_t SafetyToSegment(const Double_t *point, Int_t ipl,
		Bool_t in=kTRUE, Double_t safmin=TGeoShape::Big()) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoPcon, 1) // polycone class	ClassDef(TGeoPcon, 1) // polycone class
	};	};


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

	TGeoPgon.h	TGeoPgon.h

	skipping to change at line 39	skipping to change at line 39
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPgon : public TGeoPcon	class TGeoPgon : public TGeoPcon
	{	{
	protected:	protected:
	// data members	// data members
	Int_t fNedges; // number of edges (at least one)	Int_t fNedges; // number of edges (at least one)
	mutable Int_t *fIntBuffer; //![fNedges+4] temporary int buffer ar ray	mutable Int_t *fIntBuffer; //![fNedges+4] temporary int buffer ar ray
	mutable Double_t *fDblBuffer; //![fNedges+4] temporary double buffer array	mutable Double_t *fDblBuffer; //![fNedges+4] temporary double buffer array


	Int_t GetPhiCrossList(Double_t point, Double_t dir, In	Int_t GetPhiCrossList(const Double_t *point, const Doubl
	t_t istart, Double_t sphi, Int_t iphi, Double_t stepmax=TGeoShape::Big())	e_t dir, Int_t istart, Double_t sphi, Int_t *iphi, Double_t stepmax=TGeoS
	const;	hape::Big()) const;
	Bool_t IsCrossingSlice(Double_t point, Double_t dir, In	Bool_t IsCrossingSlice(const Double_t *point, const Doubl
	t_t iphi, Double_t sstart, Int_t &ipl, Double_t &snext, Double_t stepmax) c	e_t *dir, Int_t iphi, Double_t sstart, Int_t &ipl, Double_t &snext, Double_
	onst;	t stepmax) const;
	void LocatePhi(Double_t *point, Int_t &ipsec) const;	void LocatePhi(const Double_t *point, Int_t &ipsec) con
		st;
	Double_t Rpg(Double_t z, Int_t ipl, Bool_t inner, Double_t &a, Double_t &b) const;	Double_t Rpg(Double_t z, Int_t ipl, Bool_t inner, Double_t &a, Double_t &b) const;

	Double_t Rproj(Double_t z,Double_t point, Double_t dir, D	Double_t Rproj(Double_t z,const Double_t *point, const Doub
	ouble_t cphi, Double_t sphi, Double_t &a, Double_t &b) const;	le_t *dir, Double_t cphi, Double_t sphi, Double_t &a, Double_t &b) const;
	Bool_t SliceCrossing(Double_t point, Double_t dir, Int_	Bool_t SliceCrossing(const Double_t *point, const Double_
	t nphi, Int_t iphi, Double_t sphi, Double_t &snext, Double_t stepmax) con	t dir, Int_t nphi, Int_t iphi, Double_t *sphi, Double_t &snext, Double_t
	st;	stepmax) const;
	Bool_t SliceCrossingIn(Double_t point, Double_t dir, In	Bool_t SliceCrossingIn(const Double_t *point, const Doubl
	t_t ipl, Int_t nphi, Int_t iphi, Double_t sphi, Double_t &snext, Double_t	e_t dir, Int_t ipl, Int_t nphi, Int_t iphi, Double_t *sphi, Double_t &sne
	stepmax) const;	xt, Double_t stepmax) const;
	Bool_t SliceCrossingZ(Double_t point, Double_t dir, Int	Bool_t SliceCrossingZ(const Double_t *point, const Double
	_t nphi, Int_t iphi, Double_t sphi, Double_t &snext, Double_t stepmax) co	_t dir, Int_t nphi, Int_t iphi, Double_t *sphi, Double_t &snext, Double_t
	nst;	stepmax) const;
	Bool_t SliceCrossingInZ(Double_t point, Double_t dir, I	Bool_t SliceCrossingInZ(const Double_t *point, const Doub
	nt_t nphi, Int_t iphi, Double_t sphi, Double_t &snext, Double_t stepmax)	le_t dir, Int_t nphi, Int_t iphi, Double_t *sphi, Double_t &snext, Double
	const;	_t stepmax) const;

	public:	public:
	// constructors	// constructors
	TGeoPgon();	TGeoPgon();
	TGeoPgon(Double_t phi, Double_t dphi, Int_t nedges, Int_t nz);	TGeoPgon(Double_t phi, Double_t dphi, Int_t nedges, Int_t nz);
	TGeoPgon(const char *name, Double_t phi, Double_t dphi, Int_t nedges, In t_t nz);	TGeoPgon(const char *name, Double_t phi, Double_t dphi, Int_t nedges, In t_t nz);
	TGeoPgon(Double_t *params);	TGeoPgon(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoPgon();	virtual ~TGeoPgon();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 64+12*fNz;}	virtual Int_t GetByteCount() const {return 64+12*fNz;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	Int_t GetNedges() const {return fNedges;}	Int_t GetNedges() const {return fNedges;}
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Int_t GetNsegments() const {return fNedges;}	virtual Int_t GetNsegments() const {return fNedges;}
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const {return TGeoBBox::GetPointsOnSegments(npoints,array);}	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const {return TGeoBBox::GetPointsOnSegments(npoints,array);}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	Double_t SafetyToSegment(Double_t *point, Int_t ipl, Int_t	st;
	iphi, Bool_t in, Double_t safphi, Double_t safmin=TGeoShape::Big()) const;	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		Double_t SafetyToSegment(const Double_t *point, Int_t ipl,
		Int_t iphi, Bool_t in, Double_t safphi, Double_t safmin=TGeoShape::Big()) c
		onst;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	void SetNedges(Int_t ne) {if (ne>2) fNedges=ne;}	void SetNedges(Int_t ne) {if (ne>2) fNedges=ne;}
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoPgon, 1) // polygone class	ClassDef(TGeoPgon, 1) // polygone class
	};	};

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

	TGeoPolygon.h	TGeoPolygon.h

	skipping to change at line 51	skipping to change at line 51
	Int_t fNvert; // number of vertices (must be de fined clockwise in XY plane)	Int_t fNvert; // number of vertices (must be de fined clockwise in XY plane)
	Int_t fNconvex; // number of points of the outscr ibed convex polygon	Int_t fNconvex; // number of points of the outscr ibed convex polygon
	Int_t *fInd; //[fNvert] list of vertex indices	Int_t *fInd; //[fNvert] list of vertex indices
	Int_t *fIndc; //[fNconvex] indices of vertices of the outscribed convex polygon	Int_t *fIndc; //[fNconvex] indices of vertices of the outscribed convex polygon
	Double_t *fX; //! pointer to list of current X coordinates of vertices	Double_t *fX; //! pointer to list of current X coordinates of vertices
	Double_t *fY; //! pointer to list of current Y coordinates of vertices	Double_t *fY; //! pointer to list of current Y coordinates of vertices
	TObjArray *fDaughters; // list of concave daughters	TObjArray *fDaughters; // list of concave daughters
	private:	private:
	void ConvexCheck(); // force convexity checking	void ConvexCheck(); // force convexity checking
	Bool_t IsSegConvex(Int_t i1, Int_t i2=-1) const;	Bool_t IsSegConvex(Int_t i1, Int_t i2=-1) const;

	Bool_t IsRightSided(Double_t *point, Int_t ind1, Int_t ind2 ) const;	Bool_t IsRightSided(const Double_t *point, Int_t ind1, Int_ t ind2) const;
	void OutscribedConvex();	void OutscribedConvex();
	public:	public:
	// constructors	// constructors
	TGeoPolygon();	TGeoPolygon();
	TGeoPolygon(Int_t nvert);	TGeoPolygon(Int_t nvert);
	// destructor	// destructor
	virtual ~TGeoPolygon();	virtual ~TGeoPolygon();
	// methods	// methods
	Double_t Area() const;	Double_t Area() const;

	Bool_t Contains(Double_t *point) const;	Bool_t Contains(const Double_t *point) const;
	virtual void Draw(Option_t *option="");	virtual void Draw(Option_t *option="");
	void FinishPolygon();	void FinishPolygon();
	Int_t GetNvert() const {return fNvert;}	Int_t GetNvert() const {return fNvert;}
	Int_t GetNconvex() const {return fNconvex;}	Int_t GetNconvex() const {return fNconvex;}
	Double_t *GetX() {return fX;}	Double_t *GetX() {return fX;}
	Double_t *GetY() {return fY;}	Double_t *GetY() {return fY;}
	void GetVertices(Double_t x, Double_t y) const;	void GetVertices(Double_t x, Double_t y) const;
	void GetConvexVertices(Double_t x, Double_t y) const;	void GetConvexVertices(Double_t x, Double_t y) const;
	Bool_t IsClockwise() const {return !TObject::TestBit(kGeoAC W);}	Bool_t IsClockwise() const {return !TObject::TestBit(kGeoAC W);}
	Bool_t IsConvex() const {return TObject::TestBit(kGeoConvex );}	Bool_t IsConvex() const {return TObject::TestBit(kGeoConvex );}
	Bool_t IsFinished() const {return TObject::TestBit(kGeoFini shPolygon);}	Bool_t IsFinished() const {return TObject::TestBit(kGeoFini shPolygon);}
	Bool_t IsIllegalCheck() const;	Bool_t IsIllegalCheck() const;

	Double_t Safety(Double_t *point, Int_t &isegment) const;	Double_t Safety(const Double_t *point, Int_t &isegment) const ;
	void SetConvex(Bool_t flag=kTRUE) {TObject::SetBit(kGeoCo nvex,flag);}	void SetConvex(Bool_t flag=kTRUE) {TObject::SetBit(kGeoCo nvex,flag);}
	void SetXY(Double_t x, Double_t y);	void SetXY(Double_t x, Double_t y);
	void SetNextIndex(Int_t index=-1);	void SetNextIndex(Int_t index=-1);

	ClassDef(TGeoPolygon, 2) // class for handling arbitrary polygon s	ClassDef(TGeoPolygon, 2) // class for handling arbitrary polygon s
	};	};

	#endif	#endif

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

	TGeoScaledShape.h	TGeoScaledShape.h

	skipping to change at line 46	skipping to change at line 46
	public:	public:
	// constructors	// constructors
	TGeoScaledShape();	TGeoScaledShape();
	TGeoScaledShape(const char name, TGeoShape shape, TGeoScale *scale);	TGeoScaledShape(const char name, TGeoShape shape, TGeoScale *scale);
	TGeoScaledShape(TGeoShape shape, TGeoScale scale);	TGeoScaledShape(TGeoShape shape, TGeoScale scale);
	// destructor	// destructor
	virtual ~TGeoScaledShape();	virtual ~TGeoScaledShape();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const {return fShape->GetNmeshV ertices();}	virtual Int_t GetNmeshVertices() const {return fShape->GetNmeshV ertices();}
	TGeoShape *GetShape() const {return fShape;}	TGeoShape *GetShape() const {return fShape;}
	TGeoScale *GetScale() const {return fScale;}	TGeoScale *GetScale() const {return fScale;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsAssembly() const;	virtual Bool_t IsAssembly() const;
	virtual Bool_t IsCylType() const {return fShape->IsCylType();}	virtual Bool_t IsCylType() const {return fShape->IsCylType();}
	virtual Bool_t IsReflected() const;	virtual Bool_t IsReflected() const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;
	static TGeoShape MakeScaledShape(const char name, TGeoShape shape , TGeoScale scale);	static TGeoShape MakeScaledShape(const char name, TGeoShape shape , TGeoScale scale);

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetScale(TGeoScale *scale) {fScale = scale;}	void SetScale(TGeoScale *scale) {fScale = scale;}
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buffer) const;	virtual void SetSegsAndPols(TBuffer3D &buffer) const;

	ClassDef(TGeoScaledShape, 1) // a scaled shape	ClassDef(TGeoScaledShape, 1) // a scaled shape
	};	};

	#endif	#endif

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

	TGeoShapeAssembly.h	TGeoShapeAssembly.h

	skipping to change at line 44	skipping to change at line 44

	// methods	// methods
	public:	public:
	// constructors	// constructors
	TGeoShapeAssembly();	TGeoShapeAssembly();
	TGeoShapeAssembly(TGeoVolumeAssembly *vol);	TGeoShapeAssembly(TGeoVolumeAssembly *vol);
	// destructor	// destructor
	virtual ~TGeoShapeAssembly();	virtual ~TGeoShapeAssembly();
	// methods	// methods
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const {return 0;}	virtual Int_t GetNmeshVertices() const {return 0;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsAssembly() const {return kTRUE;}	virtual Bool_t IsAssembly() const {return kTRUE;}
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}
	void NeedsBBoxRecompute() {fBBoxOK = kFALSE;}	void NeedsBBoxRecompute() {fBBoxOK = kFALSE;}
	void RecomputeBoxLast();	void RecomputeBoxLast();

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;

	ClassDef(TGeoShapeAssembly, 2) // assembly shape	ClassDef(TGeoShapeAssembly, 2) // assembly shape
	};	};

	#endif	#endif

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

	TGeoSphere.h	TGeoSphere.h

	skipping to change at line 56	skipping to change at line 56
	TGeoSphere(Double_t rmin, Double_t rmax, Double_t theta1=0, Double_t the ta2=180,	TGeoSphere(Double_t rmin, Double_t rmax, Double_t theta1=0, Double_t the ta2=180,
	Double_t phi1=0, Double_t phi2=360);	Double_t phi1=0, Double_t phi2=360);
	TGeoSphere(const char *name, Double_t rmin, Double_t rmax, Double_t thet a1=0, Double_t theta2=180,	TGeoSphere(const char *name, Double_t rmin, Double_t rmax, Double_t thet a1=0, Double_t theta2=180,
	Double_t phi1=0, Double_t phi2=360);	Double_t phi1=0, Double_t phi2=360);
	TGeoSphere(Double_t *param, Int_t nparam=6);	TGeoSphere(Double_t *param, Int_t nparam=6);
	// destructor	// destructor
	virtual ~TGeoSphere();	virtual ~TGeoSphere();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	Double_t DistToSphere(Double_t point, Double_t dir, Doubl	virtual void DistFromOutside_v(const Double_t *points, const Do
	e_t rsph, Bool_t check=kTRUE, Bool_t firstcross=kTRUE) const;	uble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		Double_t DistToSphere(const Double_t *point, const Double_t
		*dir, Double_t rsph, Bool_t check=kTRUE, Bool_t firstcross=kTRUE) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 42;}	virtual Int_t GetByteCount() const {return 42;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;

	skipping to change at line 85	skipping to change at line 89
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	Int_t GetNz() const {return fNz;}	Int_t GetNz() const {return fNz;}
	virtual Double_t GetRmin() const {return fRmin;}	virtual Double_t GetRmin() const {return fRmin;}
	virtual Double_t GetRmax() const {return fRmax;}	virtual Double_t GetRmax() const {return fRmax;}
	Double_t GetTheta1() const {return fTheta1;}	Double_t GetTheta1() const {return fTheta1;}
	Double_t GetTheta2() const {return fTheta2;}	Double_t GetTheta2() const {return fTheta2;}
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetPhi2() const {return fPhi2;}	Double_t GetPhi2() const {return fPhi2;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	Int_t IsOnBoundary(Double_t *point) const;	Int_t IsOnBoundary(const Double_t *point) const;
	Bool_t IsPointInside(Double_t *point, Bool_t checkR=kTRUE	Bool_t IsPointInside(const Double_t *point, Bool_t checkR
	, Bool_t checkTh=kTRUE, Bool_t checkPh=kTRUE) const;	=kTRUE, Bool_t checkTh=kTRUE, Bool_t checkPh=kTRUE) const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetSphDimensions(Double_t rmin, Double_t rmax, Dou ble_t theta1,	void SetSphDimensions(Double_t rmin, Double_t rmax, Dou ble_t theta1,
	Double_t theta2, Double_t phi1, Doub le_t phi2);	Double_t theta2, Double_t phi1, Doub le_t phi2);
	virtual void SetNumberOfDivisions(Int_t p);	virtual void SetNumberOfDivisions(Int_t p);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);

		void SetDimensions(Double_t *param, Int_t nparam);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoSphere, 1) // sphere class	ClassDef(TGeoSphere, 1) // sphere class
	};	};

	#endif	#endif

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

	TGeoTorus.h	TGeoTorus.h

	skipping to change at line 43	skipping to change at line 43
	// data members	// data members
	Double_t fR; // axial radius	Double_t fR; // axial radius
	Double_t fRmin; // inner radius	Double_t fRmin; // inner radius
	Double_t fRmax; // outer radius	Double_t fRmax; // outer radius
	Double_t fPhi1; // starting phi	Double_t fPhi1; // starting phi
	Double_t fDphi; // phi extent	Double_t fDphi; // phi extent
	// methods	// methods

	public:	public:
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;

	Double_t Daxis(Double_t pt, Double_t dir, Double_t t) con	Double_t Daxis(const Double_t pt, const Double_t dir, Dou
	st;	ble_t t) const;
	Double_t DDaxis(Double_t pt, Double_t dir, Double_t t) co	Double_t DDaxis(const Double_t pt, const Double_t dir, Do
	nst;	uble_t t) const;
	Double_t DDDaxis(Double_t pt, Double_t dir, Double_t t) c	Double_t DDDaxis(const Double_t pt, const Double_t dir, D
	onst;	ouble_t t) const;
	Double_t ToBoundary(Double_t pt, Double_t dir, Double_t r	Double_t ToBoundary(const Double_t pt, const Double_t dir
	, Bool_t in) const;	, Double_t r, Bool_t in) const;
	Int_t SolveCubic(Double_t a, Double_t b, Double_t c, Dou ble_t *x) const;	Int_t SolveCubic(Double_t a, Double_t b, Double_t c, Dou ble_t *x) const;
	Int_t SolveQuartic(Double_t a, Double_t b, Double_t c, D ouble_t d, Double_t *x) const;	Int_t SolveQuartic(Double_t a, Double_t b, Double_t c, D ouble_t d, Double_t *x) const;
	public:	public:
	// constructors	// constructors
	TGeoTorus();	TGeoTorus();
	TGeoTorus(Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Dou ble_t dphi=360);	TGeoTorus(Double_t r, Double_t rmin, Double_t rmax, Double_t phi1=0, Dou ble_t dphi=360);
	TGeoTorus(const char * name, Double_t r, Double_t rmin, Double_t rmax, D ouble_t phi1=0, Double_t dphi=360);	TGeoTorus(const char * name, Double_t r, Double_t rmin, Double_t rmax, D ouble_t phi1=0, Double_t dphi=360);
	TGeoTorus(Double_t *params);	TGeoTorus(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoTorus() {}	virtual ~TGeoTorus() {}
	// methods	// methods

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

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 56;}	virtual Int_t GetByteCount() const {return 56;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}	virtual Bool_t GetPointsOnSegments(Int_t /npoints/, Double_t * /array/) const {return kFALSE;}
	Double_t GetR() const {return fR;}	Double_t GetR() const {return fR;}
	Double_t GetRmin() const {return fRmin;}	Double_t GetRmin() const {return fRmin;}
	Double_t GetRmax() const {return fRmax;}	Double_t GetRmax() const {return fRmax;}
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetDphi() const {return fDphi;}	Double_t GetDphi() const {return fDphi;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetTorusDimensions(Double_t r, Double_t rmin, Doub le_t rmax, Double_t phi1, Double_t dphi);	void SetTorusDimensions(Double_t r, Double_t rmin, Doub le_t rmax, Double_t phi1, Double_t dphi);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoTorus, 1) // torus class	ClassDef(TGeoTorus, 1) // torus class


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

	TGeoTrd1.h	TGeoTrd1.h

	skipping to change at line 50	skipping to change at line 50
	TGeoTrd1();	TGeoTrd1();
	TGeoTrd1(Double_t dx1, Double_t dx2, Double_t dy, Double_t dz);	TGeoTrd1(Double_t dx1, Double_t dx2, Double_t dy, Double_t dz);
	TGeoTrd1(const char *name, Double_t dx1, Double_t dx2, Double_t dy, Doub le_t dz);	TGeoTrd1(const char *name, Double_t dx1, Double_t dx2, Double_t dy, Doub le_t dz);
	TGeoTrd1(Double_t *params);	TGeoTrd1(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoTrd1();	virtual ~TGeoTrd1();
	// methods	// methods

	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual Int_t GetByteCount() const {return 52;}	virtual Int_t GetByteCount() const {return 52;}
	Double_t GetDx1() const {return fDx1;}	Double_t GetDx1() const {return fDx1;}
	Double_t GetDx2() const {return fDx2;}	Double_t GetDx2() const {return fDx2;}
	Double_t GetDy() const {return fDy;}	Double_t GetDy() const {return fDy;}
	Double_t GetDz() const {return fDz;}	Double_t GetDz() const {return fDz;}
	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;

	void GetVisibleCorner(Double_t point, Double_t vertex	void GetVisibleCorner(const Double_t point, Double_t
	, Double_t *normals) const;	vertex, Double_t *normals) const;
	void GetOppositeCorner(Double_t *point, Int_t inorm, Do	void GetOppositeCorner(const Double_t *point, Int_t ino
	uble_t vertex, Double_t normals) const;	rm, Double_t vertex, Double_t normals) const;
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	void SetVertex(Double_t *vertex) const;	void SetVertex(Double_t *vertex) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoTrd1, 1) // TRD1 shape class	ClassDef(TGeoTrd1, 1) // TRD1 shape class
	};	};


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

	TGeoTrd2.h	TGeoTrd2.h

	skipping to change at line 50	skipping to change at line 50
	// constructors	// constructors
	TGeoTrd2();	TGeoTrd2();
	TGeoTrd2(Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_ t dz);	TGeoTrd2(Double_t dx1, Double_t dx2, Double_t dy1, Double_t dy2, Double_ t dz);
	TGeoTrd2(const char *name, Double_t dx1, Double_t dx2, Double_t dy1, Dou ble_t dy2, Double_t dz);	TGeoTrd2(const char *name, Double_t dx1, Double_t dx2, Double_t dy1, Dou ble_t dy2, Double_t dz);
	TGeoTrd2(Double_t *params);	TGeoTrd2(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoTrd2();	virtual ~TGeoTrd2();
	// methods	// methods

	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	virtual void ComputeNormal_v(const Double_t *points, const Doub
	_t iact=1,	le_t dirs, Double_t norms, Int_t vecsize);
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual Int_t GetByteCount() const {return 56;}	virtual Int_t GetByteCount() const {return 56;}
	Double_t GetDx1() const {return fDx1;}	Double_t GetDx1() const {return fDx1;}
	Double_t GetDx2() const {return fDx2;}	Double_t GetDx2() const {return fDx2;}
	Double_t GetDy1() const {return fDy1;}	Double_t GetDy1() const {return fDy1;}
	Double_t GetDy2() const {return fDy2;}	Double_t GetDy2() const {return fDy2;}
	Double_t GetDz() const {return fDz;}	Double_t GetDz() const {return fDz;}
	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;

	void GetVisibleCorner(Double_t point, Double_t vertex	void GetVisibleCorner(const Double_t point, Double_t
	, Double_t *normals) const;	vertex, Double_t *normals) const;
	void GetOppositeCorner(Double_t *point, Int_t inorm, Do	void GetOppositeCorner(const Double_t *point, Int_t ino
	uble_t vertex, Double_t normals) const;	rm, Double_t vertex, Double_t normals) const;
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	void SetVertex(Double_t *vertex) const;	void SetVertex(Double_t *vertex) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoTrd2, 1) // TRD2 shape class	ClassDef(TGeoTrd2, 1) // TRD2 shape class
	};	};


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

	TGeoTube.h	TGeoTube.h

	skipping to change at line 50	skipping to change at line 50
	TGeoTube(Double_t rmin, Double_t rmax, Double_t dz);	TGeoTube(Double_t rmin, Double_t rmax, Double_t dz);
	TGeoTube(const char * name, Double_t rmin, Double_t rmax, Double_t dz);	TGeoTube(const char * name, Double_t rmin, Double_t rmax, Double_t dz);
	TGeoTube(Double_t *params);	TGeoTube(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoTube();	virtual ~TGeoTube();
	// methods	// methods

	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	static Double_t Capacity(Double_t rmin, Double_t rmax, Double_t dz );	static Double_t Capacity(Double_t rmin, Double_t rmax, Double_t dz );
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	static void ComputeNormalS(Double_t point, Double_t dir, Dou	virtual void ComputeNormal_v(const Double_t *points, const Doub
	ble_t *norm,	le_t dirs, Double_t norms, Int_t vecsize);
		static void ComputeNormalS(const Double_t *point, const Double
		_t dir, Double_t norm,
	Double_t rmin, Double_t rmax, Doubl e_t dz);	Double_t rmin, Double_t rmax, Doubl e_t dz);

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
	static Double_t DistFromInsideS(Double_t point, Double_t dir, Do	virtual void Contains_v(const Double_t points, Bool_t inside,
	uble_t rmin, Double_t rmax, Double_t dz);	Int_t vecsize) const;
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	static Double_t DistFromInsideS(const Double_t *point, const Doubl
	_t iact=1,	e_t *dir, Double_t rmin, Double_t rmax, Double_t dz);
	Double_t step=TGeoShape::Big(), Double_t	virtual Double_t DistFromInside(const Double_t *point, const Double
	*safe=0) const;	_t *dir, Int_t iact=1,
	static Double_t DistFromOutsideS(Double_t point, Double_t dir, D	Double_t step=TGeoShape::Big(), Double_t
	ouble_t rmin, Double_t rmax, Double_t dz);	*safe=0) const;
	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		static Double_t DistFromOutsideS(const Double_t *point, const Doub
		le_t *dir, Double_t rmin, Double_t rmax, Double_t dz);
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	static void DistToTube(Double_t rsq, Double_t nsq, Double_t rd otn, Double_t radius, Double_t &b, Double_t &delta);	static void DistToTube(Double_t rsq, Double_t nsq, Double_t rd otn, Double_t radius, Double_t &b, Double_t &delta);
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 48;}	virtual Int_t GetByteCount() const {return 48;}
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual Double_t GetRmin() const {return fRmin;}	virtual Double_t GetRmin() const {return fRmin;}
	virtual Double_t GetRmax() const {return fRmax;}	virtual Double_t GetRmax() const {return fRmax;}
	virtual Double_t GetDz() const {return fDz;}	virtual Double_t GetDz() const {return fDz;}
	Bool_t HasRmin() const {return (fRmin>0)?kTRUE:kFALSE;}	Bool_t HasRmin() const {return (fRmin>0)?kTRUE:kFALSE;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kTRUE;}	virtual Bool_t IsCylType() const {return kTRUE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	static Double_t SafetyS(Double_t *point, Bool_t in, Double_t rmin,	st;
	Double_t rmax, Double_t dz, Int_t skipz=0);	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		static Double_t SafetyS(const Double_t *point, Bool_t in, Double_t
		rmin, Double_t rmax, Double_t dz, Int_t skipz=0);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetTubeDimensions(Double_t rmin, Double_t rmax, Do uble_t dz);	void SetTubeDimensions(Double_t rmin, Double_t rmax, Do uble_t dz);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoTube, 1) // cylindrical tube class	ClassDef(TGeoTube, 1) // cylindrical tube class


	skipping to change at line 124	skipping to change at line 129
	Double_t phi1, Double_t phi2);	Double_t phi1, Double_t phi2);
	TGeoTubeSeg(const char * name, Double_t rmin, Double_t rmax, Double_t dz ,	TGeoTubeSeg(const char * name, Double_t rmin, Double_t rmax, Double_t dz ,
	Double_t phi1, Double_t phi2);	Double_t phi1, Double_t phi2);
	TGeoTubeSeg(Double_t *params);	TGeoTubeSeg(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoTubeSeg();	virtual ~TGeoTubeSeg();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	static Double_t Capacity(Double_t rmin, Double_t rmax, Double_t dz , Double_t phi1, Double_t phi2);	static Double_t Capacity(Double_t rmin, Double_t rmax, Double_t dz , Double_t phi1, Double_t phi2);
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	static void ComputeNormalS(Double_t point, Double_t dir, Dou	virtual void ComputeNormal_v(const Double_t *points, const Doub
	ble_t *norm,	le_t dirs, Double_t norms, Int_t vecsize);
		static void ComputeNormalS(const Double_t *point, const Double
		_t dir, Double_t norm,
	Double_t rmin, Double_t rmax, Doubl e_t dz,	Double_t rmin, Double_t rmax, Doubl e_t dz,
	Double_t c1, Double_t s1, Double_t c2, Double_t s2);	Double_t c1, Double_t s1, Double_t c2, Double_t s2);

	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	static Double_t DistFromInsideS(Double_t point, Double_t dir,Dou ble_t rmin, Double_t rmax, Double_t dz,	static Double_t DistFromInsideS(const Double_t point, const Doubl e_t dir,Double_t rmin, Double_t rmax, Double_t dz,
	Double_t c1, Double_t s1, Double_t c2, Double_t s2, Double_t cm, Double_t sm, Double_t cdfi);	Double_t c1, Double_t s1, Double_t c2, Double_t s2, Double_t cm, Double_t sm, Double_t cdfi);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	static Double_t DistFromOutsideS(Double_t point, Double_t dir, D	virtual void DistFromInside_v(const Double_t *points, const Dou
	ouble_t rmin, Double_t rmax, Double_t dz,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		static Double_t DistFromOutsideS(const Double_t *point, const Doub
		le_t *dir, Double_t rmin, Double_t rmax, Double_t dz,
	Double_t c1, Double_t s1, Double_t c2, D ouble_t s2, Double_t cm, Double_t sm, Double_t cdfi);	Double_t c1, Double_t s1, Double_t c2, D ouble_t s2, Double_t cm, Double_t sm, Double_t cdfi);

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Doubl e_t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 56;}	virtual Int_t GetByteCount() const {return 56;}
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetPhi2() const {return fPhi2;}	Double_t GetPhi2() const {return fPhi2;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	static Double_t SafetyS(Double_t *point, Bool_t in, Double_t rmin,	st;
	Double_t rmax, Double_t dz,	virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
		static Double_t SafetyS(const Double_t *point, Bool_t in, Double_t
		rmin, Double_t rmax, Double_t dz,
	Double_t phi1, Double_t phi2, Int_t skipz= 0);	Double_t phi1, Double_t phi2, Int_t skipz= 0);
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetTubsDimensions(Double_t rmin, Double_t rmax, Do uble_t dz,	void SetTubsDimensions(Double_t rmin, Double_t rmax, Do uble_t dz,
	Double_t phi1, Double_t phi2);	Double_t phi1, Double_t phi2);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;


	skipping to change at line 198	skipping to change at line 208
	TGeoCtub(Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Doubl e_t phi2,	TGeoCtub(Double_t rmin, Double_t rmax, Double_t dz, Double_t phi1, Doubl e_t phi2,
	Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty , Double_t tz);	Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty , Double_t tz);
	TGeoCtub(const char *name, Double_t rmin, Double_t rmax, Double_t dz, Do uble_t phi1, Double_t phi2,	TGeoCtub(const char *name, Double_t rmin, Double_t rmax, Double_t dz, Do uble_t phi1, Double_t phi2,
	Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty , Double_t tz);	Double_t lx, Double_t ly, Double_t lz, Double_t tx, Double_t ty , Double_t tz);
	TGeoCtub(Double_t *params);	TGeoCtub(Double_t *params);
	// destructor	// destructor
	virtual ~TGeoCtub();	virtual ~TGeoCtub();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int	le_t dirs, Double_t norms, Int_t vecsize);
	_t iact=1,	virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
		virtual Double_t DistFromInside(const Double_t *point, const Double
		_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 98;}	virtual Int_t GetByteCount() const {return 98;}
	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;	virtual Bool_t GetPointsOnSegments(Int_t npoints, Double_t *array ) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const;
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	const Double_t *GetNlow() const {return &fNlow[0];}	const Double_t *GetNlow() const {return &fNlow[0];}
	const Double_t *GetNhigh() const {return &fNhigh[0];}	const Double_t *GetNhigh() const {return &fNhigh[0];}
	Double_t GetZcoord(Double_t xc, Double_t yc, Double_t zc) c onst;	Double_t GetZcoord(Double_t xc, Double_t yc, Double_t zc) c onst;
	virtual void InspectShape() const;	virtual void InspectShape() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetCtubDimensions(Double_t rmin, Double_t rmax, Do uble_t dz,	void SetCtubDimensions(Double_t rmin, Double_t rmax, Do uble_t dz,
	Double_t phi1, Double_t phi2, Double _t lx, Double_t ly, Double_t lz,	Double_t phi1, Double_t phi2, Double _t lx, Double_t ly, Double_t lz,
	Double_t tx, Double_t ty, Double_t t z);	Double_t tx, Double_t ty, Double_t t z);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;

	ClassDef(TGeoCtub, 1) // cut tube segment class	ClassDef(TGeoCtub, 1) // cut tube segment class
	};	};

End of changes. 16 change blocks.
	39 lines changed or deleted	69 lines changed or added

	TGeoXtru.h	TGeoXtru.h

	skipping to change at line 67	skipping to change at line 67
	Double_t *fScale; //[fNz] array of scale factors (for each Z )	Double_t *fScale; //[fNz] array of scale factors (for each Z )
	Double_t *fX0; //[fNz] array of X offsets (for each Z)	Double_t *fX0; //[fNz] array of X offsets (for each Z)
	Double_t *fY0; //[fNz] array of Y offsets (for each Z)	Double_t *fY0; //[fNz] array of Y offsets (for each Z)

	mutable std::vector<ThreadData_t*> fThreadData; //! Navigation data per thread	mutable std::vector<ThreadData_t*> fThreadData; //! Navigation data per thread
	mutable Int_t fThreadSize; //! size of thread-speci fic array	mutable Int_t fThreadSize; //! size of thread-speci fic array
	TGeoXtru(const TGeoXtru&);	TGeoXtru(const TGeoXtru&);
	TGeoXtru& operator=(const TGeoXtru&);	TGeoXtru& operator=(const TGeoXtru&);

	// methods	// methods

	Double_t DistToPlane(Double_t point, Double_t dir, Int_t iz, Int_t ivert, Double_t stepmax, Bool_t in) const;	Double_t DistToPlane(const Double_t point, const Double_t dir, Int_t iz, Int_t ivert, Double_t stepmax, Bool_t in) const;
	void GetPlaneVertices(Int_t iz, Int_t ivert, Double_t * vert) const;	void GetPlaneVertices(Int_t iz, Int_t ivert, Double_t * vert) const;
	void GetPlaneNormal(const Double_t vert, Double_t nor m) const;	void GetPlaneNormal(const Double_t vert, Double_t nor m) const;

	Bool_t IsPointInsidePlane(Double_t point, Double_t vert	Bool_t IsPointInsidePlane(const Double_t *point, Double_t
	, Double_t *norm) const;	vert, Double_t norm) const;
	Double_t SafetyToSector(Double_t *point, Int_t iz, Double_t	Double_t SafetyToSector(const Double_t *point, Int_t iz, Do
	safmin, Bool_t in);	uble_t safmin, Bool_t in);
	void SetIz(Int_t iz);	void SetIz(Int_t iz);
	void SetSeg(Int_t iseg);	void SetSeg(Int_t iseg);

	public:	public:
	// constructors	// constructors
	TGeoXtru();	TGeoXtru();
	TGeoXtru(Int_t nz);	TGeoXtru(Int_t nz);
	TGeoXtru(Double_t *param);	TGeoXtru(Double_t *param);
	// destructor	// destructor
	virtual ~TGeoXtru();	virtual ~TGeoXtru();
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	Bool_t DefinePolygon(Int_t nvert, const Double_t xv, con st Double_t yv);	Bool_t DefinePolygon(Int_t nvert, const Double_t xv, con st Double_t yv);
	virtual void DefineSection(Int_t snum, Double_t z, Double_t x0= 0., Double_t y0=0., Double_t scale=1.);	virtual void DefineSection(Int_t snum, Double_t z, Double_t x0= 0., Double_t y0=0., Double_t scale=1.);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *points, const Dou
	t_t iact=1,	ble_t dirs, Double_t dists, Int_t vecsize, Double_t *step) const;
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	void DrawPolygon(Option_t *option="");	void DrawPolygon(Option_t *option="");
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	// virtual Int_t GetByteCount() const {return 60+12*fNz;}	// virtual Int_t GetByteCount() const {return 60+12*fNz;}
	Int_t GetNz() const {return fNz;}	Int_t GetNz() const {return fNz;}
	Int_t GetNvert() const {return fNvert;}	Int_t GetNvert() const {return fNvert;}
	Double_t GetX(Int_t i) const {return (i<fNvert&&i>-1 &&fX!= 0) ? fX[i] : -1.0E10;}	Double_t GetX(Int_t i) const {return (i<fNvert&&i>-1 &&fX!= 0) ? fX[i] : -1.0E10;}
	Double_t GetY(Int_t i) const {return (i<fNvert&&i>-1 &&fY!= 0) ? fY[i] : -1.0E10;}	Double_t GetY(Int_t i) const {return (i<fNvert&&i>-1 &&fY!= 0) ? fY[i] : -1.0E10;}
	Double_t GetXOffset(Int_t i) const {return (i<fNz&&i>-1 && fX0!=0) ? fX0[i] : 0.0;}	Double_t GetXOffset(Int_t i) const {return (i<fNz&&i>-1 && fX0!=0) ? fX0[i] : 0.0;}
	Double_t GetYOffset(Int_t i) const {return (i<fNz&&i>-1 && fY0!=0) ? fY0[i] : 0.0;}	Double_t GetYOffset(Int_t i) const {return (i<fNz&&i>-1 && fY0!=0) ? fY0[i] : 0.0;}
	Double_t GetScale(Int_t i) const {return (i<fNz&&i>-1 && fS cale!=0) ? fScale[i] : 1.0;}	Double_t GetScale(Int_t i) const {return (i<fNz&&i>-1 && fS cale!=0) ? fScale[i] : 1.0;}
	Double_t *GetZ() const {return fZ;}	Double_t *GetZ() const {return fZ;}
	Double_t GetZ(Int_t ipl) const;	Double_t GetZ(Int_t ipl) const;
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}	virtual TGeoShape GetMakeRuntimeShape(TGeoShape /mother/, TGeoMa trix * /mat/) const {return 0;}
	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;	virtual void GetMeshNumbers(Int_t &nvert, Int_t &nsegs, Int_t & npols) const;
	virtual Int_t GetNmeshVertices() const;	virtual Int_t GetNmeshVertices() const;
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;
	Double_t &Z(Int_t ipl) {return fZ[ipl];}	Double_t &Z(Int_t ipl) {return fZ[ipl];}

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetCurrentZ(Double_t z, Int_t iz);	void SetCurrentZ(Double_t z, Int_t iz);
	void SetCurrentVertices(Double_t x0, Double_t y0, Doubl e_t scale);	void SetCurrentVertices(Double_t x0, Double_t y0, Doubl e_t scale);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buff) const;	virtual void SetSegsAndPols(TBuffer3D &buff) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoXtru, 3) // extruded polygon class	ClassDef(TGeoXtru, 3) // extruded polygon class

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

	TPDF.h	TPDF.h

	skipping to change at line 102	skipping to change at line 102
	void SetLineScale(Float_t scale=1) {fLineScale = scale;}	void SetLineScale(Float_t scale=1) {fLineScale = scale;}
	void SetLineStyle(Style_t linestyle = 1);	void SetLineStyle(Style_t linestyle = 1);
	void SetLineWidth(Width_t linewidth = 1);	void SetLineWidth(Width_t linewidth = 1);
	void SetMarkerColor( Color_t cindex=1);	void SetMarkerColor( Color_t cindex=1);
	void SetTextColor( Color_t cindex=1);	void SetTextColor( Color_t cindex=1);
	void Text(Double_t x, Double_t y, const char *string);	void Text(Double_t x, Double_t y, const char *string);
	void Text(Double_t, Double_t, const wchar_t *){}	void Text(Double_t, Double_t, const wchar_t *){}
	void TextNDC(Double_t u, Double_t v, const char *string);	void TextNDC(Double_t u, Double_t v, const char *string);
	void TextNDC(Double_t, Double_t, const wchar_t *){}	void TextNDC(Double_t, Double_t, const wchar_t *){}
	void WriteCompressedBuffer();	void WriteCompressedBuffer();

	virtual void WriteReal(Float_t r);	virtual void WriteReal(Float_t r, Bool_t space=kTRUE);
	Double_t UtoPDF(Double_t u);	Double_t UtoPDF(Double_t u);
	Double_t VtoPDF(Double_t v);	Double_t VtoPDF(Double_t v);
	Double_t XtoPDF(Double_t x);	Double_t XtoPDF(Double_t x);
	Double_t YtoPDF(Double_t y);	Double_t YtoPDF(Double_t y);

	ClassDef(TPDF,0) //PDF driver	ClassDef(TPDF,0) //PDF driver
	};	};

	#endif	#endif

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

	TPacketizerUnit.h	TPacketizerUnit.h

	skipping to change at line 50	skipping to change at line 50
	class TStopwatch;	class TStopwatch;

	class TPacketizerUnit : public TVirtualPacketizer {	class TPacketizerUnit : public TVirtualPacketizer {

	public: // public because of Sun CC bug	public: // public because of Sun CC bug
	class TSlaveStat;	class TSlaveStat;

	private:	private:
	TList *fPackets; // All processed packets	TList *fPackets; // All processed packets
	TMap *fWrkStats; // Worker status, keyed by correspondig TS lave	TMap *fWrkStats; // Worker status, keyed by correspondig TS lave

		TList *fWrkExcluded; // List of nodes excluded from distributio
		n
		// (submasters with no active workers)
	TStopwatch *fStopwatch; // For measuring the start time of each pa cket	TStopwatch *fStopwatch; // For measuring the start time of each pa cket
	Long64_t fProcessing; // Event being processed	Long64_t fProcessing; // Event being processed
	Long64_t fAssigned; // Entries processed or being processed.	Long64_t fAssigned; // Entries processed or being processed.
	Double_t fCalibFrac; // Size of the calibrating packet as fract ion of Ntot/Nwrk	Double_t fCalibFrac; // Size of the calibrating packet as fract ion of Ntot/Nwrk
	Long64_t fNumPerWorker; // Number of cycles per worker, if this op tion	Long64_t fNumPerWorker; // Number of cycles per worker, if this op tion
	// is chosen	// is chosen

		Bool_t fFixedNum; // Whether we must assign a fixed number o f cycles per worker

	Long64_t fPacketSeq; // Sequential number of the last packet as signed	Long64_t fPacketSeq; // Sequential number of the last packet as signed

		TList *fInput; // Input list

	TPacketizerUnit();	TPacketizerUnit();
	TPacketizerUnit(const TPacketizerUnit&); // no implementation, will generate	TPacketizerUnit(const TPacketizerUnit&); // no implementation, will generate

	void operator=(const TPacketizerUnit&); // error on accidental usage	void operator=(const TPacketizerUnit&); // error on accidental usag e

	public:	public:
	TPacketizerUnit(TList slaves, Long64_t num, TList input, TProofProgres sStatus *st = 0);	TPacketizerUnit(TList slaves, Long64_t num, TList input, TProofProgres sStatus *st = 0);
	virtual ~TPacketizerUnit();	virtual ~TPacketizerUnit();


		Int_t AssignWork(TDSet * /dset/, Long64_t /first/, Long64_t num);
	TDSetElement GetNextPacket(TSlave sl, TMessage *r);	TDSetElement GetNextPacket(TSlave sl, TMessage *r);

	Double_t GetCurrentTime();	Double_t GetCurrentTime();

	Float_t GetCurrentRate(Bool_t &all);	Float_t GetCurrentRate(Bool_t &all);
	Int_t GetActiveWorkers() { return fWrkStats->GetSize(); }	Int_t GetActiveWorkers() { return fWrkStats->GetSize(); }


		Int_t AddWorkers(TList *workers);

	ClassDef(TPacketizerUnit,0) //Generate work packets for parallel proces sing	ClassDef(TPacketizerUnit,0) //Generate work packets for parallel proces sing
	};	};

	#endif	#endif

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

	TPainter3dAlgorithms.h	TPainter3dAlgorithms.h

	skipping to change at line 74	skipping to change at line 74
	Double_t fDXrast; //	Double_t fDXrast; //
	Double_t fDYrast; //	Double_t fDYrast; //
	Int_t fSystem; //Coordinate system	Int_t fSystem; //Coordinate system
	Int_t fNT; //	Int_t fNT; //
	Int_t fNlevel; //Number of color levels	Int_t fNlevel; //Number of color levels
	Int_t fColorLevel[258]; //Color levels corresponding to function s	Int_t fColorLevel[258]; //Color levels corresponding to function s
	Int_t *fColorMain; //	Int_t *fColorMain; //
	Int_t *fColorDark; //	Int_t *fColorDark; //
	Int_t fColorTop; //	Int_t fColorTop; //
	Int_t fColorBottom; //	Int_t fColorBottom; //

		Int_t *fEdgeColor; //
		Int_t *fEdgeStyle; //
		Int_t *fEdgeWidth; //
		Int_t fEdgeIdx; //
	Int_t fMesh; //(=1 if mesh to draw, o otherwise)	Int_t fMesh; //(=1 if mesh to draw, o otherwise)
	Int_t fNlines; //	Int_t fNlines; //
	Int_t fLevelLine[200]; //	Int_t fLevelLine[200]; //
	Int_t fLoff; //	Int_t fLoff; //
	Int_t fNqs; //	Int_t fNqs; //
	Int_t fNStack; //Number of histograms in the stack to b e painted	Int_t fNStack; //Number of histograms in the stack to b e painted
	Int_t fNxrast; //	Int_t fNxrast; //
	Int_t fNyrast; //	Int_t fNyrast; //
	Int_t fIfrast; //	Int_t fIfrast; //
	Int_t *fRaster; //pointer to raster buffer	Int_t *fRaster; //pointer to raster buffer

	skipping to change at line 169	skipping to change at line 173
	void MarchingCubeSurfacePenetration(Double_t a00, Double_t a10, Doubl e_t a11, Double_t a01, Double_t b00, Double_t b10, Double_t b11, Double_t b 01, Int_t &irep);	void MarchingCubeSurfacePenetration(Double_t a00, Double_t a10, Doubl e_t a11, Double_t a01, Double_t b00, Double_t b10, Double_t b11, Double_t b 01, Int_t &irep);
	void MarchingCubeFindNodes(Int_t nnod, Int_t *ie, Double_t xyz[52][3] , Double_t grad[52][3]);	void MarchingCubeFindNodes(Int_t nnod, Int_t *ie, Double_t xyz[52][3] , Double_t grad[52][3]);
	void ModifyScreen(Double_t r1, Double_t r2);	void ModifyScreen(Double_t r1, Double_t r2);
	void SetDrawFace(DrawFaceFunc_t pointer);	void SetDrawFace(DrawFaceFunc_t pointer);
	void SetIsoSurfaceParameters(Double_t fmin, Double_t fmax, Int_t ncol or, Int_t ic1, Int_t ic2, Int_t ic3){fFmin=fmin; fFmax=fmax; fNcolor=ncolor ; fIc1=ic1; fIc2=ic2; fIc3=ic3;}	void SetIsoSurfaceParameters(Double_t fmin, Double_t fmax, Int_t ncol or, Int_t ic1, Int_t ic2, Int_t ic3){fFmin=fmin; fFmax=fmax; fNcolor=ncolor ; fIc1=ic1; fIc2=ic2; fIc3=ic3;}
	void SetLegoFunction(LegoFunc_t pointer);	void SetLegoFunction(LegoFunc_t pointer);
	void SetMesh(Int_t mesh=1) {fMesh=mesh;}	void SetMesh(Int_t mesh=1) {fMesh=mesh;}
	void SetSurfaceFunction(SurfaceFunc_t pointer);	void SetSurfaceFunction(SurfaceFunc_t pointer);
	void SetColorDark(Color_t color, Int_t n=0);	void SetColorDark(Color_t color, Int_t n=0);
	void SetColorMain(Color_t color, Int_t n=0);	void SetColorMain(Color_t color, Int_t n=0);

		void SetEdgeAtt(Color_t color=1, Style_t style=1, Width_t width=1, In t_t n=0);
	void SideVisibilityDecode(Double_t val, Int_t &iv1, Int_t &iv2, Int_t &iv3, Int_t &iv4, Int_t &iv5, Int_t &iv6, Int_t &ir);	void SideVisibilityDecode(Double_t val, Int_t &iv1, Int_t &iv2, Int_t &iv3, Int_t &iv4, Int_t &iv5, Int_t &iv6, Int_t &ir);
	void SideVisibilityEncode(Int_t iopt, Double_t phi1, Double_t phi2, D ouble_t &val);	void SideVisibilityEncode(Int_t iopt, Double_t phi1, Double_t phi2, D ouble_t &val);
	void Spectrum(Int_t nl, Double_t fmin, Double_t fmax, Int_t ic, Int_t idc, Int_t &irep);	void Spectrum(Int_t nl, Double_t fmin, Double_t fmax, Int_t ic, Int_t idc, Int_t &irep);
	void SurfaceCartesian(Double_t ang, Int_t nx, Int_t ny, const char *c hopt);	void SurfaceCartesian(Double_t ang, Int_t nx, Int_t ny, const char *c hopt);
	void SurfacePolar(Int_t iordr, Int_t na, Int_t nb, const char *chopt) ;	void SurfacePolar(Int_t iordr, Int_t na, Int_t nb, const char *chopt) ;
	void SurfaceCylindrical(Int_t iordr, Int_t na, Int_t nb, const char * chopt);	void SurfaceCylindrical(Int_t iordr, Int_t na, Int_t nb, const char * chopt);
	void SurfaceFunction(Int_t ia, Int_t ib, Double_t f, Double_t t);	void SurfaceFunction(Int_t ia, Int_t ib, Double_t f, Double_t t);
	void SurfaceSpherical(Int_t ipsdr, Int_t iordr, Int_t na, Int_t nb, c onst char *chopt);	void SurfaceSpherical(Int_t ipsdr, Int_t iordr, Int_t na, Int_t nb, c onst char *chopt);
	void SurfaceProperty(Double_t qqa, Double_t qqd, Double_t qqs, Int_t nnqs, Int_t &irep);	void SurfaceProperty(Double_t qqa, Double_t qqd, Double_t qqs, Int_t nnqs, Int_t &irep);
	void TestEdge(Double_t del, Double_t xyz[52][3], Int_t i1, Int_t i2, Int_t iface[3], Double_t abcd[4], Int_t &irep);	void TestEdge(Double_t del, Double_t xyz[52][3], Int_t i1, Int_t i2, Int_t iface[3], Double_t abcd[4], Int_t &irep);

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

	TProofPerfAnalysis.h	TProofPerfAnalysis.h

	skipping to change at line 39	skipping to change at line 39
	#endif	#endif

	class TFile;	class TFile;
	class TH1F;	class TH1F;
	class TH2F;	class TH2F;
	class TList;	class TList;
	class TTree;	class TTree;
	class TProofPerfAnalysis : public TNamed {	class TProofPerfAnalysis : public TNamed {

	public: // public because of Sun CC bug	public: // public because of Sun CC bug

		class TFileInfo;
		class TPackInfo;
		class TWrkEntry;
	class TWrkInfo;	class TWrkInfo;

		class TWrkInfoFile;

	private:	private:
	TFile *fFile; // The open performance file	TFile *fFile; // The open performance file
	TString fDirName; // The name of the subdir with the perfoma nce tree	TString fDirName; // The name of the subdir with the perfoma nce tree
	TString fTreeName; // The name of the performance tree	TString fTreeName; // The name of the performance tree
	TTree *fTree; // The performance tree	TTree *fTree; // The performance tree
	TSortedList fWrksInfo; // Sorted list of workers info	TSortedList fWrksInfo; // Sorted list of workers info

		TSortedList fFilesInfo; // Sorted list of files info
	Float_t fInitTime; // End of initialization time for this que ry	Float_t fInitTime; // End of initialization time for this que ry
	Float_t fMergeTime; // Begin of merging time for this query	Float_t fMergeTime; // Begin of merging time for this query
	Float_t fMaxTime; // Max time for this query (slowest worker )	Float_t fMaxTime; // Max time for this query (slowest worker )
	TH1F *fEvents; // Event distribution per worker	TH1F *fEvents; // Event distribution per worker
	TH1F *fPackets; // Packet distribution per worker	TH1F *fPackets; // Packet distribution per worker
	Double_t fEvtRateMax; // Max event processing rate per packet	Double_t fEvtRateMax; // Max event processing rate per packet
	Double_t fMBRateMax; // Max MB processing rate per packet	Double_t fMBRateMax; // Max MB processing rate per packet
	Double_t fLatencyMax; // Max retrieval latency per packet	Double_t fLatencyMax; // Max retrieval latency per packet

		TH1F *fEvtRate; // Event processing rate vs query time
		TH1F *fEvtRateRun; // Event processing rate running avg vs qu
		ery time
		TH1F *fMBRate; // Byte processing rate vs query time
		TH1F *fMBRateRun; // Byte processing rate running avg vs que
		ry time
		Double_t fEvtRateAvgMax; // Max running event processing rate
		Double_t fMBRateAvgMax; // Max running MB processing rate
		Double_t fEvtRateAvg; // Average event processing rate
		Double_t fMBRateAvg; // Average MB processing rate


	static Int_t fgDebug; // Verbosity level	Int_t fDebug; // Local verbosity level

		static Bool_t fgDebug; // Global verbosity on/off

	Int_t CompareOrd(const char ord1, const char ord2);	Int_t CompareOrd(const char ord1, const char ord2);
	void FillFileDist(TH1F hf, TH1F hb, TH2F *hx, Bool_t wdet = kFALSE);	void FillFileDist(TH1F hf, TH1F hb, TH2F *hx, Bool_t wdet = kFALSE);
	void FillFileDistOneSrv(TH1F *hx, Bool_t wdet = kFALSE);	void FillFileDistOneSrv(TH1F *hx, Bool_t wdet = kFALSE);
	void FillWrkInfo(Bool_t force = kFALSE);	void FillWrkInfo(Bool_t force = kFALSE);

		void FillFileInfo(Bool_t force = kFALSE);
	TString GetCanvasTitle(const char *t);	TString GetCanvasTitle(const char *t);

	void GetFileInfo(TList wl, TList sl);	void GetWrkFileList(TList wl, TList sl);
	void LoadTree(TDirectory *dir);	void LoadTree(TDirectory *dir);

	public:	public:

	TProofPerfAnalysis(const char perffile, const char title = "",	TProofPerfAnalysis(const char perffile, const char title = "",
	const char *treename = "PROOF_PerfStats");	const char *treename = "PROOF_PerfStats");
	virtual ~TProofPerfAnalysis();	virtual ~TProofPerfAnalysis();

	Bool_t IsValid() const { return (fFile && fTree) ? kTRUE : kFALSE; }	Bool_t IsValid() const { return (fFile && fTree) ? kTRUE : kFALSE; }
	Bool_t WrkInfoOK() const { return (fWrksInfo.GetSize() > 0) ? kTRUE : kF ALSE; }	Bool_t WrkInfoOK() const { return (fWrksInfo.GetSize() > 0) ? kTRUE : kF ALSE; }

	void EventDist(); // Analyse event and packet distribution	void EventDist(); // Analyse event and packet distribution
	void FileDist(Bool_t writedet = kFALSE); // Analyse the file distribu tion	void FileDist(Bool_t writedet = kFALSE); // Analyse the file distribu tion
	void LatencyPlot(const char *wrks = 0); // Packet latency distributi on vs time	void LatencyPlot(const char *wrks = 0); // Packet latency distributi on vs time
	void RatePlot(const char *wrks = 0); // Rate distribution vs time	void RatePlot(const char *wrks = 0); // Rate distribution vs time
	void WorkerActivity(); // Analyse the worker activi ty	void WorkerActivity(); // Analyse the worker activi ty
	void PrintWrkInfo(Int_t showlast = 10); // Print workers info	void PrintWrkInfo(Int_t showlast = 10); // Print workers info
	void PrintWrkInfo(const char *wrk); // Print worker info by name	void PrintWrkInfo(const char *wrk); // Print worker info by name


		void PrintFileInfo(Int_t showlast = 10, const char *opt = "", const cha
		r *out = 0); // Print file info
		void PrintFileInfo(const char fn, const char opt = "P", const char *o
		ut = 0); // Print file info by name
		void FileProcPlot(const char fn, const char out = 0); // Plot info ab
		out file processing
		void FileRatePlot(const char *fns = 0); // Plot info about file proc
		essing rates

		void Summary(Option_t opt = "", const char out = "");

	void SetDebug(Int_t d = 0); // Setter for the verbosity level	void SetDebug(Int_t d = 0); // Setter for the verbosity level

		static void SetgDebug(Bool_t on = kTRUE); // Overall verbosity level

	ClassDef(TProofPerfAnalysis, 0) // Set of tools to analyse the perform ance tree	ClassDef(TProofPerfAnalysis, 0) // Set of tools to analyse the perform ance tree
	};	};

	#endif	#endif

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

	TProofProgressLog.h	TProofProgressLog.h

	// @(#)root/sessionviewer:$Id$	// @(#)root/sessionviewer:$Id: c52dc6cb225c25e34d388329d41570a484d98ce0 $
	/*************************************************************************	/*************************************************************************
	* 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_TProofProgressLog	#ifndef ROOT_TProofProgressLog
	#define ROOT_TProofProgressLog	#define ROOT_TProofProgressLog

	skipping to change at line 40	skipping to change at line 40
	class TGTextView;	class TGTextView;
	class TGTextButton;	class TGTextButton;
	class TProofProgressDialog;	class TProofProgressDialog;
	class TProofLog;	class TProofLog;
	class TGTextEntry;	class TGTextEntry;
	class TGNumberEntry;	class TGNumberEntry;
	class TGListBox;	class TGListBox;
	class TGSplitButton;	class TGSplitButton;
	class TGVerticalFrame;	class TGVerticalFrame;
	class TGCheckButton;	class TGCheckButton;

		class TGLabel;

	class TProofProgressLog : public TGTransientFrame {	class TProofProgressLog : public TGTransientFrame {

	private:	private:
	enum ETextType { kRaw = 0, kStd = 1, kGrep = 2 };	enum ETextType { kRaw = 0, kStd = 1, kGrep = 2 };

	TString fSessionUrl;	TString fSessionUrl;
	Int_t fSessionIdx;	Int_t fSessionIdx;

	TGTextView *fText; // text widget	TGTextView *fText; // text widget

	skipping to change at line 68	skipping to change at line 69
	TGTextEntry *fUrlText; // url to connect to	TGTextEntry *fUrlText; // url to connect to
	TGNumberEntry *fSessNum; // relative index of the session to ge t	TGNumberEntry *fSessNum; // relative index of the session to ge t
	TGTextEntry *fFileName; // file to save to	TGTextEntry *fFileName; // file to save to
	TGTextButton *fSave; // save button	TGTextButton *fSave; // save button
	TGTextButton *fGrepButton; //grep button	TGTextButton *fGrepButton; //grep button
	TGTextButton *fUrlButton; //rebuild button	TGTextButton *fUrlButton; //rebuild button
	TGCheckButton *fAllLines; // display all lines button	TGCheckButton *fAllLines; // display all lines button
	TGCheckButton *fRawLines; // display raw lines button	TGCheckButton *fRawLines; // display raw lines button
	TGSplitButton *fAllWorkers; // display all workers button	TGSplitButton *fAllWorkers; // display all workers button
	TGVerticalFrame *fVworkers; // Vertical frame	TGVerticalFrame *fVworkers; // Vertical frame

		TGLabel *fGrepLabel; // label indicating if grepping or pi
		ping
		TGCheckButton *fGrepCheckCmd; // checkbox active if piping
		TGCheckButton *fGrepCheckInv; // checkbox active if inverting

	Bool_t fFullText; // 0 - when grep was called	Bool_t fFullText; // 0 - when grep was called
	Int_t fTextType; // Type of retrieval	Int_t fTextType; // Type of retrieval

	void Init(Int_t w = 700, Int_t h = 600);	void Init(Int_t w = 700, Int_t h = 600);

	public:	public:
	TProofProgressLog(TProofProgressDialog *d, Int_t w = 700, Int_t h = 600) ;	TProofProgressLog(TProofProgressDialog *d, Int_t w = 700, Int_t h = 600) ;
	TProofProgressLog(const char *url = 0, Int_t sessionidx = 0, Int_t w = 7 00, Int_t h = 600);	TProofProgressLog(const char *url = 0, Int_t sessionidx = 0, Int_t w = 7 00, Int_t h = 600);
	virtual ~TProofProgressLog();	virtual ~TProofProgressLog();

	skipping to change at line 93	skipping to change at line 97

	void LoadBuffer(const char *buffer);	void LoadBuffer(const char *buffer);
	void AddBuffer(const char *buffer);	void AddBuffer(const char *buffer);

	void LoadFile(const char *file);	void LoadFile(const char *file);

	void Clear(Option_t * = 0);	void Clear(Option_t * = 0);
	void Popup();	void Popup();
	void SaveToFile();	void SaveToFile();
	void NoLineEntry();	void NoLineEntry();

		void SetGrepView();
	void Select(Int_t id, Bool_t all = kTRUE);	void Select(Int_t id, Bool_t all = kTRUE);

	void SetUrl(const char *url) { fSessionUrl = url; }	void SetUrl(const char *url) { fSessionUrl = url; }
	// slots	// slots
	void CloseWindow();	void CloseWindow();

	ClassDef(TProofProgressLog,0) //Class implementing a log graphic box	ClassDef(TProofProgressLog,0) //Class implementing a log graphic box
	};	};

	#endif	#endif

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

	TSlave.h	TSlave.h

	skipping to change at line 60	skipping to change at line 60

	friend class TProof;	friend class TProof;
	friend class TProofLite;	friend class TProofLite;
	friend class TSlaveLite;	friend class TSlaveLite;
	friend class TXSlave;	friend class TXSlave;

	public:	public:

	enum ESlaveType { kMaster, kSlave };	enum ESlaveType { kMaster, kSlave };
	enum ESlaveStatus { kInvalid, kActive, kInactive };	enum ESlaveStatus { kInvalid, kActive, kInactive };

		enum EStatusBits {
		kOutputRequested = BIT(15) // If output has been requested
		};

	private:	private:

	static TSlave_t fgTXSlaveHook;	static TSlave_t fgTXSlaveHook;

	TSlave(const TSlave &s) : TObject(s) { }	TSlave(const TSlave &s) : TObject(s) { }
	TSlave(const char host, const char ord, Int_t perf,	TSlave(const char host, const char ord, Int_t perf,
	const char image, TProof proof, Int_t stype,	const char image, TProof proof, Int_t stype,
	const char workdir, const char msd);	const char workdir, const char msd);


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

	TTF.h	TTF.h

	skipping to change at line 61	skipping to change at line 61

	class TGX11TTF;	class TGX11TTF;
	class TGWin32;	class TGWin32;
	class TMathTextRenderer;	class TMathTextRenderer;

	class TTF {	class TTF {

	friend class TGX11TTF;	friend class TGX11TTF;
	friend class TGWin32;	friend class TGWin32;
	friend class TMathTextRenderer;	friend class TMathTextRenderer;

	friend class TGQuartz;

	protected:	protected:
	enum { kTTMaxFonts = 32, kMaxGlyphs = 1024 };	enum { kTTMaxFonts = 32, kMaxGlyphs = 1024 };

	static Int_t fgAscent; // string ascent, used to co mpute Y alignment	static Int_t fgAscent; // string ascent, used to co mpute Y alignment
	static FT_BBox fgCBox; // string control box	static FT_BBox fgCBox; // string control box
	static FT_CharMap fgCharMap[kTTMaxFonts]; // font character map	static FT_CharMap fgCharMap[kTTMaxFonts]; // font character map
	static Int_t fgCurFontIdx; // current font index	static Int_t fgCurFontIdx; // current font index
	static Int_t fgSymbItaFontIdx; // Symbol italic font index	static Int_t fgSymbItaFontIdx; // Symbol italic font index
	static Int_t fgFontCount; // number of fonts loaded	static Int_t fgFontCount; // number of fonts loaded

End of changes. 1 change blocks.
	1 lines changed or deleted	0 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/

	Measurement.h	Measurement.h

	skipping to change at line 37	skipping to change at line 37
	namespace HistFactory {	namespace HistFactory {

	class Measurement : public TNamed {	class Measurement : public TNamed {

	public:	public:

	Measurement();	Measurement();
	// Measurement( const Measurement& other ); // Copy	// Measurement( const Measurement& other ); // Copy
	Measurement(const char* Name, const char* Title="");	Measurement(const char* Name, const char* Title="");


	// std::string Name;	// set output prefix

	void SetOutputFilePrefix( const std::string& prefix ) { fOutputFilePrefix = prefix; }	void SetOutputFilePrefix( const std::string& prefix ) { fOutputFilePrefix = prefix; }

		// retrieve prefix for output files
	std::string GetOutputFilePrefix() { return fOutputFilePrefix; }	std::string GetOutputFilePrefix() { return fOutputFilePrefix; }


		// insert PoI at beginning of vector of PoIs
	void SetPOI( const std::string& POI ) { fPOI.insert( fPOI.begin(), POI ); }	void SetPOI( const std::string& POI ) { fPOI.insert( fPOI.begin(), POI ); }

		// append parameter to vector of PoIs
	void AddPOI( const std::string& POI ) { fPOI.push_back(POI); }	void AddPOI( const std::string& POI ) { fPOI.push_back(POI); }

		// get name of PoI at given index
	std::string GetPOI(unsigned int i=0) { return fPOI.at(i); }	std::string GetPOI(unsigned int i=0) { return fPOI.at(i); }

		// get vector of PoI names
	std::vector<std::string>& GetPOIList() { return fPOI; }	std::vector<std::string>& GetPOIList() { return fPOI; }

	// Add a parameter to be set as constant	// Add a parameter to be set as constant
	// (Similar to ParamSetting method below)	// (Similar to ParamSetting method below)
	void AddConstantParam( const std::string& param );	void AddConstantParam( const std::string& param );

		// empty vector of constant parameters
	void ClearConstantParams() { fConstantParams.clear(); }	void ClearConstantParams() { fConstantParams.clear(); }

		// get vector of all constant parameters
	std::vector< std::string >& GetConstantParams() { return fConstantParams; }	std::vector< std::string >& GetConstantParams() { return fConstantParams; }

	// Set a parameter to a specific value	// Set a parameter to a specific value
	// (And optionally fix it)	// (And optionally fix it)
	void SetParamValue( const std::string& param, double value);	void SetParamValue( const std::string& param, double value);

		// get map: parameter name <--> parameter value
	std::map<std::string, double>& GetParamValues() { return fParamValues; }	std::map<std::string, double>& GetParamValues() { return fParamValues; }

		// clear map of parameter values
	void ClearParamValues() { fParamValues.clear(); }	void ClearParamValues() { fParamValues.clear(); }

	void AddPreprocessFunction( std::string name, std::string expression, std ::string dependencies );	void AddPreprocessFunction( std::string name, std::string expression, std ::string dependencies );

		// add a preprocess function object
	void AddFunctionObject( const RooStats::HistFactory::PreprocessFunction f unction) { fFunctionObjects.push_back( function ); }	void AddFunctionObject( const RooStats::HistFactory::PreprocessFunction f unction) { fFunctionObjects.push_back( function ); }
	void SetFunctionObjects( std::vector< RooStats::HistFactory::PreprocessFu nction > objects ) { fFunctionObjects = objects; }	void SetFunctionObjects( std::vector< RooStats::HistFactory::PreprocessFu nction > objects ) { fFunctionObjects = objects; }

		// get vector of defined function objects
	std::vector< RooStats::HistFactory::PreprocessFunction >& GetFunctionObje cts() { return fFunctionObjects; }	std::vector< RooStats::HistFactory::PreprocessFunction >& GetFunctionObje cts() { return fFunctionObjects; }
	std::vector< std::string > GetPreprocessFunctions();	std::vector< std::string > GetPreprocessFunctions();


	// Get and set Asimov Datasets	// get vector of defined Asimov Datasets
	std::vector< RooStats::HistFactory::Asimov >& GetAsimovDatasets() { retur n fAsimovDatasets; }	std::vector< RooStats::HistFactory::Asimov >& GetAsimovDatasets() { retur n fAsimovDatasets; }

		// add an Asimov Dataset
	void AddAsimovDataset( RooStats::HistFactory::Asimov dataset ) { fAsimovD atasets.push_back(dataset); }	void AddAsimovDataset( RooStats::HistFactory::Asimov dataset ) { fAsimovD atasets.push_back(dataset); }


		// set integrated luminosity used to normalise histograms (if NormalizeBy Theory is true for this sample)
	void SetLumi(double Lumi ) { fLumi = Lumi; }	void SetLumi(double Lumi ) { fLumi = Lumi; }

		// set relative uncertainty on luminosity
	void SetLumiRelErr( double RelErr ) { fLumiRelErr = RelErr; }	void SetLumiRelErr( double RelErr ) { fLumiRelErr = RelErr; }

		// retrieve integrated luminosity
	double GetLumi() { return fLumi; }	double GetLumi() { return fLumi; }

		// retrieve relative uncertainty on luminosity
	double GetLumiRelErr() { return fLumiRelErr; }	double GetLumiRelErr() { return fLumiRelErr; }

	void SetBinLow( int BinLow ) { fBinLow = BinLow; }	void SetBinLow( int BinLow ) { fBinLow = BinLow; }
	void SetBinHigh ( int BinHigh ) { fBinHigh = BinHigh; }	void SetBinHigh ( int BinHigh ) { fBinHigh = BinHigh; }
	int GetBinLow() { return fBinLow; }	int GetBinLow() { return fBinLow; }
	int GetBinHigh() { return fBinHigh; }	int GetBinHigh() { return fBinHigh; }


		// do not produce any plots or tables, just save the model
	void SetExportOnly( bool ExportOnly ) { fExportOnly = ExportOnly; }	void SetExportOnly( bool ExportOnly ) { fExportOnly = ExportOnly; }
	bool GetExportOnly() { return fExportOnly; }	bool GetExportOnly() { return fExportOnly; }

	void PrintTree( std::ostream& = std::cout ); // Print to a stream	void PrintTree( std::ostream& = std::cout ); // Print to a stream
	void PrintXML( std::string Directory="", std::string NewOutputPrefix="" ) ;	void PrintXML( std::string Directory="", std::string NewOutputPrefix="" ) ;

	std::vector< RooStats::HistFactory::Channel >& GetChannels() { return fCh annels; }	std::vector< RooStats::HistFactory::Channel >& GetChannels() { return fCh annels; }
	RooStats::HistFactory::Channel& GetChannel( std::string );	RooStats::HistFactory::Channel& GetChannel( std::string );

		// add a completely configured channel
	void AddChannel( RooStats::HistFactory::Channel chan ) { fChannels.push_b ack( chan ); }	void AddChannel( RooStats::HistFactory::Channel chan ) { fChannels.push_b ack( chan ); }

	bool HasChannel( std::string );	bool HasChannel( std::string );
	void writeToFile( TFile* file );	void writeToFile( TFile* file );

	void CollectHistograms();	void CollectHistograms();

	void AddGammaSyst(std::string syst, double uncert);	void AddGammaSyst(std::string syst, double uncert);
	void AddLogNormSyst(std::string syst, double uncert);	void AddLogNormSyst(std::string syst, double uncert);
	void AddUniformSyst(std::string syst);	void AddUniformSyst(std::string syst);

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

	MessageTypes.h	MessageTypes.h

	skipping to change at line 66	skipping to change at line 66
	kPROOF_OUTPUTLIST = 1016, //return the output list from Proc ess()	kPROOF_OUTPUTLIST = 1016, //return the output list from Proc ess()
	kPROOF_AUTOBIN = 1017, //callback for auto binning	kPROOF_AUTOBIN = 1017, //callback for auto binning
	kPROOF_CACHE = 1018, //cache and package handling messa ges	kPROOF_CACHE = 1018, //cache and package handling messa ges
	kPROOF_GETENTRIES = 1019, //report back number of entries to master	kPROOF_GETENTRIES = 1019, //report back number of entries to master
	kPROOF_PROGRESS = 1020, //event loop progress	kPROOF_PROGRESS = 1020, //event loop progress
	kPROOF_FEEDBACK = 1021, //intermediate version of objects	kPROOF_FEEDBACK = 1021, //intermediate version of objects
	kPROOF_STOPPROCESS = 1022, //stop or abort the current proces s call	kPROOF_STOPPROCESS = 1022, //stop or abort the current proces s call
	kPROOF_HOSTAUTH = 1023, //HostAuth info follows	kPROOF_HOSTAUTH = 1023, //HostAuth info follows
	kPROOF_GETSLAVEINFO = 1024, //get worker info from master	kPROOF_GETSLAVEINFO = 1024, //get worker info from master
	kPROOF_GETTREEHEADER = 1025, //get tree object	kPROOF_GETTREEHEADER = 1025, //get tree object

	kPROOF_GETOUTPUTLIST = 1026, //get the output list	kPROOF_GETOUTPUTLIST = 1026, //get the output list names
	kPROOF_GETSTATS = 1027, //get statistics of workers	kPROOF_GETSTATS = 1027, //get statistics of workers
	kPROOF_GETPARALLEL = 1028, //get number of parallel workers	kPROOF_GETPARALLEL = 1028, //get number of parallel workers
	kPROOF_VALIDATE_DSET = 1029, //validate a TDSet	kPROOF_VALIDATE_DSET = 1029, //validate a TDSet
	kPROOF_DATA_READY = 1030, //ask if the data is ready on node s	kPROOF_DATA_READY = 1030, //ask if the data is ready on node s
	kPROOF_QUERYLIST = 1031, //ask/send the list of queries	kPROOF_QUERYLIST = 1031, //ask/send the list of queries
	kPROOF_RETRIEVE = 1032, //asynchronous retrieve of query r esults	kPROOF_RETRIEVE = 1032, //asynchronous retrieve of query r esults
	kPROOF_ARCHIVE = 1033, //archive query results	kPROOF_ARCHIVE = 1033, //archive query results
	kPROOF_REMOVE = 1034, //remove query results from the li sts	kPROOF_REMOVE = 1034, //remove query results from the li sts
	kPROOF_STARTPROCESS = 1035, //signals the start of query proce ssing	kPROOF_STARTPROCESS = 1035, //signals the start of query proce ssing
	kPROOF_SETIDLE = 1036, //signals idle state of session	kPROOF_SETIDLE = 1036, //signals idle state of session

	skipping to change at line 97	skipping to change at line 97
	kPROOF_DATASET_STATUS = 1047, //status of data set preparation b efore processing	kPROOF_DATASET_STATUS = 1047, //status of data set preparation b efore processing
	kPROOF_OUTPUTOBJECT = 1048, //output object follows	kPROOF_OUTPUTOBJECT = 1048, //output object follows
	kPROOF_SETENV = 1049, //buffer with env vars to set	kPROOF_SETENV = 1049, //buffer with env vars to set
	kPROOF_REALTIMELOG = 1050, //switch on/off real-time retrieva l of log messages	kPROOF_REALTIMELOG = 1050, //switch on/off real-time retrieva l of log messages
	kPROOF_VERSARCHCOMP = 1051, //String with worker version/archi tecture/compiler follows	kPROOF_VERSARCHCOMP = 1051, //String with worker version/archi tecture/compiler follows
	kPROOF_ENDINIT = 1052, //signals end of initialization on worker	kPROOF_ENDINIT = 1052, //signals end of initialization on worker
	kPROOF_TOUCH = 1053, //touch the client admin file	kPROOF_TOUCH = 1053, //touch the client admin file
	kPROOF_FORK = 1054, //ask the worker to clone itself	kPROOF_FORK = 1054, //ask the worker to clone itself
	kPROOF_GOASYNC = 1055, //switch to asynchronous mode	kPROOF_GOASYNC = 1055, //switch to asynchronous mode
	kPROOF_SUBMERGER = 1056, //sub-merger based approach in fin alization	kPROOF_SUBMERGER = 1056, //sub-merger based approach in fin alization

		kPROOF_ECHO = 1057, //object echo request from client
		kPROOF_SENDOUTPUT = 1058, //control output sending

	//---- ROOTD message opcodes (2000 - 2099)	//---- ROOTD message opcodes (2000 - 2099)
	kROOTD_USER = 2000, //user id follows	kROOTD_USER = 2000, //user id follows
	kROOTD_PASS = 2001, //passwd follows	kROOTD_PASS = 2001, //passwd follows
	kROOTD_AUTH = 2002, //authorization status (to client)	kROOTD_AUTH = 2002, //authorization status (to client)
	kROOTD_FSTAT = 2003, //filename follows	kROOTD_FSTAT = 2003, //filename follows
	kROOTD_OPEN = 2004, //filename follows + mode	kROOTD_OPEN = 2004, //filename follows + mode
	kROOTD_PUT = 2005, //offset, number of bytes and buff er	kROOTD_PUT = 2005, //offset, number of bytes and buff er
	kROOTD_GET = 2006, //offset, number of bytes	kROOTD_GET = 2006, //offset, number of bytes
	kROOTD_FLUSH = 2007, //flush file	kROOTD_FLUSH = 2007, //flush file

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

	RooAbsPdf.h	RooAbsPdf.h

	skipping to change at line 112	skipping to change at line 112

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

		virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;

	virtual RooPlot* paramOn(RooPlot* frame,	virtual RooPlot* paramOn(RooPlot* frame,
	const RooCmdArg& arg1=RooCmdArg::none(), const R ooCmdArg& arg2=RooCmdArg::none(),	const RooCmdArg& arg1=RooCmdArg::none(), const R ooCmdArg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(), const R ooCmdArg& arg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(), const R ooCmdArg& arg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(), const R ooCmdArg& arg6=RooCmdArg::none(),	const RooCmdArg& arg5=RooCmdArg::none(), const R ooCmdArg& arg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(), const R ooCmdArg& arg8=RooCmdArg::none()) ;	const RooCmdArg& arg7=RooCmdArg::none(), const R ooCmdArg& arg8=RooCmdArg::none()) ;

	virtual RooPlot* paramOn(RooPlot* frame, const RooAbsData* data, const ch ar *label= "", Int_t sigDigits = 2,	virtual RooPlot* paramOn(RooPlot* frame, const RooAbsData* data, const ch ar *label= "", Int_t sigDigits = 2,
	Option_t *options = "NELU", Double_t xmin=0.50,	Option_t *options = "NELU", Double_t xmin=0.50,
	Double_t xmax= 0.99,Double_t ymax=0.95) ;	Double_t xmax= 0.99,Double_t ymax=0.95) ;

	skipping to change at line 257	skipping to change at line 258

	RooDataSet generate(RooAbsGenContext& context, const RooArgSet& whatVars , const RooDataSet prototype,	RooDataSet generate(RooAbsGenContext& context, const RooArgSet& whatVars , const RooDataSet prototype,
	Double_t nEvents, Bool_t verbose, Bool_t randProtoOrd er, Bool_t resampleProto, Bool_t skipInit=kFALSE,	Double_t nEvents, Bool_t verbose, Bool_t randProtoOrd er, Bool_t resampleProto, Bool_t skipInit=kFALSE,
	Bool_t extended=kFALSE) const ;	Bool_t extended=kFALSE) const ;

	// Implementation version	// Implementation version
	virtual RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants=kFALSE,	virtual RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants=kFALSE,
	const char label= "", Int_t sigDigits = 2, Opti on_t options = "NELU", Double_t xmin=0.65,	const char label= "", Int_t sigDigits = 2, Opti on_t options = "NELU", Double_t xmin=0.65,
	Double_t xmax= 0.99,Double_t ymax=0.95, const Roo CmdArg* formatCmd=0) ;	Double_t xmax= 0.99,Double_t ymax=0.95, const Roo CmdArg* formatCmd=0) ;


	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;
	void plotOnCompSelect(RooArgSet* selNodes) const ;	void plotOnCompSelect(RooArgSet* selNodes) const ;

	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;	virtual RooPlot plotOn(RooPlot frame, PlotOpt o) const;

	friend class RooEffGenContext ;	friend class RooEffGenContext ;
	friend class RooAddGenContext ;	friend class RooAddGenContext ;
	friend class RooProdGenContext ;	friend class RooProdGenContext ;
	friend class RooSimGenContext ;	friend class RooSimGenContext ;
	friend class RooSimSplitGenContext ;	friend class RooSimSplitGenContext ;
	friend class RooConvGenContext ;	friend class RooConvGenContext ;

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

	RooAbsTestStatistic.h	RooAbsTestStatistic.h

	skipping to change at line 38	skipping to change at line 38
	class RooAbsReal ;	class RooAbsReal ;
	class RooSimultaneous ;	class RooSimultaneous ;
	class RooRealMPFE ;	class RooRealMPFE ;

	class RooAbsTestStatistic ;	class RooAbsTestStatistic ;
	typedef RooAbsTestStatistic* pRooAbsTestStatistic ;	typedef RooAbsTestStatistic* pRooAbsTestStatistic ;
	typedef RooAbsData* pRooAbsData ;	typedef RooAbsData* pRooAbsData ;
	typedef RooRealMPFE* pRooRealMPFE ;	typedef RooRealMPFE* pRooRealMPFE ;

	class RooAbsTestStatistic : public RooAbsReal {	class RooAbsTestStatistic : public RooAbsReal {

		friend class RooRealMPFE;
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	RooAbsTestStatistic() ;	RooAbsTestStatistic() ;
	RooAbsTestStatistic(const char name, const char title, RooAbsReal& real , RooAbsData& data,	RooAbsTestStatistic(const char name, const char title, RooAbsReal& real , RooAbsData& data,
	const RooArgSet& projDeps, const char* rangeName=0, co nst char* addCoefRangeName=0,	const RooArgSet& projDeps, const char* rangeName=0, co nst char* addCoefRangeName=0,
	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::BulkP artition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE) ;	Int_t nCPU=1, RooFit::MPSplit interleave=RooFit::BulkP artition, Bool_t verbose=kTRUE, Bool_t splitCutRange=kTRUE) ;
	RooAbsTestStatistic(const RooAbsTestStatistic& other, const char* name=0) ;	RooAbsTestStatistic(const RooAbsTestStatistic& other, const char* name=0) ;
	virtual ~RooAbsTestStatistic();	virtual ~RooAbsTestStatistic();
	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& data,	virtual RooAbsTestStatistic* create(const char name, const char title, RooAbsReal& real, RooAbsData& data,

	skipping to change at line 64	skipping to change at line 65
	virtual Double_t globalNormalization() const {	virtual Double_t globalNormalization() const {
	// Default value of global normalization factor is 1.0	// Default value of global normalization factor is 1.0
	return 1.0 ;	return 1.0 ;
	}	}

	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;

	void enableOffsetting(Bool_t flag) ;	void enableOffsetting(Bool_t flag) ;
	Bool_t isOffsetting() const { return _doOffset ; }	Bool_t isOffsetting() const { return _doOffset ; }
	virtual Double_t offset() const { return _offset ; }	virtual Double_t offset() const { return _offset ; }

		virtual Double_t offsetCarry() const { return _offsetCarry; }

	protected:	protected:

	virtual void printCompactTreeHook(std::ostream& os, const char* indent="" ) ;	virtual void printCompactTreeHook(std::ostream& os, const char* indent="" ) ;

	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;

	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const = 0 ;	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const = 0 ;

		virtual Double_t getCarry() const;

	void setMPSet(Int_t setNum, Int_t numSets) ;	void setMPSet(Int_t setNum, Int_t numSets) ;
	void setSimCount(Int_t simCount) {	void setSimCount(Int_t simCount) {
	// Store total number of components p.d.f. of a RooSimultaneous in this component test statistic	// Store total number of components p.d.f. of a RooSimultaneous in this component test statistic
	_simCount = simCount ;	_simCount = simCount ;
	}	}

	void setEventCount(Int_t nEvents) {	void setEventCount(Int_t nEvents) {
	// Store total number of events in this component test statistic	// Store total number of events in this component test statistic
	_nEvents = nEvents ;	_nEvents = nEvents ;

	skipping to change at line 143	skipping to change at line 146
	std::vector<RooFit::MPSplit> _gofSplitMode ; //! GOF MP Split mode specif ied by component (when Auto is active)	std::vector<RooFit::MPSplit> _gofSplitMode ; //! GOF MP Split mode specif ied by component (when Auto is active)

	// Parallel mode data	// Parallel mode data
	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode
	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends

	RooFit::MPSplit _mpinterl ; // Use interleaving strategy rather th an N-wise split for partioning of dataset for multiprocessor-split	RooFit::MPSplit _mpinterl ; // Use interleaving strategy rather th an N-wise split for partioning of dataset for multiprocessor-split
	Bool_t _doOffset ; // Apply interval value offset to control nume ric precision?	Bool_t _doOffset ; // Apply interval value offset to control nume ric precision?
	mutable Double_t _offset ; //! Offset	mutable Double_t _offset ; //! Offset
	mutable Double_t _offsetCarry; //! avoids loss of precision	mutable Double_t _offsetCarry; //! avoids loss of precision

		mutable Double_t _evalCarry; //! carry of Kahan sum in evaluatePartition

	ClassDef(RooAbsTestStatistic,2) // Abstract base class for real-valued te st statistics	ClassDef(RooAbsTestStatistic,2) // Abstract base class for real-valued te st statistics

	};	};

	#endif	#endif

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

	RooSimultaneous.h	RooSimultaneous.h

	skipping to change at line 71	skipping to change at line 71

	using RooAbsPdf::plotOn ;	using RooAbsPdf::plotOn ;
	virtual RooPlot* plotOn(RooPlot* frame,	virtual RooPlot* plotOn(RooPlot* frame,
	const RooCmdArg& arg1 , const RooCmdArg & arg2=RooCmdArg(),	const RooCmdArg& arg1 , const RooCmdArg & arg2=RooCmdArg(),
	const RooCmdArg& arg3=RooCmdArg(), const RooCmdArg & arg4=RooCmdArg(),	const RooCmdArg& arg3=RooCmdArg(), const RooCmdArg & arg4=RooCmdArg(),
	const RooCmdArg& arg5=RooCmdArg(), const RooCmdArg & arg6=RooCmdArg(),	const RooCmdArg& arg5=RooCmdArg(), const RooCmdArg & arg6=RooCmdArg(),
	const RooCmdArg& arg7=RooCmdArg(), const RooCmdArg & arg8=RooCmdArg(),	const RooCmdArg& arg7=RooCmdArg(), const RooCmdArg & arg8=RooCmdArg(),
	const RooCmdArg& arg9=RooCmdArg(), const RooCmdArg & arg10=RooCmdArg()) const {	const RooCmdArg& arg9=RooCmdArg(), const RooCmdArg & arg10=RooCmdArg()) 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) ;
	}	}

		virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;

	// 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) ;	virtual RooDataSet* generateSimGlobal(const RooArgSet& whatVars, Int_t nE vents) ;

	virtual RooDataHist* fillDataHist(RooDataHist hist, const RooArgSet nse t, Double_t scaleFactor,	virtual RooDataHist* fillDataHist(RooDataHist hist, const RooArgSet nse t, Double_t scaleFactor,
	Bool_t correctForBinVolume=kFALSE, Bool_ t showProgress=kFALSE) const ;	Bool_t correctForBinVolume=kFALSE, Bool_ t showProgress=kFALSE) const ;

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

	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	virtual ~CacheElem() {} ;	virtual ~CacheElem() {} ;
	RooArgList containedArgs(Action) { return RooArgList(_partIntList) ; }	RooArgList containedArgs(Action) { return RooArgList(_partIntList) ; }

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

	TBits.h	TBits.h

	skipping to change at line 139	skipping to change at line 139
	void Get(UInt_t array) const { Get((Int_t)array); }	void Get(UInt_t array) const { Get((Int_t)array); }
	void Get(Long64_t *array) const;	void Get(Long64_t *array) const;
	void Get(ULong64_t array) const { Get((Long64_t)array); }	void Get(ULong64_t array) const { Get((Long64_t)array); }

	//----- Utilities	//----- Utilities
	void Clear(Option_t *option="");	void Clear(Option_t *option="");
	void Compact(); // Reduce the space used.	void Compact(); // Reduce the space used.
	UInt_t CountBits(UInt_t startBit=0) const ; // return number of bi ts set to 1	UInt_t CountBits(UInt_t startBit=0) const ; // return number of bi ts set to 1
	UInt_t FirstNullBit(UInt_t startBit=0) const;	UInt_t FirstNullBit(UInt_t startBit=0) const;
	UInt_t FirstSetBit(UInt_t startBit=0) const;	UInt_t FirstSetBit(UInt_t startBit=0) const;

		UInt_t LastNullBit(UInt_t startBit=999999999) const;
		UInt_t LastSetBit(UInt_t startBit=999999999) const;
	UInt_t GetNbits() const { return fNbits; }	UInt_t GetNbits() const { return fNbits; }
	UInt_t GetNbytes() const { return fNbytes; }	UInt_t GetNbytes() const { return fNbytes; }

	Bool_t operator==(const TBits &other) const;	Bool_t operator==(const TBits &other) const;
	Bool_t operator!=(const TBits &other) const { return !(*this==other); }	Bool_t operator!=(const TBits &other) const { return !(*this==other); }

	void Paint(Option_t *option=""); // to visualize the bits arra y as an histogram, etc	void Paint(Option_t *option=""); // to visualize the bits arra y as an histogram, etc
	void Print(Option_t *option="") const; // to show the list of active bits	void Print(Option_t *option="") const; // to show the list of active bits
	void Output(ostream &) const;	void Output(ostream &) const;


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

	TBranchElement.h	TBranchElement.h

	skipping to change at line 113	skipping to change at line 113
	TBranchElement& operator=(const TBranchElement&); // not implemented	TBranchElement& operator=(const TBranchElement&); // not implemented

	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 *GetParentClass(); // Class referenced by fParen tName	TClass *GetParentClass(); // Class referenced by fParen tName
	TStreamerInfo *GetInfoImp() const;	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);
	inline 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 );

	skipping to change at line 181	skipping to change at line 180
	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 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();

		TClass *GetCurrentClass(); // Class referenced by trans ient description
	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) ;	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; }

	skipping to change at line 222	skipping to change at line 222
	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 SetTargetClass(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();


		enum EBranchElementType {
		kLeafNode = 0,
		kBaseClassNode = 1, // -- We are a base class element.
		// Note: This does not include an STL container
		class which is
		// being used as a base class because the
		streamer element
		// in that case is not the base streamer
		element it is the
		// STL streamer element.
		kObjectNode = 2,
		kClonesNode = 3,
		kSTLNode = 4,
		kClonesMemberNode = 31,
		kSTLMemberNode = 41
		};

	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	inline void TBranchElement::ValidateAddress() const

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

	TCint.h	TCint.h

	skipping to change at line 183	skipping to change at line 183
	virtual void Setgvp(Long_t) const;	virtual void Setgvp(Long_t) const;
	virtual void SetRTLD_NOW() const;	virtual void SetRTLD_NOW() const;
	virtual void SetRTLD_LAZY() const;	virtual void SetRTLD_LAZY() const;
	virtual void SetTempLevel(int val) const;	virtual void SetTempLevel(int val) const;
	virtual int UnloadFile(const char *path) const;	virtual int UnloadFile(const char *path) const;

	// G__CallFunc interface	// G__CallFunc interface
	virtual void CallFunc_Delete(void *func) const;	virtual void CallFunc_Delete(void *func) const;
	virtual void CallFunc_Exec(CallFunc_t func, void address) const;	virtual void CallFunc_Exec(CallFunc_t func, void address) const;
	virtual Long_t CallFunc_ExecInt(CallFunc_t func, void address) cons t;	virtual Long_t CallFunc_ExecInt(CallFunc_t func, void address) cons t;

	virtual Long_t CallFunc_ExecInt64(CallFunc_t func, void address) co nst;	virtual Long64_t CallFunc_ExecInt64(CallFunc_t func, void address) co nst;
	virtual Double_t CallFunc_ExecDouble(CallFunc_t func, void address) c onst;	virtual Double_t CallFunc_ExecDouble(CallFunc_t func, void address) c onst;
	virtual CallFunc_t *CallFunc_Factory() const;	virtual CallFunc_t *CallFunc_Factory() const;
	virtual CallFunc_t CallFunc_FactoryCopy(CallFunc_t func) const;	virtual CallFunc_t CallFunc_FactoryCopy(CallFunc_t func) const;
	virtual MethodInfo_t CallFunc_FactoryMethod(CallFunc_t func) const;	virtual MethodInfo_t CallFunc_FactoryMethod(CallFunc_t func) const;
	virtual void CallFunc_Init(CallFunc_t *func) const;	virtual void CallFunc_Init(CallFunc_t *func) const;
	virtual Bool_t CallFunc_IsValid(CallFunc_t *func) const;	virtual Bool_t CallFunc_IsValid(CallFunc_t *func) const;
	virtual void CallFunc_ResetArg(CallFunc_t *func) const;	virtual void CallFunc_ResetArg(CallFunc_t *func) const;
	virtual void CallFunc_SetArg(CallFunc_t *func, Long_t param) const;	virtual void CallFunc_SetArg(CallFunc_t *func, Long_t param) const;
	virtual void CallFunc_SetArg(CallFunc_t *func, Double_t param) const;	virtual void CallFunc_SetArg(CallFunc_t *func, Double_t param) const;
	virtual void CallFunc_SetArg(CallFunc_t *func, Long64_t param) const;	virtual void CallFunc_SetArg(CallFunc_t *func, Long64_t param) const;

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

	TDataSetManagerAliEn.h	TDataSetManagerAliEn.h

	// @(#)root/proof:$Id$	// @(#)root/proof:$Id: 511148a2a899e02c8f5b86a7d87caee2e5979f9d $
	// Author: Dario Berzano, 26.11.12	// Author: Dario Berzano, 26.11.12

	/*************************************************************************	/*************************************************************************
	* 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 126	skipping to change at line 126
	virtual void Init(TString cacheDir, TString urlTpl,	virtual void Init(TString cacheDir, TString urlTpl,
	ULong_t cacheExpire_s);	ULong_t cacheExpire_s);

	public:	public:

	TDataSetManagerAliEn() : TDataSetManager(0, 0, 0) {}	TDataSetManagerAliEn() : TDataSetManager(0, 0, 0) {}
	TDataSetManagerAliEn(const char cacheDir, const char urlTpl,	TDataSetManagerAliEn(const char cacheDir, const char urlTpl,
	ULong_t cacheExpire_s);	ULong_t cacheExpire_s);
	TDataSetManagerAliEn(const char , const char , const char *cfgStr);	TDataSetManagerAliEn(const char , const char , const char *cfgStr);


	virtual TList *GetFindCommandsFromUri(TString &uri, EDataMode &dataMo de);	virtual TList *GetFindCommandsFromUri(TString &uri, EDataMode &dataMo de, Bool_t &forceUpdate);

	virtual ~TDataSetManagerAliEn();	virtual ~TDataSetManagerAliEn();
	virtual TFileCollection GetDataSet(const char uri, const char * = 0 );	virtual TFileCollection GetDataSet(const char uri, const char * = 0 );
	virtual Bool_t ExistsDataSet(const char *uri);	virtual Bool_t ExistsDataSet(const char *uri);

	// Not implemented functionalities	// Not implemented functionalities
	virtual Int_t RegisterDataSet(const char , TFileCollection ,	virtual Int_t RegisterDataSet(const char , TFileCollection ,
	const char *);	const char *);
	virtual TMap GetDataSets(const char , UInt_t);	virtual TMap GetDataSets(const char , UInt_t);
	virtual void ShowDataSets(const char * = "", const char = "");	virtual void ShowDataSets(const char * = "", const char = "");

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

	TGeoBBox.h	TGeoBBox.h

	skipping to change at line 51	skipping to change at line 51
	TGeoBBox();	TGeoBBox();
	TGeoBBox(Double_t dx, Double_t dy, Double_t dz, Double_t *origin=0);	TGeoBBox(Double_t dx, Double_t dy, Double_t dz, Double_t *origin=0);
	TGeoBBox(const char name, Double_t dx, Double_t dy, Double_t dz, Double _t origin=0);	TGeoBBox(const char name, Double_t dx, Double_t dy, Double_t dz, Double _t origin=0);
	TGeoBBox(Double_t *param);	TGeoBBox(Double_t *param);
	// destructor	// destructor
	virtual ~TGeoBBox();	virtual ~TGeoBBox();
	// methods	// methods
	static Bool_t AreOverlapping(const TGeoBBox box1, const TGeoMat rix mat1, const TGeoBBox box2, const TGeoMatrix mat2);	static Bool_t AreOverlapping(const TGeoBBox box1, const TGeoMat rix mat1, const TGeoBBox box2, const TGeoMatrix mat2);
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm);	t dir, Double_t norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual void ComputeNormal_v(const Double_t *points, const Doub
		le_t dirs, Double_t norms, Int_t vecsize);
		virtual Bool_t Contains(const Double_t *point) const;
		virtual void Contains_v(const Double_t points, Bool_t inside,
		Int_t vecsize) const;
	static Bool_t Contains(const Double_t point, Double_t dx, Doubl e_t dy, Double_t dz, const Double_t origin);	static Bool_t Contains(const Double_t point, Double_t dx, Doubl e_t dy, Double_t dz, const Double_t origin);

	virtual Bool_t CouldBeCrossed(Double_t point, Double_t dir) con st;	virtual Bool_t CouldBeCrossed(const Double_t point, const Double _t dir) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromInside_v(const Double_t points, const Dou ble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	static Double_t DistFromInside(const Double_t point,const Double_ t dir,	static Double_t DistFromInside(const Double_t point,const Double_ t dir,
	Double_t dx, Double_t dy, Double_t dz, c onst Double_t *origin, Double_t stepmax=TGeoShape::Big());	Double_t dx, Double_t dy, Double_t dz, c onst Double_t *origin, Double_t stepmax=TGeoShape::Big());

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,	virtual Double_t DistFromOutside(const Double_t point, const Doubl e_t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

		virtual void DistFromOutside_v(const Double_t points, const Do uble_t dirs, Double_t dists, Int_t vecsize, Double_t step) const;
	static Double_t DistFromOutside(const Double_t point,const Double _t dir,	static Double_t DistFromOutside(const Double_t point,const Double _t dir,
	Double_t dx, Double_t dy, Double_t dz, c onst Double_t *origin, Double_t stepmax=TGeoShape::Big());	Double_t dx, Double_t dy, Double_t dz, c onst Double_t *origin, Double_t stepmax=TGeoShape::Big());
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 36;}	virtual Int_t GetByteCount() const {return 36;}
	virtual Double_t GetFacetArea(Int_t index=0) const;	virtual Double_t GetFacetArea(Int_t index=0) const;

	skipping to change at line 87	skipping to change at line 91
	virtual Int_t GetNmeshVertices() const {return 8;}	virtual Int_t GetNmeshVertices() const {return 8;}
	virtual Double_t GetDX() const {return fDX;}	virtual Double_t GetDX() const {return fDX;}
	virtual Double_t GetDY() const {return fDY;}	virtual Double_t GetDY() const {return fDY;}
	virtual Double_t GetDZ() const {return fDZ;}	virtual Double_t GetDZ() const {return fDZ;}
	virtual const Double_t *GetOrigin() const {return fOrigin;}	virtual const Double_t *GetOrigin() const {return fOrigin;}
	virtual void InspectShape() const;	virtual void InspectShape() const;
	virtual Bool_t IsCylType() const {return kFALSE;}	virtual Bool_t IsCylType() const {return kFALSE;}
	virtual Bool_t IsValidBox() const {return ((fDX<0)\|\|(fDY<0)\|\|(fDZ <0))?kFALSE:kTRUE;}	virtual Bool_t IsValidBox() const {return ((fDX<0)\|\|(fDY<0)\|\|(fDZ <0))?kFALSE:kTRUE;}
	virtual Bool_t IsNullBox() const {return ((fDX<1.E-16)&&(fDY<1.E- 16)&&(fDZ<1.E-16))?kTRUE:kFALSE;}	virtual Bool_t IsNullBox() const {return ((fDX<1.E-16)&&(fDY<1.E- 16)&&(fDZ<1.E-16))?kTRUE:kFALSE;}
	virtual TBuffer3D *MakeBuffer3D() const;	virtual TBuffer3D *MakeBuffer3D() const;

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
		st;
		virtual void Safety_v(const Double_t points, const Bool_t ins
		ide, Double_t *safe, Int_t vecsize) const;
	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	void SetBoxDimensions(Double_t dx, Double_t dy, Double_ t dz, Double_t *origin=0);	void SetBoxDimensions(Double_t dx, Double_t dy, Double_ t dz, Double_t *origin=0);
	virtual void SetDimensions(Double_t *param);	virtual void SetDimensions(Double_t *param);
	void SetBoxPoints(Double_t *points) const;	void SetBoxPoints(Double_t *points) const;
	virtual void SetPoints(Double_t *points) const;	virtual void SetPoints(Double_t *points) const;
	virtual void SetPoints(Float_t *points) const;	virtual void SetPoints(Float_t *points) const;
	virtual void SetSegsAndPols(TBuffer3D &buffer) const;	virtual void SetSegsAndPols(TBuffer3D &buffer) const;
	virtual void Sizeof3D() const;	virtual void Sizeof3D() const;

	ClassDef(TGeoBBox, 1) // box primitive	ClassDef(TGeoBBox, 1) // box primitive

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

	TGeoExtension.h	TGeoExtension.h

	skipping to change at line 40	skipping to change at line 40

	class TGeoExtension : public TObject	class TGeoExtension : public TObject
	{	{
	protected:	protected:
	TGeoExtension() : TObject() {}	TGeoExtension() : TObject() {}
	virtual ~TGeoExtension() {}	virtual ~TGeoExtension() {}

	public:	public:
	// Method called whenever requiring a pointer to the extension	// Method called whenever requiring a pointer to the extension
	// Equivalent to new()	// Equivalent to new()

	virtual TGeoExtension *Grab() const = 0;	virtual TGeoExtension *Grab() = 0;
	// Method called always when the pointer to the extension is not needed	// Method called always when the pointer to the extension is not needed
	// Equivalent to delete()	// Equivalent to delete()
	virtual void Release() const = 0;	virtual void Release() const = 0;

	ClassDef(TGeoExtension, 1) // User extension for volumes and nodes	ClassDef(TGeoExtension, 1) // User extension for volumes and nodes
	};	};

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	// TGeoRCExtension - Reference counted extension which has a pointer to a nd	// TGeoRCExtension - Reference counted extension which has a pointer to a nd
	// owns a user defined TObject. This class can be used as	// owns a user defined TObject. This class can be used as

	skipping to change at line 63	skipping to change at line 63
	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____

	class TGeoRCExtension : public TGeoExtension	class TGeoRCExtension : public TGeoExtension
	{	{
	protected:	protected:
	virtual ~TGeoRCExtension() {delete fUserObject;}	virtual ~TGeoRCExtension() {delete fUserObject;}
	public:	public:
	TGeoRCExtension() : TGeoExtension(), fRC(0), fUserObject(0) {fRC++;}	TGeoRCExtension() : TGeoExtension(), fRC(0), fUserObject(0) {fRC++;}
	TGeoRCExtension(TObject *obj) : TGeoExtension(), fRC(0), fUserObject(obj ) {fRC++;}	TGeoRCExtension(TObject *obj) : TGeoExtension(), fRC(0), fUserObject(obj ) {fRC++;}


	TGeoExtension Grab() const {fRC++; return (TGeoExt ension)this;}	TGeoExtension *Grab() {fRC++; return this;}
	void Release() const {assert(fRC > 0); fRC-- ; if (fRC ==0) delete this;}	void Release() const {assert(fRC > 0); fRC-- ; if (fRC ==0) delete this;}

	void SetUserObject(TObject *obj) {fUserObject = obj;}	void SetUserObject(TObject *obj) {fUserObject = obj;}
	TObject *GetUserObject() const {return fUserObject;}	TObject *GetUserObject() const {return fUserObject;}

	private:	private:
	// Copy constructor and assignment not allowed	// Copy constructor and assignment not allowed

	TGeoRCExtension(const TGeoRCExtension &) {}	TGeoRCExtension(const TGeoRCExtension &); // Not implemented
	TGeoRCExtension &operator =(const TGeoRCExtension &) {return *this;}	TGeoRCExtension &operator =(const TGeoRCExtension &); // Not implemented
	mutable Int_t fRC; // Reference counter	mutable Int_t fRC; // Reference counter
	TObject *fUserObject; // Attached user object	TObject *fUserObject; // Attached user object

	ClassDef(TGeoRCExtension, 1) // Reference counted extension for vo lumes and nodes	ClassDef(TGeoRCExtension, 1) // Reference counted extension for vo lumes and nodes
	};	};

	#endif	#endif

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

	TGeoManager.h	TGeoManager.h

	skipping to change at line 79	skipping to change at line 79
	Int_t fNsegments; // number of segments to approx imate circles	Int_t fNsegments; // number of segments to approx imate circles
	Int_t fNtracks; // number of tracks	Int_t fNtracks; // number of tracks
	Int_t fMaxVisNodes; // maximum number of visible no des	Int_t fMaxVisNodes; // maximum number of visible no des
	TVirtualGeoTrack *fCurrentTrack; //! current track	TVirtualGeoTrack *fCurrentTrack; //! current track
	Int_t fNpdg; // number of different pdg's st ored	Int_t fNpdg; // number of different pdg's st ored
	Int_t fPdgId[256]; // pdg conversion table	Int_t fPdgId[256]; // pdg conversion table
	Bool_t fClosed; //! flag that geometry is close d	Bool_t fClosed; //! flag that geometry is close d
	Bool_t fLoopVolumes; //! flag volume lists loop	Bool_t fLoopVolumes; //! flag volume lists loop
	Bool_t fStreamVoxels; // flag to allow voxelization I /O	Bool_t fStreamVoxels; // flag to allow voxelization I /O
	Bool_t fIsGeomReading; //! flag set when reading geome try	Bool_t fIsGeomReading; //! flag set when reading geome try

		Bool_t fIsGeomCleaning; //! flag to notify that the man ager is being destructed
	Bool_t fPhiCut; // flag for phi cuts	Bool_t fPhiCut; // flag for phi cuts
	Bool_t fTimeCut; // time cut for tracks	Bool_t fTimeCut; // time cut for tracks
	Bool_t fDrawExtra; //! flag that the list of physi cal nodes has to be drawn	Bool_t fDrawExtra; //! flag that the list of physi cal nodes has to be drawn
	Bool_t fMatrixTransform; //! flag for using GL matrix	Bool_t fMatrixTransform; //! flag for using GL matrix
	Bool_t fMatrixReflection; //! flag for GL reflections	Bool_t fMatrixReflection; //! flag for GL reflections
	Bool_t fActivity; //! switch ON/OFF volume activi ty (default OFF - all volumes active))	Bool_t fActivity; //! switch ON/OFF volume activi ty (default OFF - all volumes active))
	Bool_t fIsNodeSelectable; //! flag that nodes are the sel ected objects in pad rather than volumes	Bool_t fIsNodeSelectable; //! flag that nodes are the sel ected objects in pad rather than volumes
	TVirtualGeoPainter *fPainter; //! current painter	TVirtualGeoPainter *fPainter; //! current painter

	TObjArray *fMatrices; //-> list of local transformati ons	TObjArray *fMatrices; //-> list of local transformati ons

	skipping to change at line 451	skipping to change at line 452

	//--- I/O	//--- I/O
	virtual Int_t Export(const char filename, const char name="", Option_t *option="vg");	virtual Int_t Export(const char filename, const char name="", Option_t *option="vg");
	static void LockGeometry();	static void LockGeometry();
	static void UnlockGeometry();	static void UnlockGeometry();
	static Int_t GetVerboseLevel();	static Int_t GetVerboseLevel();
	static void SetVerboseLevel(Int_t vl);	static void SetVerboseLevel(Int_t vl);
	static TGeoManager Import(const char filename, const char name="", Option_t option="");	static TGeoManager Import(const char filename, const char name="", Option_t option="");
	static Bool_t IsLocked();	static Bool_t IsLocked();
	Bool_t IsStreamingVoxels() const {return fStreamVoxels;}	Bool_t IsStreamingVoxels() const {return fStreamVoxels;}

		Bool_t IsCleaning() const {return fIsGeomCleaning;}

	//--- list getters	//--- list getters
	TObjArray *GetListOfNodes() {return fNodes;}	TObjArray *GetListOfNodes() {return fNodes;}
	TObjArray *GetListOfPhysicalNodes() {return fPhysicalNo des;}	TObjArray *GetListOfPhysicalNodes() {return fPhysicalNo des;}
	TObjArray *GetListOfOverlaps() {return fOverlaps;}	TObjArray *GetListOfOverlaps() {return fOverlaps;}
	TObjArray *GetListOfMatrices() const {return fMatrices;}	TObjArray *GetListOfMatrices() const {return fMatrices;}
	TList *GetListOfMaterials() const {return fMaterials; }	TList *GetListOfMaterials() const {return fMaterials; }
	TList *GetListOfMedia() const {return fMedia;}	TList *GetListOfMedia() const {return fMedia;}
	TObjArray *GetListOfVolumes() const {return fVolumes;}	TObjArray *GetListOfVolumes() const {return fVolumes;}
	TObjArray *GetListOfGVolumes() const {return fGVolumes;}	TObjArray *GetListOfGVolumes() const {return fGVolumes;}

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

	TGeoNode.h	TGeoNode.h

	skipping to change at line 119	skipping to change at line 119
	virtual Bool_t IsFolder() const {return (GetNdaughters()?kTRUE:kFALSE );}	virtual Bool_t IsFolder() const {return (GetNdaughters()?kTRUE:kFALSE );}
	Bool_t IsOffset() const {return TObject::TestBit(kGeoNodeOffs et);}	Bool_t IsOffset() const {return TObject::TestBit(kGeoNodeOffs et);}
	Bool_t IsOnScreen() const; // MENU	Bool_t IsOnScreen() const; // MENU
	Bool_t IsOverlapping() const {return TObject::TestBit(kGeoNod eOverlap);}	Bool_t IsOverlapping() const {return TObject::TestBit(kGeoNod eOverlap);}
	Bool_t IsVirtual() const {return TObject::TestBit(kGeoNodeVC) ;}	Bool_t IsVirtual() const {return TObject::TestBit(kGeoNodeVC) ;}
	Bool_t IsVisible() const {return (TGeoAtt::IsVisible() && fVo lume->IsVisible());}	Bool_t IsVisible() const {return (TGeoAtt::IsVisible() && fVo lume->IsVisible());}
	Bool_t IsVisDaughters() const {return (TGeoAtt::IsVisDaughter s() && fVolume->IsVisDaughters());}	Bool_t IsVisDaughters() const {return (TGeoAtt::IsVisDaughter s() && fVolume->IsVisDaughters());}
	Bool_t MayOverlap(Int_t iother) const;	Bool_t MayOverlap(Int_t iother) const;

	virtual TGeoNode *MakeCopyNode() const {return 0;}	virtual TGeoNode *MakeCopyNode() const {return 0;}

	Double_t Safety(Double_t *point, Bool_t in=kTRUE) const;	Double_t Safety(const Double_t *point, Bool_t in=kTRUE) const;
	void SaveAttributes(std::ostream &out);	void SaveAttributes(std::ostream &out);
	void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {f Volume->SetCurrentPoint(x,y,z);}// MENU	void SetCurrentPoint(Double_t x, Double_t y, Double_t z) {f Volume->SetCurrentPoint(x,y,z);}// MENU
	void SetVolume(TGeoVolume *volume) {fVolume = volume; }	void SetVolume(TGeoVolume *volume) {fVolume = volume; }
	void SetNumber(Int_t number) {fNumber=number;}	void SetNumber(Int_t number) {fNumber=number;}
	void SetOverlapping(Bool_t flag=kTRUE) {TObject::SetBit(k GeoNodeOverlap, flag);}	void SetOverlapping(Bool_t flag=kTRUE) {TObject::SetBit(k GeoNodeOverlap, flag);}
	void SetVirtual() {TObject::SetBit(k GeoNodeVC, kTRUE);}	void SetVirtual() {TObject::SetBit(k GeoNodeVC, kTRUE);}
	void SetVisibility(Bool_t vis=kTRUE); // MENU	void SetVisibility(Bool_t vis=kTRUE); // MENU
	void SetInvisible() {SetVisibility(kFA LSE);} // MENU	void SetInvisible() {SetVisibility(kFA LSE);} // MENU
	void SetAllInvisible() {VisibleDaughters( kFALSE);} // MENU	void SetAllInvisible() {VisibleDaughters( kFALSE);} // MENU
	void SetMotherVolume(TGeoVolume *mother) {fMother = mother; }	void SetMotherVolume(TGeoVolume *mother) {fMother = mother; }

	skipping to change at line 214	skipping to change at line 214
	TGeoNodeOffset(const TGeoVolume *vol, Int_t index, Double_t offset);	TGeoNodeOffset(const TGeoVolume *vol, Int_t index, Double_t offset);
	// destructor	// destructor
	virtual ~TGeoNodeOffset();	virtual ~TGeoNodeOffset();

	virtual void cd() const {fFinder->cd(fIndex);}	virtual void cd() const {fFinder->cd(fIndex);}
	Double_t GetOffset() const {return fOffset;}	Double_t GetOffset() const {return fOffset;}
	virtual Int_t GetIndex() const;	virtual Int_t GetIndex() const;
	virtual TGeoPatternFinder *GetFinder() const {return fFinder;}	virtual TGeoPatternFinder *GetFinder() const {return fFinder;}
	virtual TGeoMatrix *GetMatrix() const {cd(); return fFinder->GetMatrix() ;}	virtual TGeoMatrix *GetMatrix() const {cd(); return fFinder->GetMatrix() ;}
	virtual TGeoNode *MakeCopyNode() const;	virtual TGeoNode *MakeCopyNode() const;

	void SetFinder(const TGeoPatternFinder finder) {fFinder = (TGeoPatternFinder)finder;}	void SetFinder(TGeoPatternFinder *finder) {fFinder = finder ;}

	ClassDef(TGeoNodeOffset, 1) // a geometry node with just an offset	ClassDef(TGeoNodeOffset, 1) // a geometry node with just an offset
	};	};

	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /
	// / /	// / /
	// TGeoIteratorPlugin - Plugin for a TGeoIterator providing the method / /	// TGeoIteratorPlugin - Plugin for a TGeoIterator providing the method / /
	// ProcessNode each time Next is called. / /	// ProcessNode each time Next is called. / /
	// / /	// / /
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

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

	TGeoShape.h	TGeoShape.h

	skipping to change at line 107	skipping to change at line 107

	static Double_t Big() {return 1.E30;}	static Double_t Big() {return 1.E30;}
	static TGeoMatrix *GetTransform();	static TGeoMatrix *GetTransform();
	static void SetTransform(TGeoMatrix *matrix);	static void SetTransform(TGeoMatrix *matrix);
	static Double_t Tolerance() {return 1.E-10;}	static Double_t Tolerance() {return 1.E-10;}
	static Double_t ComputeEpsMch();	static Double_t ComputeEpsMch();
	static Double_t EpsMch();	static Double_t EpsMch();
	virtual Double_t Capacity() const = 0;	virtual Double_t Capacity() const = 0;
	void CheckShape(Int_t testNo, Int_t nsamples=10000, Opt ion_t *option="");	void CheckShape(Int_t testNo, Int_t nsamples=10000, Opt ion_t *option="");
	virtual void ComputeBBox() = 0;	virtual void ComputeBBox() = 0;

	virtual void ComputeNormal(Double_t point, Double_t dir, Doub	virtual void ComputeNormal(const Double_t *point, const Double_
	le_t *norm) = 0;	t dir, Double_t norm) = 0;
	virtual Bool_t Contains(Double_t *point) const = 0;	virtual void ComputeNormal_v(const Double_t , const Double_t
	virtual Bool_t CouldBeCrossed(Double_t point, Double_t dir) con	, Double_t *, Int_t) {}
	st = 0;	virtual Bool_t Contains(const Double_t *point) const = 0;
		virtual void Contains_v(const Double_t , Bool_t , Int_t) cons
		t {}
		virtual Bool_t CouldBeCrossed(const Double_t *point, const Double
		_t *dir) const = 0;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) = 0;	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py) = 0;

	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(const Double_t point, const Double _t dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const = 0;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const = 0;

	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In	virtual void DistFromInside_v(const Double_t *, const Double_t
	t_t iact=1,	, Double_t , Int_t, Double_t *) const {}
		virtual Double_t DistFromOutside(const Double_t *point, const Doubl
		e_t *dir, Int_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const = 0;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const = 0;

	static Double_t DistToPhiMin(Double_t point, Double_t dir, Doubl	virtual void DistFromOutside_v(const Double_t *, const Double_t
	e_t s1, Double_t c1, Double_t s2, Double_t c2,	, Double_t , Int_t, Double_t *) const {}
		static Double_t DistToPhiMin(const Double_t *point, const Double_t
		*dir, Double_t s1, Double_t c1, Double_t s2, Double_t c2,
	Double_t sm, Double_t cm, Bool_t in=k TRUE);	Double_t sm, Double_t cm, Bool_t in=k TRUE);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step) = 0;	Double_t start, Double_t step) = 0;
	virtual void Draw(Option_t option=""); // MENU*	virtual void Draw(Option_t option=""); // MENU*
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	virtual const char *GetAxisName(Int_t iaxis) const = 0;	virtual const char *GetAxisName(Int_t iaxis) const = 0;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const = 0;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const = 0;
	virtual void GetBoundingCylinder(Double_t *param) const = 0;	virtual void GetBoundingCylinder(Double_t *param) const = 0;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const = 0;	virtual Int_t GetByteCount() const = 0;

	skipping to change at line 137	skipping to change at line 141
	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const = 0;	virtual Int_t GetFittingBox(const TGeoBBox parambox, TGeoMatrix mat, Double_t &dx, Double_t &dy, Double_t &dz) const = 0;
	Int_t GetId() const {return fShapeId;}	Int_t GetId() const {return fShapeId;}
	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const = 0;	virtual TGeoShape GetMakeRuntimeShape(TGeoShape mother, TGeoMatrix *mat) const = 0;
	virtual void GetMeshNumbers(Int_t &/nvert/, Int_t &/nsegs/, Int_t &/npols/) const {;}	virtual void GetMeshNumbers(Int_t &/nvert/, Int_t &/nsegs/, Int_t &/npols/) const {;}
	virtual const char *GetName() const;	virtual const char *GetName() const;
	virtual Int_t GetNmeshVertices() const {return 0;}	virtual Int_t GetNmeshVertices() const {return 0;}
	const char *GetPointerName() const;	const char *GetPointerName() const;
	virtual Bool_t IsAssembly() const {return kFALSE;}	virtual Bool_t IsAssembly() const {return kFALSE;}
	virtual Bool_t IsComposite() const {return kFALSE;}	virtual Bool_t IsComposite() const {return kFALSE;}
	virtual Bool_t IsCylType() const = 0;	virtual Bool_t IsCylType() const = 0;

	static Bool_t IsCloseToPhi(Double_t epsil, Double_t *point, Doub	static Bool_t IsCloseToPhi(Double_t epsil, const Double_t *point
	le_t c1, Double_t s1, Double_t c2, Double_t s2);	, Double_t c1, Double_t s1, Double_t c2, Double_t s2);
	static Bool_t IsCrossingSemiplane(Double_t point, Double_t dir	static Bool_t IsCrossingSemiplane(const Double_t *point, const D
	, Double_t cphi, Double_t sphi, Double_t &snext, Double_t &rxy);	ouble_t *dir, Double_t cphi, Double_t sphi, Double_t &snext, Double_t &rxy)
		;
	static Bool_t IsSameWithinTolerance(Double_t a, Double_t b);	static Bool_t IsSameWithinTolerance(Double_t a, Double_t b);
	static Bool_t IsSegCrossing(Double_t x1, Double_t y1, Double_t x 2, Double_t y2,Double_t x3, Double_t y3,Double_t x4, Double_t y4);	static Bool_t IsSegCrossing(Double_t x1, Double_t y1, Double_t x 2, Double_t y2,Double_t x3, Double_t y3,Double_t x4, Double_t y4);

	static Bool_t IsInPhiRange(Double_t *point, Double_t phi1, Doubl e_t phi2);	static Bool_t IsInPhiRange(const Double_t *point, Double_t phi1, Double_t phi2);
	virtual Bool_t IsReflected() const {return kFALSE;}	virtual Bool_t IsReflected() const {return kFALSE;}
	Bool_t IsRunTimeShape() const {return TestShapeBit(kGeoRu nTimeShape);}	Bool_t IsRunTimeShape() const {return TestShapeBit(kGeoRu nTimeShape);}
	Bool_t IsValid() const {return !TestShapeBit(kGeoInvalidS hape);}	Bool_t IsValid() const {return !TestShapeBit(kGeoInvalidS hape);}
	virtual Bool_t IsValidBox() const = 0;	virtual Bool_t IsValidBox() const = 0;
	virtual void InspectShape() const = 0;	virtual void InspectShape() const = 0;
	virtual TBuffer3D *MakeBuffer3D() const {return 0;}	virtual TBuffer3D *MakeBuffer3D() const {return 0;}

	static void NormalPhi(Double_t point, Double_t dir, Double_t *norm, Double_t c1, Double_t s1, Double_t c2, Double_t s2);	static void NormalPhi(const Double_t point, const Double_t d ir, Double_t *norm, Double_t c1, Double_t s1, Double_t c2, Double_t s2);
	virtual void Paint(Option_t *option="");	virtual void Paint(Option_t *option="");

	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const = 0	virtual Double_t Safety(const Double_t *point, Bool_t in=kTRUE) con
	;	st = 0;
	static Double_t SafetyPhi(Double_t *point, Bool_t in, Double_t phi	virtual void Safety_v(const Double_t , const Bool_t , Double_
	1, Double_t phi2);	t *, Int_t) const {}
		static Double_t SafetyPhi(const Double_t *point, Bool_t in, Double
		_t phi1, Double_t phi2);
	static Double_t SafetySeg(Double_t r, Double_t z, Double_t r1, Dou ble_t z1, Double_t r2, Double_t z2, Bool_t outer);	static Double_t SafetySeg(Double_t r, Double_t z, Double_t r1, Dou ble_t z1, Double_t r2, Double_t z2, Bool_t outer);
	virtual void SetDimensions(Double_t *param) = 0;	virtual void SetDimensions(Double_t *param) = 0;
	void SetId(Int_t id) {fShapeId = id;}	void SetId(Int_t id) {fShapeId = id;}
	virtual void SetPoints(Double_t *points) const = 0;	virtual void SetPoints(Double_t *points) const = 0;
	virtual void SetPoints(Float_t *points) const = 0;	virtual void SetPoints(Float_t *points) const = 0;
	virtual void SetSegsAndPols(TBuffer3D &buff) const = 0;	virtual void SetSegsAndPols(TBuffer3D &buff) const = 0;
	void SetRuntime(Bool_t flag=kTRUE) {SetShapeBit(kGeoRun TimeShape, flag);}	void SetRuntime(Bool_t flag=kTRUE) {SetShapeBit(kGeoRun TimeShape, flag);}
	Int_t ShapeDistancetoPrimitive(Int_t numpoints, Int_t px , Int_t py) const;	Int_t ShapeDistancetoPrimitive(Int_t numpoints, Int_t px , Int_t py) const;
	virtual void Sizeof3D() const = 0;	virtual void Sizeof3D() const = 0;


End of changes. 8 change blocks.
	20 lines changed or deleted	31 lines changed or added

	TGeoVolume.h	TGeoVolume.h

	skipping to change at line 121	skipping to change at line 121
	void CheckShapes();	void CheckShapes();
	void ClearNodes() {fNodes = 0;}	void ClearNodes() {fNodes = 0;}
	void ClearShape();	void ClearShape();
	void CleanAll();	void CleanAll();
	virtual TGeoVolume *CloneVolume() const;	virtual TGeoVolume *CloneVolume() const;
	void CloneNodesAndConnect(TGeoVolume *newmother) const;	void CloneNodesAndConnect(TGeoVolume *newmother) const;
	void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const;	void CheckGeometry(Int_t nrays=1, Double_t startx=0, Double_t starty=0, Double_t startz=0) const;
	void CheckOverlaps(Double_t ovlp=0.1, Option_t option="") co nst; // MENU*	void CheckOverlaps(Double_t ovlp=0.1, Option_t option="") co nst; // MENU*
	void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t option=""); // MENU*	void CheckShape(Int_t testNo, Int_t nsamples=10000, Option_t option=""); // MENU*
	Int_t CountNodes(Int_t nlevels=1000, Int_t option=0);	Int_t CountNodes(Int_t nlevels=1000, Int_t option=0);

	Bool_t Contains(Double_t *point) const {return fShape->Contains (point);}	Bool_t Contains(const Double_t *point) const {return fShape->Co ntains(point);}
	virtual Bool_t IsAssembly() const;	virtual Bool_t IsAssembly() const;
	virtual Bool_t IsFolder() const;	virtual Bool_t IsFolder() const;
	Bool_t IsRunTime() const {return fShape->IsRunTimeShape();}	Bool_t IsRunTime() const {return fShape->IsRunTimeShape();}
	virtual Bool_t IsVolumeMulti() const {return kFALSE;}	virtual Bool_t IsVolumeMulti() const {return kFALSE;}
	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat=0, Option_t *option=""); // most general case	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat=0, Option_t *option=""); // most general case
	void AddNodeOffset(const TGeoVolume vol, Int_t copy_no, Doub le_t offset=0, Option_t option="");	void AddNodeOffset(const TGeoVolume vol, Int_t copy_no, Doub le_t offset=0, Option_t option="");
	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat=0, Option_t *option="");	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat=0, Option_t *option="");

	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);

	skipping to change at line 283	skipping to change at line 283
	public:	public:
	TGeoVolumeMulti();	TGeoVolumeMulti();
	TGeoVolumeMulti(const char* name, TGeoMedium *med=0);	TGeoVolumeMulti(const char* name, TGeoMedium *med=0);
	virtual ~TGeoVolumeMulti();	virtual ~TGeoVolumeMulti();

	void AddVolume(TGeoVolume *vol);	void AddVolume(TGeoVolume *vol);
	TGeoVolume GetVolume(Int_t id) const {return (TGeoVolume)fVolumes- >At(id);}	TGeoVolume GetVolume(Int_t id) const {return (TGeoVolume)fVolumes- >At(id);}
	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat, Option_t *option=""); // most general case	virtual void AddNode(const TGeoVolume vol, Int_t copy_no, TGeoMatrix mat, Option_t *option=""); // most general case
	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat, Option_t *option="");	virtual void AddNodeOverlap(const TGeoVolume vol, Int_t copy_no, TGe oMatrix mat, Option_t *option="");
	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");	virtual TGeoVolume Divide(const char divname, Int_t iaxis, Int_t ndiv, Double_t start, Double_t step, Int_t numed=0, Option_t *option="");

	TGeoShape *GetLastShape() const {return GetVolume(fVolumes->GetEntr iesFast()-1)->GetShape();}	TGeoShape *GetLastShape() const;
	Int_t GetNvolumes() const {return fVolumes->GetEntriesFast();}	Int_t GetNvolumes() const {return fVolumes->GetEntriesFast();}
	Int_t GetAxis() const {return fNdiv;}	Int_t GetAxis() const {return fNdiv;}
	Int_t GetNdiv() const {return fNdiv;}	Int_t GetNdiv() const {return fNdiv;}
	Double_t GetStart() const {return fStart;}	Double_t GetStart() const {return fStart;}
	Double_t GetStep() const {return fStep;}	Double_t GetStep() const {return fStep;}
	virtual Bool_t IsVolumeMulti() const {return kTRUE;}	virtual Bool_t IsVolumeMulti() const {return kTRUE;}
	virtual TGeoVolume MakeCopyVolume(TGeoShape newshape);	virtual TGeoVolume MakeCopyVolume(TGeoShape newshape);
	virtual void SetLineColor(Color_t lcolor);	virtual void SetLineColor(Color_t lcolor);
	virtual void SetLineStyle(Style_t lstyle);	virtual void SetLineStyle(Style_t lstyle);
	virtual void SetLineWidth(Width_t lwidth);	virtual void SetLineWidth(Width_t lwidth);

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

	TGeoVoxelFinder.h	TGeoVoxelFinder.h

	skipping to change at line 79	skipping to change at line 79
	UChar_t *fIndcY; //[fNy] array of slices bits on Y	UChar_t *fIndcY; //[fNy] array of slices bits on Y
	UChar_t *fIndcZ; //[fNz] array of slices bits on Z	UChar_t *fIndcZ; //[fNz] array of slices bits on Z

	TGeoVoxelFinder(const TGeoVoxelFinder&);	TGeoVoxelFinder(const TGeoVoxelFinder&);
	TGeoVoxelFinder& operator=(const TGeoVoxelFinder&);	TGeoVoxelFinder& operator=(const TGeoVoxelFinder&);

	void BuildVoxelLimits();	void BuildVoxelLimits();
	Int_t *GetExtraX(Int_t islice, Bool_t left, Int_t &nextra) const;	Int_t *GetExtraX(Int_t islice, Bool_t left, Int_t &nextra) const;
	Int_t *GetExtraY(Int_t islice, Bool_t left, Int_t &nextra) const;	Int_t *GetExtraY(Int_t islice, Bool_t left, Int_t &nextra) const;
	Int_t *GetExtraZ(Int_t islice, Bool_t left, Int_t &nextra) const;	Int_t *GetExtraZ(Int_t islice, Bool_t left, Int_t &nextra) const;

	Bool_t GetIndices(Double_t *point, TGeoStateInfo &td);	Bool_t GetIndices(const Double_t *point, TGeoStateInfo &td) ;
	Int_t GetPriority(Int_t iaxis) const {return fPriority[iax is];}	Int_t GetPriority(Int_t iaxis) const {return fPriority[iax is];}
	Int_t GetNcandidates( TGeoStateInfo &td) const;	Int_t GetNcandidates( TGeoStateInfo &td) const;
	Int_t GetValidExtra(Int_t list, Int_t &ncheck, TGeoStateI nfo &td);	Int_t GetValidExtra(Int_t list, Int_t &ncheck, TGeoStateI nfo &td);
	Int_t GetValidExtra(Int_t n1, UChar_t array1, Int_t *list , Int_t &ncheck, TGeoStateInfo &td);	Int_t GetValidExtra(Int_t n1, UChar_t array1, Int_t *list , Int_t &ncheck, TGeoStateInfo &td);
	Int_t GetValidExtra(Int_t n1, UChar_t array1, Int_t n2, U Char_t array2, Int_t list, Int_t &ncheck, TGeoStateInfo &td);	Int_t GetValidExtra(Int_t n1, UChar_t array1, Int_t n2, U Char_t array2, Int_t list, Int_t &ncheck, TGeoStateInfo &td);
	Int_t *GetVoxelCandidates(Int_t i, Int_t j, Int_t k, Int_t &ncheck, TGeoStateInfo &td);	Int_t *GetVoxelCandidates(Int_t i, Int_t j, Int_t k, Int_t &ncheck, TGeoStateInfo &td);
	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t &nf, Int_ t result);	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t &nf, Int_ t result);
	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t n2, UChar _t array2,	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t n2, UChar _t array2,
	Int_t &nf, Int_t *result);	Int_t &nf, Int_t *result);
	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t n2, UChar _t array2,	Bool_t Intersect(Int_t n1, UChar_t array1, Int_t n2, UChar _t array2,

	skipping to change at line 104	skipping to change at line 104
	Int_t n3, UChar_t *array3, TGeoStateInfo &td);	Int_t n3, UChar_t *array3, TGeoStateInfo &td);
	void SortAll(Option_t *option="");	void SortAll(Option_t *option="");
	Bool_t Union(Int_t n1, UChar_t *array1, TGeoStateInfo &td);	Bool_t Union(Int_t n1, UChar_t *array1, TGeoStateInfo &td);
	Bool_t Union(Int_t n1, UChar_t array1, Int_t n2, UChar_t array2, TGeoStateInfo &td);	Bool_t Union(Int_t n1, UChar_t array1, Int_t n2, UChar_t array2, TGeoStateInfo &td);
	Bool_t Union(Int_t n1, UChar_t array1, Int_t n2, UChar_t array2,	Bool_t Union(Int_t n1, UChar_t array1, Int_t n2, UChar_t array2,
	Int_t n3, UChar_t *array3, TGeoStateInfo &td);	Int_t n3, UChar_t *array3, TGeoStateInfo &td);
	public :	public :
	TGeoVoxelFinder();	TGeoVoxelFinder();
	TGeoVoxelFinder(TGeoVolume *vol);	TGeoVoxelFinder(TGeoVolume *vol);
	virtual ~TGeoVoxelFinder();	virtual ~TGeoVoxelFinder();

	void DaughterToMother(Int_t id, Double_t local, Double_t master) const;	void DaughterToMother(Int_t id, const Double_t local, Do uble_t master) const;
	virtual Double_t Efficiency();	virtual Double_t Efficiency();

	virtual Int_t GetCheckList(Double_t point, Int_t &nelem, TGeoStat eInfo &td);	virtual Int_t GetCheckList(const Double_t point, Int_t &nelem, TG eoStateInfo &td);
	Int_t *GetCheckList(Int_t &nelem, TGeoStateInfo &td) const;	Int_t *GetCheckList(Int_t &nelem, TGeoStateInfo &td) const;

	virtual Int_t GetNextCandidates(Double_t point, Int_t &ncheck, TG eoStateInfo &td);	virtual Int_t GetNextCandidates(const Double_t point, Int_t &nche ck, TGeoStateInfo &td);
	virtual void FindOverlaps(Int_t inode) const;	virtual void FindOverlaps(Int_t inode) const;
	Bool_t IsInvalid() const {return TObject::TestBit(kGeoInval idVoxels);}	Bool_t IsInvalid() const {return TObject::TestBit(kGeoInval idVoxels);}
	Bool_t NeedRebuild() const {return TObject::TestBit(kGeoReb uildVoxels);}	Bool_t NeedRebuild() const {return TObject::TestBit(kGeoReb uildVoxels);}
	Double_t *GetBoxes() const {return fBoxes;}	Double_t *GetBoxes() const {return fBoxes;}

	Bool_t IsSafeVoxel(Double_t *point, Int_t inode, Double_t m insafe) const;	Bool_t IsSafeVoxel(const Double_t *point, Int_t inode, Doub le_t minsafe) const;
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;

	void PrintVoxelLimits(Double_t *point) const;	void PrintVoxelLimits(const Double_t *point) const;
	void SetInvalid(Bool_t flag=kTRUE) {TObject::SetBit(kGeoI nvalidVoxels, flag);}	void SetInvalid(Bool_t flag=kTRUE) {TObject::SetBit(kGeoI nvalidVoxels, flag);}
	void SetNeedRebuild(Bool_t flag=kTRUE) {TObject::SetBit(k GeoRebuildVoxels, flag);}	void SetNeedRebuild(Bool_t flag=kTRUE) {TObject::SetBit(k GeoRebuildVoxels, flag);}

	virtual Int_t GetNextVoxel(Double_t point, Double_t *dir, Int_t &	virtual Int_t GetNextVoxel(const Double_t point, const Double_t *
	ncheck, TGeoStateInfo &td);	dir, Int_t &ncheck, TGeoStateInfo &td);
	virtual void SortCrossedVoxels(Double_t point, Double_t dir, TG	virtual void SortCrossedVoxels(const Double_t *point, const Doubl
	eoStateInfo &td);	e_t *dir, TGeoStateInfo &td);
	virtual void Voxelize(Option_t *option="");	virtual void Voxelize(Option_t *option="");

	ClassDef(TGeoVoxelFinder, 4) // voxel finder class	ClassDef(TGeoVoxelFinder, 4) // voxel finder class
	};	};

	#endif	#endif

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

	TGraph2D.h	TGraph2D.h

	skipping to change at line 115	skipping to change at line 115
	TList *GetContourList(Double_t contour);	TList *GetContourList(Double_t contour);
	TDirectory *GetDirectory() const {return fDirectory;}	TDirectory *GetDirectory() const {return fDirectory;}
	Int_t GetNpx() const {return fNpx;}	Int_t GetNpx() const {return fNpx;}
	Int_t GetNpy() const {return fNpy;}	Int_t GetNpy() const {return fNpy;}
	TH2D GetHistogram(Option_t option="");	TH2D GetHistogram(Option_t option="");
	TList *GetListOfFunctions() const { return fFunctions; }	TList *GetListOfFunctions() const { return fFunctions; }
	virtual Double_t GetErrorX(Int_t bin) const;	virtual Double_t GetErrorX(Int_t bin) const;
	virtual Double_t GetErrorY(Int_t bin) const;	virtual Double_t GetErrorY(Int_t bin) const;
	virtual Double_t GetErrorZ(Int_t bin) const;	virtual Double_t GetErrorZ(Int_t bin) const;
	Double_t GetMargin() const {return fMargin;}	Double_t GetMargin() const {return fMargin;}

		Double_t GetMaximum() const {return fMaximum;};
		Double_t GetMinimum() const {return fMinimum;};
	TAxis *GetXaxis() const ;	TAxis *GetXaxis() const ;
	TAxis *GetYaxis() const ;	TAxis *GetYaxis() const ;
	TAxis *GetZaxis() const ;	TAxis *GetZaxis() const ;
	Int_t GetN() const {return fNpoints;}	Int_t GetN() const {return fNpoints;}
	Double_t *GetX() const {return fX;}	Double_t *GetX() const {return fX;}
	Double_t *GetY() const {return fY;}	Double_t *GetY() const {return fY;}
	Double_t *GetZ() const {return fZ;}	Double_t *GetZ() const {return fZ;}
	virtual Double_t *GetEX() const {return 0;}	virtual Double_t *GetEX() const {return 0;}
	virtual Double_t *GetEY() const {return 0;}	virtual Double_t *GetEY() const {return 0;}
	virtual Double_t *GetEZ() const {return 0;}	virtual Double_t *GetEZ() const {return 0;}

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

	TH2Poly.h	TH2Poly.h

	skipping to change at line 119	skipping to change at line 119
	Double_t GetMaximum(Double_t maxval) const;	Double_t GetMaximum(Double_t maxval) const;
	Double_t GetMinimum() const;	Double_t GetMinimum() const;
	Double_t GetMinimum(Double_t minval) const;	Double_t GetMinimum(Double_t minval) const;
	Bool_t GetNewBinAdded() const{return fNewBinAdded;}	Bool_t GetNewBinAdded() const{return fNewBinAdded;}
	Int_t GetNumberOfBins() const{return fNcells;}	Int_t GetNumberOfBins() const{return fNcells;}
	void Honeycomb(Double_t xstart, Double_t ystart, Double_t a, Int _t k, Int_t s); // Bins the histogram using a honeycomb structure	void Honeycomb(Double_t xstart, Double_t ystart, Double_t a, Int _t k, Int_t s); // Bins the histogram using a honeycomb structure
	Double_t Integral(Option_t* option = "") const;	Double_t Integral(Option_t* option = "") const;
	Double_t Integral(Int_t, Int_t, const Option_t*) const{return 0;} //MayNotUse	Double_t Integral(Int_t, Int_t, const Option_t*) const{return 0;} //MayNotUse
	Double_t Integral(Int_t, Int_t, Int_t, Int_t, const Option_t*) const {return 0;} //MayNotUse	Double_t Integral(Int_t, Int_t, Int_t, Int_t, const Option_t*) const {return 0;} //MayNotUse
	Double_t Integral(Int_t, Int_t, Int_t, Int_t, Int_t, Int_t, const Op tion_t*) const{return 0;} //MayNotUse	Double_t Integral(Int_t, Int_t, Int_t, Int_t, Int_t, Int_t, const Op tion_t*) const{return 0;} //MayNotUse

		Long64_t Merge(TCollection *);
	void Reset(Option_t *option);	void Reset(Option_t *option);
	void SavePrimitive(ostream& out, Option_t* option = "");	void SavePrimitive(ostream& out, Option_t* option = "");
	void SetBinContent(Int_t bin, Double_t content);	void SetBinContent(Int_t bin, Double_t content);
	void SetBinContent(Int_t, Int_t, Double_t){return;} // MayNotUse	void SetBinContent(Int_t, Int_t, Double_t){return;} // MayNotUse
	void SetBinContent(Int_t, Int_t, Int_t, Double_t){return;} // MayNotUse	void SetBinContent(Int_t, Int_t, Int_t, Double_t){return;} // MayNotUse
	void SetBinContentChanged(Bool_t flag){fBinContentChanged = flag ;}	void SetBinContentChanged(Bool_t flag){fBinContentChanged = flag ;}
	void SetFloat(Bool_t flag = true);	void SetFloat(Bool_t flag = true);
	void SetNewBinAdded(Bool_t flag){fNewBinAdded = flag;}	void SetNewBinAdded(Bool_t flag){fNewBinAdded = flag;}

	protected:	protected:

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

	TInterpreter.h	TInterpreter.h

	skipping to change at line 154	skipping to change at line 154
	virtual void Setgvp(Long_t) const {;}	virtual void Setgvp(Long_t) const {;}
	virtual void SetRTLD_NOW() const {;}	virtual void SetRTLD_NOW() const {;}
	virtual void SetRTLD_LAZY() const {;}	virtual void SetRTLD_LAZY() const {;}
	virtual void SetTempLevel(int /* val */) const {;}	virtual void SetTempLevel(int /* val */) const {;}
	virtual int UnloadFile(const char * /* path */) const {return 0;}	virtual int UnloadFile(const char * /* path */) const {return 0;}

	// G__CallFunc interface	// G__CallFunc interface
	virtual void CallFunc_Delete(void * /* func */) const {;}	virtual void CallFunc_Delete(void * /* func */) const {;}
	virtual void CallFunc_Exec(CallFunc_t * /* func /, void /* address */) const {;}	virtual void CallFunc_Exec(CallFunc_t * /* func /, void /* address */) const {;}
	virtual Long_t CallFunc_ExecInt(CallFunc_t * /* func /, void /* ad dress */) const {return 0;}	virtual Long_t CallFunc_ExecInt(CallFunc_t * /* func /, void /* ad dress */) const {return 0;}

	virtual Long_t CallFunc_ExecInt64(CallFunc_t * /* func /, void /* address */) const {return 0;}	virtual Long64_t CallFunc_ExecInt64(CallFunc_t * /* func /, void /* address */) const {return 0;}
	virtual Double_t CallFunc_ExecDouble(CallFunc_t * /* func /, void /* address */) const {return 0;}	virtual Double_t CallFunc_ExecDouble(CallFunc_t * /* func /, void /* address */) const {return 0;}
	virtual CallFunc_t *CallFunc_Factory() const {return 0;}	virtual CallFunc_t *CallFunc_Factory() const {return 0;}
	virtual CallFunc_t CallFunc_FactoryCopy(CallFunc_t /* func */) cons t {return 0;}	virtual CallFunc_t CallFunc_FactoryCopy(CallFunc_t /* func */) cons t {return 0;}
	virtual MethodInfo_t CallFunc_FactoryMethod(CallFunc_t /* func */) co nst {return 0;}	virtual MethodInfo_t CallFunc_FactoryMethod(CallFunc_t /* func */) co nst {return 0;}
	virtual void CallFunc_Init(CallFunc_t * /* func */) const {;}	virtual void CallFunc_Init(CallFunc_t * /* func */) const {;}
	virtual Bool_t CallFunc_IsValid(CallFunc_t * /* func */) const {return 0 ;}	virtual Bool_t CallFunc_IsValid(CallFunc_t * /* func */) const {return 0 ;}
	virtual void CallFunc_ResetArg(CallFunc_t * /* func */) const {;}	virtual void CallFunc_ResetArg(CallFunc_t * /* func */) const {;}
	virtual void CallFunc_SetArg(CallFunc_t * /func /, Long_t /* param * /) const {;}	virtual void CallFunc_SetArg(CallFunc_t * /func /, Long_t /* param * /) const {;}
	virtual void CallFunc_SetArg(CallFunc_t * /* func /, Double_t / para m */) const {;}	virtual void CallFunc_SetArg(CallFunc_t * /* func /, Double_t / para m */) const {;}
	virtual void CallFunc_SetArg(CallFunc_t * /* func /, Long64_t / para m */) const {;}	virtual void CallFunc_SetArg(CallFunc_t * /* func /, Long64_t / para m */) const {;}

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

	TProofLog.h	TProofLog.h

	// @(#)root/proof:$Id$	// @(#)root/proof:$Id: 5d579564fccbadad9cd6f81ccb7726dddea80e0d $
	// Author: G. Ganis 31/08/06	// Author: G. Ganis 31/08/06

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


	skipping to change at line 66	skipping to change at line 66
	enum ERetrieveOpt { kLeading = 0x1, kTrailing = 0x2,	enum ERetrieveOpt { kLeading = 0x1, kTrailing = 0x2,
	kAll = 0x3, kGrep = 0x4 };	kAll = 0x3, kGrep = 0x4 };

	TProofLog(const char stag, const char url, TProofMgr *mgr);	TProofLog(const char stag, const char url, TProofMgr *mgr);
	virtual ~TProofLog();	virtual ~TProofLog();

	void Display(const char ord = "", Int_t from = -10, Int_t to = -1);	void Display(const char ord = "", Int_t from = -10, Int_t to = -1);
	TList *GetListOfLogs() const { return fElem; }	TList *GetListOfLogs() const { return fElem; }
	Int_t Grep(const char *txt, Int_t from = 0);	Int_t Grep(const char *txt, Int_t from = 0);
	void Print(Option_t *opt = 0) const;	void Print(Option_t *opt = 0) const;

	void Prt(const char *what);	void Prt(const char *what, Bool_t newline = kTRUE);
	Int_t Retrieve(const char ord = "",	Int_t Retrieve(const char ord = "",
	TProofLog::ERetrieveOpt opt = TProofLog::kTrailing,	TProofLog::ERetrieveOpt opt = TProofLog::kTrailing,
	const char fname = 0, const char pattern = 0);	const char fname = 0, const char pattern = 0);
	Int_t Save(const char ord = "", const char fname = 0, Option_t opt= "w");	Int_t Save(const char ord = "", const char fname = 0, Option_t opt= "w");

	TDatime StartTime() { return fStartTime; }	TDatime StartTime() { return fStartTime; }

	// Where to log	// Where to log
	void SetLogToBox(Bool_t lgbox = kFALSE) { SetBit(kLogToBox, lgbox); }	void SetLogToBox(Bool_t lgbox = kFALSE) { SetBit(kLogToBox, lgbox); }
	Bool_t LogToBox() { return (TestBit(kLogToBox)) ? kTRUE : kFALSE; }	Bool_t LogToBox() { return (TestBit(kLogToBox)) ? kTRUE : kFALSE; }

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

	TProofPlayer.h	TProofPlayer.h

	skipping to change at line 72	skipping to change at line 72
	class TVirtualPacketizer;	class TVirtualPacketizer;
	class TSlave;	class TSlave;
	class TEventIter;	class TEventIter;
	class TProofStats;	class TProofStats;
	class TMutex;	class TMutex;
	class TStatus;	class TStatus;
	class TTimer;	class TTimer;
	class THashList;	class THashList;
	class TH1;	class TH1;
	class TFile;	class TFile;

		class TStopwatch;

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

	class TProofPlayer : public TVirtualProofPlayer {	class TProofPlayer : public TVirtualProofPlayer {

	private:	private:
	TList *fAutoBins; // Map of min/max values by name for slaves	TList *fAutoBins; // Map of min/max values by name for slaves

	protected:	protected:
	TList *fInput; //-> list with input objects	TList *fInput; //-> list with input objects

	skipping to change at line 109	skipping to change at line 110
	TQueryResult *fQuery; //Instance of TQueryResult currently pro cessed	TQueryResult *fQuery; //Instance of TQueryResult currently pro cessed
	TQueryResult *fPreviousQuery; //Previous instance of TQueryResult proc essed	TQueryResult *fPreviousQuery; //Previous instance of TQueryResult proc essed
	Int_t fDrawQueries; //Number of Draw queries in the list	Int_t fDrawQueries; //Number of Draw queries in the list
	Int_t fMaxDrawQueries; //Max number of Draw queries kept	Int_t fMaxDrawQueries; //Max number of Draw queries kept

	TTimer *fStopTimer; //Timer associated with a stop request	TTimer *fStopTimer; //Timer associated with a stop request
	TMutex *fStopTimerMtx; //To protect the stop timer	TMutex *fStopTimerMtx; //To protect the stop timer

	TTimer *fDispatchTimer; //Dispatch pending events while process ing	TTimer *fDispatchTimer; //Dispatch pending events while process ing


		TTimer *fProcTimeTimer; //Notifies reaching of allowed max proc
		time
		TStopwatch *fProcTime; //Packet proc time

	TString fOutputFilePath; //Path to file with (partial) results o f the query	TString fOutputFilePath; //Path to file with (partial) results o f the query
	TFile *fOutputFile; //TFile object attached to fOutputFileP ath	TFile *fOutputFile; //TFile object attached to fOutputFileP ath
	Long_t fSaveMemThreshold; //Threshold for saving output to file	Long_t fSaveMemThreshold; //Threshold for saving output to file
	Bool_t fSavePartialResults; //Whether to save the partial results	Bool_t fSavePartialResults; //Whether to save the partial results
	Bool_t fSaveResultsPerPacket; //Whether to save partial results a fter each packet	Bool_t fSaveResultsPerPacket; //Whether to save partial results a fter each packet

	static THashList *fgDrawInputPars; // List of input parameters to be ke pt on drawing actions	static THashList *fgDrawInputPars; // List of input parameters to be ke pt on drawing actions

	void *GetSender() { return this; } //used to set gTQSender	void *GetSender() { return this; } //used to set gTQSender


	skipping to change at line 143	skipping to change at line 147
	TCleanup(TProofPlayer *p) : fPlayer(p) { }	TCleanup(TProofPlayer *p) : fPlayer(p) { }
	~TCleanup() { fPlayer->StopFeedback(); }	~TCleanup() { fPlayer->StopFeedback(); }
	};	};

	Int_t AssertSelector(const char *selector_file);	Int_t AssertSelector(const char *selector_file);
	Bool_t CheckMemUsage(Long64_t &mfreq, Bool_t &w80r, Bool_t &w80v, TStrin g &wmsg);	Bool_t CheckMemUsage(Long64_t &mfreq, Bool_t &w80r, Bool_t &w80v, TStrin g &wmsg);

	void MapOutputListToDataMembers() const;	void MapOutputListToDataMembers() const;

	public:	public:

	enum EStatusBits { kDispatchOneEvent = BIT(15), kIsProcessing = BIT(16)	enum EStatusBits { kDispatchOneEvent = BIT(15), kIsProcessing = BIT(16),
	};	kMaxProcTimeReached = BIT(17), kMaxProcTimeExtended =
		BIT(18) };

	TProofPlayer(TProof *proof = 0);	TProofPlayer(TProof *proof = 0);
	virtual ~TProofPlayer();	virtual ~TProofPlayer();

	Long64_t Process(TDSet *set,	Long64_t Process(TDSet *set,
	const char selector, Option_t option = "",	const char selector, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0);	Long64_t nentries = -1, Long64_t firstentry = 0);
	Long64_t Process(TDSet *set,	Long64_t Process(TDSet *set,
	TSelector selector, Option_t option = "",	TSelector selector, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0);	Long64_t nentries = -1, Long64_t firstentry = 0);

		virtual Bool_t JoinProcess(TList *workers);
	TVirtualPacketizer *GetPacketizer() const { return 0; }	TVirtualPacketizer *GetPacketizer() const { return 0; }
	Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);	Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);
	Long64_t Finalize(TQueryResult *qr);	Long64_t Finalize(TQueryResult *qr);
	Long64_t DrawSelect(TDSet set, const char varexp,	Long64_t DrawSelect(TDSet set, const char varexp,
	const char selection, Option_t option = "",	const char selection, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0);	Long64_t nentries = -1, Long64_t firstentry = 0);
	Int_t GetDrawArgs(const char var, const char sel, Option_t *opt,	Int_t GetDrawArgs(const char var, const char sel, Option_t *opt,
	TString &selector, TString &objname);	TString &selector, TString &objname);
	void HandleGetTreeHeader(TMessage *mess);	void HandleGetTreeHeader(TMessage *mess);
	void HandleRecvHisto(TMessage *mess);	void HandleRecvHisto(TMessage *mess);

	skipping to change at line 296	skipping to change at line 302
	TProof *fProof; // link to associated PROOF session	TProof *fProof; // link to associated PROOF session
	TList *fOutputLists; // results returned by slaves	TList *fOutputLists; // results returned by slaves
	TList *fFeedback; // reference for use on master	TList *fFeedback; // reference for use on master
	TList *fFeedbackLists; // intermediate results	TList *fFeedbackLists; // intermediate results
	TVirtualPacketizer *fPacketizer; // transform TDSet into packets for slaves	TVirtualPacketizer *fPacketizer; // transform TDSet into packets for slaves
	Bool_t fMergeFiles; // is True when merging output files centrally is needed	Bool_t fMergeFiles; // is True when merging output files centrally is needed
	TDSet *fDSet; //!tdset for current processing	TDSet *fDSet; //!tdset for current processing
	ErrorHandlerFunc_t fErrorHandler; // Store previous handler when redir ecting output	ErrorHandlerFunc_t fErrorHandler; // Store previous handler when redir ecting output
	Bool_t fMergeTH1OneByOne; // If kTRUE forces TH1 merge one -by-one [kTRUE]	Bool_t fMergeTH1OneByOne; // If kTRUE forces TH1 merge one -by-one [kTRUE]
	TH1 *fProcPackets; //!Histogram with packets being pro cessed (owned by TPerfStats)	TH1 *fProcPackets; //!Histogram with packets being pro cessed (owned by TPerfStats)

		TMessage *fProcessMessage; // Process message to replay when
		adding new workers dynamically
		TString fSelectorFileName; // Current Selector's name, set
		by Process()

	virtual Bool_t HandleTimer(TTimer *timer);	virtual Bool_t HandleTimer(TTimer *timer);
	Int_t InitPacketizer(TDSet *dset, Long64_t nentries,	Int_t InitPacketizer(TDSet *dset, Long64_t nentries,
	Long64_t first, const char *defpackunit,	Long64_t first, const char *defpackunit,
	const char *defpackdata);	const char *defpackdata);
	TList *MergeFeedback();	TList *MergeFeedback();
	Bool_t MergeOutputFiles();	Bool_t MergeOutputFiles();
	void NotifyMemory(TObject *obj);	void NotifyMemory(TObject *obj);
	void SetLastMergingMsg(TObject *obj);	void SetLastMergingMsg(TObject *obj);
	virtual Bool_t SendSelector(const char *selector_file); //send selector to slaves	virtual Bool_t SendSelector(const char *selector_file); //send selector to slaves
	TProof *GetProof() const { return fProof; }	TProof *GetProof() const { return fProof; }
	void SetupFeedback(); // specialized setup	void SetupFeedback(); // specialized setup
	void StopFeedback(); // specialized teardown	void StopFeedback(); // specialized teardown
	void SetSelectorDataMembersFromOutputList();	void SetSelectorDataMembersFromOutputList();

	public:	public:
	TProofPlayerRemote(TProof *proof = 0) : fProof(proof), fOutputLists(0), fFeedback(0),	TProofPlayerRemote(TProof *proof = 0) : fProof(proof), fOutputLists(0), fFeedback(0),
	fFeedbackLists(0), fPacketizer(0 ),	fFeedbackLists(0), fPacketizer(0 ),
	fMergeFiles(kFALSE), fDSet(0), f ErrorHandler(0),	fMergeFiles(kFALSE), fDSet(0), f ErrorHandler(0),

	fMergeTH1OneByOne(kTRUE), fProcP	fMergeTH1OneByOne(kTRUE), fProcP
	ackets(0)	ackets(0),
		fProcessMessage(0)
	{ fProgressStatus = new TProofPr ogressStatus(); }	{ fProgressStatus = new TProofPr ogressStatus(); }
	virtual ~TProofPlayerRemote(); // Owns the fOutput list	virtual ~TProofPlayerRemote(); // Owns the fOutput list
	virtual Long64_t Process(TDSet set, const char selector,	virtual Long64_t Process(TDSet set, const char selector,
	Option_t *option = "", Long64_t nentries = -1,	Option_t *option = "", Long64_t nentries = -1,
	Long64_t firstentry = 0);	Long64_t firstentry = 0);
	virtual Long64_t Process(TDSet set, TSelector selector,	virtual Long64_t Process(TDSet set, TSelector selector,
	Option_t *option = "", Long64_t nentries = -1,	Option_t *option = "", Long64_t nentries = -1,
	Long64_t firstentry = 0);	Long64_t firstentry = 0);

		virtual Bool_t JoinProcess(TList *workers);
	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);
	virtual Long64_t Finalize(TQueryResult *qr);	virtual Long64_t Finalize(TQueryResult *qr);
	Long64_t DrawSelect(TDSet set, const char varexp,	Long64_t DrawSelect(TDSet set, const char varexp,
	const char selection, Option_t option = "",	const char selection, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0);	Long64_t nentries = -1, Long64_t firstentry = 0);

	void RedirectOutput(Bool_t on = kTRUE);	void RedirectOutput(Bool_t on = kTRUE);
	void StopProcess(Bool_t abort, Int_t timeout = -1);	void StopProcess(Bool_t abort, Int_t timeout = -1);
	void StoreOutput(TList *out); // Adopts the list	void StoreOutput(TList *out); // Adopts the list
	virtual void StoreFeedback(TObject slave, TList out); // Adopts the list	virtual void StoreFeedback(TObject slave, TList out); // Adopts the list

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

	TStreamerElement.h	TStreamerElement.h

	// @(#)root/meta:$Id$	// @(#)root/meta:$Id: e0eac11e63ad37390c9467c97c5c6849c4ab7d39 $
	// 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 92	skipping to change at line 92
	virtual const char *GetFullName() const;	virtual const char *GetFullName() const;
	virtual const char *GetInclude() const {return "";}	virtual const char *GetInclude() const {return "";}
	Int_t GetMaxIndex(Int_t i) const {return fMaxIndex[i];}	Int_t GetMaxIndex(Int_t i) const {return fMaxIndex[i];}
	virtual ULong_t GetMethod() const {return ULong_t(fStreamer);}	virtual ULong_t GetMethod() const {return ULong_t(fStreamer);}
	TMemberStreamer *GetStreamer() const;	TMemberStreamer *GetStreamer() const;
	virtual Int_t GetSize() const;	virtual Int_t GetSize() const;
	Int_t GetNewType() const {return fNewType;}	Int_t GetNewType() const {return fNewType;}
	TClass* GetNewClass() const { return fNewClass; }	TClass* GetNewClass() const { return fNewClass; }
	Int_t GetType() const {return fType;}	Int_t GetType() const {return fType;}
	Int_t GetOffset() const {return fOffset;}	Int_t GetOffset() const {return fOffset;}

		void GetSequenceType(TString &type) const;
	Int_t GetTObjectOffset() const { return fTObjectOffset; }	Int_t GetTObjectOffset() const { return fTObjectOffset; }
	const char *GetTypeName() const {return fTypeName.Data();}	const char *GetTypeName() const {return fTypeName.Data();}
	const char *GetTypeNameBasic() const;	const char *GetTypeNameBasic() const;
	Double_t GetFactor() const {return fFactor;}	Double_t GetFactor() const {return fFactor;}
	Double_t GetXmin() const {return fXmin;}	Double_t GetXmin() const {return fXmin;}
	Double_t GetXmax() const {return fXmax;}	Double_t GetXmax() const {return fXmax;}
	virtual void Init(TObject *obj=0);	virtual void Init(TObject *obj=0);
	virtual Bool_t IsaPointer() const {return kFALSE;}	virtual Bool_t IsaPointer() const {return kFALSE;}
	virtual Bool_t HasCounter() const {return kFALSE;}	virtual Bool_t HasCounter() const {return kFALSE;}
	virtual Bool_t IsOldFormat(const char *newTypeName);	virtual Bool_t IsOldFormat(const char *newTypeName);

	skipping to change at line 364	skipping to change at line 365

	protected:	protected:
	Int_t fSTLtype; //type of STL vector	Int_t fSTLtype; //type of STL vector
	Int_t fCtype; //STL contained type	Int_t fCtype; //STL contained type

	public:	public:

	TStreamerSTL();	TStreamerSTL();
	TStreamerSTL(const char name, const char title, Int_t offset,	TStreamerSTL(const char name, const char title, Int_t offset,
	const char typeName, const char trueType, Bool_t dmPointe r);	const char typeName, const char trueType, Bool_t dmPointe r);

		TStreamerSTL(const char name, const char title, Int_t offset,
		const char *typeName, const TVirtualCollectionProxy &proxy
		, Bool_t dmPointer);
	virtual ~TStreamerSTL();	virtual ~TStreamerSTL();
	Bool_t CannotSplit() const;	Bool_t CannotSplit() const;
	Bool_t IsaPointer() const;	Bool_t IsaPointer() const;
	Bool_t IsBase() const;	Bool_t IsBase() const;
	Int_t GetSTLtype() const {return fSTLtype;}	Int_t GetSTLtype() const {return fSTLtype;}
	Int_t GetCtype() const {return fCtype;}	Int_t GetCtype() const {return fCtype;}
	const char *GetInclude() const;	const char *GetInclude() const;
	Int_t GetSize() const;	Int_t GetSize() const;
	virtual void ls(Option_t *option="") const;	virtual void ls(Option_t *option="") const;
	void SetSTLtype(Int_t t) {fSTLtype = t;}	void SetSTLtype(Int_t t) {fSTLtype = t;}

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

	TStyle.h	TStyle.h

	// @(#)root/base:$Id$	// @(#)root/base:$Id: 5214d7dc2746ceb518366bc6c4f4068b652d5241 $
	// Author: Rene Brun 12/12/94	// Author: Rene Brun 12/12/94

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 371	skipping to change at line 371
	void SetHistFillColor(Color_t color=1) {fHistFillColor = col or;}	void SetHistFillColor(Color_t color=1) {fHistFillColor = col or;}
	void SetHistLineColor(Color_t color=1) {fHistLineColor = col or;}	void SetHistLineColor(Color_t color=1) {fHistLineColor = col or;}
	void SetHistFillStyle(Style_t styl=0) {fHistFillStyle = sty l;}	void SetHistFillStyle(Style_t styl=0) {fHistFillStyle = sty l;}
	void SetHistLineStyle(Style_t styl=0) {fHistLineStyle = sty l;}	void SetHistLineStyle(Style_t styl=0) {fHistLineStyle = sty l;}
	void SetHistLineWidth(Width_t width=1) {fHistLineWidth = wid th;}	void SetHistLineWidth(Width_t width=1) {fHistLineWidth = wid th;}
	void SetHistMinimumZero(Bool_t zero=kTRUE);	void SetHistMinimumZero(Bool_t zero=kTRUE);
	void SetHistTopMargin(Double_t hmax=0.05) {fHistTopMargin = hmax;}	void SetHistTopMargin(Double_t hmax=0.05) {fHistTopMargin = hmax;}
	void SetPaintTextFormat(const char *format="g") {fPaintTextF ormat = format;}	void SetPaintTextFormat(const char *format="g") {fPaintTextF ormat = format;}
	void SetPaperSize(EPaperSize size);	void SetPaperSize(EPaperSize size);
	void SetPaperSize(Float_t xsize=20, Float_t ysize=26);	void SetPaperSize(Float_t xsize=20, Float_t ysize=26);

	void SetStatColor(Int_t color=19) {fStatColor=color;}	void SetStatColor(Color_t color=19) {fStatColor=color;}
	void SetStatTextColor(Int_t color=1) {fStatTextColor=color;}	void SetStatTextColor(Color_t color=1) {fStatTextColor=color
		;}
	void SetStatStyle(Style_t style=1001) {fStatStyle=style;}	void SetStatStyle(Style_t style=1001) {fStatStyle=style;}
	void SetStatBorderSize(Width_t size=2) {fStatBorderSize=size ;}	void SetStatBorderSize(Width_t size=2) {fStatBorderSize=size ;}
	void SetStatFont(Style_t font=62) {fStatFont=font;}	void SetStatFont(Style_t font=62) {fStatFont=font;}
	void SetStatFontSize(Float_t size=0) {fStatFontSize=size;}	void SetStatFontSize(Float_t size=0) {fStatFontSize=size;}
	void SetStatFormat(const char *format="6.4g") {fStatFormat = format;}	void SetStatFormat(const char *format="6.4g") {fStatFormat = format;}
	void SetStatX(Float_t x=0) {fStatX=x;}	void SetStatX(Float_t x=0) {fStatX=x;}
	void SetStatY(Float_t y=0) {fStatY=y;}	void SetStatY(Float_t y=0) {fStatY=y;}
	void SetStatW(Float_t w=0.19) {fStatW=w;}	void SetStatW(Float_t w=0.19) {fStatW=w;}
	void SetStatH(Float_t h=0.1) {fStatH=h;}	void SetStatH(Float_t h=0.1) {fStatH=h;}
	void SetStripDecimals(Bool_t strip=kTRUE);	void SetStripDecimals(Bool_t strip=kTRUE);

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

	TVirtualPS.h	TVirtualPS.h

	skipping to change at line 77	skipping to change at line 77
	virtual void DrawPS(Int_t n, Double_t xw, Double_t yw) = 0;	virtual void DrawPS(Int_t n, Double_t xw, Double_t yw) = 0;
	virtual void NewPage() = 0;	virtual void NewPage() = 0;
	virtual void Open(const char *filename, Int_t type=-111) = 0;	virtual void Open(const char *filename, Int_t type=-111) = 0;
	virtual void Text(Double_t x, Double_t y, const char *string) = 0;	virtual void Text(Double_t x, Double_t y, const char *string) = 0;
	virtual void Text(Double_t x, Double_t y, const wchar_t *string) = 0;	virtual void Text(Double_t x, Double_t y, const wchar_t *string) = 0;
	virtual void SetColor(Float_t r, Float_t g, Float_t b) = 0;	virtual void SetColor(Float_t r, Float_t g, Float_t b) = 0;

	virtual void PrintFast(Int_t nch, const char *string="");	virtual void PrintFast(Int_t nch, const char *string="");
	virtual void PrintStr(const char *string="");	virtual void PrintStr(const char *string="");
	virtual void WriteInteger(Int_t i, Bool_t space=kTRUE);	virtual void WriteInteger(Int_t i, Bool_t space=kTRUE);

	virtual void WriteReal(Float_t r);	virtual void WriteReal(Float_t r, Bool_t space=kTRUE);
	virtual void PrintRaw(Int_t len, const char *str);	virtual void PrintRaw(Int_t len, const char *str);
	virtual void GetStream() const { return (void)fStream; }	virtual void GetStream() const { return (void)fStream; }
	virtual void SetStream(std::ofstream *os) { fStream = os; }	virtual void SetStream(std::ofstream *os) { fStream = os; }

	virtual void SetType(Int_t /type/ = -111) { }	virtual void SetType(Int_t /type/ = -111) { }
	virtual Int_t GetType() const { return 111; }	virtual Int_t GetType() const { return 111; }

	ClassDef(TVirtualPS,0) //Abstract interface to a PostScript driver	ClassDef(TVirtualPS,0) //Abstract interface to a PostScript driver
	};	};


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

	TVirtualPacketizer.h	TVirtualPacketizer.h

	skipping to change at line 133	skipping to change at line 133
	Long64_t GetEntriesProcessed() const { return (fProgressS tatus? fProgressStatus->GetEntries() : 0); }	Long64_t GetEntriesProcessed() const { return (fProgressS tatus? fProgressStatus->GetEntries() : 0); }
	virtual Int_t GetEstEntriesProcessed(Float_t, Long64_t &ent, L ong64_t &bytes, Long64_t &calls)	virtual Int_t GetEstEntriesProcessed(Float_t, Long64_t &ent, L ong64_t &bytes, Long64_t &calls)
	{ ent = GetEntriesProcessed(); bytes = GetBytesR ead(); calls = GetReadCalls(); return 0; }	{ ent = GetEntriesProcessed(); bytes = GetBytesR ead(); calls = GetReadCalls(); return 0; }
	virtual Float_t GetCurrentRate(Bool_t &all) { all = kTRUE; retur n (fProgressStatus? fProgressStatus->GetCurrentRate() : 0.); }	virtual Float_t GetCurrentRate(Bool_t &all) { all = kTRUE; retur n (fProgressStatus? fProgressStatus->GetCurrentRate() : 0.); }
	Long64_t GetTotalEntries() const { return fTotalEntries; }	Long64_t GetTotalEntries() const { return fTotalEntries; }
	virtual TDSetElement GetNextPacket(TSlave sl, TMessage *r);	virtual TDSetElement GetNextPacket(TSlave sl, TMessage *r);
	virtual void SetInitTime();	virtual void SetInitTime();
	virtual void StopProcess(Bool_t abort, Bool_t stoptimer = kFA LSE);	virtual void StopProcess(Bool_t abort, Bool_t stoptimer = kFA LSE);
	TList *GetFailedPackets() { return fFailedPackets; }	TList *GetFailedPackets() { return fFailedPackets; }
	void SetFailedPackets(TList *list) { fFailedPackets = list; }	void SetFailedPackets(TList *list) { fFailedPackets = list; }

		virtual Int_t AddWorkers(TList *workers);

	Long64_t GetBytesRead() const { return (fProgressStatus? fProgressS tatus->GetBytesRead() : 0); }	Long64_t GetBytesRead() const { return (fProgressStatus? fProgressS tatus->GetBytesRead() : 0); }
	Long64_t GetReadCalls() const { return (fProgressStatus? fProgressS tatus->GetReadCalls() : 0); }	Long64_t GetReadCalls() const { return (fProgressStatus? fProgressS tatus->GetReadCalls() : 0); }
	Double_t GetCumProcTime() const { return fProgressStatus->GetProcTi me(); }	Double_t GetCumProcTime() const { return fProgressStatus->GetProcTi me(); }
	Float_t GetInitTime() const { return fInitTime; }	Float_t GetInitTime() const { return fInitTime; }
	Float_t GetProcTime() const { return fProcTime; }	Float_t GetProcTime() const { return fProcTime; }
	TNtuple GetProgressPerf(Bool_t steal = kFALSE) { if (steal) { TNtu ple n = fProgressPerf; fProgressPerf = 0; return n;	TNtuple GetProgressPerf(Bool_t steal = kFALSE) { if (steal) { TNtu ple n = fProgressPerf; fProgressPerf = 0; return n;
	} else { re turn fProgressPerf;} }	} else { re turn fProgressPerf;} }
	TList GetConfigParams(Bool_t steal = kFALSE) { if (steal) { TLis t l = fConfigParams; fConfigParams = 0; return l;	TList GetConfigParams(Bool_t steal = kFALSE) { if (steal) { TLis t l = fConfigParams; fConfigParams = 0; return l;
	} else { re turn fConfigParams;} }	} else { re turn fConfigParams;} }

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

	TVirtualProofPlayer.h	TVirtualProofPlayer.h

	skipping to change at line 62	skipping to change at line 62

	TVirtualProofPlayer() { ResetBit(TVirtualProofPlayer::kIsSubmerger); }	TVirtualProofPlayer() { ResetBit(TVirtualProofPlayer::kIsSubmerger); }
	virtual ~TVirtualProofPlayer() { }	virtual ~TVirtualProofPlayer() { }

	virtual Long64_t Process(TDSet *set,	virtual Long64_t Process(TDSet *set,
	const char selector, Option_t option = "",	const char selector, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;
	virtual Long64_t Process(TDSet *set,	virtual Long64_t Process(TDSet *set,
	TSelector selector, Option_t option = "",	TSelector selector, Option_t option = "",
	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;

		virtual Bool_t JoinProcess(TList *workers) = 0;
	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE) = 0;	virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE) = 0;
	virtual Long64_t Finalize(TQueryResult *qr) = 0;	virtual Long64_t Finalize(TQueryResult *qr) = 0;
	virtual Long64_t DrawSelect(TDSet set, const char varexp,	virtual Long64_t DrawSelect(TDSet set, const char varexp,
	const char selection, Option_t option = " ",	const char selection, Option_t option = " ",
	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;	Long64_t nentries = -1, Long64_t firstentry = 0) = 0;
	virtual Int_t GetDrawArgs(const char var, const char sel, Option_t *opt,	virtual Int_t GetDrawArgs(const char var, const char sel, Option_t *opt,
	TString &selector, TString &objname) = 0;	TString &selector, TString &objname) = 0;
	virtual void HandleGetTreeHeader(TMessage *mess) = 0;	virtual void HandleGetTreeHeader(TMessage *mess) = 0;
	virtual void HandleRecvHisto(TMessage *mess) = 0;	virtual void HandleRecvHisto(TMessage *mess) = 0;


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