ROOT: headers diff between 5.33.02 and 5.34.00 versions

	AsymptoticCalculator.h	AsymptoticCalculator.h

	// @(#)root/roostats:$Id: AsymptoticCalculator.h 43189 2012-03-01 11:16:40Z moneta $	// @(#)root/roostats:$Id: AsymptoticCalculator.h 44269 2012-05-16 12:53:49Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_AsymptoticCalculator	#ifndef ROOSTATS_AsymptoticCalculator
	#define ROOSTATS_AsymptoticCalculator	#define ROOSTATS_AsymptoticCalculator

	skipping to change at line 65	skipping to change at line 65
	// genPoiValues is optionally a different set of POI values used for generating. By default the same POI are used for generating and for finding the nuisance parameters	// genPoiValues is optionally a different set of POI values used for generating. By default the same POI are used for generating and for finding the nuisance parameters
	static RooAbsData * MakeAsimovData( RooAbsData & data, const ModelCon fig & model, const RooArgSet & poiValues, RooArgSet & globObs, const RooAr gSet * genPoiValues = 0);	static RooAbsData * MakeAsimovData( RooAbsData & data, const ModelCon fig & model, const RooArgSet & poiValues, RooArgSet & globObs, const RooAr gSet * genPoiValues = 0);

	// make a nominal asimov data from the ModelConfig and parameter valu es	// make a nominal asimov data from the ModelConfig and parameter valu es
	// The parameter values (including the nunisance) could be given from a fit to data or be at the nominal values	// The parameter values (including the nunisance) could be given from a fit to data or be at the nominal values
	static RooAbsData * MakeAsimovData( const ModelConfig & model, const RooArgSet & allParamValues, RooArgSet & globObs);	static RooAbsData * MakeAsimovData( const ModelConfig & model, const RooArgSet & allParamValues, RooArgSet & globObs);

	static RooAbsData * GenerateAsimovData(const RooAbsPdf & pdf, const R ooArgSet & observables );	static RooAbsData * GenerateAsimovData(const RooAbsPdf & pdf, const R ooArgSet & observables );

	// function given the null and the alt p value - return the expected one given the N - sigma value	// function given the null and the alt p value - return the expected one given the N - sigma value

	static double GetExpectedPValues(double pnull, double palt, double ns	static double GetExpectedPValues(double pnull, double palt, double ns
	igma, bool usecls );	igma, bool usecls, bool oneSided = true );

	// get expected limit
	// static void GetExpectedLimit(double nsigma, double alpha, double &c
	lsblimit, double &clslimit);


		// set test statistic for one sided (upper limits)
	void SetOneSided(bool on) { fOneSided = on; }	void SetOneSided(bool on) { fOneSided = on; }


		// set the test statistics for two sided (in case of upper limits
		// for discovery does not make really sense)
		void SetTwoSided() { fOneSided = false; fOneSidedDiscovery = false;}

		// set the test statistics for one-sided discovery
		void SetOneSidedDiscovery(bool on) { fOneSidedDiscovery = on; }

		bool IsTwoSided() const { return (!fOneSided && !fOneSidedDiscovery);
		}
		bool IsOneSidedDiscovery() const { return fOneSidedDiscovery; }

	// set using of qtilde, by default is controlled if RoORealVar is lim ited or not	// set using of qtilde, by default is controlled if RoORealVar is lim ited or not
	void SetQTilde(bool on) { fUseQTilde = on; }	void SetQTilde(bool on) { fUseQTilde = on; }


		// return snapshot of the best fit parameter
		const RooArgSet & GetBestFitPoi() const { return fBestFitPoi; }
		// return best fit parameter (firs of poi)
		const RooRealVar * GetMuHat() const { return dynamic_cast<RooRealVar*
		>(fBestFitPoi.first()); }
		// return best fit value for all parameters
		const RooArgSet & GetBestFitParams() const { return fBestFitPoi; }

	static void SetPrintLevel(int level);	static void SetPrintLevel(int level);

	protected:	protected:
	// // configure TestStatSampler for the Null run	// // configure TestStatSampler for the Null run
	// int PreNullHook(RooArgSet *parameterPoint, double obsTestStat) con st;	// int PreNullHook(RooArgSet *parameterPoint, double obsTestStat) con st;

	// // configure TestStatSampler for the Alt run	// // configure TestStatSampler for the Alt run
	// int PreAltHook(RooArgSet *parameterPoint, double obsTestStat) cons t;	// int PreAltHook(RooArgSet *parameterPoint, double obsTestStat) cons t;

	static RooAbsData * GenerateAsimovDataSinglePdf(const RooAbsPdf & pdf , const RooArgSet & obs, const RooRealVar & weightVar,	static RooAbsData * GenerateAsimovDataSinglePdf(const RooAbsPdf & pdf , const RooArgSet & obs, const RooRealVar & weightVar,

	skipping to change at line 103	skipping to change at line 118
	static double EvaluateNLL(RooAbsPdf & pdf, RooAbsData& data, const Ro oArgSet *poiSet = 0);	static double EvaluateNLL(RooAbsPdf & pdf, RooAbsData& data, const Ro oArgSet *poiSet = 0);

	static bool SetObsToExpected(RooAbsPdf &pdf, const RooArgSet &obs);	static bool SetObsToExpected(RooAbsPdf &pdf, const RooArgSet &obs);
	static bool SetObsToExpected(RooProdPdf &prod, const RooArgSet &obs);	static bool SetObsToExpected(RooProdPdf &prod, const RooArgSet &obs);

	protected:	protected:
	ClassDef(AsymptoticCalculator,1)	ClassDef(AsymptoticCalculator,1)

	private:	private:


	bool fOneSided; // for one sided PL test statistic	bool fOneSided; // for one sided PL test statistic (up
	bool fNominalAsimov;	per limits)
		bool fOneSidedDiscovery; // for one sided PL test stat
		istic (for discovery)
	mutable int fUseQTilde; // flag to indicate if using qti lde or not (-1 (default based on RooRealVar)), 0 false, 1 (true)	mutable int fUseQTilde; // flag to indicate if using qti lde or not (-1 (default based on RooRealVar)), 0 false, 1 (true)
	static int fgPrintLevel; // control print level (0 minimal, 1 no rmal, 2 debug)	static int fgPrintLevel; // control print level (0 minimal, 1 no rmal, 2 debug)
	mutable double fNLLObs;	mutable double fNLLObs;
	mutable double fNLLAsimov;	mutable double fNLLAsimov;

	mutable RooAbsData * fAsimovData; // asimov data set	mutable RooAbsData * fAsimovData; // asimov data set
	RooArgSet fAsimovGlobObs; // snapshot of Asimov global observables	RooArgSet fAsimovGlobObs; // snapshot of Asimov global observables
	mutable RooArgSet fBestFitPoi; // snapshot of best fitted POI values	mutable RooArgSet fBestFitPoi; // snapshot of best fitted POI values
	mutable RooArgSet fBestFitParams; // snapshot of all best fitt ed Parameter values	mutable RooArgSet fBestFitParams; // snapshot of all best fitt ed Parameter values


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

	BayesianCalculator.h	BayesianCalculator.h

	// @(#)root/roostats:$Id: BayesianCalculator.h 39975 2011-06-26 22:49:46Z m oneta $	// @(#)root/roostats:$Id: BayesianCalculator.h 44073 2012-05-02 15:11:16Z m oneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_BayesianCalculator	#ifndef ROOSTATS_BayesianCalculator

	skipping to change at line 51	skipping to change at line 51
	class BayesianCalculator : public IntervalCalculator, public TNamed {	class BayesianCalculator : public IntervalCalculator, public TNamed {

	public:	public:

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

	BayesianCalculator( RooAbsData& data,	BayesianCalculator( RooAbsData& data,
	RooAbsPdf& pdf,	RooAbsPdf& pdf,
	const RooArgSet& POI,	const RooArgSet& POI,

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

	BayesianCalculator( RooAbsData& data,	BayesianCalculator( RooAbsData& data,
	ModelConfig& model );	ModelConfig& model );

	// destructor	// destructor
	virtual ~BayesianCalculator();	virtual ~BayesianCalculator();

	// get the plot with option to get it normalized	// get the plot with option to get it normalized
	RooPlot* GetPosteriorPlot(bool norm = false, double precision = 0.01) const;	RooPlot* GetPosteriorPlot(bool norm = false, double precision = 0.01) const;

	skipping to change at line 81	skipping to change at line 81
	virtual SimpleInterval* GetInterval() const ;	virtual SimpleInterval* GetInterval() const ;

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

	// set the model via the ModelConfig	// set the model via the ModelConfig
	virtual void SetModel( const ModelConfig& model );	virtual void SetModel( const ModelConfig& model );


		// specify the parameters of interest in the interval
		virtual void SetParameters(const RooArgSet& set) { fPOI.removeAll();
		fPOI.add(set); }

		// specify the nuisance parameters (eg. the rest of the parameters)
		virtual void SetNuisanceParameters(const RooArgSet& set) {fNuisancePa
		rameters.removeAll(); fNuisanceParameters.add(set);}

		// Set only the Prior Pdf
		virtual void SetPriorPdf(RooAbsPdf& pdf) { fPriorPdf = &pdf; }

	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)
	virtual void SetTestSize( Double_t size ) {	virtual void SetTestSize( Double_t size ) {
	fSize = size;	fSize = size;
	fValidInterval = false;	fValidInterval = false;
	}	}
	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)
	virtual void SetConfidenceLevel( Double_t cl ) { SetTestSize(1.-cl); }	virtual void SetConfidenceLevel( Double_t cl ) { SetTestSize(1.-cl); }
	// Get the size of the test (eg. rate of Type I error)	// Get the size of the test (eg. rate of Type I error)
	virtual Double_t Size() const { return fSize; }	virtual Double_t Size() const { return fSize; }
	// Get the Confidence level for the test	// Get the Confidence level for the test

	skipping to change at line 150	skipping to change at line 159

	private:	private:

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

	RooAbsData* fData; // data set	RooAbsData* fData; // data set
	RooAbsPdf* fPdf; // model pdf (could conta in the nuisance pdf as constraint term)	RooAbsPdf* fPdf; // model pdf (could conta in the nuisance pdf as constraint term)
	RooArgSet fPOI; // POI	RooArgSet fPOI; // POI

	RooAbsPdf* fPriorPOI; // prior pdf for POI	RooAbsPdf* fPriorPdf; // prior pdf (typically fo r the POI)
	RooAbsPdf* fNuisancePdf; // nuisance pdf (needed wh en using nuisance sampling technique)	RooAbsPdf* fNuisancePdf; // nuisance pdf (needed wh en using nuisance sampling technique)
	RooArgSet fNuisanceParameters;	RooArgSet fNuisanceParameters;

	mutable RooAbsPdf* fProductPdf; // internal pointer to m odel * prior	mutable RooAbsPdf* fProductPdf; // internal pointer to m odel * prior
	mutable RooAbsReal* fLogLike; // internal pointer to l og likelihood function	mutable RooAbsReal* fLogLike; // internal pointer to l og likelihood function
	mutable RooAbsReal* fLikelihood; // internal pointer to l ikelihood function	mutable RooAbsReal* fLikelihood; // internal pointer to l ikelihood function
	mutable RooAbsReal* fIntegratedLikelihood; // integrated likelihood function, i.e - unnormalized posterior function	mutable RooAbsReal* fIntegratedLikelihood; // integrated likelihood function, i.e - unnormalized posterior function
	mutable RooAbsPdf* fPosteriorPdf; // normalized (on the p oi) posterior pdf	mutable RooAbsPdf* fPosteriorPdf; // normalized (on the p oi) posterior pdf
	mutable ROOT::Math::IGenFunction * fPosteriorFunction; // function representing the posterior	mutable ROOT::Math::IGenFunction * fPosteriorFunction; // function representing the posterior
	mutable TF1 * fApproxPosterior; // TF1 representing the scanned po sterior function	mutable TF1 * fApproxPosterior; // TF1 representing the scanned po sterior function

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

	CallFunc.h	CallFunc.h

	skipping to change at line 52	skipping to change at line 52
	result(cf.result),	result(cf.result),
	#ifdef G__ASM_WHOLEFUNC	#ifdef G__ASM_WHOLEFUNC
	bytecode(cf.bytecode),	bytecode(cf.bytecode),
	#endif	#endif
	method(cf.method),	method(cf.method),
	para(cf.para)	para(cf.para)
	#endif /* __MAKECINT__ */	#endif /* __MAKECINT__ */
	{}	{}

	G__CallFunc& operator=(const G__CallFunc& cf) {	G__CallFunc& operator=(const G__CallFunc& cf) {

		if (&cf != this) {
	#ifndef __MAKECINT__	#ifndef __MAKECINT__

	pfunc=cf.pfunc;	pfunc=cf.pfunc;
	result=cf.result;	result=cf.result;
	#ifdef G__ASM_WHOLEFUNC	#ifdef G__ASM_WHOLEFUNC

	bytecode=cf.bytecode;	bytecode=cf.bytecode;
	#endif	#endif

	method=cf.method;	method=cf.method;
	para=cf.para;	para=cf.para;
	#endif /* __MAKECINT__ */	#endif /* __MAKECINT__ */

	return *this;}	}
		return *this;
		}

	void Init() ;	void Init() ;

	enum MatchMode { ExactMatch=0, ConversionMatch=1 };	enum MatchMode { ExactMatch=0, ConversionMatch=1 };
	void SetFunc(G__ClassInfo* cls,const char* fname,const char* args	void SetFunc(G__ClassInfo* cls,const char* fname,const char* args
	,long* poffset,MatchMode mode=ConversionMatch);	,long* poffset,MatchMode mode=ConversionMatch);
	void SetFuncProto(G__ClassInfo* cls,const char* fname,const char* argtype ,long* poffset);	void SetFuncProto(G__ClassInfo* cls,const char* fname,const char* argtype ,long* poffset);
	// begin old interface	// begin old interface
	void SetFunc(G__InterfaceMethod f);	void SetFunc(G__InterfaceMethod f);
	void SetFunc(G__MethodInfo m);	void SetFunc(G__MethodInfo m);

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

	Cintex.h	Cintex.h

	// @(#)root/cintex:$Id: Cintex.h 28276 2009-04-17 19:08:08Z pcanal $	// @(#)root/cintex:$Id: Cintex.h 44070 2012-05-02 14:46:38Z axel $
	// Author: Pere Mato 2005	// Author: Pere Mato 2005

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


	skipping to change at line 36	skipping to change at line 36

	class Callback : public ROOT::Reflex::ICallback {	class Callback : public ROOT::Reflex::ICallback {
	public:	public:
	virtual void operator () ( const ROOT::Reflex::Type& t );	virtual void operator () ( const ROOT::Reflex::Type& t );
	virtual void operator () ( const ROOT::Reflex::Member& m );	virtual void operator () ( const ROOT::Reflex::Member& m );
	};	};

	typedef TClass* (ROOTCreator_t)( ROOT::Reflex::Type, ROOT::TGenericCla ssInfo );	typedef TClass* (ROOTCreator_t)( ROOT::Reflex::Type, ROOT::TGenericCla ssInfo );

	class Cintex {	class Cintex {

		private:
		Cintex(const Cintex&); // not implemented
		Cintex& operator=(const Cintex&); // not implemented
	public:	public:
	Cintex();	Cintex();
	~Cintex();	~Cintex();
	static void Enable();	static void Enable();
	static void SetROOTCreator(ROOTCreator_t);	static void SetROOTCreator(ROOTCreator_t);
	static ROOTCreator_t GetROOTCreator();	static ROOTCreator_t GetROOTCreator();
	static int Debug();	static int Debug();
	static void SetDebug(int);	static void SetDebug(int);
	static bool PropagateClassTypedefs();	static bool PropagateClassTypedefs();
	static void SetPropagateClassTypedefs(bool);	static void SetPropagateClassTypedefs(bool);

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

	FastAllocString.h	FastAllocString.h

	skipping to change at line 89	skipping to change at line 89
	int FormatArgList(const char *fmt, va_list args);	int FormatArgList(const char *fmt, va_list args);
	int FormatArgList(size_t offset, const char *fmt, va_list args);	int FormatArgList(size_t offset, const char *fmt, va_list args);
	G__FastAllocString& Format(const char *fmt, ...);	G__FastAllocString& Format(const char *fmt, ...);
	G__FastAllocString& Format(size_t offset, const char *fmt, ...);	G__FastAllocString& Format(size_t offset, const char *fmt, ...);

	size_t Capacity() const { return fCapacity; }	size_t Capacity() const { return fCapacity; }

	G__FastAllocString& operator=(const G__FastAllocString& s) {	G__FastAllocString& operator=(const G__FastAllocString& s) {
	// Copy s into *this.	// Copy s into *this.
	// Cannot rely on operator=(const char*) overload - compiler-generate d one wins resolution!	// Cannot rely on operator=(const char*) overload - compiler-generate d one wins resolution!

	return operator=(s.data());	operator=(s.data());
		return *this;
	}	}
	G__FastAllocString& operator=(const char*);	G__FastAllocString& operator=(const char*);
	G__FastAllocString& operator+=(const char*);	G__FastAllocString& operator+=(const char*);
	G__FastAllocString& Swap(G__FastAllocString&);	G__FastAllocString& Swap(G__FastAllocString&);
	void Resize(size_t cap);	void Resize(size_t cap);

	void Set(size_t pos, char c) {	void Set(size_t pos, char c) {
	// Set character at position pos to c; resize if needed.	// Set character at position pos to c; resize if needed.
	Resize(pos + 1);	Resize(pos + 1);
	fBuf[pos] = c;	fBuf[pos] = c;

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

	FlexibleInterpVar.h	FlexibleInterpVar.h

	skipping to change at line 30	skipping to change at line 30

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

	class FlexibleInterpVar : public RooAbsReal {	class FlexibleInterpVar : public RooAbsReal {
	public:	public:

	FlexibleInterpVar() ;	FlexibleInterpVar() ;
	FlexibleInterpVar(const char name, const char title,	FlexibleInterpVar(const char name, const char title,
	const RooArgList& _paramList,	const RooArgList& _paramList,

	double nominal, vector<double> low, vector<double> hig h);	double nominal, std::vector<double> low, std::vector<d ouble> high);

	FlexibleInterpVar(const char name, const char title,	FlexibleInterpVar(const char name, const char title,

	const RooArgList& _paramList, double nominal, vector<d	const RooArgList& _paramList, double nominal, std::vec
	ouble> low,	tor<double> low,
	vector<double> high,vector<int> code);	std::vector<double> high,std::vector<int> code);

	FlexibleInterpVar(const char name, const char title);	FlexibleInterpVar(const char name, const char title);
	FlexibleInterpVar(const FlexibleInterpVar&, const char*);	FlexibleInterpVar(const FlexibleInterpVar&, const char*);

	void setInterpCode(RooAbsReal& param, int code);	void setInterpCode(RooAbsReal& param, int code);
	void setAllInterpCodes(int code);	void setAllInterpCodes(int code);

		void setGlobalBoundary(double boundary) {_interpBoundary = boundary;}

	void printAllInterpCodes();	void printAllInterpCodes();

	virtual TObject* clone(const char* newname) const { return new Flexible InterpVar(*this, newname); }	virtual TObject* clone(const char* newname) const { return new Flexible InterpVar(*this, newname); }
	virtual ~FlexibleInterpVar() ;	virtual ~FlexibleInterpVar() ;

	protected:	protected:

	RooListProxy _paramList ;	RooListProxy _paramList ;

	double _nominal;	Double_t _nominal;
	vector<double> _low;	std::vector<double> _low;
	vector<double> _high;	std::vector<double> _high;
	vector<int> _interpCode;	std::vector<int> _interpCode;
		Double_t _interpBoundary;

	TIterator* _paramIter ; //! do not persist	TIterator* _paramIter ; //! do not persist

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


	ClassDef(RooStats::HistFactory::FlexibleInterpVar,1) // flexible interp olation	ClassDef(RooStats::HistFactory::FlexibleInterpVar,2) // flexible interp olation
	};	};
	}	}
	}	}

	#endif	#endif

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

	FrequentistCalculator.h	FrequentistCalculator.h

	skipping to change at line 31	skipping to change at line 31
	//	//

	#ifndef ROOSTATS_HypoTestCalculatorGeneric	#ifndef ROOSTATS_HypoTestCalculatorGeneric
	#include "RooStats/HypoTestCalculatorGeneric.h"	#include "RooStats/HypoTestCalculatorGeneric.h"
	#endif	#endif

	#ifndef ROOSTATS_ToyMCSampler	#ifndef ROOSTATS_ToyMCSampler
	#include "RooStats/ToyMCSampler.h"	#include "RooStats/ToyMCSampler.h"
	#endif	#endif


		#ifndef ROOSTATS_DetailedOutputAggregator
		#include "RooStats/DetailedOutputAggregator.h"
		#endif

		#include "RooFitResult.h"

	namespace RooStats {	namespace RooStats {

	class FrequentistCalculator : public HypoTestCalculatorGeneric {	class FrequentistCalculator : public HypoTestCalculatorGeneric {

	public:	public:
	FrequentistCalculator(	FrequentistCalculator(
	const RooAbsData &data,	const RooAbsData &data,
	const ModelConfig &altModel,	const ModelConfig &altModel,
	const ModelConfig &nullModel,	const ModelConfig &nullModel,
	TestStatSampler* sampler=0	TestStatSampler* sampler=0
	) :	) :
	HypoTestCalculatorGeneric(data, altModel, nullModel, sampler),	HypoTestCalculatorGeneric(data, altModel, nullModel, sampler),
	fConditionalMLEsNull(NULL),	fConditionalMLEsNull(NULL),
	fConditionalMLEsAlt(NULL),	fConditionalMLEsAlt(NULL),
	fNToysNull(-1),	fNToysNull(-1),
	fNToysAlt(-1),	fNToysAlt(-1),
	fNToysNullTail(0),	fNToysNullTail(0),

	fNToysAltTail(0)	fNToysAltTail(0),
		fFitInfo(NULL),
		fStoreFitInfo(false)
	{	{
	}	}

	~FrequentistCalculator() {	~FrequentistCalculator() {
	if( fConditionalMLEsNull ) delete fConditionalMLEsNull;	if( fConditionalMLEsNull ) delete fConditionalMLEsNull;

	if( fConditionalMLEsAlt ) delete fConditionalMLEsAlt;	if( fConditionalMLEsAlt ) delete fConditionalMLEsAlt;
		if( fFitInfo ) delete fFitInfo;
	}	}

	// set number of toys	// set number of toys
	void SetToys(int toysNull, int toysAlt) { fNToysNull = toysNull; fNTo ysAlt = toysAlt; }	void SetToys(int toysNull, int toysAlt) { fNToysNull = toysNull; fNTo ysAlt = toysAlt; }

	// set least number of toys in tails	// set least number of toys in tails
	void SetNToysInTails(int toysNull, int toysAlt) { fNToysNullTail = to ysNull; fNToysAltTail = toysAlt; }	void SetNToysInTails(int toysNull, int toysAlt) { fNToysNullTail = to ysNull; fNToysAltTail = toysAlt; }

	// set given nuisance parameters to a specific value that will be use d instead of their	// set given nuisance parameters to a specific value that will be use d instead of their
	// profiled value for Null toys	// profiled value for Null toys

	skipping to change at line 81	skipping to change at line 90

	// set given nuisance parameters to a specific value that will be use d instead of their	// set given nuisance parameters to a specific value that will be use d instead of their
	// profiled value for Alternate toys	// profiled value for Alternate toys
	void SetConditionalMLEsAlt( const RooArgSet* c ) {	void SetConditionalMLEsAlt( const RooArgSet* c ) {
	if( fConditionalMLEsAlt ) delete fConditionalMLEsAlt;	if( fConditionalMLEsAlt ) delete fConditionalMLEsAlt;

	if( c ) fConditionalMLEsAlt = (const RooArgSet*)c->snapshot();	if( c ) fConditionalMLEsAlt = (const RooArgSet*)c->snapshot();
	else fConditionalMLEsAlt = NULL;	else fConditionalMLEsAlt = NULL;
	}	}


		void StoreFitInfo(bool val = true) {
		fStoreFitInfo = val;
		}

		const RooArgSet* GetFitInfo() const {
		return fFitInfo;
		}

	protected:	protected:
	// configure TestStatSampler for the Null run	// configure TestStatSampler for the Null run
	int PreNullHook(RooArgSet *parameterPoint, double obsTestStat) const;	int PreNullHook(RooArgSet *parameterPoint, double obsTestStat) const;

	// configure TestStatSampler for the Alt run	// configure TestStatSampler for the Alt run
	int PreAltHook(RooArgSet *parameterPoint, double obsTestStat) const;	int PreAltHook(RooArgSet *parameterPoint, double obsTestStat) const;


		void PreHook() const;
		void PostHook() const;

	protected:	protected:
	// MLE inputs	// MLE inputs
	const RooArgSet* fConditionalMLEsNull;	const RooArgSet* fConditionalMLEsNull;
	const RooArgSet* fConditionalMLEsAlt;	const RooArgSet* fConditionalMLEsAlt;

	// different number of toys for null and alt	// different number of toys for null and alt
	int fNToysNull;	int fNToysNull;
	int fNToysAlt;	int fNToysAlt;

	// adaptive sampling	// adaptive sampling
	int fNToysNullTail;	int fNToysNullTail;
	int fNToysAltTail;	int fNToysAltTail;


		private:
		mutable RooArgSet* fFitInfo;
		bool fStoreFitInfo;

	protected:	protected:
	ClassDef(FrequentistCalculator,1)	ClassDef(FrequentistCalculator,1)
	};	};
	}	}

	#endif	#endif

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

	G__ci_fproto.h	G__ci_fproto.h

	skipping to change at line 18	skipping to change at line 18
	* C/C++ interpreter header file for API function prototypes	* C/C++ interpreter header file for API function prototypes
	************************************************************************	************************************************************************
	* Copyright(c) 1995~2005 Masaharu Goto (cint@pcroot.cern.ch)	* Copyright(c) 1995~2005 Masaharu Goto (cint@pcroot.cern.ch)
	*	*
	* For the licensing terms see the file COPYING	* For the licensing terms see the file COPYING
	*	*
	************************************************************************/	************************************************************************/
	#ifndef G__CI_FPROTO_INCLUDE	#ifndef G__CI_FPROTO_INCLUDE
	#define G__CI_FPROTO_INCLUDE	#define G__CI_FPROTO_INCLUDE


		#if defined(__clang__)
		# if __has_warning("-Wreturn-type-c-linkage")
		// 'G__getfunction' has C-linkage specified, but returns
		// user-defined type 'G__value' which is incompatible with C
		# pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
		# endif
		#endif

	G__DECL_API(0, unsigned long, G__uint, (G__value buf))	G__DECL_API(0, unsigned long, G__uint, (G__value buf))
	G__DECL_API(1, int, G__fgetline, (char *string))	G__DECL_API(1, int, G__fgetline, (char *string))
	G__DECL_API(2, int, G__load, (char *commandfile))	G__DECL_API(2, int, G__load, (char *commandfile))
	/* G__DECL_API(???, float, G__float, (G__value buf))*/	/* G__DECL_API(???, float, G__float, (G__value buf))*/
	G__DECL_API(221, int, G__globalsetup,(void))	G__DECL_API(221, int, G__globalsetup,(void))
	G__DECL_API(3, int, G__call_setup_funcs, (void))	G__DECL_API(3, int, G__call_setup_funcs, (void))
	G__DECL_API(4, void, G__reset_setup_funcs, (void))	G__DECL_API(4, void, G__reset_setup_funcs, (void))
	G__DECL_API(5, G__CONST char*, G__cint_version, (void))	G__DECL_API(5, G__CONST char*, G__cint_version, (void))
	G__DECL_API(6, void, G__init_garbagecollection, (void))	G__DECL_API(6, void, G__init_garbagecollection, (void))
	G__DECL_API(7, int, G__garbagecollection, (void))	G__DECL_API(7, int, G__garbagecollection, (void))

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

	HistoToWorkspaceFactory.h	HistoToWorkspaceFactory.h

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

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

	struct EstimateSummary;	struct EstimateSummary;

	class HistoToWorkspaceFactory: public TObject {	class HistoToWorkspaceFactory: public TObject {

	public:	public:


	HistoToWorkspaceFactory( string, string , vector<string> , double =200 , double =20, int =0, int =6, TFile * =0);	HistoToWorkspaceFactory( std::string, std::string , std::vector<std:: string> , double =200, double =20, int =0, int =6, TFile * =0);
	HistoToWorkspaceFactory();	HistoToWorkspaceFactory();
	virtual ~HistoToWorkspaceFactory();	virtual ~HistoToWorkspaceFactory();


	void AddEfficiencyTerms(RooWorkspace* proto, string prefix, string in	void AddEfficiencyTerms(RooWorkspace* proto, std::string prefix, std:
	terpName,	:string interpName,
	map<string,pair<double,double> > systMap,	std::map<std::string,std::pair<double,double> > systMap,
	vector<string>& likelihoodTermNames, vector<string>& totSystTer	std::vector<std::string>& likelihoodTermNames, std::vector<std:
	mNames);	:string>& totSystTermNames);


	string AddNormFactor(RooWorkspace *, string & , string & , EstimateSu mmary & , bool );	std::string AddNormFactor(RooWorkspace *, std::string & , std::string & , EstimateSummary & , bool );


	void AddMultiVarGaussConstraint(RooWorkspace* proto, string prefix,in t lowBin, int highBin, vector<string>& likelihoodTermNames);	void AddMultiVarGaussConstraint(RooWorkspace* proto, std::string pref ix,int lowBin, int highBin, std::vector<std::string>& likelihoodTermNames);


	void AddPoissonTerms(RooWorkspace* proto, string prefix, string obsPr	void AddPoissonTerms(RooWorkspace* proto, std::string prefix, std::st
	efix, string expPrefix, int lowBin, int highBin,	ring obsPrefix, std::string expPrefix, int lowBin, int highBin,
	vector<string>& likelihoodTermNames);	std::vector<std::string>& likelihoodTermNames);

	//void Combine_old();	//void Combine_old();


	RooWorkspace * MakeCombinedModel(vector<string>, vector<RooWorkspace *>);	RooWorkspace * MakeCombinedModel(std::vector<std::string>, std::vect or<RooWorkspace*>);


	//void Combine_ratio(vector<string> , vector<RooWorkspace*>);	//void Combine_ratio(std::vector<std::string> , std::vector<RooWorksp ace*>);


	void Customize(RooWorkspace* proto, const char* pdfNameChar, map<stri ng,string> renameMap);	void Customize(RooWorkspace* proto, const char* pdfNameChar, std::map <std::string,std::string> renameMap);


	void EditSyst(RooWorkspace* proto, const char* pdfNameChar, map<strin g,double> gammaSyst, map<string,double> uniformSyst, map<string,double> log NormSyst);	void EditSyst(RooWorkspace* proto, const char* pdfNameChar, std::map< std::string,double> gammaSyst, std::map<std::string,double> uniformSyst, st d::map<std::string,double> logNormSyst);


	void FormatFrameForLikelihood(RooPlot* frame, string XTitle=string("# sigma / #sigma_{SM}"), string YTitle=string("-log likelihood"));	void FormatFrameForLikelihood(RooPlot* frame, std::string XTitle=std: :string("#sigma / #sigma_{SM}"), std::string YTitle=std::string("-log likel ihood"));


	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, vecto	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, std::
	r<TH1> lowHist, vector<TH1> highHist,	vector<TH1> lowHist, std::vector<TH1> highHist,
	vector<string> sourceName, string prefix, string productPr	std::vector<std::string> sourceName, std::string prefix, s
	efix, string systTerm,	td::string productPrefix, std::string systTerm,
	int lowBin, int highBin, vector<string>& likelihoodTermNam	int lowBin, int highBin, std::vector<std::string>& likelih
	es);	oodTermNames);


	TDirectory* Makedirs( TDirectory* file, vector<string> names );	TDirectory* Makedirs( TDirectory* file, std::vector<std::string> name s );


	RooWorkspace* MakeSingleChannelModel(vector<RooStats::HistFactory::Es timateSummary> summary, vector<string> systToFix, bool doRatio=false);	RooWorkspace* MakeSingleChannelModel(std::vector<RooStats::HistFactor y::EstimateSummary> summary, std::vector<std::string> systToFix, bool doRat io=false);


	void MakeTotalExpected(RooWorkspace* proto, string totName, string /	void MakeTotalExpected(RooWorkspace* proto, std::string totName, std
	/, string //,	::string //, std::string //,
	int lowBin, int highBin, vector<string>& syst_x_expectedPrefixN	int lowBin, int highBin, std::vector<std::string>& syst_x_expec
	ames,	tedPrefixNames,
	vector<string>& normByNames);	std::vector<std::string>& normByNames);


	TDirectory* Mkdir( TDirectory * file, string name );	TDirectory* Mkdir( TDirectory * file, std::string name );


	void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* params, s	void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* params, s
	tring filename);	td::string filename);
	void ProcessExpectedHisto(TH1* hist,RooWorkspace* proto, string prefi	void ProcessExpectedHisto(TH1* hist,RooWorkspace* proto, std::string
	x, string productPrefix, string systTerm, double low, double high, int lowB	prefix, std::string productPrefix, std::string systTerm, double low, double
	in, int highBin);	high, int lowBin, int highBin);
	void SetObsToExpected(RooWorkspace* proto, string obsPrefix, string e	void SetObsToExpected(RooWorkspace* proto, std::string obsPrefix, std
	xpPrefix, int lowBin, int highBin);	::string expPrefix, int lowBin, int highBin);
	void FitModel(RooWorkspace *, string, string, string, bool=false );	void FitModel(RooWorkspace *, std::string, std::string, std::string,
		bool=false );
	std::string FilePrefixStr(std::string);	std::string FilePrefixStr(std::string);


	string fFileNamePrefix;	std::string fFileNamePrefix;
	string fRowTitle;	std::string fRowTitle;
	vector<string> fSystToFix;	std::vector<std::string> fSystToFix;
	double fNomLumi, fLumiError;	double fNomLumi, fLumiError;
	int fLowBin, fHighBin;	int fLowBin, fHighBin;
	std::stringstream fResultsPrefixStr;	std::stringstream fResultsPrefixStr;
	TFile * fOut_f;	TFile * fOut_f;
	FILE * pFile;	FILE * pFile;

	ClassDef(RooStats::HistFactory::HistoToWorkspaceFactory,1)	ClassDef(RooStats::HistFactory::HistoToWorkspaceFactory,1)
	};	};

	}	}
	}	}

End of changes. 17 change blocks.
	42 lines changed or deleted	43 lines changed or added

	HistoToWorkspaceFactoryFast.h	HistoToWorkspaceFactoryFast.h

	skipping to change at line 31	skipping to change at line 31
	#include <RooArgSet.h>	#include <RooArgSet.h>
	#include <RooFitResult.h>	#include <RooFitResult.h>
	#include <RooAbsReal.h>	#include <RooAbsReal.h>
	#include <RooRealVar.h>	#include <RooRealVar.h>
	#include <RooWorkspace.h>	#include <RooWorkspace.h>
	#include <TObject.h>	#include <TObject.h>
	#include <TH1.h>	#include <TH1.h>
	#include <TDirectory.h>	#include <TDirectory.h>

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

		#include "RooStats/HistFactory/Measurement.h"

	class ParamHistFunc;	class ParamHistFunc;

	namespace RooStats{	namespace RooStats{
	namespace HistFactory{	namespace HistFactory{
	class HistoToWorkspaceFactoryFast: public TObject {	class HistoToWorkspaceFactoryFast: public TObject {


	public:	public:


	HistoToWorkspaceFactoryFast( string, string , vector<string> , double	HistoToWorkspaceFactoryFast( std::string, std::string , std::vector<st
	=200, double =20, int =0, int =6, TFile * =0);	d::string> , double =200, double =20, int =0, int =6, TFile* =NULL);
	HistoToWorkspaceFactoryFast();	HistoToWorkspaceFactoryFast( RooStats::HistFactory::Measurement& Meas
	virtual ~HistoToWorkspaceFactoryFast();	);
		static void ConfigureWorkspaceForMeasurement( const std::string& ModelN
		ame, RooWorkspace* ws_single, Measurement& measurement );


	void SetFunctionsToPreprocess(vector<string> lines){ fPreprocessFunct	HistoToWorkspaceFactoryFast();
	ions = lines;}	virtual ~HistoToWorkspaceFactoryFast();


	void AddEfficiencyTerms(RooWorkspace* proto, string prefix, string in	RooWorkspace* MakeSingleChannelModel( Measurement& measurement, Channel
	terpName,	& channel );
	map<string,pair<double,double> > systMap,	static RooWorkspace* MakeCombinedModel( Measurement& measurement );
	vector<string>& likelihoodTermNames, vector<string>& totSystTer
	mNames);


	string AddNormFactor(RooWorkspace *, string & , string & , EstimateSu mmary & , bool );	void SetFunctionsToPreprocess(std::vector<std::string> lines){ fPreproc essFunctions = lines;}


	void AddMultiVarGaussConstraint(RooWorkspace* proto, string prefix,in	void AddEfficiencyTerms(RooWorkspace* proto, std::string prefix, std::s
	t lowBin, int highBin, vector<string>& likelihoodTermNames);	tring interpName,
		std::map<std::string,std::pair<double,double> >
		systMap,
		std::vector<std::string>& likelihoodTermNames, s
		td::vector<std::string>& totSystTermNames);


	void AddPoissonTerms(RooWorkspace* proto, string prefix, string obsPr	std::string AddNormFactor(RooWorkspace *, std::string & , std::string &
	efix, string expPrefix, int lowBin, int highBin,	, EstimateSummary & , bool );
	vector<string>& likelihoodTermNames);


	//void Combine_old();	void AddMultiVarGaussConstraint(RooWorkspace* proto, std::string prefix ,int lowBin, int highBin, std::vector<std::string>& likelihoodTermNames);


	RooWorkspace * MakeCombinedModel(vector<string>, vector<RooWorkspace	void AddPoissonTerms(RooWorkspace* proto, std::string prefix, std::stri
	*>);	ng obsPrefix, std::string expPrefix, int lowBin, int highBin,
		std::vector<std::string>& likelihoodTermNames);


	//void Combine_ratio(vector<string> , vector<RooWorkspace*>);	//void Combine_old();


	void Customize(RooWorkspace* proto, const char* pdfNameChar, map<stri ng,string> renameMap);	RooWorkspace * MakeCombinedModel(std::vector<std::string>, std::vector <RooWorkspace*>);


	void EditSyst(RooWorkspace* proto, const char* pdfNameChar,	//void Combine_ratio(std::vector<std::string> , std::vector<RooWorkspac
	map<string,double> gammaSyst, map<string,double> uniform	e*>);
	Syst, map<string,double> logNormSyst, map<string,double> noSyst);


	void FormatFrameForLikelihood(RooPlot* frame, string XTitle=string("# sigma / #sigma_{SM}"), string YTitle=string("-log likelihood"));	void Customize(RooWorkspace* proto, const char* pdfNameChar, std::map<s td::string,std::string> renameMap);


	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, vecto	static void EditSyst(RooWorkspace* proto, const char* pdfNameChar,
	r<TH1> lowHist, vector<TH1> highHist,	std::map<std::string,double> gammaSyst, std::map<st
	vector<string> sourceName, string prefix, string productPr	d::string,double> uniformSyst, std::map<std::string,double> logNormSyst, st
	efix, string systTerm,	d::map<std::string,double> noSyst);
	int lowBin, int highBin, vector<string>& likelihoodTermNam
	es);


	TDirectory* Makedirs( TDirectory* file, vector<string> names );	//void FormatFrameForLikelihood(RooPlot* frame, std::string XTitle=std: :string("#sigma / #sigma_{SM}"), std::string YTitle=std::string("-log likel ihood"));


	RooWorkspace* MakeSingleChannelModel(vector<RooStats::HistFactory::Es	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, std::ve
	timateSummary> summary, vector<string> systToFix, bool doRatio=false);	ctor<TH1> lowHist, std::vector<TH1> highHist,
		std::vector<std::string> sourceName, std::s
		tring prefix, std::string productPrefix, std::string systTerm,
		int lowBin, int highBin, std::vector<std::s
		tring>& likelihoodTermNames);


	void MakeTotalExpected(RooWorkspace* proto, string totName, string /	TDirectory* Makedirs( TDirectory* file, std::vector<std::string> names
	/, string //,	);
	int lowBin, int highBin, vector<string>& syst_x_expectedPrefixN
	ames,
	vector<string>& normByNames);


	TDirectory* Mkdir( TDirectory * file, string name );	RooWorkspace* MakeSingleChannelModel(std::vector<RooStats::HistFactory: :EstimateSummary> summary, std::vector<std::string> systToFix, bool doRatio =false);


	void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* params, s	void MakeTotalExpected(RooWorkspace* proto, std::string totName, std::
	tring filename);	string //, std::string //,
	void ProcessExpectedHisto(TH1* hist,RooWorkspace* proto, string prefi	int lowBin, int highBin, std::vector<std::string
	x, string productPrefix, string systTerm, double low, double high, int lowB	>& syst_x_expectedPrefixNames,
	in, int highBin);	std::vector<std::string>& normByNames);
	void SetObsToExpected(RooWorkspace* proto, string obsPrefix, string e
	xpPrefix, int lowBin, int highBin);	TDirectory* Mkdir( TDirectory * file, std::string name );
	void FitModel(RooWorkspace *, string, string, string, bool=false );
	std::string FilePrefixStr(std::string);	static void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* para
		ms, std::string filename);
		void ProcessExpectedHisto(TH1* hist,RooWorkspace* proto, std::string pr
		efix, std::string productPrefix, std::string systTerm, double low, double h
		igh, int lowBin, int highBin);
		void SetObsToExpected(RooWorkspace* proto, std::string obsPrefix, std::
		string expPrefix, int lowBin, int highBin);
		//void FitModel(const std::string& FileNamePrefix, RooWorkspace *, std:
		:string, std::string, TFile, FILE);
		//std::string FilePrefixStr(std::string);

	TH1* MakeScaledUncertaintyHist( const std::string& Name, std::vector< s td::pair<TH1,TH1> > HistVec );	TH1* MakeScaledUncertaintyHist( const std::string& Name, std::vector< s td::pair<TH1,TH1> > HistVec );
	TH1* MakeAbsolUncertaintyHist( const std::string& Name, const TH1* Hist );	TH1* MakeAbsolUncertaintyHist( const std::string& Name, const TH1* Hist );

	RooArgList createStatConstraintTerms( RooWorkspace* proto, vector<strin g>& constraintTerms, ParamHistFunc& paramHist, TH1* uncertHist,	RooArgList createStatConstraintTerms( RooWorkspace* proto, std::vector< std::string>& constraintTerms, ParamHistFunc& paramHist, TH1* uncertHist,
	EstimateSummary::ConstraintType ty pe, Double_t minSigma );	EstimateSummary::ConstraintType ty pe, Double_t minSigma );


	inline void SetObsNameVec(const std::vector<std::string>& obsNameVec)	inline void SetObsNameVec(const std::vector<std::string>& obsNameVec) {
	{ fObsNameVec = obsNameVec; }	fObsNameVec = obsNameVec; }
	inline void SetObsName(const std::string& obsName) { fObsNameVec.clea	inline void SetObsName(const std::string& obsName) { fObsNameVec.clear(
	r(); fObsNameVec.push_back(obsName); fObsName = obsName; }	); fObsNameVec.push_back(obsName); fObsName = obsName; }
	inline void AddObsName(const std::string& obsName) { fObsNameVec.push	inline void AddObsName(const std::string& obsName) { fObsNameVec.push_b
	_back(obsName); }	ack(obsName); }

	string fFileNamePrefix;	//string fFileNamePrefix;
	string fRowTitle;	//string fRowTitle;
	vector<string> fSystToFix;	std::vector<std::string> fSystToFix;
	double fNomLumi, fLumiError;	double fNomLumi, fLumiError;
	int fLowBin, fHighBin;	int fLowBin, fHighBin;
	std::stringstream fResultsPrefixStr;	//std::stringstream fResultsPrefixStr;
	TFile * fOut_f;	//TFile * fOut_f;
	FILE * pFile;	// FILE * pFile;

	private:	private:


	void GuessObsNameVec(TH1* hist);	void GuessObsNameVec(TH1* hist);


	std::vector<std::string> fObsNameVec;	std::vector<std::string> fObsNameVec;
	std::string fObsName;	std::string fObsName;
	vector<string> fPreprocessFunctions;	std::vector<std::string> fPreprocessFunctions;


	ClassDef(RooStats::HistFactory::HistoToWorkspaceFactoryFast,3)	ClassDef(RooStats::HistFactory::HistoToWorkspaceFactoryFast,3)
	};	};

	}	}
	}	}

	#endif	#endif

End of changes. 25 change blocks.
	72 lines changed or deleted	84 lines changed or added

	HypoTestInverter.h	HypoTestInverter.h

	// @(#)root/roostats:$Id: HypoTestInverter.h 41455 2011-10-18 13:23:21Z mon eta $	// @(#)root/roostats:$Id: HypoTestInverter.h 44368 2012-05-30 15:38:44Z axe l $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_HypoTestInverter	#ifndef ROOSTATS_HypoTestInverter

	skipping to change at line 65	skipping to change at line 65
	// constructor from frequentist calculator	// constructor from frequentist calculator
	HypoTestInverter( FrequentistCalculator & hc,	HypoTestInverter( FrequentistCalculator & hc,
	RooRealVar* scannedVariable,	RooRealVar* scannedVariable,
	double size = 0.05) ;	double size = 0.05) ;

	// constructor from asymptotic calculator	// constructor from asymptotic calculator
	HypoTestInverter( AsymptoticCalculator & hc,	HypoTestInverter( AsymptoticCalculator & hc,
	RooRealVar* scannedVariable,	RooRealVar* scannedVariable,
	double size = 0.05) ;	double size = 0.05) ;


	// constructor from two ModelConfigs	// constructor from two ModelConfigs (first sb (the null model) then b (
	HypoTestInverter( RooAbsData& data, ModelConfig &b, ModelConfig &sb,	the alt model)
	RooRealVar * scannedVariable = 0, ECalculatorType typ	HypoTestInverter( RooAbsData& data, ModelConfig &sb, ModelConfig &b,
	e = kFrequentist,	RooRealVar * scannedVariable = 0, ECalculatorType type
		= kFrequentist,
	double size = 0.05) ;	double size = 0.05) ;

	virtual HypoTestInverterResult* GetInterval() const;	virtual HypoTestInverterResult* GetInterval() const;

	void Clear();	void Clear();

	// set for a fixed scan in nbins	// set for a fixed scan in nbins

	void SetFixedScan(int nBins, double xMin = 1, double xMax = -1) {	void SetFixedScan(int nBins, double xMin = 1, double xMax = -1, bool sca nLog = false ) {
	fNBins = nBins;	fNBins = nBins;
	fXmin = xMin; fXmax = xMax;	fXmin = xMin; fXmax = xMax;

		fScanLog = scanLog;
	}	}

	// set auto scan (default)	// set auto scan (default)
	void SetAutoScan() { SetFixedScan(0); }	void SetAutoScan() { SetFixedScan(0); }


	bool RunFixedScan( int nBins, double xMin, double xMax ) const;	bool RunFixedScan( int nBins, double xMin, double xMax, bool scanLog = f alse ) const;

	bool RunOnePoint( double thisX, bool adaptive = false, double clTarget = -1 ) const;	bool RunOnePoint( double thisX, bool adaptive = false, double clTarget = -1 ) const;

	//bool RunAutoScan( double xMin, double xMax, double target, double epsi lon=0.005, unsigned int numAlgorithm=0 );	//bool RunAutoScan( double xMin, double xMax, double target, double epsi lon=0.005, unsigned int numAlgorithm=0 );

	bool RunLimit(double &limit, double &limitErr, double absTol = 0, double relTol = 0, const double *hint=0) const;	bool RunLimit(double &limit, double &limitErr, double absTol = 0, double relTol = 0, const double *hint=0) const;

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

	virtual void SetData(RooAbsData &);	virtual void SetData(RooAbsData &);

	skipping to change at line 173	skipping to change at line 174
	static std::string fgAlgo;	static std::string fgAlgo;

	// graph, used to compute the limit, not just for plotting!	// graph, used to compute the limit, not just for plotting!
	mutable std::auto_ptr<TGraphErrors> fLimitPlot; //! plot of limits	mutable std::auto_ptr<TGraphErrors> fLimitPlot; //! plot of limits

	// performance counter: remember how many toys have been thrown	// performance counter: remember how many toys have been thrown
	mutable int fTotalToysRun;	mutable int fTotalToysRun;
	int fMaxToys; // maximum number of toys to run	int fMaxToys; // maximum number of toys to run

	HypoTestCalculatorGeneric* fCalculator0; // pointer to the calculator passed in the constructor	HypoTestCalculatorGeneric* fCalculator0; // pointer to the calculator passed in the constructor

	auto_ptr<HypoTestCalculatorGeneric> fHC;	std::auto_ptr<HypoTestCalculatorGeneric> fHC;
	RooRealVar* fScannedVariable; // pointer to the constrained variable	RooRealVar* fScannedVariable; // pointer to the constrained variable
	mutable HypoTestInverterResult* fResults; // pointer to the result	mutable HypoTestInverterResult* fResults; // pointer to the result

	bool fUseCLs;	bool fUseCLs;

		bool fScanLog;
	double fSize;	double fSize;
	int fVerbose;	int fVerbose;
	ECalculatorType fCalcType;	ECalculatorType fCalcType;
	int fNBins;	int fNBins;
	double fXmin;	double fXmin;
	double fXmax;	double fXmax;
	double fNumErr;	double fNumErr;

	protected:	protected:


	ClassDef(HypoTestInverter,2) // HypoTestInverter class	ClassDef(HypoTestInverter,3) // HypoTestInverter class

	};	};

	}	}

	#endif	#endif

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

	HypoTestInverterResult.h	HypoTestInverterResult.h

	// @(#)root/roostats:$Id: HypoTestInverterResult.h 41810 2011-11-08 14:16:5 9Z moneta $	// @(#)root/roostats:$Id: HypoTestInverterResult.h 44126 2012-05-04 16:55:4 7Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_HypoTestInverterResult	#ifndef ROOSTATS_HypoTestInverterResult

	skipping to change at line 99	skipping to change at line 99

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

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

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


		// query if one sided result
		bool IsOneSided() const { return !fIsTwoSided; }
		// query if two sided result
		bool IsTwoSided() const { return fIsTwoSided; }

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

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

	// Estimate of lower limit error	// Estimate of lower limit error

	skipping to change at line 154	skipping to change at line 159

	enum InterpolOption_t { kLinear, kSpline };	enum InterpolOption_t { kLinear, kSpline };

	// set the interpolation option, linear (kLinear ) or spline (kSpline)	// set the interpolation option, linear (kLinear ) or spline (kSpline)
	void SetInterpolationOption( InterpolOption_t opt) { fInterpolOption = o pt; }	void SetInterpolationOption( InterpolOption_t opt) { fInterpolOption = o pt; }

	InterpolOption_t GetInterpolationOption() const { return fInterpolOption ; }	InterpolOption_t GetInterpolationOption() const { return fInterpolOption ; }

	private:	private:


	double CalculateEstimatedError(double target);	double CalculateEstimatedError(double target, bool lower = true, double
	int FindClosestPointIndex(double target);	xmin = 1, double xmax = 0);

		int FindClosestPointIndex(double target, int mode = 0, double xtarget =
		0);

	SamplingDistribution* GetLimitDistribution(bool lower ) const;	SamplingDistribution* GetLimitDistribution(bool lower ) const;

	double GetExpectedLimit(double nsig, bool lower, const char * opt = "" ) const ;	double GetExpectedLimit(double nsig, bool lower, const char * opt = "" ) const ;


	double GetGraphX(const TGraph & g, double y0, bool lowSearch = false, do	double GetGraphX(const TGraph & g, double y0, bool lowSearch, double &xm
	uble xmin=1, double xmax=0) const;	in, double &xmax) const;
		double GetGraphX(const TGraph & g, double y0, bool lowSearch = true) con
		st {
		double xmin=1; double xmax = 0;
		return GetGraphX(g,y0,lowSearch,xmin,xmax);
		}

	protected:	protected:

	bool fUseCLs;	bool fUseCLs;

		bool fIsTwoSided; // two sided scan (look for lower/upp er limit)
	bool fInterpolateLowerLimit;	bool fInterpolateLowerLimit;
	bool fInterpolateUpperLimit;	bool fInterpolateUpperLimit;
	bool fFittedLowerLimit;	bool fFittedLowerLimit;
	bool fFittedUpperLimit;	bool fFittedUpperLimit;
	InterpolOption_t fInterpolOption; // interpolatation option (linear or spline)	InterpolOption_t fInterpolOption; // interpolatation option (linear or spline)

	double fLowerLimitError;	double fLowerLimitError;
	double fUpperLimitError;	double fUpperLimitError;

	static double fgAsymptoticMaxSigma; // max sigma value used to scan asy mptotic expected p values	static double fgAsymptoticMaxSigma; // max sigma value used to scan asy mptotic expected p values

	std::vector<double> fXValues;	std::vector<double> fXValues;

	TList fYObjects; // list of HypoTestResult for each point	TList fYObjects; // list of HypoTestResult for each point
	TList fExpPValues; // list of expected sampling distribution for eac h point	TList fExpPValues; // list of expected sampling distribution for eac h point

	friend class HypoTestInverter;	friend class HypoTestInverter;
	friend class HypoTestInverterPlot;	friend class HypoTestInverterPlot;
	friend class HypoTestInverterOriginal;	friend class HypoTestInverterOriginal;


	ClassDef(HypoTestInverterResult,4) // HypoTestInverterResult class	ClassDef(HypoTestInverterResult,5) // HypoTestInverterResult class
	};	};
	}	}

	#endif	#endif

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

	LinInterpVar.h	LinInterpVar.h

	skipping to change at line 29	skipping to change at line 29
	class RooArgList ;	class RooArgList ;

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

	class LinInterpVar : public RooAbsReal {	class LinInterpVar : public RooAbsReal {
	public:	public:

	LinInterpVar() ;	LinInterpVar() ;
	LinInterpVar(const char name, const char title,	LinInterpVar(const char name, const char title,

	const RooArgList& _paramList, double nominal, vector<double> low , vector<double> high);	const RooArgList& _paramList, double nominal, std::vector< double> low, std::vector<double> high);

	LinInterpVar(const char name, const char title);	LinInterpVar(const char name, const char title);
	LinInterpVar(const LinInterpVar&, const char*);	LinInterpVar(const LinInterpVar&, const char*);

	virtual TObject* clone(const char* newname) const { return new LinInter pVar(*this, newname); }	virtual TObject* clone(const char* newname) const { return new LinInter pVar(*this, newname); }
	virtual ~LinInterpVar() ;	virtual ~LinInterpVar() ;

	protected:	protected:

	RooListProxy _paramList ;	RooListProxy _paramList ;
	double _nominal;	double _nominal;

	vector<double> _low;	std::vector<double> _low;
	vector<double> _high;	std::vector<double> _high;

	TIterator* _paramIter ; //! do not persist	TIterator* _paramIter ; //! do not persist

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

	ClassDef(RooStats::HistFactory::LinInterpVar,1) // Piecewise linear int erpolation	ClassDef(RooStats::HistFactory::LinInterpVar,1) // Piecewise linear int erpolation
	};	};
	}	}
	}	}


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

	MarkovChain.h	MarkovChain.h

	// @(#)root/roostats:$Id: MarkovChain.h 43068 2012-02-21 16:09:05Z moneta $	// @(#)root/roostats:$Id: MarkovChain.h 44077 2012-05-02 17:10:21Z moneta $
	// Authors: Kevin Belasco 17/06/2009	// Authors: Kevin Belasco 17/06/2009
	// Authors: Kyle Cranmer 17/06/2009	// Authors: Kyle Cranmer 17/06/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 39	skipping to change at line 39
	#ifndef ROO_DATA_HIST	#ifndef ROO_DATA_HIST
	#include "RooDataHist.h"	#include "RooDataHist.h"
	#endif	#endif
	#ifndef ROOT_THnSparse	#ifndef ROOT_THnSparse
	#include "THnSparse.h"	#include "THnSparse.h"
	#endif	#endif
	//#include "RooArgSet.h"	//#include "RooArgSet.h"
	//#include "RooMsgService.h"	//#include "RooMsgService.h"
	//#include "RooRealVar.h"	//#include "RooRealVar.h"


	using namespace std;

	namespace RooStats {	namespace RooStats {

	class MarkovChain : public TNamed {	class MarkovChain : public TNamed {

	public:	public:
	MarkovChain();	MarkovChain();
	MarkovChain(RooArgSet& parameters);	MarkovChain(RooArgSet& parameters);
	MarkovChain(const char* name, const char* title, RooArgSet& parameter s);	MarkovChain(const char* name, const char* title, RooArgSet& parameter s);

	// safely add an entry to the chain	// safely add an entry to the chain

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

	MaxLikelihoodEstimateTestStat.h	MaxLikelihoodEstimateTestStat.h

	skipping to change at line 37	skipping to change at line 37
	#ifndef ROO_NLL_VAR	#ifndef ROO_NLL_VAR
	#include "RooNLLVar.h"	#include "RooNLLVar.h"
	#endif	#endif

	#include "RooFitResult.h"	#include "RooFitResult.h"
	#include "RooStats/TestStatistic.h"	#include "RooStats/TestStatistic.h"
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooMinimizer.h"	#include "RooMinimizer.h"
	#include "Math/MinimizerOptions.h"	#include "Math/MinimizerOptions.h"

		#include "RooStats/RooStatsUtils.h"

	namespace RooStats {	namespace RooStats {

	class MaxLikelihoodEstimateTestStat: public TestStatistic {	class MaxLikelihoodEstimateTestStat: public TestStatistic {

	public:	public:

	//__________________________________	//__________________________________
	MaxLikelihoodEstimateTestStat() :	MaxLikelihoodEstimateTestStat() :
	fPdf(NULL),fParameter(NULL), fUpperLimit(true)	fPdf(NULL),fParameter(NULL), fUpperLimit(true)

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

	Member.h	Member.h

	// @(#)root/reflex:$Id: Member.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: Member.h 44032 2012-04-30 14:49:20Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 531	skipping to change at line 531
	inline bool	inline bool
	Reflex::Member::operator !=(const Member& rh) const {	Reflex::Member::operator !=(const Member& rh) const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return !(*this == rh);	return !(*this == rh);
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::Member&	inline Reflex::Member&
	Reflex::Member::operator =(const Member& rh) {	Reflex::Member::operator =(const Member& rh) {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------

	fMemberBase = rh.fMemberBase;	if (&rh != this) {
		fMemberBase = rh.fMemberBase;
		}
	return *this;	return *this;
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline	inline
	Reflex::Member::operator bool() const {	Reflex::Member::operator bool() const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return 0 != fMemberBase;	return 0 != fMemberBase;
	}	}


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

	MemberBase.h	MemberBase.h

	// @(#)root/reflex:$Id: MemberBase.h 36289 2010-10-11 09:54:28Z axel $	// @(#)root/reflex:$Id: MemberBase.h 44084 2012-05-03 09:55:25Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 34	skipping to change at line 34
	class Object;	class Object;
	class DictionaryGenerator;	class DictionaryGenerator;

	/**	/**
	* @class MemberBase MemberBase.h Reflex/internal/MemberBase.h	* @class MemberBase MemberBase.h Reflex/internal/MemberBase.h
	* @author Stefan Roiser	* @author Stefan Roiser
	* @date 24/11/2003	* @date 24/11/2003
	* @ingroup Ref	* @ingroup Ref
	*/	*/
	class RFLX_API MemberBase {	class RFLX_API MemberBase {

		private:
		MemberBase(const MemberBase&); // not implemented
		MemberBase& operator=(const MemberBase&); // not implemented
	public:	public:
	/** default constructor */	/** default constructor */
	MemberBase(const char* name,	MemberBase(const char* name,
	const Type &type,	const Type &type,
	TYPE memberType,	TYPE memberType,
	unsigned int modifiers);	unsigned int modifiers);

	/** destructor */	/** destructor */
	virtual ~MemberBase();	virtual ~MemberBase();


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

	MemberTemplate.h	MemberTemplate.h

	// @(#)root/reflex:$Id: MemberTemplate.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: MemberTemplate.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 43	skipping to change at line 43
	/** default constructor */	/** default constructor */
	MemberTemplate(const MemberTemplateName * memberTemplateName = 0);	MemberTemplate(const MemberTemplateName * memberTemplateName = 0);

	/** copy constructor */	/** copy constructor */
	MemberTemplate(const MemberTemplate &rh);	MemberTemplate(const MemberTemplate &rh);

	/** destructor */	/** destructor */
	~MemberTemplate();	~MemberTemplate();

	/**	/**

		* operator = will make *this point to rh's member templates
		*/
		MemberTemplate& operator =(const MemberTemplate& rh);

		/**
	* operator bool will return true if the member template is resolved	* operator bool will return true if the member template is resolved
	* @return true if member template is resolved	* @return true if member template is resolved
	*/	*/
	operator bool() const;	operator bool() const;

	/**	/**
	* operator == will return true if two member templates are the same	* operator == will return true if two member templates are the same
	* @return true if member templates match	* @return true if member templates match
	*/	*/
	bool operator ==(const MemberTemplate& rh) const;	bool operator ==(const MemberTemplate& rh) const;

	skipping to change at line 264	skipping to change at line 269
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::MemberTemplate::~MemberTemplate() {	inline Reflex::MemberTemplate::~MemberTemplate() {
	}	}

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

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline	inline

		Reflex::MemberTemplate&
		Reflex::MemberTemplate::operator=(const MemberTemplate& rh) {
		//-------------------------------------------------------------------------
		------
		if (&rh != this) {
		fMemberTemplateName = rh.fMemberTemplateName;
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
		inline
	Reflex::MemberTemplate::operator bool() const {	Reflex::MemberTemplate::operator bool() const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	if (this->fMemberTemplateName && this->fMemberTemplateName->fMemberTempl ateImpl) {	if (this->fMemberTemplateName && this->fMemberTemplateName->fMemberTempl ateImpl) {
	return true;	return true;
	}	}
	return false;	return false;
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline bool	inline bool

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

	Method.h	Method.h

	skipping to change at line 48	skipping to change at line 48
	G__MethodInfo()	G__MethodInfo()
	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()
	{ Init(); }	{ Init(); }
	G__MethodInfo(G__ClassInfo &a)	G__MethodInfo(G__ClassInfo &a)
	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()	: handle(0), index(0), usingIndex(0), belongingclass(NULL), memberOf(0) , type()
	{ Init(a); }	{ Init(a); }
	G__MethodInfo(const G__MethodInfo& mi)	G__MethodInfo(const G__MethodInfo& mi)
	: handle(mi.handle), index(mi.index), usingIndex(mi.usingIndex),	: handle(mi.handle), index(mi.index), usingIndex(mi.usingIndex),
	belongingclass(mi.belongingclass), memberOf(0), type(mi.type) {}	belongingclass(mi.belongingclass), memberOf(0), type(mi.type) {}
	G__MethodInfo& operator=(const G__MethodInfo& mi) {	G__MethodInfo& operator=(const G__MethodInfo& mi) {

	handle=mi.handle; index=mi.index; usingIndex=mi.usingIndex;	if (&mi != this) {
	belongingclass=mi.belongingclass; memberOf=NULL; type=mi.type; return *	handle=mi.handle; index=mi.index; usingIndex=mi.usingIndex;
	this;}	belongingclass=mi.belongingclass; memberOf=NULL; type=mi.type;
		}
		return *this;}

	void Init();	void Init();
	void Init(G__ClassInfo &a);	void Init(G__ClassInfo &a);
	void Init(long handlein,long indexin,G__ClassInfo *belongingclassin);	void Init(long handlein,long indexin,G__ClassInfo *belongingclassin);
	void Init(G__ClassInfo *belongingclassin,long funcpage,long indexin);	void Init(G__ClassInfo *belongingclassin,long funcpage,long indexin);

	const char *Name() ;	const char *Name() ;
	#ifndef __MAKECINT__	#ifndef __MAKECINT__
	int Hash() ;	int Hash() ;
	struct G__ifunc_table* ifunc();	struct G__ifunc_table* ifunc();

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

	MethodAr.h	MethodAr.h

	skipping to change at line 44	skipping to change at line 44
	G__MethodArgInfo {	G__MethodArgInfo {
	public:	public:
	~G__MethodArgInfo() {}	~G__MethodArgInfo() {}
	void Init(class G__MethodInfo &a);	void Init(class G__MethodInfo &a);
	G__MethodArgInfo(class G__MethodInfo &a)	G__MethodArgInfo(class G__MethodInfo &a)
	: argn(0), belongingmethod(NULL), type() { Init(a); }	: argn(0), belongingmethod(NULL), type() { Init(a); }
	G__MethodArgInfo(const G__MethodArgInfo& mai)	G__MethodArgInfo(const G__MethodArgInfo& mai)
	: argn(mai.argn), belongingmethod(mai.belongingmethod), type(mai.type)	: argn(mai.argn), belongingmethod(mai.belongingmethod), type(mai.type)
	{ }	{ }
	G__MethodArgInfo& operator=(const G__MethodArgInfo& mai) {	G__MethodArgInfo& operator=(const G__MethodArgInfo& mai) {

	argn=mai.argn; belongingmethod=mai.belongingmethod;	if (&mai != this) {
	type=mai.type; return *this;}	argn=mai.argn; belongingmethod=mai.belongingmethod;
		type=mai.type;
		}
		return *this;}

	const char *Name();	const char *Name();
	G__TypeInfo* Type() { return(&type); }	G__TypeInfo* Type() { return(&type); }
	long Property();	long Property();
	char *DefaultValue();	char *DefaultValue();
	G__MethodInfo* ArgOf() { return(belongingmethod); }	G__MethodInfo* ArgOf() { return(belongingmethod); }
	int IsValid();	int IsValid();
	int Next();	int Next();

	private:	private:

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

	MethodPDEFoam.h	MethodPDEFoam.h

	// @(#)root/tmva $Id: MethodPDEFoam.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: MethodPDEFoam.h 44110 2012-05-04 08:34:05Z evt $
	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt

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

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

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

	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///
	// //	// //
	// MethodPDEFoam //	// MethodPDEFoam //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///


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

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

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

	#ifndef ROOT_TMVA_PDEFoamDecisionTree	#ifndef ROOT_TMVA_PDEFoamDecisionTree
	#include "TMVA/PDEFoamDecisionTree.h"	#include "TMVA/PDEFoamDecisionTree.h"

	skipping to change at line 179	skipping to change at line 175
	ETargetSelection UIntToTargetSelection(UInt_t its);	ETargetSelection UIntToTargetSelection(UInt_t its);

	protected:	protected:

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

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


		// calculate the error on the Mva value
		Double_t CalculateMVAError();

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

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

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

	// create pdefoam kernel	// create pdefoam kernel

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

	ModelConfig.h	ModelConfig.h

	// @(#)root/roostats:$Id: ModelConfig.h 39391 2011-05-26 09:51:59Z moneta $	// @(#)root/roostats:$Id: ModelConfig.h 44368 2012-05-30 15:38:44Z axel $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_ModelConfig	#ifndef ROOSTATS_ModelConfig

	skipping to change at line 114	skipping to change at line 114
	}	}

	// specify the parameters of interest in the interval	// specify the parameters of interest in the interval
	virtual void SetParameters(const RooArgSet& set) {	virtual void SetParameters(const RooArgSet& set) {
	fPOIName=std::string(GetName()) + "_POI";	fPOIName=std::string(GetName()) + "_POI";
	DefineSetInWS(fPOIName.c_str(), set);	DefineSetInWS(fPOIName.c_str(), set);
	}	}
	virtual void SetParametersOfInterest(const RooArgSet& set) {	virtual void SetParametersOfInterest(const RooArgSet& set) {
	SetParameters(set);	SetParameters(set);
	}	}

		// specify the parameters of interest
		// through a list of comma-separated arguments already in the workspace
		virtual void SetParameters(const char *argList) {
		if(!GetWS()) return;
		SetParameters(GetWS()->argSet(argList));
		}
		virtual void SetParametersOfInterest(const char *argList) {
		SetParameters(argList);
		}


	// specify the nuisance parameters (eg. the rest of the parameters)	// specify the nuisance parameters (e.g. the rest of the parameters)
	virtual void SetNuisanceParameters(const RooArgSet& set) {	virtual void SetNuisanceParameters(const RooArgSet& set) {
	fNuisParamsName=std::string(GetName()) + "_NuisParams";	fNuisParamsName=std::string(GetName()) + "_NuisParams";
	DefineSetInWS(fNuisParamsName.c_str(), set);	DefineSetInWS(fNuisParamsName.c_str(), set);
	}	}

		// specify the nuisance parameters
		// through a list of comma-separated arguments already in the workspace
		virtual void SetNuisanceParameters(const char *argList) {
		if(!GetWS()) return;
		SetNuisanceParameters(GetWS()->argSet(argList));
		}

	// specify the constraint parameters	// specify the constraint parameters
	virtual void SetConstraintParameters(const RooArgSet& set) {	virtual void SetConstraintParameters(const RooArgSet& set) {
	fConstrParamsName=std::string(GetName()) + "_ConstrainedParams";	fConstrParamsName=std::string(GetName()) + "_ConstrainedParams";
	DefineSetInWS(fConstrParamsName.c_str(), set);	DefineSetInWS(fConstrParamsName.c_str(), set);
	}	}

		// specify the constraint parameters
		// through a list of comma-separated arguments already in the workspace
		virtual void SetConstraintParameters(const char *argList) {
		if(!GetWS()) return;
		SetConstraintParameters(GetWS()->argSet(argList));
		}

	// specify the observables	// specify the observables
	virtual void SetObservables(const RooArgSet& set) {	virtual void SetObservables(const RooArgSet& set) {
	fObservablesName=std::string(GetName()) + "_Observables";	fObservablesName=std::string(GetName()) + "_Observables";
	DefineSetInWS(fObservablesName.c_str(), set);	DefineSetInWS(fObservablesName.c_str(), set);
	}	}

		// specify the observables
		// through a list of comma-separated arguments already in the workspace
		virtual void SetObservables(const char *argList) {
		if(!GetWS()) return;
		SetObservables(GetWS()->argSet(argList));
		}

	// specify the conditional observables	// specify the conditional observables
	virtual void SetConditionalObservables(const RooArgSet& set) {	virtual void SetConditionalObservables(const RooArgSet& set) {
	fConditionalObsName=std::string(GetName()) + "_ConditionalObservables ";	fConditionalObsName=std::string(GetName()) + "_ConditionalObservables ";
	DefineSetInWS(fConditionalObsName.c_str(), set);	DefineSetInWS(fConditionalObsName.c_str(), set);
	}	}


	// specify the conditional observables	// specify the conditional observables

		// through a list of comma-separated arguments already in the workspace
		virtual void SetConditionalObservables(const char *argList) {
		if(!GetWS()) return;
		SetConditionalObservables(GetWS()->argSet(argList));
		}

		// specify the global observables
	virtual void SetGlobalObservables(const RooArgSet& set) {	virtual void SetGlobalObservables(const RooArgSet& set) {
	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";	fGlobalObsName=std::string(GetName()) + "_GlobalObservables";
	DefineSetInWS(fGlobalObsName.c_str(), set);	DefineSetInWS(fGlobalObsName.c_str(), set);
	}	}

		// specify the global observables
		// through a list of comma-separated arguments already in the workspace
		virtual void SetGlobalObservables(const char *argList) {
		if(!GetWS()) return;
		SetGlobalObservables(GetWS()->argSet(argList));
		}

	// set parameter values for a particular hypothesis if using a common PD F	// set parameter values for a particular hypothesis if using a common PD F
	// by saving a snapshot in the workspace	// by saving a snapshot in the workspace
	virtual void SetSnapshot(const RooArgSet& set);	virtual void SetSnapshot(const RooArgSet& set);

	// specify the name of the PDF in the workspace to be used	// specify the name of the PDF in the workspace to be used
	virtual void SetPdf(const char* name) {	virtual void SetPdf(const char* name) {
	if (! GetWS() ) return;	if (! GetWS() ) return;

	if(GetWS()->pdf(name))	if(GetWS()->pdf(name))
	fPdfName = name;	fPdfName = name;
	else	else

	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<std::endl;
	}	}

	// specify the name of the PDF in the workspace to be used	// specify the name of the PDF in the workspace to be used
	virtual void SetPriorPdf(const char* name) {	virtual void SetPriorPdf(const char* name) {
	if (! GetWS() ) return;	if (! GetWS() ) return;

	if(GetWS()->pdf(name))	if(GetWS()->pdf(name))
	fPriorPdfName = name;	fPriorPdfName = name;
	else	else

	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<endl;	coutE(ObjectHandling) << "pdf "<<name<< " does not exist in worksp ace"<<std::endl;
	}	}

	// specify the name of the dataset in the workspace to be used	// specify the name of the dataset in the workspace to be used
	virtual void SetProtoData(const char* name){	virtual void SetProtoData(const char* name){
	if (! GetWS() ) return;	if (! GetWS() ) return;

	if(GetWS()->data(name))	if(GetWS()->data(name))
	fProtoDataName = name;	fProtoDataName = name;
	else	else

	coutE(ObjectHandling) << "dataset "<<name<< " does not exist in wo rkspace"<<endl;	coutE(ObjectHandling) << "dataset "<<name<< " does not exist in wo rkspace"<<std::endl;
	}	}

	/* getter methods */	/* getter methods */

	/// get model PDF (return NULL if pdf has not been specified or does not exist)	/// get model PDF (return NULL if pdf has not been specified or does not exist)
	RooAbsPdf * GetPdf() const { return (GetWS()) ? GetWS()->pdf(fPdfName.c_ str()) : 0; }	RooAbsPdf * GetPdf() const { return (GetWS()) ? GetWS()->pdf(fPdfName.c_ str()) : 0; }

	/// get RooArgSet containing the parameter of interest (return NULL if n ot existing)	/// get RooArgSet containing the parameter of interest (return NULL if n ot existing)
	const RooArgSet * GetParametersOfInterest() const { return (GetWS()) ? G etWS()->set(fPOIName.c_str()) : 0; }	const RooArgSet * GetParametersOfInterest() const { return (GetWS()) ? G etWS()->set(fPOIName.c_str()) : 0; }


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

	NumEventsTestStat.h	NumEventsTestStat.h

	// @(#)root/roostats:$Id: NumEventsTestStat.h 39391 2011-05-26 09:51:59Z mo neta $	// @(#)root/roostats:$Id: NumEventsTestStat.h 44376 2012-05-30 21:47:29Z mo neta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_NumEventsTestStat	#ifndef ROOSTATS_NumEventsTestStat

	skipping to change at line 29	skipping to change at line 29
	It should probably support simple cuts as well.	It should probably support simple cuts as well.
	</p>	</p>
	END_HTML	END_HTML
	*/	*/
	//	//

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


	#include <vector>	#ifndef ROO_REAL_VAR
		#include "RooRealVar.h"
		#endif


	//#include "RooStats/DistributionCreator.h"	#ifndef ROO_ABS_DATA
	#include "RooStats/SamplingDistribution.h"	#include "RooAbsData.h"
		#endif

		#ifndef ROO_ABS_PDF
		#include "RooAbsPdf.h"
		#endif

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

		#endif


	#include "RooRealVar.h"	//#include "RooStats/DistributionCreator.h"

	namespace RooStats {	namespace RooStats {

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

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

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

	if(!&data) {
	cout << "problem with data" << endl;	if(!&data) {
	return 0 ;	std::cout << "Data set reference is NULL" << std::endl;
	} else {	return 0;
		}
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL) ;
	return data.numEntries();	if(data.isWeighted()) {
	}	return data.sumEntries();
		}

		// if no pdf is given in the constructor, we assume by default it
		can be extended
		if (!fPdf \|\| fPdf->canBeExtended()) {
		return data.numEntries();
		}

		// data is not weighted as pdf cannot be extended
		if(data.numEntries() == 1) {

		const RooArgSet *obsSet = data.get(0);
		RooLinkedListIter iter = obsSet->iterator();

		RooRealVar *obs = NULL; Double_t numEvents = 0.0;
		while((obs = (RooRealVar *)iter.Next()) != NULL) {
		numEvents += obs->getValV();
		}
		return numEvents;
		}

		std::cout << "Data set is invalid" << std::endl;
		return 0;
	}	}

	// Get the TestStatistic	// Get the TestStatistic
	virtual const RooAbsArg* GetTestStatistic() const {return fPdf;}	virtual const RooAbsArg* GetTestStatistic() const {return fPdf;}

	virtual const TString GetVarName() const {return "Number of events";}	virtual const TString GetVarName() const {return "Number of events";}

	private:	private:
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf;


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

	Object.h	Object.h

	// @(#)root/reflex:$Id: Object.h 36314 2010-10-12 12:40:57Z axel $	// @(#)root/reflex:$Id: Object.h 44032 2012-04-30 14:49:20Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


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

	template <typename T>	template <typename T>
	static Object	static Object
	Create(T& v) {	Create(T& v) {
	return Object(Type::ByTypeInfo(typeid(T)), &v);	return Object(Type::ByTypeInfo(typeid(T)), &v);
	}	}

	/**	/**
	* operator assigment	* operator assigment
	*/	*/

	Object operator =(const Object& obj);	Object& operator =(const Object& obj);

	/**	/**
	* operator ==	* operator ==
	*/	*/
	bool operator ==(const Object& obj);	bool operator ==(const Object& obj);

	/**	/**
	* inequal operator	* inequal operator
	*/	*/
	bool operator !=(const Object& obj);	bool operator !=(const Object& obj);

	skipping to change at line 241	skipping to change at line 241
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::Object::Object(const Object& obj)	inline Reflex::Object::Object(const Object& obj)
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	: fType(obj.fType),	: fType(obj.fType),
	fAddress(obj.fAddress) {	fAddress(obj.fAddress) {
	}	}

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

	inline Reflex::Object	inline Reflex::Object&
	Reflex::Object::operator =(const Object& obj) {	Reflex::Object::operator =(const Object& obj) {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------

	fType = obj.fType;	if (&obj != this) {
	fAddress = obj.fAddress;	fType = obj.fType;
		fAddress = obj.fAddress;
		}
	return *this;	return *this;
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline bool	inline bool
	Reflex::Object::operator ==(const Object& obj) {	Reflex::Object::operator ==(const Object& obj) {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return fType == obj.fType && fAddress == obj.fAddress;	return fType == obj.fType && fAddress == obj.fAddress;
	}	}


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

	PDEFoamMultiTarget.h	PDEFoamMultiTarget.h

	// @(#)root/tmva $Id: PDEFoamMultiTarget.h 40005 2011-06-27 15:29:10Z stelz er $	// @(#)root/tmva $Id: PDEFoamMultiTarget.h 44112 2012-05-04 10:00:41Z evt $
	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt	// Author: Tancredi Carli, Dominik Dannheim, Alexander Voigt

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Classes: PDEFoamMultiTarget *	* Classes: PDEFoamMultiTarget *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Concrete PDEFoamEvent sub-class. This foam stores the number *	* Concrete PDEFoamEvent sub-class. This foam stores the number *

	skipping to change at line 52	skipping to change at line 52
	// target selection method	// target selection method
	enum ETargetSelection { kMean = 0, kMpv = 1 };	enum ETargetSelection { kMean = 0, kMpv = 1 };

	class PDEFoamMultiTarget : public PDEFoamEvent	class PDEFoamMultiTarget : public PDEFoamEvent
	{	{

	protected:	protected:
	ETargetSelection fTargetSelection; // the target selection method	ETargetSelection fTargetSelection; // the target selection method

	PDEFoamMultiTarget(const PDEFoamMultiTarget&); // Copy Constructor N OT USED	PDEFoamMultiTarget(const PDEFoamMultiTarget&); // Copy Constructor N OT USED

		virtual void CalculateMpv(std::map<Int_t, Float_t>&, const std::vecto
		r<PDEFoamCell*>&); // Calculate mpv target
		virtual void CalculateMean(std::map<Int_t, Float_t>&, const std::vect
		or<PDEFoamCell*>&); // Calculate mean target

	// ---------- Public functions ----------------------------------	// ---------- Public functions ----------------------------------
	public:	public:
	PDEFoamMultiTarget(); // Default constructor (used o nly by ROOT streamer)	PDEFoamMultiTarget(); // Default constructor (used o nly by ROOT streamer)
	PDEFoamMultiTarget(const TString&, ETargetSelection); // Principal us er-defined constructor	PDEFoamMultiTarget(const TString&, ETargetSelection); // Principal us er-defined constructor
	virtual ~PDEFoamMultiTarget() {}; // Default destructor	virtual ~PDEFoamMultiTarget() {}; // Default destructor

	// overridden from PDEFoam: extract the targets from the foam	// overridden from PDEFoam: extract the targets from the foam
	virtual std::vector<Float_t> GetCellValue(const std::map<Int_t, Float _t>&, ECellValue);	virtual std::vector<Float_t> GetCellValue(const std::map<Int_t, Float _t>&, ECellValue);
	using PDEFoam::GetCellValue;	using PDEFoam::GetCellValue;

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

	ParamHistFunc.h	ParamHistFunc.h

	skipping to change at line 50	skipping to change at line 50
	//ParamHistFunc(const char name, const char title, const RooRealVar& va r, const RooArgList& paramSet, const RooAbsReal& nominal );	//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(ostream& os) const ;	// void printMetaArgs(ostream& os) const ;

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


	virtual Bool_t forceAnalyticalInt(const RooAbsArg&) const { return kTRUE ; }	Int_t numBins() const { return _dataSet.numEntries(); } // Number of bins (called numEntries in RooDataHist)


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


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

		RooRealVar& getParameter( Int_t masterIdx ) const ;


	void setParamConst( Int_t, Bool_t=kTRUE );	const RooArgSet* get(Int_t masterIdx) const { return _dataSet.get( master
		Idx ) ; }
		const RooArgSet* get(const RooArgSet& coord) const { return _dataSet.get(
		coord ) ; }

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

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

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

	static RooArgList createParamSet(RooWorkspace& w, const std::string&, con st RooArgList& Vars);	static RooArgList createParamSet(RooWorkspace& w, const std::string&, con st RooArgList& Vars);
	static RooArgList createParamSet(RooWorkspace& w, const std::string&, con st RooArgList& Vars, Double_t, Double_t);	static RooArgList createParamSet(RooWorkspace& w, const std::string&, con st RooArgList& Vars, Double_t, Double_t);
	static RooArgList createParamSet(const std::string&, Int_t, Double_t, Dou ble_t);	static RooArgList createParamSet(const std::string&, Int_t, Double_t, Dou ble_t);

	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* binBoundaries(RooAbsRealLValue& /obs/, Dou ble_t /xlo/, Double_t /xhi/) const ;
	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& obs, Doub le_t xlo, Double_t xhi) const ;
	virtual Bool_t isBinnedDistribution(const RooArgSet& /obs/) const {retu rn kTRUE;}	virtual Bool_t isBinnedDistribution(const RooArgSet& /obs/) const {retu rn kTRUE;}

	protected:	protected:

	skipping to change at line 101	skipping to change at line 107
	RooListProxy _paramSet ; // interpolation parameters	RooListProxy _paramSet ; // interpolation parameters
	//RooAbsBinning* _binning; // Holds the binning of the dataVar (at const ruction time)	//RooAbsBinning* _binning; // Holds the binning of the dataVar (at const ruction time)

	Int_t _numBins;	Int_t _numBins;
	mutable std::map<Int_t, Int_t> _binMap;	mutable std::map<Int_t, Int_t> _binMap;
	mutable RooDataHist _dataSet;	mutable RooDataHist _dataSet;

	// std::vector< Double_t > _nominalVals; // The nominal vals when gamma = 1.0 ( = 1.0 by default)	// std::vector< Double_t > _nominalVals; // The nominal vals when gamma = 1.0 ( = 1.0 by default)
	RooArgList _ownedList ; // List of owned components	RooArgList _ownedList ; // List of owned components


		Int_t getCurrentBin() const ;
	Int_t addVarSet( const RooArgList& vars );	Int_t addVarSet( const RooArgList& vars );
	Int_t addParamSet( const RooArgList& params );	Int_t addParamSet( const RooArgList& params );
	static Int_t GetNumBins( const RooArgSet& vars );	static Int_t GetNumBins( const RooArgSet& vars );
	Double_t evaluate() const;	Double_t evaluate() const;

	ClassDef(ParamHistFunc,4) // Sum of RooAbsReal objects	ClassDef(ParamHistFunc,4) // Sum of RooAbsReal objects
	};	};

	#endif	#endif

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

	ParameterSettings.h	ParameterSettings.h

	// @(#)root/mathcore:$Id: ParameterSettings.h 37706 2011-01-05 08:54:28Z mo neta $	// @(#)root/mathcore:$Id: ParameterSettings.h 44013 2012-04-30 07:04:56Z mo neta $
	// Author: L. Moneta Thu Sep 21 16:21:48 2006	// Author: L. Moneta Thu Sep 21 16:21:48 2006

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

	// Header file for class ParameterSettings	// Header file for class ParameterSettings

	#ifndef ROOT_Fit_ParameterSettings	#ifndef ROOT_Fit_ParameterSettings
	#define ROOT_Fit_ParameterSettings	#define ROOT_Fit_ParameterSettings

	#include <string>	#include <string>


		#ifndef ROOT_Math_Error
		#include "Math/Error.h"
		#endif

	namespace ROOT {	namespace ROOT {

	namespace Fit {	namespace Fit {

	//_________________________________________________________________________ __________	//_________________________________________________________________________ __________
	/**	/**
	Class, describing value, limits and step size of the parameters	Class, describing value, limits and step size of the parameters
	Provides functionality also to set/retrieve values, step sizes, limits a nd fix the	Provides functionality also to set/retrieve values, step sizes, limits a nd fix the
	parameters.	parameters.


	skipping to change at line 55	skipping to change at line 59
	///constructor for unlimited named Parameter	///constructor for unlimited named Parameter
	ParameterSettings(const std::string & name, double val, double err) :	ParameterSettings(const std::string & name, double val, double err) :
	fValue(val), fStepSize(err), fFix(false),	fValue(val), fStepSize(err), fFix(false),
	fLowerLimit(0.), fUpperLimit(0.), fHasLowerLimit(false), fHasUpperLimit (false),	fLowerLimit(0.), fUpperLimit(0.), fHasLowerLimit(false), fHasUpperLimit (false),
	fName(name)	fName(name)
	{}	{}

	///constructor for double limited Parameter	///constructor for double limited Parameter
	ParameterSettings(const std::string & name, double val, double err,	ParameterSettings(const std::string & name, double val, double err,
	double min, double max) :	double min, double max) :

	fValue(val), fStepSize(err), fFix(false), fName(name)	fValue(val), fStepSize(err), fFix(false),
		fLowerLimit(0.), fUpperLimit(0.), fHasLowerLimit(false), fHasUpperLim
		it(false),
		fName(name)
	{	{
	SetLimits(min,max);	SetLimits(min,max);
	}	}

	///constructor for fixed Parameter	///constructor for fixed Parameter
	ParameterSettings(const std::string & name, double val) :	ParameterSettings(const std::string & name, double val) :
	fValue(val), fStepSize(0), fFix(true),	fValue(val), fStepSize(0), fFix(true),
	fLowerLimit(0.), fUpperLimit(0.), fHasLowerLimit(false), fHasUpperLimit (false),	fLowerLimit(0.), fUpperLimit(0.), fHasLowerLimit(false), fHasUpperLimit (false),
	fName(name)	fName(name)
	{}	{}

	skipping to change at line 135	skipping to change at line 141
	void Fix() {fFix = true;}	void Fix() {fFix = true;}
	/// release the parameter	/// release the parameter
	void Release() {fFix = false;}	void Release() {fFix = false;}
	/// set the value	/// set the value
	void SetValue(double val) {fValue = val;}	void SetValue(double val) {fValue = val;}
	/// set the step size	/// set the step size
	void SetStepSize(double err) {fStepSize = err;}	void SetStepSize(double err) {fStepSize = err;}
	/// set a double side limit,	/// set a double side limit,
	/// if low == up the parameter is fixedm if low > up the limits are remo ved	/// if low == up the parameter is fixedm if low > up the limits are remo ved
	void SetLimits(double low, double up) {	void SetLimits(double low, double up) {

	if (low == up) {	if ( low > up ) {
	Fix();	RemoveLimits();
	return;	return;
	}	}

	else if ( low > up ) {	if (low == up && low == fValue) {
	RemoveLimits();	Fix();
	return;	return;
	}	}

		if (low > fValue \|\| up < fValue) {
		MATH_ERROR_MSG("ParameterSettings","Invalid lower/upper bounds - i
		gnoring the bounds ");
		}
	fLowerLimit = low;	fLowerLimit = low;
	fUpperLimit = up;	fUpperLimit = up;
	fHasLowerLimit = true;	fHasLowerLimit = true;
	fHasUpperLimit = true;	fHasUpperLimit = true;
	}	}
	/// set a single upper limit	/// set a single upper limit
	void SetUpperLimit(double up) {	void SetUpperLimit(double up) {
	fLowerLimit = 0.;	fLowerLimit = 0.;
	fUpperLimit = up;	fUpperLimit = up;
	fHasLowerLimit = false;	fHasLowerLimit = false;

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

	PdfProposal.h	PdfProposal.h

	// @(#)root/roostats:$Id: PdfProposal.h 39391 2011-05-26 09:51:59Z moneta $	// @(#)root/roostats:$Id: PdfProposal.h 44368 2012-05-30 15:38:44Z axel $
	// Authors: Kevin Belasco 17/06/2009	// Authors: Kevin Belasco 17/06/2009
	// Authors: Kyle Cranmer 17/06/2009	// Authors: Kyle Cranmer 17/06/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#endif	#endif
	#ifndef ROO_DATA_SET	#ifndef ROO_DATA_SET
	#include "RooDataSet.h"	#include "RooDataSet.h"
	#endif	#endif
	#ifndef ROO_ABS_PDF	#ifndef ROO_ABS_PDF
	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#endif	#endif

	#include <map>	#include <map>

	#include <string>

	using namespace std;

	namespace RooStats {	namespace RooStats {

	class PdfProposal : public ProposalFunction {	class PdfProposal : public ProposalFunction {

	public:	public:
	PdfProposal();	PdfProposal();
	PdfProposal(RooAbsPdf& pdf);	PdfProposal(RooAbsPdf& pdf);

	// Populate xPrime with a new proposed point	// Populate xPrime with a new proposed point

	skipping to change at line 89	skipping to change at line 86
	virtual void Reset()	virtual void Reset()
	{	{
	delete fCache;	delete fCache;
	fCache = NULL;	fCache = NULL;
	fCachePosition = 0;	fCachePosition = 0;
	fLastX.removeAll();	fLastX.removeAll();
	}	}

	virtual void printMappings()	virtual void printMappings()
	{	{

	map<RooRealVar, RooAbsReal>::iterator it;	std::map<RooRealVar, RooAbsReal>::iterator it;
	for (it = fMap.begin(); it != fMap.end(); it++)	for (it = fMap.begin(); it != fMap.end(); it++)

	cout << it->first->GetName() << " => " << it->second->GetName() << endl;	std::cout << it->first->GetName() << " => " << it->second->GetN ame() << std::endl;
	}	}

	// Set how many points to generate each time we propose from a new po int	// Set how many points to generate each time we propose from a new po int
	// Default (and minimum) is 1	// Default (and minimum) is 1
	virtual void SetCacheSize(Int_t size)	virtual void SetCacheSize(Int_t size)
	{	{
	if (size > 0)	if (size > 0)
	fCacheSize = size;	fCacheSize = size;
	else	else
	coutE(Eval) << "Warning: Requested non-positive cache size: " < <	coutE(Eval) << "Warning: Requested non-positive cache size: " < <

	size << ". Cache size unchanged." << endl;	size << ". Cache size unchanged." << std::endl;
	}	}

	// set whether we own the PDF that serves as the proposal density fun ction	// set whether we own the PDF that serves as the proposal density fun ction
	// By default, when constructed, PdfProposal does NOT own the PDF.	// By default, when constructed, PdfProposal does NOT own the PDF.
	virtual void SetOwnsPdf(Bool_t ownsPdf) { fOwnsPdf = ownsPdf; }	virtual void SetOwnsPdf(Bool_t ownsPdf) { fOwnsPdf = ownsPdf; }

	//virtual void SetIsAlwaysSymmetric(Bool_t isAlwaysSymmetric)	//virtual void SetIsAlwaysSymmetric(Bool_t isAlwaysSymmetric)
	//{ fIsAlwaysSymmetric = isAlwaysSymmetric; }	//{ fIsAlwaysSymmetric = isAlwaysSymmetric; }

	virtual ~PdfProposal()	virtual ~PdfProposal()
	{	{
	delete fCache;	delete fCache;
	if (fOwnsPdf)	if (fOwnsPdf)
	delete fPdf;	delete fPdf;
	}	}

	protected:	protected:
	RooAbsPdf* fPdf; // the proposal density function	RooAbsPdf* fPdf; // the proposal density function

	map<RooRealVar, RooAbsReal> fMap; // map of values in pdf to update	std::map<RooRealVar, RooAbsReal> fMap; // map of values in pdf to u
	map<RooRealVar, RooAbsReal>::iterator fIt; // pdf iterator	pdate
		std::map<RooRealVar, RooAbsReal>::iterator fIt; // pdf iterator
	RooArgSet fLastX; // the last point we were at	RooArgSet fLastX; // the last point we were at
	Int_t fCacheSize; // how many points to generate each time	Int_t fCacheSize; // how many points to generate each time
	Int_t fCachePosition; // our position in the cached proposal data set	Int_t fCachePosition; // our position in the cached proposal data set
	RooDataSet* fCache; // the cached proposal data set	RooDataSet* fCache; // the cached proposal data set
	RooArgSet fMaster; // pointers to master variables needed for updates	RooArgSet fMaster; // pointers to master variables needed for updates
	Bool_t fOwnsPdf; // whether we own the proposal density function	Bool_t fOwnsPdf; // whether we own the proposal density function
	//Bool_t fIsAlwaysSymmetric; // does Q(x1 \| x2) == Q(x2 \| x1) for all x1, x2	//Bool_t fIsAlwaysSymmetric; // does Q(x1 \| x2) == Q(x2 \| x1) for all x1, x2

	// determine whether these two RooArgSets represent the same point	// determine whether these two RooArgSets represent the same point
	virtual Bool_t Equals(RooArgSet& x1, RooArgSet& x2);	virtual Bool_t Equals(RooArgSet& x1, RooArgSet& x2);

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

	PluginService.h	PluginService.h

	// @(#)root/reflex:$Id: PluginService.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: PluginService.h 44084 2012-05-03 09:55:25Z axel $
	// Author: Pere Mato 2006	// Author: Pere Mato 2006

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


	skipping to change at line 35	skipping to change at line 35
	namespace Reflex {	namespace Reflex {
	class PluginFactoryMap;	class PluginFactoryMap;

	/**	/**
	* @class PluginService PluginService.h PluginService/PluginService.h	* @class PluginService PluginService.h PluginService/PluginService.h
	* @author Pere Mato	* @author Pere Mato
	* @date 01/09/2006	* @date 01/09/2006
	* @ingroup Ref	* @ingroup Ref
	*/	*/
	class RFLX_API PluginService {	class RFLX_API PluginService {

		private:
		PluginService(const PluginService&); // not implemented
		PluginService& operator=(const PluginService&); // not implemented
	public:	public:
	template <typename R>	template <typename R>
	static R	static R
	Create(const std::string& name) {	Create(const std::string& name) {
	return (R) Create(name, GetType<R>(), std::vector<ValueObject>());	return (R) Create(name, GetType<R>(), std::vector<ValueObject>());
	}	}

	template <typename R, typename A0>	template <typename R, typename A0>
	static R	static R
	Create(const std::string& name,	Create(const std::string& name,

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

	ProfileLikelihoodTestStat.h	ProfileLikelihoodTestStat.h

	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 43199 2012-03-01 20:1 7:42Z moneta $	// @(#)root/roostats:$Id: ProfileLikelihoodTestStat.h 44473 2012-06-01 16:1 2:31Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	// Additional Contributions: Giovanni Petrucciani	// Additional Contributions: Giovanni Petrucciani
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 36	skipping to change at line 36

	</p>	</p>
	END_HTML	END_HTML
	*/	*/
	//	//

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


	#include <vector>	#ifndef ROOSTATS_TestStatistic

	#include "RooStats/RooStatsUtils.h"

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

		#endif


	#include "RooStats/RooStatsUtils.h"	#ifndef ROO_REAL_VAR

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

	#include "RooProfileLL.h"	#endif

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

	#include "RooMsgService.h"	#endif


	#include "RooMinuit.h"	#ifndef ROOTT_Math_MinimizerOptions
	#include "RooMinimizer.h"
	#include "Math/MinimizerOptions.h"	#include "Math/MinimizerOptions.h"

	#include "TStopwatch.h"	#endif

	namespace RooStats {	namespace RooStats {

	class ProfileLikelihoodTestStat : public TestStatistic{	class ProfileLikelihoodTestStat : public TestStatistic{

	enum LimitType {twoSided, oneSided, oneSidedDiscovery};	enum LimitType {twoSided, oneSided, oneSidedDiscovery};

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

	fProfile = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;
	fLimitType = twoSided;	fLimitType = twoSided;
	fSigned = false;	fSigned = false;

		fDetailedOutputWithErrorsAndPulls = false;
	fDetailedOutputEnabled = false;	fDetailedOutputEnabled = false;
	fDetailedOutput = NULL;	fDetailedOutput = NULL;


	fUncML = new RooRealVar("uncondML","unconditional ML", 0.0);
	fFitStatus = new RooRealVar("fitStatus","fit status", 0.0);
	fCovQual = new RooRealVar("covQual","quality of covariance matrix",
	0.0);
	fNumInvalidNLLEval = new RooRealVar("numInvalidNLLEval","number of
	invalid NLL evaluations", 0.0);

	fVarName = "Profile Likelihood Ratio";	fVarName = "Profile Likelihood Ratio";
	fReuseNll = false;	fReuseNll = false;
	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();
	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();
	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTol erance());	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTol erance());
	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();

	}	}
	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {	ProfileLikelihoodTestStat(RooAbsPdf& pdf) {
	fPdf = &pdf;	fPdf = &pdf;

	fProfile = 0;
	fNll = 0;	fNll = 0;
	fCachedBestFitParams = 0;	fCachedBestFitParams = 0;
	fLastData = 0;	fLastData = 0;
	fLimitType = twoSided;	fLimitType = twoSided;
	fSigned = false;	fSigned = false;

		fDetailedOutputWithErrorsAndPulls = false;
	fDetailedOutputEnabled = false;	fDetailedOutputEnabled = false;
	fDetailedOutput = NULL;	fDetailedOutput = NULL;


	fUncML = new RooRealVar("uncondML","unconditional ML", 0.0);
	fFitStatus = new RooRealVar("fitStatus","fit status", 0.0);
	fCovQual = new RooRealVar("covQual","quality of covariance matrix",
	0.0);
	fNumInvalidNLLEval = new RooRealVar("numInvalidNLLEval","number of i
	nvalid NLL evaluations", 0.0);

	fVarName = "Profile Likelihood Ratio";	fVarName = "Profile Likelihood Ratio";
	fReuseNll = false;	fReuseNll = false;
	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();	fMinimizer=::ROOT::Math::MinimizerOptions::DefaultMinimizerType().c_ str();
	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();	fStrategy=::ROOT::Math::MinimizerOptions::DefaultStrategy();
	// avoid default tolerance to be too small (1. is default in RooMini mizer)	// avoid default tolerance to be too small (1. is default in RooMini mizer)
	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTole rance());	fTolerance=TMath::Max(1.,::ROOT::Math::MinimizerOptions::DefaultTole rance());
	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();	fPrintLevel=::ROOT::Math::MinimizerOptions::DefaultPrintLevel();
	}	}
	virtual ~ProfileLikelihoodTestStat() {	virtual ~ProfileLikelihoodTestStat() {

	// delete fRand;
	// delete fTestStatistic;
	if(fProfile) delete fProfile;
	if(fNll) delete fNll;	if(fNll) delete fNll;
	if(fCachedBestFitParams) delete fCachedBestFitParams;	if(fCachedBestFitParams) delete fCachedBestFitParams;
	if(fDetailedOutput) delete fDetailedOutput;	if(fDetailedOutput) delete fDetailedOutput;
	}	}


		//LM use default copy constructor and assignment copying the pointers.
		Is this what we want ?

	void SetOneSided(Bool_t flag=true) {fLimitType = (flag ? oneSided : tw oSided);}	void SetOneSided(Bool_t flag=true) {fLimitType = (flag ? oneSided : tw oSided);}
	void SetOneSidedDiscovery(Bool_t flag=true) {fLimitType = (flag ? oneS idedDiscovery : twoSided);}	void SetOneSidedDiscovery(Bool_t flag=true) {fLimitType = (flag ? oneS idedDiscovery : twoSided);}
	void SetSigned(Bool_t flag=true) {fSigned = flag;} // +/- t_mu instea d of t_mu>0 with one-sided settings	void SetSigned(Bool_t flag=true) {fSigned = flag;} // +/- t_mu instea d of t_mu>0 with one-sided settings
	//void SetOneSidedDiscovery(Bool_t flag=true) {fOneSidedDiscovery = fl ag;}	//void SetOneSidedDiscovery(Bool_t flag=true) {fOneSidedDiscovery = fl ag;}


		bool IsTwoSided() const { return fLimitType == twoSided; }
		bool IsOneSidedDiscovery() const { return fLimitType == oneSidedDiscov
		ery; }

	static void SetAlwaysReuseNLL(Bool_t flag) { fgAlwaysReuseNll = flag ; }	static void SetAlwaysReuseNLL(Bool_t flag) { fgAlwaysReuseNll = flag ; }
	void SetReuseNLL(Bool_t flag) { fReuseNll = flag ; }	void SetReuseNLL(Bool_t flag) { fReuseNll = flag ; }

	void SetMinimizer(const char* minimizer){ fMinimizer=minimizer;}	void SetMinimizer(const char* minimizer){ fMinimizer=minimizer;}
	void SetStrategy(Int_t strategy){fStrategy=strategy;}	void SetStrategy(Int_t strategy){fStrategy=strategy;}
	void SetTolerance(double tol){fTolerance=tol;}	void SetTolerance(double tol){fTolerance=tol;}
	void SetPrintLevel(Int_t printlevel){fPrintLevel=printlevel;}	void SetPrintLevel(Int_t printlevel){fPrintLevel=printlevel;}

	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& paramsOfInteres t) {
	return EvaluateProfileLikelihood(0, data, paramsOfInterest);	return EvaluateProfileLikelihood(0, data, paramsOfInterest);
	}	}

	// evaluate the profile likelihood ratio (type = 0) or the minimum of likelihood (type=1) or the conditional LL (type = 2)	// evaluate the profile likelihood ratio (type = 0) or the minimum of likelihood (type=1) or the conditional LL (type = 2)
	virtual Double_t EvaluateProfileLikelihood(int type, RooAbsData &data, RooArgSet & paramsOfInterest);	virtual Double_t EvaluateProfileLikelihood(int type, RooAbsData &data, RooArgSet & paramsOfInterest);


	virtual void EnableDetailedOutput( bool e=true ) { fDetailedOutputEnab	virtual void EnableDetailedOutput( bool e=true, bool withErrorsAndPull
	led = e; fDetailedOutput = NULL; }	s=false ) {
	virtual const RooArgSet* GetDetailedOutput(void) const { return fDetai	fDetailedOutputEnabled = e;
	ledOutput; }	fDetailedOutputWithErrorsAndPulls = withErrorsAndPulls;
		delete fDetailedOutput;
		fDetailedOutput = NULL;
		}
		virtual const RooArgSet* GetDetailedOutput(void) const {
		// Returns detailed output. The value returned by this function
		is updated after each call to Evaluate().
		// The returned RooArgSet contains the following:
		// <ul>
		// <li> the minimum nll, fitstatus and convergence quality for
		each fit </li>
		// <li> for each fit and for each non-constant parameter, the v
		alue, error and pull of the parameter are stored </li>
		// </ul>
		return fDetailedOutput;
		}

	virtual void SetVarName(const char* name) { fVarName = name; }	virtual void SetVarName(const char* name) { fVarName = name; }
	virtual const TString GetVarName() const {return fVarName;}	virtual const TString GetVarName() const {return fVarName;}


		virtual RooAbsPdf * GetPdf() const { return fPdf; }

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

	private:	private:


	double GetMinNLL(int& status);	RooFitResult* GetMinNLL();

	private:	private:

	RooProfileLL* fProfile; //!
	RooAbsPdf* fPdf;	RooAbsPdf* fPdf;
	RooNLLVar* fNll; //!	RooNLLVar* fNll; //!
	const RooArgSet* fCachedBestFitParams;	const RooArgSet* fCachedBestFitParams;
	RooAbsData* fLastData;	RooAbsData* fLastData;
	// Double_t fLastMLE;	// Double_t fLastMLE;
	LimitType fLimitType;	LimitType fLimitType;
	Bool_t fSigned;	Bool_t fSigned;

	// this will store a snapshot of the unconditional nuisance	// this will store a snapshot of the unconditional nuisance
	// parameter fit.	// parameter fit.
	bool fDetailedOutputEnabled;	bool fDetailedOutputEnabled;

	const RooArgSet* fDetailedOutput; //!	bool fDetailedOutputWithErrorsAndPulls;
		RooArgSet* fDetailedOutput; //!
	RooRealVar* fUncML; //!
	RooRealVar* fFitStatus; //!
	RooRealVar* fCovQual; //!
	RooRealVar* fNumInvalidNLLEval; //!

	TString fVarName;	TString fVarName;

	static Bool_t fgAlwaysReuseNll ;	static Bool_t fgAlwaysReuseNll ;
	Bool_t fReuseNll ;	Bool_t fReuseNll ;
	TString fMinimizer;	TString fMinimizer;
	Int_t fStrategy;	Int_t fStrategy;
	Double_t fTolerance;	Double_t fTolerance;
	Int_t fPrintLevel;	Int_t fPrintLevel;


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

	PropertyList.h	PropertyList.h

	// @(#)root/reflex:$Id: PropertyList.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: PropertyList.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 45	skipping to change at line 45
	public:	public:
	/** default constructor */	/** default constructor */
	PropertyList(PropertyListImpl * propertyListImpl = 0);	PropertyList(PropertyListImpl * propertyListImpl = 0);

	/** copy constructor */	/** copy constructor */
	PropertyList(const PropertyList &pl);	PropertyList(const PropertyList &pl);

	/** destructor */	/** destructor */
	~PropertyList();	~PropertyList();


		/** assignment op */
		PropertyList& operator=(const PropertyList &pl);

	/**	/**
	* operator bool will return true if the property list is implemented	* operator bool will return true if the property list is implemented
	* @return true if property list is not a fake one	* @return true if property list is not a fake one
	*/	*/
	operator bool() const;	operator bool() const;

	/**	/**
	* AddProperty will add a key value pair to the property list	* AddProperty will add a key value pair to the property list
	* @param key the key of the property	* @param key the key of the property
	* @param value the value of the property (as any object)	* @param value the value of the property (as any object)

	skipping to change at line 296	skipping to change at line 299
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	: fPropertyListImpl(pl.fPropertyListImpl) {	: fPropertyListImpl(pl.fPropertyListImpl) {
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::PropertyList::~PropertyList() {	inline Reflex::PropertyList::~PropertyList() {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	}	}

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

		inline
		Reflex::PropertyList&
		Reflex::PropertyList::operator=(const PropertyList& pl) {
		//-------------------------------------------------------------------------
		------
		if (&pl != this) {
		fPropertyListImpl = pl.fPropertyListImpl;
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
	inline size_t	inline size_t
	Reflex::PropertyList::AddProperty(const std::string& key,	Reflex::PropertyList::AddProperty(const std::string& key,
	const Any& value) const {	const Any& value) const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	if (fPropertyListImpl) {	if (fPropertyListImpl) {
	return fPropertyListImpl->AddProperty(key, value);	return fPropertyListImpl->AddProperty(key, value);
	}	}
	return 0;	return 0;
	}	}


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

	PropertyListImpl.h	PropertyListImpl.h

	// @(#)root/reflex:$Id: PropertyListImpl.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: PropertyListImpl.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 47	skipping to change at line 47
	public:	public:
	/** default constructor */	/** default constructor */
	PropertyListImpl();	PropertyListImpl();

	/** copy constructor */	/** copy constructor */
	PropertyListImpl(const PropertyListImpl &pl);	PropertyListImpl(const PropertyListImpl &pl);

	/** destructor */	/** destructor */
	virtual ~PropertyListImpl();	virtual ~PropertyListImpl();


		/** assignment op */
		PropertyListImpl& operator=(const PropertyListImpl &pl);

	/**	/**
	* AddProperty will add a key value pair to the PropertyNth lsit	* AddProperty will add a key value pair to the PropertyNth lsit
	* @param key the key of the PropertyNth	* @param key the key of the PropertyNth
	* @param value the value of the PropertyNth (as any object)	* @param value the value of the PropertyNth (as any object)
	* @return the property key of this property	* @return the property key of this property
	*/	*/
	size_t AddProperty(const std::string& key,	size_t AddProperty(const std::string& key,
	const Any& value);	const Any& value);

	/**	/**

	skipping to change at line 260	skipping to change at line 263
	: fProperties(0) {	: fProperties(0) {
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::PropertyListImpl::PropertyListImpl(const PropertyListImpl& p l)	inline Reflex::PropertyListImpl::PropertyListImpl(const PropertyListImpl& p l)
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	: fProperties(pl.fProperties) {	: fProperties(pl.fProperties) {
	}	}

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

		inline
		Reflex::PropertyListImpl&
		Reflex::PropertyListImpl::operator=(const PropertyListImpl& pl) {
		//-------------------------------------------------------------------------
		------
		if (&pl != this) {
		fProperties = pl.fProperties;
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
	inline size_t	inline size_t
	Reflex::PropertyListImpl::AddProperty(const std::string& key,	Reflex::PropertyListImpl::AddProperty(const std::string& key,
	const Any& value) {	const Any& value) {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	size_t k = PropertyKey(key, true);	size_t k = PropertyKey(key, true);
	AddProperty(k, value);	AddProperty(k, value);
	return k;	return k;
	}	}

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

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

	ProposalFunction.h	ProposalFunction.h

	// @(#)root/roostats:$Id: ProposalFunction.h 39391 2011-05-26 09:51:59Z mon eta $	// @(#)root/roostats:$Id: ProposalFunction.h 44077 2012-05-02 17:10:21Z mon eta $
	// Authors: Kevin Belasco 17/06/2009	// Authors: Kevin Belasco 17/06/2009
	// Authors: Kyle Cranmer 17/06/2009	// Authors: Kyle Cranmer 17/06/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 46	skipping to change at line 46
	#ifndef ROO_MSG_SERVICE	#ifndef ROO_MSG_SERVICE
	#include "RooMsgService.h"	#include "RooMsgService.h"
	#endif	#endif
	#ifndef ROOT_TIterator	#ifndef ROOT_TIterator
	#include "TIterator.h"	#include "TIterator.h"
	#endif	#endif
	#ifndef ROO_REAL_VAR	#ifndef ROO_REAL_VAR
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#endif	#endif


	using namespace std;

	namespace RooStats {	namespace RooStats {

	class ProposalFunction : public TObject {	class ProposalFunction : public TObject {

	public:	public:
	//Default constructor	//Default constructor
	ProposalFunction() {}	ProposalFunction() {}

	virtual ~ProposalFunction() {}	virtual ~ProposalFunction() {}


	skipping to change at line 83	skipping to change at line 81
	// Return true if all objects are RooRealVars, false otherwise	// Return true if all objects are RooRealVars, false otherwise
	virtual bool CheckParameters(RooArgSet& params)	virtual bool CheckParameters(RooArgSet& params)
	{	{
	TIterator* it = params.createIterator();	TIterator* it = params.createIterator();
	TObject* obj;	TObject* obj;
	while ((obj = it->Next()) != NULL) {	while ((obj = it->Next()) != NULL) {
	if (!dynamic_cast<RooRealVar*>(obj)) {	if (!dynamic_cast<RooRealVar*>(obj)) {
	coutE(Eval) << "Error when checking parameters in"	coutE(Eval) << "Error when checking parameters in"
	<< "ProposalFunction: "	<< "ProposalFunction: "
	<< "Object \"" << obj->GetName() << "\" not of t ype "	<< "Object \"" << obj->GetName() << "\" not of t ype "

	<< "RooRealVar" << endl;	<< "RooRealVar" << std::endl;
	delete it;	delete it;
	return false;	return false;
	}	}
	}	}
	delete it;	delete it;
	// Made it here, so all parameters are RooRealVars	// Made it here, so all parameters are RooRealVars
	return true;	return true;
	}	}

	protected:	protected:

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

	ProposalHelper.h	ProposalHelper.h

	// @(#)root/roostats:$Id: ProposalHelper.h 39391 2011-05-26 09:51:59Z monet a $	// @(#)root/roostats:$Id: ProposalHelper.h 44368 2012-05-30 15:38:44Z axel $
	// Authors: Kevin Belasco 7/22/2009	// Authors: Kevin Belasco 7/22/2009
	// Authors: Kyle Cranmer 7/22/2009	// Authors: Kyle Cranmer 7/22/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40
	#ifndef ROO_MSG_SERVICE	#ifndef ROO_MSG_SERVICE
	#include "RooMsgService.h"	#include "RooMsgService.h"
	#endif	#endif
	#ifndef ROO_REAL_VAR	#ifndef ROO_REAL_VAR
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#endif	#endif
	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif


	#include <map>

	using namespace std;

	namespace RooStats {	namespace RooStats {

	class ProposalHelper : public TObject {	class ProposalHelper : public TObject {

	public:	public:
	ProposalHelper();	ProposalHelper();

	// Set the PDF to be the proposal density function	// Set the PDF to be the proposal density function
	virtual void SetPdf(RooAbsPdf& pdf) { fPdf = &pdf; }	virtual void SetPdf(RooAbsPdf& pdf) { fPdf = &pdf; }
	// Set the bank of clues to add to the current proposal density funct ion	// Set the bank of clues to add to the current proposal density funct ion

	skipping to change at line 65	skipping to change at line 61

	// Get the ProposalFunction that we've been designing	// Get the ProposalFunction that we've been designing
	virtual ProposalFunction* GetProposalFunction();	virtual ProposalFunction* GetProposalFunction();

	virtual void SetCacheSize(Int_t size)	virtual void SetCacheSize(Int_t size)
	{	{
	if (size > 0)	if (size > 0)
	fCacheSize = size;	fCacheSize = size;
	else	else
	coutE(Eval) << "Warning: Requested non-positive cache size: " < <	coutE(Eval) << "Warning: Requested non-positive cache size: " < <

	size << ". Cache size unchanged." << endl;	size << ". Cache size unchanged." << std::endl;
	}	}

	virtual void SetUpdateProposalParameters(Bool_t updateParams)	virtual void SetUpdateProposalParameters(Bool_t updateParams)
	{ fUseUpdates = updateParams; }	{ fUseUpdates = updateParams; }

	virtual void SetVariables(RooArgList& vars)	virtual void SetVariables(RooArgList& vars)
	{ fVars = &vars; }	{ fVars = &vars; }

	virtual void SetVariables(const RooArgList& vars)	virtual void SetVariables(const RooArgList& vars)
	{ fVars = new RooArgList(vars); fOwnsVars = kTRUE; }	{ fVars = new RooArgList(vars); fOwnsVars = kTRUE; }

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

	RConfig.h	RConfig.h

	/* @(#)root/base:$Id: RConfig.h 39359 2011-05-24 14:51:26Z axel $ */	/* @(#)root/base:$Id: RConfig.h 43709 2012-04-12 11:04:01Z rdm $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2002, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_RConfig	#ifndef ROOT_RConfig

	skipping to change at line 104	skipping to change at line 104
	# define R__PLACEMENTDELETE /* supports overloading placement delet e */	# define R__PLACEMENTDELETE /* supports overloading placement delet e */
	# define R__PLACEMENTINLINE /* placement new/delete is inline in <n ew> */	# define R__PLACEMENTINLINE /* placement new/delete is inline in <n ew> */
	# define R__THROWNEWDELETE /* new/delete throw exceptions */	# define R__THROWNEWDELETE /* new/delete throw exceptions */
	# endif	# endif
	# if defined __GNUC__	# if defined __GNUC__
	# define R__NAMESPACE_TEMPLATE_IMP_BUG	# define R__NAMESPACE_TEMPLATE_IMP_BUG
	# define R__PLACEMENTINLINE /* placement new/delete is inline in <n ew> */	# define R__PLACEMENTINLINE /* placement new/delete is inline in <n ew> */
	# else	# else
	# define R__TEMPLATE_OVERLOAD_BUG	# define R__TEMPLATE_OVERLOAD_BUG
	# endif	# endif

	# else
	# define R__VMS
	# define cxxbug
	# define NEED_STRCASECMP
	# define R__NONSCALARFPOS
	# endif	# endif
	#endif	#endif

	#if defined(__sun) && !(defined(linux) \|\| defined(__FCC_VERSION))	#if defined(__sun) && !(defined(linux) \|\| defined(__FCC_VERSION))
	# ifdef __SVR4	# ifdef __SVR4
	# define R__SOLARIS	# define R__SOLARIS
	# define R__SEEK64	# define R__SEEK64
	# define ANSICPP	# define ANSICPP
	# ifdef __i386	# ifdef __i386
	# define R__BYTESWAP	# define R__BYTESWAP

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

	RConfigure.h	RConfigure.h

	skipping to change at line 26	skipping to change at line 26
	#define EXTRAICONPATH ""	#define EXTRAICONPATH ""
	#define TTFFONTDIR "$(ROOTSYS)/fonts"	#define TTFFONTDIR "$(ROOTSYS)/fonts"
	#define CINTINCDIR "$(ROOTSYS)/cint"	#define CINTINCDIR "$(ROOTSYS)/cint"
	#endif	#endif

	#define R__HAS_SETRESUID /**/	#define R__HAS_SETRESUID /**/
	#define R__HAS_MATHMORE /**/	#define R__HAS_MATHMORE /**/
	#define R__HAS_PTHREAD /**/	#define R__HAS_PTHREAD /**/
	#define R__HAS_XFT /**/	#define R__HAS_XFT /**/
	#undef R__HAS_CLING /**/	#undef R__HAS_CLING /**/

		#undef R__HAS_COCOA /**/
		#undef R__USE_CXX11 /**/

	#endif	#endif

End of changes. 1 change blocks.
	0 lines changed or deleted	2 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.33/02"	#define ROOT_RELEASE "5.34/00"
	#define ROOT_RELEASE_DATE "Mar 6 2012"	#define ROOT_RELEASE_DATE "Jun 5 2012"
	#define ROOT_RELEASE_TIME "10:30:14"	#define ROOT_RELEASE_TIME "15:17:17"
	#define ROOT_SVN_REVISION 43245	#define ROOT_SVN_REVISION 44555
	#define ROOT_SVN_BRANCH "trunk"	#define ROOT_SVN_BRANCH "branches/v5-34-00-patches"
	#define ROOT_VERSION_CODE 336130	#define ROOT_VERSION_CODE 336384
	#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. 1 change blocks.
	6 lines changed or deleted	6 lines changed or added

	RatioOfProfiledLikelihoodsTestStat.h	RatioOfProfiledLikelihoodsTestStat.h

	// @(#)root/roostats:$Id: RatioOfProfiledLikelihoodsTestStat.h 42324 2011-1 1-30 16:31:03Z moneta $	// @(#)root/roostats:$Id: RatioOfProfiledLikelihoodsTestStat.h 44157 2012-0 5-07 16:41:44Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_RatioOfProfiledLikelihoodsTestStat	#ifndef ROOSTATS_RatioOfProfiledLikelihoodsTestStat
	#define ROOSTATS_RatioOfProfiledLikelihoodsTestStat	#define ROOSTATS_RatioOfProfiledLikelihoodsTestStat

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

	class RatioOfProfiledLikelihoodsTestStat: public TestStatistic {	class RatioOfProfiledLikelihoodsTestStat: public TestStatistic {

	public:	public:

	RatioOfProfiledLikelihoodsTestStat() :	RatioOfProfiledLikelihoodsTestStat() :
	fNullProfile(),	fNullProfile(),
	fAltProfile(),	fAltProfile(),
	fAltPOI(NULL),	fAltPOI(NULL),

	fSubtractMLE(true)	fSubtractMLE(true),
		fDetailedOutputEnabled(false),
		fDetailedOutput(NULL)
	{	{
	// Proof constructor. Don't use.	// Proof constructor. Don't use.
	}	}

	RatioOfProfiledLikelihoodsTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf,	RatioOfProfiledLikelihoodsTestStat(RooAbsPdf& nullPdf, RooAbsPdf& altPdf,
	const RooArgSet* altPOI=0) :	const RooArgSet* altPOI=0) :
	fNullProfile(nullPdf),	fNullProfile(nullPdf),
	fAltProfile(altPdf),	fAltProfile(altPdf),

	fSubtractMLE(true)	fSubtractMLE(true),
		fDetailedOutputEnabled(false),
		fDetailedOutput(NULL)
	{	{
	/*	/*
	Calculates the ratio of profiled likelihoods.	Calculates the ratio of profiled likelihoods.

	By default the calculation is:	By default the calculation is:

	Lambda(mu_alt , conditional MLE for alt nuisance)	Lambda(mu_alt , conditional MLE for alt nuisance)
	log --------------------------------------------	log --------------------------------------------
	Lambda(mu_null , conditional MLE for null nuisance)	Lambda(mu_null , conditional MLE for null nuisance)


	skipping to change at line 95	skipping to change at line 99
	if(altPOI)	if(altPOI)
	fAltPOI = (RooArgSet*) altPOI->snapshot();	fAltPOI = (RooArgSet*) altPOI->snapshot();
	else	else
	fAltPOI = new RooArgSet(); // empty set	fAltPOI = new RooArgSet(); // empty set

	}	}

	//__________________________________________	//__________________________________________
	~RatioOfProfiledLikelihoodsTestStat(void) {	~RatioOfProfiledLikelihoodsTestStat(void) {
	if(fAltPOI) delete fAltPOI;	if(fAltPOI) delete fAltPOI;

		if(fDetailedOutput) delete fDetailedOutput;
	}	}

	//__________________________________________	//__________________________________________
	Double_t ProfiledLikelihood(RooAbsData& data, RooArgSet& poi, RooAbsPdf & pdf) {	Double_t ProfiledLikelihood(RooAbsData& data, RooArgSet& poi, RooAbsPdf & pdf) {
	// returns -logL(poi, conditonal MLE of nuisance params)	// returns -logL(poi, conditonal MLE of nuisance params)
	// it does not subtract off the global MLE	// it does not subtract off the global MLE
	// because nuisance parameters of null and alternate may not	// because nuisance parameters of null and alternate may not
	// be the same.	// be the same.
	RooAbsReal* nll = pdf.createNLL(data, RooFit::CloneData(kFALSE));	RooAbsReal* nll = pdf.createNLL(data, RooFit::CloneData(kFALSE));
	RooAbsReal* profile = nll->createProfile(poi);	RooAbsReal* profile = nll->createProfile(poi);

	skipping to change at line 128	skipping to change at line 133
	}	}

	//__________________________________________	//__________________________________________
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullParamsOfInte rest) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullParamsOfInte rest) {
	// evaluate the ratio of profile likelihood	// evaluate the ratio of profile likelihood

	int type = (fSubtractMLE) ? 0 : 2;	int type = (fSubtractMLE) ? 0 : 2;

	// null	// null
	double nullNLL = fNullProfile.EvaluateProfileLikelihood(type, data, nullParamsOfInterest);	double nullNLL = fNullProfile.EvaluateProfileLikelihood(type, data, nullParamsOfInterest);

		const RooArgSet *nullset = fNullProfile.GetDetailedOutput();

	// alt	// alt
	double altNLL = fAltProfile.EvaluateProfileLikelihood(type, data, *f AltPOI);	double altNLL = fAltProfile.EvaluateProfileLikelihood(type, data, *f AltPOI);

		const RooArgSet *altset = fAltProfile.GetDetailedOutput();

		if (fDetailedOutput != NULL) {
		delete fDetailedOutput;
		fDetailedOutput = NULL;
		}
		if (fDetailedOutputEnabled) {
		fDetailedOutput = new RooArgSet();
		RooRealVar* var(0);
		for(TIterator *it = nullset->createIterator();(var = dynamic_
		cast<RooRealVar*>(it->Next()));) {
		RooRealVar* cloneVar = new RooRealVar(TString::Format
		("nullprof_%s", var->GetName()),
		TString::Format("%s
		for null", var->GetTitle()), var->getVal());
		fDetailedOutput->addOwned(*cloneVar);
		}
		for(TIterator *it = altset->createIterator();(var = dynamic_c
		ast<RooRealVar*>(it->Next()));) {
		RooRealVar* cloneVar = new RooRealVar(TString::Format
		("altprof_%s", var->GetName()),
		TString::Format("%s
		for null", var->GetTitle()), var->getVal());
		fDetailedOutput->addOwned(*cloneVar);
		}
		}

	/*	/*
	// set variables back to where they were	// set variables back to where they were
	nullParamsOfInterest = *saveNullPOI;	nullParamsOfInterest = *saveNullPOI;
	allVars = saveAll;	allVars = saveAll;
	delete saveAll;	delete saveAll;
	delete allVars;	delete allVars;
	*/	*/

	return nullNLL -altNLL;	return nullNLL -altNLL;
	}	}


	static void SetAlwaysReuseNLL(Bool_t flag) { fgAlwaysReuseNll = flag ; }	virtual void EnableDetailedOutput( bool e=true ) {
		fDetailedOutputEnabled = e;
		fNullProfile.EnableDetailedOutput(fDetailedOutputEnabled);
		fAltProfile.EnableDetailedOutput(fDetailedOutputEnabled);
		}

		static void SetAlwaysReuseNLL(Bool_t flag) { fgAlwaysReuseNll = flag ;
		}

	void SetReuseNLL(Bool_t flag) {	void SetReuseNLL(Bool_t flag) {
	fNullProfile.SetReuseNLL(flag);	fNullProfile.SetReuseNLL(flag);
	fAltProfile.SetReuseNLL(flag);	fAltProfile.SetReuseNLL(flag);
	}	}

	void SetMinimizer(const char* minimizer){	void SetMinimizer(const char* minimizer){
	fNullProfile.SetMinimizer(minimizer);	fNullProfile.SetMinimizer(minimizer);
	fAltProfile.SetMinimizer(minimizer);	fAltProfile.SetMinimizer(minimizer);
	}	}

	skipping to change at line 167	skipping to change at line 199
	}	}
	void SetTolerance(Double_t tol){	void SetTolerance(Double_t tol){
	fNullProfile.SetTolerance(tol);	fNullProfile.SetTolerance(tol);
	fAltProfile.SetTolerance(tol);	fAltProfile.SetTolerance(tol);
	}	}
	void SetPrintLevel(Int_t printLevel){	void SetPrintLevel(Int_t printLevel){
	fNullProfile.SetPrintLevel(printLevel);	fNullProfile.SetPrintLevel(printLevel);
	fAltProfile.SetPrintLevel(printLevel);	fAltProfile.SetPrintLevel(printLevel);
	}	}


		virtual const RooArgSet* GetDetailedOutput(void) const {
		// Returns detailed output. The value returned by this function
		is updated after each call to Evaluate().
		// The returned RooArgSet contains the following for the altern
		ative and null hypotheses:
		// <ul>
		// <li> the minimum nll, fitstatus and convergence quality for
		each fit </li>
		// <li> for each fit and for each non-constant parameter, the v
		alue, error and pull of the parameter are stored </li>
		// </ul>
		return fDetailedOutput;
		}

	virtual const TString GetVarName() const { return "log(L(#mu_{1},#hat{#n u}_{1}) / L(#mu_{0},#hat{#nu}_{0}))"; }	virtual const TString GetVarName() const { return "log(L(#mu_{1},#hat{#n u}_{1}) / L(#mu_{0},#hat{#nu}_{0}))"; }

	// const bool PValueIsRightTail(void) { return false; } // overwrite s default	// const bool PValueIsRightTail(void) { return false; } // overwrite s default

	void SetSubtractMLE(bool subtract){fSubtractMLE = subtract;}	void SetSubtractMLE(bool subtract){fSubtractMLE = subtract;}

	private:	private:
	ProfileLikelihoodTestStat fNullProfile;	ProfileLikelihoodTestStat fNullProfile;
	ProfileLikelihoodTestStat fAltProfile;	ProfileLikelihoodTestStat fAltProfile;


	RooArgSet* fAltPOI;	RooArgSet* fAltPOI;
	Bool_t fSubtractMLE;	Bool_t fSubtractMLE;
	static Bool_t fgAlwaysReuseNll ;	static Bool_t fgAlwaysReuseNll ;


		bool fDetailedOutputEnabled;
		RooArgSet* fDetailedOutput;

	protected:	protected:
	ClassDef(RatioOfProfiledLikelihoodsTestStat,3)	ClassDef(RatioOfProfiledLikelihoodsTestStat,3)
	};	};

	}	}

	#endif	#endif

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

	RooAbsArg.h	RooAbsArg.h

	skipping to change at line 33	skipping to change at line 33
	#include "RooPrintable.h"	#include "RooPrintable.h"
	#include "RooRefCountList.h"	#include "RooRefCountList.h"
	#include "RooAbsCache.h"	#include "RooAbsCache.h"
	#include "RooLinkedListIter.h"	#include "RooLinkedListIter.h"
	#include "RooNameReg.h"	#include "RooNameReg.h"
	#include <map>	#include <map>
	#include <set>	#include <set>
	#include <deque>	#include <deque>

	#include <iostream>	#include <iostream>

	using namespace std ;
	#include "TClass.h"	#include "TClass.h"

	class TTree ;	class TTree ;
	class RooArgSet ;	class RooArgSet ;
	class RooAbsCollection ;	class RooAbsCollection ;
	class RooTreeData ;	class RooTreeData ;
	class RooTreeDataStore ;	class RooTreeDataStore ;
	class RooVectorDataStore ;	class RooVectorDataStore ;
	class RooAbsData ;	class RooAbsData ;
	class RooAbsDataStore ;	class RooAbsDataStore ;

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

	RooAbsReal.h	RooAbsReal.h

	skipping to change at line 52	skipping to change at line 52
	class RooVectorDataStore ;	class RooVectorDataStore ;

	class TH1;	class TH1;
	class TH1F;	class TH1F;
	class TH2F;	class TH2F;
	class TH3F;	class TH3F;

	#include <list>	#include <list>
	#include <string>	#include <string>
	#include <iostream>	#include <iostream>

	using namespace std ;

	class RooAbsReal : public RooAbsArg {	class RooAbsReal : public RooAbsArg {
	public:	public:
	// Constructors, assignment etc	// Constructors, assignment etc
	RooAbsReal() ;	RooAbsReal() ;
	RooAbsReal(const char name, const char title, const char *unit= "") ;	RooAbsReal(const char name, const char title, const char *unit= "") ;
	RooAbsReal(const char name, const char title, Double_t minVal, Double_t maxVal,	RooAbsReal(const char name, const char title, Double_t minVal, Double_t maxVal,
	const char *unit= "") ;	const char *unit= "") ;
	RooAbsReal(const RooAbsReal& other, const char* name=0);	RooAbsReal(const RooAbsReal& other, const char* name=0);
	virtual ~RooAbsReal();	virtual ~RooAbsReal();

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

	RooArgSet.h	RooArgSet.h

	skipping to change at line 23	skipping to change at line 23
	* 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_ARG_SET	#ifndef ROO_ARG_SET
	#define ROO_ARG_SET	#define ROO_ARG_SET

	#include "RooAbsCollection.h"	#include "RooAbsCollection.h"
	#include "RooErrorHandler.h"	#include "RooErrorHandler.h"
	#include <map>	#include <map>
	#include <iostream>	#include <iostream>

	using namespace std ;

	class RooArgList ;	class RooArgList ;

	#define USEMEMPOOL	#define USEMEMPOOL

	class RooArgSet : public RooAbsCollection {	class RooArgSet : public RooAbsCollection {
	public:	public:

	#ifdef USEMEMPOOL	#ifdef USEMEMPOOL
	void* operator new (size_t bytes);	void* operator new (size_t bytes);

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

	RooCacheManager.h	RooCacheManager.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooCacheManager.h 42984 2012-02-13 15:30:31Z wouter $	* File: $Id: RooCacheManager.h 44368 2012-05-30 15:38:44Z axel $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */
	#ifndef ROO_CACHE_MANAGER	#ifndef ROO_CACHE_MANAGER
	#define ROO_CACHE_MANAGER	#define ROO_CACHE_MANAGER

	#include "Rtypes.h"	#include "Rtypes.h"


	#include "Riostream.h"
	#include "RooMsgService.h"	#include "RooMsgService.h"
	#include "RooNormSetCache.h"	#include "RooNormSetCache.h"
	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooArgSet.h"	#include "RooArgSet.h"
	#include "RooArgList.h"	#include "RooArgList.h"
	#include "RooAbsCache.h"	#include "RooAbsCache.h"
	#include "RooAbsCacheElement.h"	#include "RooAbsCacheElement.h"
	#include "RooNameReg.h"	#include "RooNameReg.h"
	#include <vector>	#include <vector>


	skipping to change at line 96	skipping to change at line 95
	T* getObjByIndex(Int_t index) const ;	T* getObjByIndex(Int_t index) const ;
	const RooNameSet* nameSet1ByIndex(Int_t index) const ;	const RooNameSet* nameSet1ByIndex(Int_t index) const ;
	const RooNameSet* nameSet2ByIndex(Int_t index) const ;	const RooNameSet* nameSet2ByIndex(Int_t index) const ;

	virtual void insertObjectHook(T&) {	virtual void insertObjectHook(T&) {
	// Interface function to perform post-insert operations on cached objec t	// Interface function to perform post-insert operations on cached objec t
	}	}

	void wireCache() {	void wireCache() {
	if (_size==0) {	if (_size==0) {

	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") no cached elements!" << endl ;	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") no cached elements!" << std::endl ;
	} else if (_size==1) {	} else if (_size==1) {

	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") now wiring cache" << endl ;	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") now wiring cache" << std::endl ;
	_wired=kTRUE ;	_wired=kTRUE ;
	} else if (_size>1) {	} else if (_size>1) {

	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") cache cannot be wired because it contains more than one element" << endl ;	oocoutI(_owner,Optimization) << "RooCacheManager::wireCache(" << _own er->GetName() << ") cache cannot be wired because it contains more than one element" << std::endl ;
	}	}
	}	}

	protected:	protected:

	Int_t _maxSize ; // Maximum size	Int_t _maxSize ; // Maximum size
	Int_t _size ; // Actual use	Int_t _size ; // Actual use
	Int_t _lastIndex ; // Last slot accessed	Int_t _lastIndex ; // Last slot accessed

	std::vector<RooNormSetCache> _nsetCache ; //! Normalization/Integration s et manager	std::vector<RooNormSetCache> _nsetCache ; //! Normalization/Integration s et manager

	skipping to change at line 168	skipping to change at line 167
	// Copy constructor	// Copy constructor

	_maxSize = other._maxSize ;	_maxSize = other._maxSize ;
	_size = other._size ;	_size = other._size ;

	_nsetCache.resize(_maxSize) ; // = new RooNormSetCache[_maxSize] ;	_nsetCache.resize(_maxSize) ; // = new RooNormSetCache[_maxSize] ;
	_object.resize(_maxSize,0) ; // = new T*[_maxSize] ;	_object.resize(_maxSize,0) ; // = new T*[_maxSize] ;
	_wired = kFALSE ;	_wired = kFALSE ;
	_lastIndex = -1 ;	_lastIndex = -1 ;


	// cout << "RooCacheManager:cctor(" << this << ")" << endl ;	// cout << "RooCacheManager:cctor(" << this << ")" << std::endl ;

	Int_t i ;	Int_t i ;
	for (i=0 ; i<other._size ; i++) {	for (i=0 ; i<other._size ; i++) {
	_nsetCache[i].initialize(other._nsetCache[i]) ;	_nsetCache[i].initialize(other._nsetCache[i]) ;
	_object[i] = 0 ;	_object[i] = 0 ;
	}	}

	for (i=other._size ; i<_maxSize ; i++) {	for (i=other._size ; i<_maxSize ; i++) {
	_object[i] = 0 ;	_object[i] = 0 ;
	}	}

	skipping to change at line 306	skipping to change at line 305
	return 0 ;	return 0 ;
	}	}

	template<class T>	template<class T>
	T* RooCacheManager<T>::getObjByIndex(Int_t index) const	T* RooCacheManager<T>::getObjByIndex(Int_t index) const
	{	{
	// Retrieve payload object by slot index	// Retrieve payload object by slot index

	if (index<0\|\|index>=_size) {	if (index<0\|\|index>=_size) {
	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("

	<< index << ") out of range [0," << _size -1 << "]" << endl ;	<< index << ") out of range [0," << _size -1 << "]" << std::endl ;
	return 0 ;	return 0 ;
	}	}
	return _object[index] ;	return _object[index] ;
	}	}

	template<class T>	template<class T>
	const RooNameSet* RooCacheManager<T>::nameSet1ByIndex(Int_t index) const	const RooNameSet* RooCacheManager<T>::nameSet1ByIndex(Int_t index) const
	{	{
	// Retrieve RooNameSet associated with slot at given index	// Retrieve RooNameSet associated with slot at given index

	if (index<0\|\|index>=_size) {	if (index<0\|\|index>=_size) {
	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("

	<< index << ") out of range [0," << _size -1 << "]" << endl ;	<< index << ") out of range [0," << _size -1 << "]" << std::endl ;
	return 0 ;	return 0 ;
	}	}
	return &_nsetCache[index].nameSet1() ;	return &_nsetCache[index].nameSet1() ;
	}	}

	template<class T>	template<class T>
	const RooNameSet* RooCacheManager<T>::nameSet2ByIndex(Int_t index) const	const RooNameSet* RooCacheManager<T>::nameSet2ByIndex(Int_t index) const
	{	{
	// Retrieve RooNameSet associated with slot at given index	// Retrieve RooNameSet associated with slot at given index

	if (index<0\|\|index>=_size) {	if (index<0\|\|index>=_size) {
	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("	oocoutE(_owner,ObjectHandling) << "RooCacheManager::getNormListByIndex: ERROR index ("

	<< index << ") out of range [0," << _size -1 << "]" << endl ;	<< index << ") out of range [0," << _size -1 << "]" << std::endl ;
	return 0 ;	return 0 ;
	}	}
	return &_nsetCache[index].nameSet2() ;	return &_nsetCache[index].nameSet2() ;
	}	}

	#endif	#endif

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

	RooFitResult.h	RooFitResult.h

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

	RooAbsPdf* createHessePdf(const RooArgSet& params) const ;	RooAbsPdf* createHessePdf(const RooArgSet& params) const ;

	// Accessors	// Accessors
	inline Int_t status() const {	inline Int_t status() const {
	// Return MINUIT status code	// Return MINUIT status code
	return _status ;	return _status ;
	}	}

	inline UInt_t numStatusHistory() const { return _statusHistory.size() ; }	inline UInt_t numStatusHistory() const { return _statusHistory.size() ; }

	Int_t statusCodeHistory(UInt_t icycle) ;	Int_t statusCodeHistory(UInt_t icycle) const ;
	const char* statusLabelHistory(UInt_t icycle) ;	const char* statusLabelHistory(UInt_t icycle) const ;

	inline Int_t covQual() const {	inline Int_t covQual() const {
	// Return MINUIT quality code of covariance matrix	// Return MINUIT quality code of covariance matrix
	return _covQual ;	return _covQual ;
	}	}
	inline Int_t numInvalidNLL() const {	inline Int_t numInvalidNLL() const {
	// Return number of NLL evaluations with problems	// Return number of NLL evaluations with problems
	return _numBadNLL ;	return _numBadNLL ;
	}	}
	inline Double_t edm() const {	inline Double_t edm() const {

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

	RooHistError.h	RooHistError.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_HIST_ERROR	#ifndef ROO_HIST_ERROR
	#define ROO_HIST_ERROR	#define ROO_HIST_ERROR

	#include "Rtypes.h"	#include "Rtypes.h"
	#include "RooNumber.h"	#include "RooNumber.h"
	#include "RooAbsFunc.h"	#include "RooAbsFunc.h"
	#include <math.h>	#include <math.h>
	#include <iostream>	#include <iostream>

	using namespace std ;

	class RooHistError {	class RooHistError {
	public:	public:
	static const RooHistError &instance();	static const RooHistError &instance();
	virtual ~RooHistError() {} ;	virtual ~RooHistError() {} ;

	Bool_t getPoissonInterval(Int_t n, Double_t &mu1, Double_t &mu2, Double_t nSigma= 1) const;	Bool_t getPoissonInterval(Int_t n, Double_t &mu1, Double_t &mu2, Double_t nSigma= 1) const;
	Bool_t getBinomialIntervalAsym(Int_t n, Int_t m, Double_t &a1, Double_t & a2, Double_t nSigma= 1) const;	Bool_t getBinomialIntervalAsym(Int_t n, Int_t m, Double_t &a1, Double_t & a2, Double_t nSigma= 1) const;
	Bool_t getBinomialIntervalEff(Int_t n, Int_t m, Double_t &a1, Double_t &a 2, Double_t nSigma= 1) const;	Bool_t getBinomialIntervalEff(Int_t n, Int_t m, Double_t &a1, Double_t &a 2, Double_t nSigma= 1) const;
	Bool_t getInterval(const RooAbsFunc Qu, const RooAbsFunc Ql, Double_t p ointEstimate, Double_t stepSize,	Bool_t getInterval(const RooAbsFunc Qu, const RooAbsFunc Ql, Double_t p ointEstimate, Double_t stepSize,

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

	RooMinimizerFcn.h	RooMinimizerFcn.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* @(#)root/roofitcore:$Id: RooMinimizerFcn.h 30408 2009-09-24 15:03:37Z wo uter $	* @(#)root/roofitcore:$Id: RooMinimizerFcn.h 44381 2012-05-31 06:45:52Z mo neta $
	* Authors: *	* Authors: *
	* AL, Alfio Lazzaro, INFN Milan, alfio.lazzaro@mi.infn.it *	* AL, Alfio Lazzaro, INFN Milan, alfio.lazzaro@mi.infn.it *
	* *	* *
	* *	* *
	* 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 __ROOFIT_NOROOMINIMIZER	#ifndef __ROOFIT_NOROOMINIMIZER

	skipping to change at line 74	skipping to change at line 74

	Double_t GetPdfParamVal(Int_t index);	Double_t GetPdfParamVal(Int_t index);
	Double_t GetPdfParamErr(Int_t index);	Double_t GetPdfParamErr(Int_t index);
	void SetPdfParamErr(Int_t index, Double_t value);	void SetPdfParamErr(Int_t index, Double_t value);
	void ClearPdfParamAsymErr(Int_t index);	void ClearPdfParamAsymErr(Int_t index);
	void SetPdfParamErr(Int_t index, Double_t loVal, Double_t hiVal);	void SetPdfParamErr(Int_t index, Double_t loVal, Double_t hiVal);

	inline Bool_t SetPdfParamVal(const Int_t &index, const Double_t &value) c onst;	inline Bool_t SetPdfParamVal(const Int_t &index, const Double_t &value) c onst;

	virtual double DoEval(const double * x) const;	virtual double DoEval(const double * x) const;

		void updateFloatVec() ;

	private:	private:

	RooAbsReal *_funct;	RooAbsReal *_funct;
	RooMinimizer *_context;	RooMinimizer *_context;

	mutable double _maxFCN;	mutable double _maxFCN;
	mutable int _numBadNLL;	mutable int _numBadNLL;
	mutable int _printEvalErrors;	mutable int _printEvalErrors;
	Bool_t _doEvalErrorWall;	Bool_t _doEvalErrorWall;

	int _nDim;	int _nDim;
	ofstream *_logfile;	ofstream *_logfile;
	bool _verbose;	bool _verbose;

	RooArgList* _floatParamList;	RooArgList* _floatParamList;

		std::vector<RooAbsArg*> _floatParamVec ;
	RooArgList* _constParamList;	RooArgList* _constParamList;
	RooArgList* _initFloatParamList;	RooArgList* _initFloatParamList;
	RooArgList* _initConstParamList;	RooArgList* _initConstParamList;

	};	};

	#endif	#endif
	#endif	#endif

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

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

	* File: $Id: RooMultiVarGaussian.h 42242 2011-11-25 14:02:26Z wouter $	* File: $Id: RooMultiVarGaussian.h 44368 2012-05-30 15:38:44Z axel $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *

	skipping to change at line 58	skipping to change at line 58
	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 initGenerator(Int_t code) ;	void initGenerator(Int_t code) ;
	void generateEvent(Int_t code);	void generateEvent(Int_t code);

	const TMatrixDSym& covarianceMatrix() const { return _cov ; }	const TMatrixDSym& covarianceMatrix() const { return _cov ; }

	class AnaIntData {	class AnaIntData {
	public:	public:
	TMatrixD S22bar ;	TMatrixD S22bar ;
	Double_t S22det ;	Double_t S22det ;

	vector<int> pmap ;	std::vector<int> pmap ;
	Int_t nint ;	Int_t nint ;
	} ;	} ;

	class GenData {	class GenData {
	public:	public:
	TMatrixD UT ;	TMatrixD UT ;

	vector<int> omap ;	std::vector<int> omap ;
	vector<int> pmap ;	std::vector<int> pmap ;
	TVectorD mu1 ;	TVectorD mu1 ;
	TVectorD mu2 ;	TVectorD mu2 ;
	TMatrixD S12S22I ;	TMatrixD S12S22I ;
	} ;	} ;

	class BitBlock {	class BitBlock {
	public:	public:
	BitBlock() : b0(0), b1(0), b2(0), b3(0) {} ;	BitBlock() : b0(0), b1(0), b2(0), b3(0) {} ;

	void setBit(Int_t ibit) ;	void setBit(Int_t ibit) ;
	Bool_t getBit(Int_t ibit) ;	Bool_t getBit(Int_t ibit) ;
	Bool_t operator==(const BitBlock& other) ;	Bool_t operator==(const BitBlock& other) ;

	Int_t b0 ;	Int_t b0 ;
	Int_t b1 ;	Int_t b1 ;
	Int_t b2 ;	Int_t b2 ;
	Int_t b3 ;	Int_t b3 ;
	} ;	} ;


	static void blockDecompose(const TMatrixD& input, const vector<int>& map1 , const vector<int>& map2, TMatrixDSym& S11, TMatrixD& S12, TMatrixD& S21, TMatrixDSym& S22) ;	static void blockDecompose(const TMatrixD& input, const std::vector<int>& map1, const std::vector<int>& map2, TMatrixDSym& S11, TMatrixD& S12, TMatr ixD& S21, TMatrixDSym& S22) ;

	protected:	protected:


	void decodeCode(Int_t code, vector<int>& map1, vector<int>& map2) const;	void decodeCode(Int_t code, std::vector<int>& map1, std::vector<int>& map 2) const;
	AnaIntData& anaIntData(Int_t code) const ;	AnaIntData& anaIntData(Int_t code) const ;
	GenData& genData(Int_t code) const ;	GenData& genData(Int_t code) const ;

	mutable std::map<int,AnaIntData> _anaIntCache ; //!	mutable std::map<int,AnaIntData> _anaIntCache ; //!
	mutable std::map<int,GenData> _genCache ; //!	mutable std::map<int,GenData> _genCache ; //!

	mutable std::vector<BitBlock> _aicMap ; //!	mutable std::vector<BitBlock> _aicMap ; //!

	RooListProxy _x ;	RooListProxy _x ;
	RooListProxy _mu ;	RooListProxy _mu ;

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

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

	* File: $Id: RooNDKeysPdf.h 37727 2011-01-06 13:56:56Z wouter $	* File: $Id: RooNDKeysPdf.h 44368 2012-05-30 15:38:44Z axel $
	* Authors: *	* Authors: *
	* Max Baak, CERN, mbaak@cern.ch *	* Max Baak, CERN, mbaak@cern.ch *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *
	************************************************************************ */	************************************************************************ */

	skipping to change at line 33	skipping to change at line 33
	#include "TMatrixD.h"	#include "TMatrixD.h"
	#include "TMatrixDSym.h"	#include "TMatrixDSym.h"
	#include <map>	#include <map>
	#include <vector>	#include <vector>
	#include <string>	#include <string>

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


	using namespace std;

	#ifndef __CINT__	#ifndef __CINT__
	class VecVecDouble : public std::vector<std::vector<Double_t> > { } ;	class VecVecDouble : public std::vector<std::vector<Double_t> > { } ;
	class VecTVecDouble : public std::vector<TVectorD> { } ;	class VecTVecDouble : public std::vector<TVectorD> { } ;
	typedef std::pair<Int_t, VecVecDouble::iterator > iiPair;	typedef std::pair<Int_t, VecVecDouble::iterator > iiPair;
	typedef std::vector< iiPair > iiVec;	typedef std::vector< iiPair > iiVec;
	typedef std::pair<Int_t, VecTVecDouble::iterator > itPair;	typedef std::pair<Int_t, VecTVecDouble::iterator > itPair;
	typedef std::vector< itPair > itVec;	typedef std::vector< itPair > itVec;
	#else	#else
	class itPair ;	class itPair ;
	#endif	#endif

	skipping to change at line 85	skipping to change at line 83
	inline void fixShape(Bool_t fix) {	inline void fixShape(Bool_t fix) {
	createPdf(kFALSE);	createPdf(kFALSE);
	_fixedShape=fix;	_fixedShape=fix;
	}	}

	struct BoxInfo {	struct BoxInfo {
	Bool_t filled;	Bool_t filled;
	Bool_t netFluxZ;	Bool_t netFluxZ;
	Double_t nEventsBW;	Double_t nEventsBW;
	Double_t nEventsBMSW;	Double_t nEventsBMSW;

	vector<Double_t> xVarLo, xVarHi;	std::vector<Double_t> xVarLo, xVarHi;
	vector<Double_t> xVarLoM3s, xVarLoP3s, xVarHiM3s, xVarHiP3s;	std::vector<Double_t> xVarLoM3s, xVarLoP3s, xVarHiM3s, xVarHiP3s;
	map<Int_t,Bool_t> bpsIdcs;	std::map<Int_t,Bool_t> bpsIdcs;
	vector<Int_t> sIdcs;	std::vector<Int_t> sIdcs;
	vector<Int_t> bIdcs;	std::vector<Int_t> bIdcs;
	vector<Int_t> bmsIdcs;	std::vector<Int_t> bmsIdcs;
	} ;	} ;

	protected:	protected:

	RooListProxy _varList ;	RooListProxy _varList ;
	TIterator* _varItr ; //! do not persist	TIterator* _varItr ; //! do not persist

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

	void createPdf(Bool_t firstCall=kTRUE) const;	void createPdf(Bool_t firstCall=kTRUE) const;
	void setOptions() const;	void setOptions() const;
	void initialize() const;	void initialize() const;
	void loadDataSet(Bool_t firstCall) const;	void loadDataSet(Bool_t firstCall) const;
	void mirrorDataSet() const;	void mirrorDataSet() const;
	void loadWeightSet() const;	void loadWeightSet() const;
	void calculateShell(BoxInfo* bi) const;	void calculateShell(BoxInfo* bi) const;
	void calculatePreNorm(BoxInfo* bi) const;	void calculatePreNorm(BoxInfo* bi) const;
	void sortDataIndices(BoxInfo* bi=0) const;	void sortDataIndices(BoxInfo* bi=0) const;
	void calculateBandWidth() const;	void calculateBandWidth() const;

	Double_t gauss(vector<Double_t>& x, vector<vector<Double_t> >& weights) c	Double_t gauss(std::vector<Double_t>& x, std::vector<std::vector<Double_t
	onst;	> >& weights) const;
	void loopRange(vector<Double_t>& x, map<Int_t,Bool_t>& ibMap) const;	void loopRange(std::vector<Double_t>& x, std::map<Int_t,Bool_t>& ibMa
		p) const;
	void boxInfoInit(BoxInfo* bi, const char* rangeName, Int_t code) cons t;	void boxInfoInit(BoxInfo* bi, const char* rangeName, Int_t code) cons t;

	RooDataSet& _data;	RooDataSet& _data;
	mutable TString _options;	mutable TString _options;
	mutable Double_t _widthFactor;	mutable Double_t _widthFactor;
	mutable Double_t _nSigma;	mutable Double_t _nSigma;

	mutable Bool_t _fixedShape;	mutable Bool_t _fixedShape;
	mutable Bool_t _mirror;	mutable Bool_t _mirror;
	mutable Bool_t _debug;	mutable Bool_t _debug;

	skipping to change at line 134	skipping to change at line 132
	mutable Double_t _sqrt2pi;	mutable Double_t _sqrt2pi;
	mutable Int_t _nDim;	mutable Int_t _nDim;
	mutable Int_t _nEvents;	mutable Int_t _nEvents;
	mutable Int_t _nEventsM;	mutable Int_t _nEventsM;
	mutable Double_t _nEventsW;	mutable Double_t _nEventsW;
	mutable Double_t _d;	mutable Double_t _d;
	mutable Double_t _n;	mutable Double_t _n;

	// cached info on variable	// cached info on variable


	mutable vector<vector<Double_t> > _dataPts;	mutable std::vector<std::vector<Double_t> > _dataPts;
	mutable vector<TVectorD> _dataPtsR;	mutable std::vector<TVectorD> _dataPtsR;
	mutable vector<vector<Double_t> > _weights0;	mutable std::vector<std::vector<Double_t> > _weights0;
	mutable vector<vector<Double_t> > _weights1;	mutable std::vector<std::vector<Double_t> > _weights1;
	mutable vector<vector<Double_t> >* _weights; //!	mutable std::vector<std::vector<Double_t> >* _weights; //!

	#ifndef __CINT__	#ifndef __CINT__

	mutable vector<iiVec> _sortIdcs;	mutable std::vector<iiVec> _sortIdcs;
	mutable vector<itVec> _sortTVIdcs;	mutable std::vector<itVec> _sortTVIdcs;
	#endif	#endif


	mutable vector<string> _varName;	mutable std::vector<std::string> _varName;
	mutable vector<Double_t> _rho;	mutable std::vector<Double_t> _rho;
	mutable RooArgSet _dataVars;	mutable RooArgSet _dataVars;

	mutable vector<Double_t> _x;	mutable std::vector<Double_t> _x;
	mutable vector<Double_t> _x0, _x1, _x2;	mutable std::vector<Double_t> _x0, _x1, _x2;
	mutable vector<Double_t> _mean, _sigma;	mutable std::vector<Double_t> _mean, _sigma;
	mutable vector<Double_t> _xDatLo, _xDatHi;	mutable std::vector<Double_t> _xDatLo, _xDatHi;
	mutable vector<Double_t> _xDatLo3s, _xDatHi3s;	mutable std::vector<Double_t> _xDatLo3s, _xDatHi3s;

	mutable Bool_t _netFluxZ;	mutable Bool_t _netFluxZ;
	mutable Double_t _nEventsBW;	mutable Double_t _nEventsBW;
	mutable Double_t _nEventsBMSW;	mutable Double_t _nEventsBMSW;

	mutable vector<Double_t> _xVarLo, _xVarHi;	mutable std::vector<Double_t> _xVarLo, _xVarHi;
	mutable vector<Double_t> _xVarLoM3s, _xVarLoP3s, _xVarHiM3s, _xVarHiP3s;	mutable std::vector<Double_t> _xVarLoM3s, _xVarLoP3s, _xVarHiM3s, _xVarHi
	mutable map<Int_t,Bool_t> _bpsIdcs;	P3s;
	mutable vector<Int_t> _sIdcs;	mutable std::map<Int_t,Bool_t> _bpsIdcs;
	mutable vector<Int_t> _bIdcs;	mutable std::vector<Int_t> _sIdcs;
	mutable vector<Int_t> _bmsIdcs;	mutable std::vector<Int_t> _bIdcs;
		mutable std::vector<Int_t> _bmsIdcs;


	mutable map<pair<string,int>,BoxInfo*> _rangeBoxInfo ;	mutable std::map<std::pair<std::string,int>,BoxInfo*> _rangeBoxInfo ;
	mutable BoxInfo _fullBoxInfo ;	mutable BoxInfo _fullBoxInfo ;


	mutable vector<Int_t> _idx;	mutable std::vector<Int_t> _idx;
	mutable Double_t _minWeight;	mutable Double_t _minWeight;
	mutable Double_t _maxWeight;	mutable Double_t _maxWeight;

	mutable map<Int_t,Double_t> _wMap;	mutable std::map<Int_t,Double_t> _wMap;

	mutable TMatrixDSym* _covMat;	mutable TMatrixDSym* _covMat;
	mutable TMatrixDSym* _corrMat;	mutable TMatrixDSym* _corrMat;
	mutable TMatrixD* _rotMat;	mutable TMatrixD* _rotMat;
	mutable TVectorD* _sigmaR;	mutable TVectorD* _sigmaR;
	mutable TVectorD* _dx;	mutable TVectorD* _dx;
	mutable Double_t _sigmaAvgR;	mutable Double_t _sigmaAvgR;

	mutable Bool_t _rotate;	mutable Bool_t _rotate;


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

	RooStatsUtils.h	RooStatsUtils.h

	// @(#)root/roostats:$Id: RooStatsUtils.h 42259 2011-11-25 21:29:16Z moneta $	// @(#)root/roostats:$Id: RooStatsUtils.h 44157 2012-05-07 16:41:44Z moneta $
	// Author: Kyle Cranmer 28/07/2008	// Author: Kyle Cranmer 28/07/2008

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_RooStatsUtils	#ifndef ROOSTATS_RooStatsUtils
	#define ROOSTATS_RooStatsUtils	#define ROOSTATS_RooStatsUtils

	#ifndef ROOT_TMath	#ifndef ROOT_TMath
	#include "TMath.h"	#include "TMath.h"
	#endif	#endif


		#ifndef ROOT_TTree
		#include "TTree.h"
		#endif

	#ifndef ROOT_Math_DistFuncMathCore	#ifndef ROOT_Math_DistFuncMathCore
	#include"Math/DistFuncMathCore.h"	#include"Math/DistFuncMathCore.h"
	#endif	#endif

	#include "RooArgSet.h"	#include "RooArgSet.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooAbsCollection.h"	#include "RooAbsCollection.h"
	#include "TIterator.h"	#include "TIterator.h"
	#include "RooStats/ModelConfig.h"	#include "RooStats/ModelConfig.h"
	#include "RooProdPdf.h"	#include "RooProdPdf.h"

		#include "RooDataSet.h"
	#include <iostream>
	using namespace std ;

	namespace RooStats {	namespace RooStats {

	// returns one-sided significance corresponding to a p-value	// returns one-sided significance corresponding to a p-value
	inline Double_t PValueToSignificance(Double_t pvalue){	inline Double_t PValueToSignificance(Double_t pvalue){
	return ::ROOT::Math::normal_quantile_c(pvalue,1);	return ::ROOT::Math::normal_quantile_c(pvalue,1);
	}	}

	// returns p-value corresponding to a 1-sided significance	// returns p-value corresponding to a 1-sided significance
	inline Double_t SignificanceToPValue(Double_t Z){	inline Double_t SignificanceToPValue(Double_t Z){

	skipping to change at line 103	skipping to change at line 105
	}	}

	void FactorizePdf(const RooArgSet &observables, RooAbsPdf &pdf, RooArgLi st &obsTerms, RooArgList &constraints);	void FactorizePdf(const RooArgSet &observables, RooAbsPdf &pdf, RooArgLi st &obsTerms, RooArgList &constraints);

	void FactorizePdf(RooStats::ModelConfig &model, RooAbsPdf &pdf, RooArgLi st &obsTerms, RooArgList &constraints);	void FactorizePdf(RooStats::ModelConfig &model, RooAbsPdf &pdf, RooArgLi st &obsTerms, RooArgList &constraints);

	RooAbsPdf * MakeNuisancePdf(RooAbsPdf &pdf, const RooArgSet &observables , const char *name);	RooAbsPdf * MakeNuisancePdf(RooAbsPdf &pdf, const RooArgSet &observables , const char *name);

	RooAbsPdf * MakeNuisancePdf(const RooStats::ModelConfig &model, const ch ar *name);	RooAbsPdf * MakeNuisancePdf(const RooStats::ModelConfig &model, const ch ar *name);


		// Create a TTree with the given name and description. All RooRealVars i
		n the RooDataSet are represented as branches that contain values of type Do
		uble_t.
		TTree* GetAsTTree(TString name, TString desc, const RooDataSet& data);

	}	}

	#endif	#endif

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

	RooUnitTest.h	RooUnitTest.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooUnitTest.h 42657 2012-01-17 07:59:06Z axel $	* File: $Id: RooUnitTest.h 44077 2012-05-02 17:10:21Z moneta $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *	* WV, Wouter Verkerke, NIKHEF, verkerke@nikhef.nl *
	* *	* *
	* Copyright (c) 2000-2011, Regents of the University of California *	* Copyright (c) 2000-2011, 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) *
	************************************************************************ */	************************************************************************ */

	skipping to change at line 68	skipping to change at line 68
	static void setMemDir(TDirectory* memDir);	static void setMemDir(TDirectory* memDir);

	protected:	protected:

	static TDirectory* gMemDir ;	static TDirectory* gMemDir ;

	TFile* _refFile ;	TFile* _refFile ;
	Bool_t _debug ;	Bool_t _debug ;
	Bool_t _write ;	Bool_t _write ;
	Int_t _verb ;	Int_t _verb ;

	std::list<std::pair<RooPlot*, string> > _regPlots ;	std::list<std::pair<RooPlot*, std::string> > _regPlots ;
	std::list<std::pair<RooFitResult*, string> > _regResults ;	std::list<std::pair<RooFitResult*, std::string> > _regResults ;
	std::list<std::pair<Double_t, string> > _regValues ;	std::list<std::pair<Double_t, std::string> > _regValues ;
	std::list<std::pair<RooTable*,string> > _regTables ;	std::list<std::pair<RooTable*,std::string> > _regTables ;
	std::list<std::pair<RooWorkspace*,string> > _regWS ;	std::list<std::pair<RooWorkspace*,std::string> > _regWS ;
	std::list<std::pair<TH1*,string> > _regTH ;	std::list<std::pair<TH1*,std::string> > _regTH ;

	ClassDef(RooUnitTest,0) ; // Abstract base class for RooFit/RooStats unit regression tests	ClassDef(RooUnitTest,0) ; // Abstract base class for RooFit/RooStats unit regression tests
	} ;	} ;
	#endif	#endif

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

	RooVectorDataStore.h	RooVectorDataStore.h
	/************************************************************************ *	/************************************************************************ *
	* Project: RooFit *	* Project: RooFit *
	* Package: RooFitCore *	* Package: RooFitCore *

	* File: $Id: RooVectorDataStore.h 42950 2012-02-09 21:21:53Z wouter $	* File: $Id: RooVectorDataStore.h 44077 2012-05-02 17:10:21Z moneta $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *

	skipping to change at line 259	skipping to change at line 259

	virtual ~RealFullVector() {	virtual ~RealFullVector() {
	if (_vecE) delete _vecE ;	if (_vecE) delete _vecE ;
	if (_vecEL) delete _vecEL ;	if (_vecEL) delete _vecEL ;
	if (_vecEH) delete _vecEH ;	if (_vecEH) delete _vecEH ;
	}	}

	RealFullVector(const RealFullVector& other, RooAbsReal* real=0) : RealV ector(other,real),	RealFullVector(const RealFullVector& other, RooAbsReal* real=0) : RealV ector(other,real),
	_bufE(other._bufE), _bufEL(other._bufEL), _bufEH(other._bufEH),	_bufE(other._bufE), _bufEL(other._bufEL), _bufEH(other._bufEH),
	_nativeBufE(other._nativeBufE), _nativeBufEL(other._nativeBufEL), _na tiveBufEH(other._nativeBufEH) {	_nativeBufE(other._nativeBufE), _nativeBufEL(other._nativeBufEL), _na tiveBufEH(other._nativeBufEH) {

	_vecE = (other._vecE) ? new vector<Double_t>(*other._vecE) : 0 ;	_vecE = (other._vecE) ? new std::vector<Double_t>(*other._vecE) : 0 ;
	_vecEL = (other._vecEL) ? new vector<Double_t>(*other._vecEL) : 0 ;	_vecEL = (other._vecEL) ? new std::vector<Double_t>(*other._vecEL) :
	_vecEH = (other._vecEH) ? new vector<Double_t>(*other._vecEH) : 0 ;	0 ;
		_vecEH = (other._vecEH) ? new std::vector<Double_t>(*other._vecEH) :
		0 ;
	}	}

	RealFullVector(const RealVector& other, RooAbsReal* real=0) : RealVecto r(other,real),	RealFullVector(const RealVector& other, RooAbsReal* real=0) : RealVecto r(other,real),
	_bufE(0), _bufEL(0), _bufEH(0),	_bufE(0), _bufEL(0), _bufEH(0),
	_nativeBufE(0), _nativeBufEL(0), _nativeBufEH(0) {	_nativeBufE(0), _nativeBufEL(0), _nativeBufEH(0) {
	_vecE = 0 ;	_vecE = 0 ;
	_vecEL = 0 ;	_vecEL = 0 ;
	_vecEH = 0 ;	_vecEH = 0 ;
	}	}

	RealFullVector& operator=(const RealFullVector& other) {	RealFullVector& operator=(const RealFullVector& other) {
	if (&other==this) return *this ;	if (&other==this) return *this ;
	RealVector::operator=(other) ;	RealVector::operator=(other) ;
	_bufE = other._bufE ;	_bufE = other._bufE ;
	_bufEL = other._bufEL ;	_bufEL = other._bufEL ;
	_bufEH = other._bufEH ;	_bufEH = other._bufEH ;
	_nativeBufE = other._nativeBufE ;	_nativeBufE = other._nativeBufE ;
	_nativeBufEL = other._nativeBufEL ;	_nativeBufEL = other._nativeBufEL ;
	_nativeBufEH = other._nativeBufEH ;	_nativeBufEH = other._nativeBufEH ;

	_vecE = other._vecE ? new vector<Double_t>(*other._vecE) : 0 ;	_vecE = other._vecE ? new std::vector<Double_t>(*other._vecE) : 0 ;
	_vecEL = other._vecEL ? new vector<Double_t>(*other._vecEL) : 0 ;	_vecEL = other._vecEL ? new std::vector<Double_t>(*other._vecEL) : 0
	_vecEH = other._vecEH ? new vector<Double_t>(*other._vecEH) : 0 ;	;
		_vecEH = other._vecEH ? new std::vector<Double_t>(*other._vecEH) : 0
		;
	return *this ;	return *this ;
	}	}

	void setErrorBuffer(Double_t* newBuf) {	void setErrorBuffer(Double_t* newBuf) {
	/* cout << "setErrorBuffer(" << _nativeReal->GetName() << ") newBuf = " << newBuf << endl ; */	/* cout << "setErrorBuffer(" << _nativeReal->GetName() << ") newBuf = " << newBuf << endl ; */
	_bufE = newBuf ;	_bufE = newBuf ;

	if (!_vecE) _vecE = new vector<Double_t> ;	if (!_vecE) _vecE = new std::vector<Double_t> ;
	_vecE->reserve(_vec.capacity()) ;	_vecE->reserve(_vec.capacity()) ;
	if (!_nativeBufE) _nativeBufE = _bufE ;	if (!_nativeBufE) _nativeBufE = _bufE ;
	}	}
	void setAsymErrorBuffer(Double_t* newBufL, Double_t* newBufH) {	void setAsymErrorBuffer(Double_t* newBufL, Double_t* newBufH) {
	_bufEL = newBufL ; _bufEH = newBufH ;	_bufEL = newBufL ; _bufEH = newBufH ;
	if (!_vecEL) {	if (!_vecEL) {

	_vecEL = new vector<Double_t> ;	_vecEL = new std::vector<Double_t> ;
	_vecEH = new vector<Double_t> ;	_vecEH = new std::vector<Double_t> ;
	_vecEL->reserve(_vec.capacity()) ;	_vecEL->reserve(_vec.capacity()) ;
	_vecEH->reserve(_vec.capacity()) ;	_vecEH->reserve(_vec.capacity()) ;
	}	}
	if (!_nativeBufEL) {	if (!_nativeBufEL) {
	_nativeBufEL = _bufEL ;	_nativeBufEL = _bufEL ;
	_nativeBufEH = _bufEH ;	_nativeBufEH = _bufEH ;
	}	}
	}	}

	inline void getNative(Int_t idx) const {	inline void getNative(Int_t idx) const {

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

	RootFinder.h	RootFinder.h

	// @(#)root/tmva $Id: RootFinder.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/mathmore:$Id: RootFinder.h 33942 2010-06-16 13:12:17Z moneta $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Authors: L. Moneta, A. Zsenei 08/2005


	/**************************************************************************	/**********************************************************************
	********	* *
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	*	* *
	* Package: TMVA	* This library is free software; you can redistribute it and/or *
	*	* modify it under the terms of the GNU General Public License *
	* Class : RootFinder	* as published by the Free Software Foundation; either version 2 *
	*	* of the License, or (at your option) any later version. *
	* Web : http://tmva.sourceforge.net	* *
	*	* This library is distributed in the hope that it will be useful, *
	*	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	*	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
	* Description:	* General Public License for more details. *
	*	* *
	* Root finding using Brents algorithm	* You should have received a copy of the GNU General Public License *
	*	* along with this library (see file COPYING); if not, write *
	* (translated from CERNLIB function RZERO)	* to the Free Software Foundation, Inc., 59 Temple Place, Suite *
	*	* 330, Boston, MA 02111-1307 USA, or contact the author. *
	*	* *
	*	**********************************************************************/
	* Authors (alphabetical):
	*	// Header file for class RootFinder
	* Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland	//
	*	// Created by: moneta at Sun Nov 14 16:59:55 2004
	* Helge Voss <Helge.Voss@cern.ch> - MPI-K Heidelberg, German	//
	y *	// Last update: Sun Nov 14 16:59:55 2004
	* Kai Voss <Kai.Voss@cern.ch> - U. of Victoria, Canada	//
	*	#ifndef ROOT_Math_RootFinder
	*	#define ROOT_Math_RootFinder
	*
	* Copyright (c) 2005:
	*
	* CERN, Switzerland
	*
	* U. of Victoria, Canada
	*
	* MPI-K Heidelberg, Germany
	*
	*
	*
	* Redistribution and use in source and binary forms, with or without
	*
	* modification, are permitted according to the terms listed in LICENSE
	*
	* (http://tmva.sourceforge.net/LICENSE)
	*
	**************************************************************************
	********/

	#ifndef ROOT_TMVA_RootFinder
	#define ROOT_TMVA_RootFinder

	//////////////////////////////////////////////////////////////////////////
	// //
	// RootFinder //
	// //
	// Root finding using Brents algorithm //
	// (translated from CERNLIB function RZERO) //
	// //
	//////////////////////////////////////////////////////////////////////////


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


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

	class RootFinder : public TObject {

	public:

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

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


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

		@ingroup NumAlgo
		*/

		namespace ROOT {
		namespace Math {

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

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

		This class does not cupport copying

		@ingroup RootFinders

		*/

		class RootFinder {

		public:

		enum EType { kBRENT, // Methods
		from MathCore
		kGSL_BISECTION, kGSL_FALSE_POS, kGSL_BRENT, // GSL Nor
		mal
		kGSL_NEWTON, kGSL_SECANT, kGSL_STEFFENSON // GSL Der
		ivatives
		};

		/**
		Construct a Root-Finder algorithm
		*/
		RootFinder(RootFinder::EType type = RootFinder::kBRENT);
		virtual ~RootFinder();

		private:
		// usually copying is non trivial, so we make this unaccessible
		RootFinder(const RootFinder & ) {}
		RootFinder & operator = (const RootFinder & rhs)
		{
		if (this == &rhs) return *this; // time saving self-test
		return *this;
		}

		public:

		bool SetMethod(RootFinder::EType type = RootFinder::kBRENT);

		/**
		Provide to the solver the function and the initial search inter
		val [xlow, xup]
		for algorithms not using derivatives (bracketing algorithms)
		The templated function f must be of a type implementing the \a
		operator() method,
		<em> double operator() ( double x ) </em>
		Returns non zero if interval is not valid (i.e. does not contai
		ns a root)
		*/

		bool SetFunction( const IGenFunction & f, double xlow, double xup)
		{
		return fSolver->SetFunction( f, xlow, xup);
		}

		/**
		Provide to the solver the function and an initial estimate of t
		he root,
		for algorithms using derivatives.
		The templated function f must be of a type implementing the \a
		operator()
		and the \a Gradient() methods.
		<em> double operator() ( double x ) </em>
		Returns non zero if starting point is not valid
		*/

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

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

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

		/**
		Compute the roots iterating until the estimate of the Root is
		within the required tolerance returning
		the iteration Status
		*/
		bool Solve( int maxIter = 100, double absTol = 1E-8, double relTol
		= 1E-10) {
		return fSolver->Solve( maxIter, absTol, relTol );
		}

		/**
		Return the number of iteration performed to find the Root.
		*/
		int Iterations() const {
		return fSolver->Iterations();
		}

		/**
		Perform a single iteration and return the Status
		*/
		int Iterate() {
		return fSolver->Iterate();
		}

		/**
		Return the current and latest estimate of the Root
		*/
		double Root() const {
		return fSolver->Root();
		}

		/**
		Return the status of the last estimate of the Root
		= 0 OK, not zero failure
		*/
		int Status() const {
		return fSolver->Status();
		}

		/**
		Return the current and latest estimate of the lower value of th
		e Root-finding interval (for bracketing algorithms)
		*/
		/* double XLower() const { */
		/* return fSolver->XLower(); */
		/* } */

		/**
		Return the current and latest estimate of the upper value of th
		e Root-finding interval (for bracketing algorithms)
		*/
		/* double XUpper() const { */
		/* return fSolver->XUpper(); */
		/* } */

		/**
		Get Name of the Root-finding solver algorithm
		*/
		const char * Name() const {
		return fSolver->Name();
		}

		protected:

		private:

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


	Double_t fRootMin; // minimum root value	};
	Double_t fRootMax; // maximum root value
	Int_t fMaxIter; // maximum number of iterations
	Double_t fAbsTol; // absolute tolerance deviation


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


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


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


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

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


	#endif	#endif /* ROOT_Math_RootFinder */

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

	Rtypes.h	Rtypes.h

	/* @(#)root/base:$Id: Rtypes.h 39611 2011-06-08 19:35:17Z pcanal $ */	/* @(#)root/base:$Id: Rtypes.h 43708 2012-04-12 10:19:00Z axel $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_Rtypes	#ifndef ROOT_Rtypes

	skipping to change at line 274	skipping to change at line 274
	// the class comment string.	// the class comment string.
	#define _ClassDef_(name,id) \	#define _ClassDef_(name,id) \
	private: \	private: \
	static TClass *fgIsA; \	static TClass *fgIsA; \
	public: \	public: \
	static TClass *Class(); \	static TClass *Class(); \
	static const char *Class_Name(); \	static const char *Class_Name(); \
	static Version_t Class_Version() { return id; } \	static Version_t Class_Version() { return id; } \
	static void Dictionary(); \	static void Dictionary(); \
	virtual TClass *IsA() const { return name::Class(); } \	virtual TClass *IsA() const { return name::Class(); } \

	virtual void ShowMembers(TMemberInspector &insp); \	virtual void ShowMembers(TMemberInspector&); \
	virtual void Streamer(TBuffer &b); \	virtual void Streamer(TBuffer&); \
	void StreamerNVirtual(TBuffer &b) { name::Streamer(b); } \	void StreamerNVirtual(TBuffer&ClassDef_StreamerNVirtual_b) { name::Strea
		mer(ClassDef_StreamerNVirtual_b); } \
	static const char *DeclFileName() { return __FILE__; } \	static const char *DeclFileName() { return __FILE__; } \
	static int ImplFileLine(); \	static int ImplFileLine(); \
	static const char *ImplFileName();	static const char *ImplFileName();

	// Version without any virtual functions.	// Version without any virtual functions.
	#define _ClassDefNV_(name,id) \	#define _ClassDefNV_(name,id) \
	private: \	private: \
	static TClass *fgIsA; \	static TClass *fgIsA; \
	public: \	public: \
	static TClass *Class(); \	static TClass *Class(); \
	static const char *Class_Name(); \	static const char *Class_Name(); \
	static Version_t Class_Version() { return id; } \	static Version_t Class_Version() { return id; } \
	static void Dictionary(); \	static void Dictionary(); \
	TClass *IsA() const { return name::Class(); } \	TClass *IsA() const { return name::Class(); } \

	void ShowMembers(TMemberInspector &insp); \	void ShowMembers(TMemberInspector&); \
	void Streamer(TBuffer &b); \	void Streamer(TBuffer&); \
	void StreamerNVirtual(TBuffer &b) { name::Streamer(b); } \	void StreamerNVirtual(TBuffer &ClassDef_StreamerNVirtual_b) { name::Streame
		r(ClassDef_StreamerNVirtual_b); } \
	static const char *DeclFileName() { return __FILE__; } \	static const char *DeclFileName() { return __FILE__; } \
	static int ImplFileLine(); \	static int ImplFileLine(); \
	static const char *ImplFileName();	static const char *ImplFileName();

	#if !defined(R__CONCRETE_INPUT_OPERATOR)	#if !defined(R__CONCRETE_INPUT_OPERATOR)
	#if !defined(R__ACCESS_IN_SYMBOL) \|\| defined(__CINT__)	#if !defined(R__ACCESS_IN_SYMBOL) \|\| defined(__CINT__)

	#define ClassDef(name,id) \	#define ClassDef(name,id) \
	_ClassDef_(name,id) \	_ClassDef_(name,id) \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#define ClassDefNV(name,id) \	#define ClassDefNV(name,id) \
	_ClassDefNV_(name,id) \	_ClassDefNV_(name,id) \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#else	#else

	#define ClassDef(name,id) \	#define ClassDef(name,id) \
	_ClassDef_(name,id) \	_ClassDef_(name,id) \

	friend void ROOT__ShowMembersFunc(name *obj, TMemberInspector &R__insp); \	friend void ROOT__ShowMembersFunc(name*, TMemberInspector&); \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#define ClassDefNV(name,id) \	#define ClassDefNV(name,id) \
	_ClassDefNV_(name,id) \	_ClassDefNV_(name,id) \

	friend void ROOT__ShowMembersFunc(name *obj, TMemberInspector &R__insp); \	friend void ROOT__ShowMembersFunc(name*, TMemberInspector&); \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#endif	#endif

	#else	#else

	#define ClassDef(name,id) \	#define ClassDef(name,id) \
	_ClassDef_(name,id) \	_ClassDef_(name,id) \

	friend TBuffer &operator>>(TBuffer &buf, name *&obj); \	friend TBuffer &operator>>(TBuffer&, name *&); \
	friend TBuffer &operator>>(TBuffer &buf, const name *&obj); \	friend TBuffer &operator>>(TBuffer&, const name *&); \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#define ClassDefNV(name,id) \	#define ClassDefNV(name,id) \
	_ClassDefNV_(name,id) \	_ClassDefNV_(name,id) \

	friend TBuffer &operator>>(TBuffer &buf, name *&obj); \	friend TBuffer &operator>>(TBuffer&, name *&); \
	friend TBuffer &operator>>(TBuffer &buf, const name *&obj); \	friend TBuffer &operator>>(TBuffer&, const name *&); \
	static int DeclFileLine() { return __LINE__; }	static int DeclFileLine() { return __LINE__; }

	#endif	#endif

	#define R__UseDummy(name) \	#define R__UseDummy(name) \
	class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }	class _NAME2_(name,_c) { public: _NAME2_(name,_c)() { if (name) { } } }

	#if defined(__CINT__)	#if defined(__CINT__)
	#define ClassImpUnique(name,key)	#define ClassImpUnique(name,key)
	#define ClassImp(name)	#define ClassImp(name)

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

	Scope.h	Scope.h

	// @(#)root/reflex:$Id: Scope.h 32228 2010-02-05 16:13:09Z axel $	// @(#)root/reflex:$Id: Scope.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 49	skipping to change at line 49
	public:	public:
	/** constructor */	/** constructor */
	Scope(const ScopeName * scopeName = 0);	Scope(const ScopeName * scopeName = 0);

	/** copy constructor */	/** copy constructor */
	Scope(const Scope &rh);	Scope(const Scope &rh);

	/** destructor */	/** destructor */
	~Scope();	~Scope();


		/** assignment op */
		Scope& operator=(const Scope &rh);

	/**	/**
	* inequal operator	* inequal operator
	*/	*/
	bool operator !=(const Scope& rh) const;	bool operator !=(const Scope& rh) const;

	/**	/**
	* the bool operator will return true if the Scope is resolved (implemen ted)	* the bool operator will return true if the Scope is resolved (implemen ted)
	* @return true if Scope is implemented	* @return true if Scope is implemented
	*/	*/
	operator bool() const;	operator bool() const;

	skipping to change at line 994	skipping to change at line 997
	: fScopeName(rh.fScopeName) {	: fScopeName(rh.fScopeName) {
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::Scope::~Scope() {	inline Reflex::Scope::~Scope() {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline	inline

		Reflex::Scope&
		Reflex::Scope::operator=(const Scope& rh) {
		//-------------------------------------------------------------------------
		------
		if (&rh != this) {
		fScopeName = rh.fScopeName;
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
		inline
	Reflex::Scope::operator bool() const {	Reflex::Scope::operator bool() const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	if (this->fScopeName && this->fScopeName->fScopeBase) {	if (this->fScopeName && this->fScopeName->fScopeBase) {
	return true;	return true;
	}	}
	//throw RuntimeError("Scope is not implemented");	//throw RuntimeError("Scope is not implemented");
	return false;	return false;
	}	}

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

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

	SimpleLikelihoodRatioTestStat.h	SimpleLikelihoodRatioTestStat.h

	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 43199 2012-03-01 20:17:42Z moneta $	// @(#)root/roostats:$Id: SimpleLikelihoodRatioTestStat.h 44368 2012-05-30 15:38:44Z axel $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_SimpleLikelihoodRatioTestStat	#ifndef ROOSTATS_SimpleLikelihoodRatioTestStat
	#define ROOSTATS_SimpleLikelihoodRatioTestStat	#define ROOSTATS_SimpleLikelihoodRatioTestStat

	skipping to change at line 32	skipping to change at line 32
	//	//

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

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


		#ifndef ROO_REAL_VAR
	#include "RooRealVar.h"	#include "RooRealVar.h"

		#endif


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

	#include "RooWorkspace.h"	#endif

	namespace RooStats {	namespace RooStats {

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

	public:	public:

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

	skipping to change at line 163	skipping to change at line 166
	delete altIt;	delete altIt;
	return ret;	return ret;
	}	}

	//______________________________	//______________________________
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullPOI) {	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullPOI) {

	if (fFirstEval && ParamsAreEqual()) {	if (fFirstEval && ParamsAreEqual()) {
	oocoutW(fNullParameters,InputArguments)	oocoutW(fNullParameters,InputArguments)
	<< "Same RooArgSet used for null and alternate, so you must explicitly SetNullParameters and SetAlternateParameters or the likelihood r atio will always be 1."	<< "Same RooArgSet used for null and alternate, so you must explicitly SetNullParameters and SetAlternateParameters or the likelihood r atio will always be 1."

	<< endl;	<< std::endl;
	}	}
	fFirstEval = false;	fFirstEval = false;

	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();	RooFit::MsgLevel msglevel = RooMsgService::instance().globalKillBe low();
	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);	RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);

	Bool_t reuse = (fReuseNll \|\| fAlwaysReuseNll) ;	Bool_t reuse = (fReuseNll \|\| fAlwaysReuseNll) ;

	Bool_t created = kFALSE ;	Bool_t created = kFALSE ;
	if (!fNllNull) {	if (!fNllNull) {

	skipping to change at line 189	skipping to change at line 192
	if (reuse && !created) {	if (reuse && !created) {
	fNllNull->setData(data, kFALSE) ;	fNllNull->setData(data, kFALSE) ;
	}	}

	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	RooArgSet* attachedSet = fNllNull->getVariables();	RooArgSet* attachedSet = fNllNull->getVariables();
	attachedSet = fNullParameters;	attachedSet = fNullParameters;
	*attachedSet = nullPOI;	*attachedSet = nullPOI;
	double nullNLL = fNllNull->getVal();	double nullNLL = fNllNull->getVal();


	//cout << endl << "SLRTS: null params:" << endl;	//cout << std::endl << "SLRTS: null params:" << std::endl;
	//attachedSet->Print("v");	//attachedSet->Print("v");

	if (!reuse) {	if (!reuse) {
	delete fNllNull ; fNllNull = NULL ;	delete fNllNull ; fNllNull = NULL ;
	}	}
	delete attachedSet;	delete attachedSet;

	created = kFALSE ;	created = kFALSE ;
	if (!fNllAlt) {	if (!fNllAlt) {
	RooArgSet* allParams = fAltPdf->getParameters(data);	RooArgSet* allParams = fAltPdf->getParameters(data);

	skipping to change at line 212	skipping to change at line 215
	created = kTRUE ;	created = kTRUE ;
	}	}
	if (reuse && !created) {	if (reuse && !created) {
	fNllAlt->setData(data, kFALSE) ;	fNllAlt->setData(data, kFALSE) ;
	}	}
	// make sure we set the variables attached to this nll	// make sure we set the variables attached to this nll
	attachedSet = fNllAlt->getVariables();	attachedSet = fNllAlt->getVariables();
	attachedSet = fAltParameters;	attachedSet = fAltParameters;
	double altNLL = fNllAlt->getVal();	double altNLL = fNllAlt->getVal();


	//cout << endl << "SLRTS: alt params:" << endl;	//cout << std::endl << "SLRTS: alt params:" << std::endl;
	//attachedSet->Print("v");	//attachedSet->Print("v");


	//cout << endl << "SLRTS null NLL: " << nullNLL << " alt NLL: " << altNLL << endl << endl;	//cout << std::endl << "SLRTS null NLL: " << nullNLL << " alt N LL: " << altNLL << std::endl << std::endl;

	if (!reuse) {	if (!reuse) {
	delete fNllAlt ; fNllAlt = NULL ;	delete fNllAlt ; fNllAlt = NULL ;
	}	}
	delete attachedSet;	delete attachedSet;

	// save this snapshot	// save this snapshot
	if( fDetailedOutputEnabled ) {	if( fDetailedOutputEnabled ) {
	if( !fDetailedOutput ) {	if( !fDetailedOutput ) {
	fDetailedOutput = new RooArgSet( *(new RooRealVar("nullNLL", "null NLL",0)), "detailedOut_SLRTS" );	fDetailedOutput = new RooArgSet( *(new RooRealVar("nullNLL", "null NLL",0)), "detailedOut_SLRTS" );
	fDetailedOutput->add( *(new RooRealVar("altNLL","alternate N LL",0)) );	fDetailedOutput->add( *(new RooRealVar("altNLL","alternate N LL",0)) );
	}	}
	fDetailedOutput->setRealValue( "nullNLL", nullNLL );	fDetailedOutput->setRealValue( "nullNLL", nullNLL );
	fDetailedOutput->setRealValue( "altNLL", altNLL );	fDetailedOutput->setRealValue( "altNLL", altNLL );


	// cout << endl << "STORING THIS AS DETAILED OUTPUT:" << endl;	// cout << std::endl << "STORING THIS AS DETAILED OUTPUT:" << s td::endl;
	// fDetailedOutput->Print("v");	// fDetailedOutput->Print("v");

	// cout << endl;	// cout << std::endl;
	}	}

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

	virtual void EnableDetailedOutput( bool e=true ) { fDetailedOutputEna bled = e; fDetailedOutput = NULL; }	virtual void EnableDetailedOutput( bool e=true ) { fDetailedOutputEna bled = e; fDetailedOutput = NULL; }
	virtual const RooArgSet* GetDetailedOutput(void) const { return fDeta iledOutput; }	virtual const RooArgSet* GetDetailedOutput(void) const { return fDeta iledOutput; }

	virtual const TString GetVarName() const {	virtual const TString GetVarName() const {

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

	SpecFuncMathMore.h	SpecFuncMathMore.h

	// @(#)root/mathmore:$Id: SpecFuncMathMore.h 37160 2010-12-01 21:52:04Z mon eta $	// @(#)root/mathmore:$Id: SpecFuncMathMore.h 43734 2012-04-13 13:59:32Z mon eta $
	// Authors: L. Moneta, A. Zsenei 08/2005	// Authors: L. Moneta, A. Zsenei 08/2005

	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005	// Authors: Andras Zsenei & Lorenzo Moneta 06/2005

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *	* Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
	* *	* *
	* This library is free software; you can redistribute it and/or *	* This library is free software; you can redistribute it and/or *
	* modify it under the terms of the GNU General Public License *	* modify it under the terms of the GNU General Public License *

	skipping to change at line 701	skipping to change at line 701

	@ingroup SpecFunc	@ingroup SpecFunc

	*/	*/
	// s-th zero of the derivative of the Airy function Bi	// s-th zero of the derivative of the Airy function Bi

	double airy_zero_Bi_deriv(unsigned int s);	double airy_zero_Bi_deriv(unsigned int s);

	/**	/**


	Calculates the Wigner 3j coupling coefficients	Calculates the Wigner 3j coupling coefficients


	For detailed description see	(ja jb jc
	<A HREF="http://mathworld.wolfram.com/Wigner3j-Symbol.html.html">	ma mb mc)
	Mathworld</A>.
	The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/3_002dj-Symbols
	.html#g_t3_002dj-Symbols">GSL</A>.


	@ingroup SpecFunc	where ja,ma,...etc are integers or half integers.
		The function takes as input arguments only integers which corresponds
		to half integer units, e.g two_ja = 2 * ja

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner3j-Symbol.html.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/3_002dj-Symbol
		s.html#g_t3_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

	*/	*/


	double wigner_3j(int ja, int jb, int jc, int ma, int mb, int mc);	double wigner_3j(int two_ja, int two_jb, int two_jc, int two_ma, int two_ mb, int two_mc);

	/**	/**

	Calculates the Wigner 6j coupling coefficients	Calculates the Wigner 6j coupling coefficients


	For detailed description see	(ja jb jc
	<A HREF="http://mathworld.wolfram.com/Wigner6j-Symbol.html">	jd je jf)
	Mathworld</A>.
	The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/6_002dj-Symbols
	.html#g_t6_002dj-Symbols">GSL</A>.


	@ingroup SpecFunc	where ja,jb,...etc are integers or half integers.
		The function takes as input arguments only integers which corresponds
		to half integer units, e.g two_ja = 2 * ja

		For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner6j-Symbol.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/6_002dj-Symbol
		s.html#g_t6_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

	*/	*/


	double wigner_6j(int ja, int jb, int jc, int jd, int je, int jf);	double wigner_6j(int two_ja, int two_jb, int two_jc, int two_jd, int two_ je, int two_jf);

	/**	/**

	Calculates the Wigner 9j coupling coefficients	Calculates the Wigner 9j coupling coefficients


	For detailed description see	(ja jb jc
	<A HREF="http://mathworld.wolfram.com/Wigner9j-Symbol.html">	jd je jf
	Mathworld</A>.	jg jh ji)
	The implementation used is that of
	<A HREF="http://www.gnu.org/software/gsl/manual/html_node/9_002dj-Symbols	where ja,jb...etc are integers or half integers.
	.html#g_t9_002dj-Symbols">GSL</A>.	The function takes as input arguments only integers which corresponds
		to half integer units, e.g two_ja = 2 * ja


	@ingroup SpecFunc	For detailed description see
		<A HREF="http://mathworld.wolfram.com/Wigner9j-Symbol.html">
		Mathworld</A>.
		The implementation used is that of
		<A HREF="http://www.gnu.org/software/gsl/manual/html_node/9_002dj-Symbol
		s.html#g_t9_002dj-Symbols">GSL</A>.

		@ingroup SpecFunc

	*/	*/


	double wigner_9j(int ja, int jb, int jc, int jd, int je, int jf, int jg, int jh, int ji);	double wigner_9j(int two_ja, int two_jb, int two_jc, int two_jd, int two _je, int two_jf, int two_jg, int two_jh, int two_ji);

	} // namespace Math	} // namespace Math
	} // namespace ROOT	} // namespace ROOT

	#endif //ROOT_Math_SpecFuncMathMore	#endif //ROOT_Math_SpecFuncMathMore

	#endif // if defined (__CINT__) && !defined(__MAKECINT__)	#endif // if defined (__CINT__) && !defined(__MAKECINT__)

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

	StackAllocator.h	StackAllocator.h

	// @(#)root/minuit2:$Id: StackAllocator.h 34992 2010-08-25 10:36:11Z moneta $	// @(#)root/minuit2:$Id: StackAllocator.h 44476 2012-06-01 16:36:12Z moneta $
	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005	// Authors: M. Winkler, F. James, L. Moneta, A. Zsenei 2003-2005

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

	#ifndef ROOT_Minuit2_StackAllocator	#ifndef ROOT_Minuit2_StackAllocator
	#define ROOT_Minuit2_StackAllocator	#define ROOT_Minuit2_StackAllocator

	skipping to change at line 27	skipping to change at line 27
	// to calculate and vanishes quickly if going to cost-intensive functions)	// to calculate and vanishes quickly if going to cost-intensive functions)
	// the library is no longer thread save however	// the library is no longer thread save however

	#ifdef MN_USE_STACK_ALLOC	#ifdef MN_USE_STACK_ALLOC
	#define _MN_NO_THREAD_SAVE_	#define _MN_NO_THREAD_SAVE_
	#endif	#endif

	//#include <iostream>	//#include <iostream>

	#include <cstdlib>	#include <cstdlib>

		#include <new>

	namespace ROOT {	namespace ROOT {

	namespace Minuit2 {	namespace Minuit2 {

	/// define stack allocator symbol	/// define stack allocator symbol

	class StackOverflow {};	class StackOverflow {};
	class StackError {};	class StackError {};
	// using namespace std;	// using namespace std;

	skipping to change at line 91	skipping to change at line 92
	void* result = fStack + fStackOffset + sizeof(int);	void* result = fStack + fStackOffset + sizeof(int);
	fStackOffset += nAlloc;	fStackOffset += nAlloc;
	fBlockCount++;	fBlockCount++;

	#ifdef DEBUG_ALLOCATOR	#ifdef DEBUG_ALLOCATOR
	CheckConsistency();	CheckConsistency();
	#endif	#endif

	#else	#else
	void* result = malloc(nBytes);	void* result = malloc(nBytes);

		if (!result) throw std::bad_alloc();
	#endif	#endif

	return result;	return result;
	}	}

	void Deallocate( void* p) {	void Deallocate( void* p) {
	#ifdef _MN_NO_THREAD_SAVE_	#ifdef _MN_NO_THREAD_SAVE_
	// int previousOffset = ReadInt( fStackOffset - sizeof(int));	// int previousOffset = ReadInt( fStackOffset - sizeof(int));
	int delBlock = ToInt(p);	int delBlock = ToInt(p);
	int nextBlock = ReadInt( delBlock);	int nextBlock = ReadInt( delBlock);

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

	TApplicationRemote.h	TApplicationRemote.h

	// @(#)root/net:$Id: TApplicationRemote.h 23091 2008-04-09 15:04:27Z rdm $	// @(#)root/net:$Id: TApplicationRemote.h 44017 2012-04-30 08:33:43Z ganis $
	// Author: G. Ganis 10/5/2007	// Author: G. Ganis 10/5/2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 71	skipping to change at line 71
	kForce = 0x2	kForce = 0x2
	};	};
	// TApplication specific bits	// TApplication specific bits
	enum EStatusBits {	enum EStatusBits {
	kCollecting = BIT(16) // TRUE while collecting from server	kCollecting = BIT(16) // TRUE while collecting from server
	};	};

	private:	private:
	class TARFileStat : public TNamed {	class TARFileStat : public TNamed {
	public:	public:

	TARFileStat(const char *fn, TMD5 md5, Long_t mt) :	TARFileStat(const char fn, TMD5 md5, Long_t mt) :
	TNamed(fn,fn), fMD5(md5), fModtime(mt) { }	TNamed(fn,fn), fMD5(*md5), fModtime(mt) { }
	TMD5 fMD5; //file's md5	TMD5 fMD5; //file's md5
	Long_t fModtime; //file's modification time	Long_t fModtime; //file's modification time
	};	};

	TString fName; //Unique name identifying this insta nce	TString fName; //Unique name identifying this insta nce
	Int_t fProtocol; //server protocol version number	Int_t fProtocol; //server protocol version number
	TUrl fUrl; //server's url	TUrl fUrl; //server's url
	TSocket *fSocket; //socket connection to server	TSocket *fSocket; //socket connection to server
	TMonitor *fMonitor; //monitor for the input socket	TMonitor *fMonitor; //monitor for the input socket
	Bool_t fInterrupt; //flag interrupt state	Bool_t fInterrupt; //flag interrupt state

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

	TAxis.h	TAxis.h

	// @(#)root/hist:$Id: TAxis.h 36506 2010-11-04 20:58:59Z brun $	// @(#)root/hist:$Id: TAxis.h 43736 2012-04-13 15:16:34Z pcanal $
	// 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 50	skipping to change at line 50
	Double_t fXmax; //upper edge of last bin	Double_t fXmax; //upper edge of last bin
	TArrayD fXbins; //Bin edges array in X	TArrayD fXbins; //Bin edges array in X
	Int_t fFirst; //first bin to display	Int_t fFirst; //first bin to display
	Int_t fLast; //last bin to display	Int_t fLast; //last bin to display
	UShort_t fBits2; //second bit status word	UShort_t fBits2; //second bit status word
	Bool_t fTimeDisplay; //on/off displaying time values instead of numerics	Bool_t fTimeDisplay; //on/off displaying time values instead of numerics
	TString fTimeFormat; //Date&time format, ex: 09/12/99 12:34:00	TString fTimeFormat; //Date&time format, ex: 09/12/99 12:34:00
	TObject *fParent; //!Object owning this axis	TObject *fParent; //!Object owning this axis
	THashList *fLabels; //List of labels	THashList *fLabels; //List of labels


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

	public:	public:
	// TAxis status bits	// TAxis status bits
	enum { kTickPlus = BIT(9),	enum { kTickPlus = BIT(9),
	kTickMinus = BIT(10),	kTickMinus = BIT(10),
	kAxisRange = BIT(11),	kAxisRange = BIT(11),
	kCenterTitle = BIT(12),	kCenterTitle = BIT(12),
	kCenterLabels = BIT(14), //bit 13 is used by TObject	kCenterLabels = BIT(14), //bit 13 is used by TObject
	kRotateTitle = BIT(15),	kRotateTitle = BIT(15),
	kPalette = BIT(16),	kPalette = BIT(16),
	kNoExponent = BIT(17),	kNoExponent = BIT(17),

	skipping to change at line 75	skipping to change at line 73
	kLabelsUp = BIT(21),	kLabelsUp = BIT(21),
	kIsInteger = BIT(22),	kIsInteger = BIT(22),
	kMoreLogLabels = BIT(23),	kMoreLogLabels = BIT(23),
	kDecimals = BIT(11)}; //in fBits2	kDecimals = BIT(11)}; //in fBits2

	TAxis();	TAxis();
	TAxis(Int_t nbins, Double_t xmin, Double_t xmax);	TAxis(Int_t nbins, Double_t xmin, Double_t xmax);
	TAxis(Int_t nbins, const Double_t *xbins);	TAxis(Int_t nbins, const Double_t *xbins);
	TAxis(const TAxis &axis);	TAxis(const TAxis &axis);
	virtual ~TAxis();	virtual ~TAxis();

		TAxis& operator=(const TAxis&);

	virtual void CenterLabels(Bool_t center=kTRUE); // TOGGLE *GETT ER=GetCenterLabels	virtual void CenterLabels(Bool_t center=kTRUE); // TOGGLE *GETT ER=GetCenterLabels
	virtual void CenterTitle(Bool_t center=kTRUE); // TOGGLE *GETTE R=GetCenterTitle	virtual void CenterTitle(Bool_t center=kTRUE); // TOGGLE *GETTE R=GetCenterTitle
	const char *ChooseTimeFormat(Double_t axislength=0);	const char *ChooseTimeFormat(Double_t axislength=0);
	virtual void Copy(TObject &axis) const;	virtual void Copy(TObject &axis) const;
	virtual void Delete(Option_t * /option/ ="") { }	virtual void Delete(Option_t * /option/ ="") { }
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TObject DrawClone(Option_t /option/ ="") const {return 0; }	virtual TObject DrawClone(Option_t /option/ ="") const {return 0; }
	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 Int_t FindBin(Double_t x);	virtual Int_t FindBin(Double_t x);
	virtual Int_t FindBin(const char *label);	virtual Int_t FindBin(const char *label);

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

	TBits.h	TBits.h

	// @(#)root/cont:$Id: TBits.h 25695 2008-10-03 14:06:16Z brun $	// @(#)root/cont:$Id: TBits.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Philippe Canal 05/02/01	// Author: Philippe Canal 05/02/01

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 154	skipping to change at line 154

	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;

	ClassDef(TBits,1) // Bit container	ClassDef(TBits,1) // Bit container
	};	};

	inline Bool_t operator&(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)	inline Bool_t operator&(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)
	{	{

	return (bool)lhs & rhs;	return (Bool_t)lhs & rhs;
	}	}

	inline Bool_t operator\|(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)	inline Bool_t operator\|(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)
	{	{

	return (bool)lhs \| rhs;	return (Bool_t)lhs \| rhs;
	}	}

	inline Bool_t operator^(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)	inline Bool_t operator^(const TBits::TReference& lhs, const TBits::TReferen ce& rhs)
	{	{

	return (bool)lhs ^ rhs;	return (Bool_t)lhs ^ rhs;
	}	}

	inline TBits operator&(const TBits& lhs, const TBits& rhs)	inline TBits operator&(const TBits& lhs, const TBits& rhs)
	{	{
	TBits result(lhs);	TBits result(lhs);
	result &= rhs;	result &= rhs;
	return result;	return result;
	}	}

	inline TBits operator\|(const TBits& lhs, const TBits& rhs)	inline TBits operator\|(const TBits& lhs, const TBits& rhs)

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

	TBranchProxy.h	TBranchProxy.h

	// @(#)root/treeplayer:$Id: TBranchProxy.h 41244 2011-10-06 19:42:35Z pcana l $	// @(#)root/treeplayer:$Id: TBranchProxy.h 43509 2012-03-27 16:23:11Z pcana l $
	// Author: Philippe Canal 01/06/2004	// Author: Philippe Canal 01/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers and al. *
	* 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 341	skipping to change at line 341
	}	}

	unsigned char operator [](Int_t i) {	unsigned char operator [](Int_t i) {
	return At(i);	return At(i);
	}	}

	unsigned char operator [](UInt_t i) {	unsigned char operator [](UInt_t i) {
	return At(i);	return At(i);
	}	}


		operator const char*() {
		if (!Read()) return "";
		return (const char*)GetStart();
		}

		const char* Data() {
		if (!Read()) return "";
		return (const char*)GetStart();
		}

	const char* c_str() {	const char* c_str() {
	if (!Read()) return "";	if (!Read()) return "";
	return (const char*)GetStart();	return (const char*)GetStart();
	}	}

	operator std::string() {	operator std::string() {
	if (!Read()) return "";	if (!Read()) return "";
	return std::string((const char*)GetStart());	return std::string((const char*)GetStart());
	}	}


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

	TClassStreamer.h	TClassStreamer.h

	// @(#)root/base:$Id: TClassStreamer.h 36096 2010-10-05 21:27:26Z pcanal $	// @(#)root/base:$Id: TClassStreamer.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Victor Perev and Philippe Canal 08/05/02	// Author: Victor Perev and Philippe Canal 08/05/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 30	skipping to change at line 30
	// TClassStreamer is used to stream an object of a specific class. //	// TClassStreamer is used to stream an object of a specific class. //
	// //	// //
	// The address passed to operator() will be the address of the start //	// The address passed to operator() will be the address of the start //
	// of the object. //	// of the object. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	class TClassStreamer {	class TClassStreamer {
	protected:	protected:
	TClassStreamer() : fStreamer(0) {};	TClassStreamer() : fStreamer(0) {};

		TClassStreamer(const TClassStreamer &rhs) : fStreamer(rhs.fStreamer), fO
		nFileClass() {};
		TClassStreamer &operator=(const TClassStreamer &rhs) { fOnFileClass =
		rhs.fOnFileClass; fStreamer = rhs.fStreamer; return *this; }

	public:	public:
	TClassStreamer(ClassStreamerFunc_t pointer) : fStreamer(pointer), fOnFil eClass() {};	TClassStreamer(ClassStreamerFunc_t pointer) : fStreamer(pointer), fOnFil eClass() {};

	TClassStreamer(const TClassStreamer &rhs) : fStreamer(rhs.fStreamer), fO nFileClass() {};

	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }
	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }

	virtual TClassStreamer *Generate() const {	virtual TClassStreamer *Generate() const {
	// Virtual copy constructor.	// Virtual copy constructor.
	return new TClassStreamer(*this);	return new TClassStreamer(*this);
	}	}

	virtual ~TClassStreamer(){};	virtual ~TClassStreamer(){};

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

	TCollectionProxyFactory.h	TCollectionProxyFactory.h

	// @(#)root/io:$Id: TCollectionProxyFactory.h 41102 2011-10-03 21:42:02Z pc anal $	// @(#)root/io:$Id: TCollectionProxyFactory.h 43271 2012-03-07 05:53:52Z pc anal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TCollectionProxyFactory	#ifndef ROOT_TCollectionProxyFactory

	skipping to change at line 171	skipping to change at line 171
	*	*
	* TEmulatedClassStreamer	* TEmulatedClassStreamer
	*	*
	* Class streamer object to implement TClassStreamr functionality	* Class streamer object to implement TClassStreamr functionality
	* for I/O emulation.	* for I/O emulation.
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	*/	*/
	class TCollectionClassStreamer : public TClassStreamer, public TCollectionS treamer {	class TCollectionClassStreamer : public TClassStreamer, public TCollectionS treamer {

	public:	protected:
	/// Initializing constructor	TCollectionClassStreamer &operator=(const TCollectionClassStreamer &rhs)
	TCollectionClassStreamer() : TClassStreamer(0) {	; // Not implemented.
	}
	/// Copy constructor	/// Copy constructor
	TCollectionClassStreamer(const TCollectionClassStreamer& c)	TCollectionClassStreamer(const TCollectionClassStreamer& c)
	: TClassStreamer(c), TCollectionStreamer(c) { }	: TClassStreamer(c), TCollectionStreamer(c) { }


		public:
		/// Initializing constructor
		TCollectionClassStreamer() : TClassStreamer(0) {
		}
	/// Standard destructor	/// Standard destructor
	virtual ~TCollectionClassStreamer() { }	virtual ~TCollectionClassStreamer() { }
	/// Streamer for I/O handling	/// Streamer for I/O handling
	virtual void operator()(TBuffer &buff, void *obj ) { Streamer(buff,obj,0 ,fOnFileClass); }	virtual void operator()(TBuffer &buff, void *obj ) { Streamer(buff,obj,0 ,fOnFileClass); }

	virtual void Stream(TBuffer &b, void obj, const TClass onfileClass)	virtual void Stream(TBuffer &b, void obj, const TClass onfileClass)
	{	{
	if (b.IsReading()) {	if (b.IsReading()) {
	TGenCollectionProxy *proxy = TCollectionStreamer::fStreamer;	TGenCollectionProxy *proxy = TCollectionStreamer::fStreamer;
	if (onfileClass==0 \|\| onfileClass == proxy->GetCollectionClass()) {	if (onfileClass==0 \|\| onfileClass == proxy->GetCollectionClass()) {

	skipping to change at line 217	skipping to change at line 220
	*	*
	* TCollectionMemberStreamer	* TCollectionMemberStreamer
	*	*
	* Class streamer object to implement TMemberStreamer functionality	* Class streamer object to implement TMemberStreamer functionality
	* for I/O emulation.	* for I/O emulation.
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	*/	*/
	class TCollectionMemberStreamer : public TMemberStreamer, public TCollectio nStreamer {	class TCollectionMemberStreamer : public TMemberStreamer, public TCollectio nStreamer {

		private:
		TCollectionMemberStreamer &operator=(const TCollectionMemberStreamer &rh
		s); // Not implemented.
	public:	public:
	/// Initializing constructor	/// Initializing constructor
	TCollectionMemberStreamer() : TMemberStreamer(0) { }	TCollectionMemberStreamer() : TMemberStreamer(0) { }
	/// Copy constructor	/// Copy constructor
	TCollectionMemberStreamer(const TCollectionMemberStreamer& c)	TCollectionMemberStreamer(const TCollectionMemberStreamer& c)
	: TMemberStreamer(c), TCollectionStreamer(c) { }	: TMemberStreamer(c), TCollectionStreamer(c) { }
	/// Standard destructor	/// Standard destructor
	virtual ~TCollectionMemberStreamer() { }	virtual ~TCollectionMemberStreamer() { }
	/// Streamer for I/O handling	/// Streamer for I/O handling
	virtual void operator()(TBuffer &buff,void *obj,Int_t siz=0)	virtual void operator()(TBuffer &buff,void *obj,Int_t siz=0)

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

	TCollectionProxyInfo.h	TCollectionProxyInfo.h

	// @(#)root/cont:$Id: TCollectionProxyInfo.h 36061 2010-10-04 16:05:51Z pca nal $	// @(#)root/cont:$Id: TCollectionProxyInfo.h 43515 2012-03-27 21:15:53Z pca nal $
	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007	// Author: Markus Frank 28/10/04. Philippe Canal 02/01/2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 397	skipping to change at line 397
	T::next,	T::next,
	T::construct,	T::construct,
	T::destruct,	T::destruct,
	T::feed,	T::feed,
	T::collect,	T::collect,
	T::Env_t::Create);	T::Env_t::Create);
	}	}

	};	};


	template <> struct TCollectionProxyInfo::Type<std::vector<bool> >	template <> struct TCollectionProxyInfo::Type<std::vector<Bool_t> >
	: public TCollectionProxyInfo::Address<std::vector<bool>::const_referenc	: public TCollectionProxyInfo::Address<std::vector<Bool_t>::const_refere
	e>	nce>
	{	{

	typedef std::vector<bool> Cont_t;	typedef std::vector<Bool_t> Cont_t;
	typedef std::vector<bool>::iterator Iter_t;	typedef std::vector<Bool_t>::iterator Iter_t;
	typedef std::vector<bool>::value_type Value_t;	typedef std::vector<Bool_t>::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	virtual ~Type() {}	virtual ~Type() {}

	static inline PCont_t object(void* ptr) {	static inline PCont_t object(void* ptr) {
	return PCont_t(PEnv_t(ptr)->fObject);	return PCont_t(PEnv_t(ptr)->fObject);
	}	}
	static void* size(void* env) {	static void* size(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	e->fSize = PCont_t(e->fObject)->size();	e->fSize = PCont_t(e->fObject)->size();
	return &e->fSize;	return &e->fSize;

	skipping to change at line 457	skipping to change at line 457
	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.	PValue_t m = PValue_t(e->fStart); // 'start' is a buffer outside t he container.
	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )	for (Iter_t i=c->begin(); i != c->end(); ++i, ++m )
	::new(m) Value_t(*i);	::new(m) Value_t(*i);
	return 0;	return 0;
	}	}
	static void destruct(void*,size_t) {	static void destruct(void*,size_t) {
	// Nothing to destruct.	// Nothing to destruct.
	}	}
	};	};


	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > :	template <> struct TCollectionProxyInfo::Pushback<std::vector<bool> > :
	public TCollectionProxyInfo::Type<std::vector<bool> > {	public TCollectionProxyInfo::Type<std::vector<Bool_t> > {
	typedef std::vector<bool> Cont_t;	typedef std::vector<Bool_t> Cont_t;
	typedef Cont_t::iterator Iter_t;	typedef Cont_t::iterator Iter_t;
	typedef Cont_t::value_type Value_t;	typedef Cont_t::value_type Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	static void resize(void* obj,size_t n) {	static void resize(void* obj,size_t n) {
	PCont_t c = PCont_t(obj);	PCont_t c = PCont_t(obj);
	c->resize(n);	c->resize(n);

	skipping to change at line 484	skipping to change at line 484
	c->push_back(*m);	c->push_back(*m);
	return 0;	return 0;
	}	}
	static int value_offset() {	static int value_offset() {
	return 0;	return 0;
	}	}
	};	};

	#ifndef __CINT__	#ifndef __CINT__
	// Need specialization for boolean references due to stupid STL vector<b ool>	// Need specialization for boolean references due to stupid STL vector<b ool>

	template<> inline void* ::ROOT::TCollectionProxyInfo::Address<std::vecto r<bool>::const_reference>::address(std::vector<bool>::const_reference ) {	template<> inline void* ::ROOT::TCollectionProxyInfo::Address<std::vecto r<Bool_t>::const_reference>::address(std::vector<Bool_t>::const_reference ) {
	R__ASSERT(0);	R__ASSERT(0);
	return 0;	return 0;
	}	}
	#endif	#endif

	template <typename T> class TStdBitsetHelper {	template <typename T> class TStdBitsetHelper {
	// This class is intentionally empty, this is scaffolding to allow th e equivalent	// This class is intentionally empty, this is scaffolding to allow th e equivalent
	// of 'template <int N> struct TCollectionProxyInfo::Type<std::bitset <N> >' which	// of 'template <int N> struct TCollectionProxyInfo::Type<std::bitset <N> >' which
	// is not effective in C++ (as of gcc 4.3.3).	// is not effective in C++ (as of gcc 4.3.3).
	};	};

	#ifndef __CINT__	#ifndef __CINT__

	template <typename Bitset_t> struct TCollectionProxyInfo::Type<ROOT::TSt dBitsetHelper<Bitset_t> > : public TCollectionProxyInfo::Address<const bool &>	template <typename Bitset_t> struct TCollectionProxyInfo::Type<ROOT::TSt dBitsetHelper<Bitset_t> > : public TCollectionProxyInfo::Address<const Bool _t &>
	{	{

	typedef Bitset_t Cont_t;	typedef Bitset_t Cont_t;
	typedef std::pair<size_t,bool> Iter_t;	typedef std::pair<size_t,Bool_t> Iter_t;
	typedef bool Value_t;	typedef Bool_t Value_t;
	typedef Environ<Iter_t> Env_t;	typedef Environ<Iter_t> Env_t;
	typedef Env_t *PEnv_t;	typedef Env_t *PEnv_t;
	typedef Cont_t *PCont_t;	typedef Cont_t *PCont_t;
	typedef Value_t *PValue_t;	typedef Value_t *PValue_t;

	virtual ~Type() {}	virtual ~Type() {}

	static inline PCont_t object(void* ptr) {	static inline PCont_t object(void* ptr) {
	return PCont_t(PEnv_t(ptr)->fObject);	return PCont_t(PEnv_t(ptr)->fObject);
	}	}
	static void* size(void* env) {	static void* size(void* env) {
	PEnv_t e = PEnv_t(env);	PEnv_t e = PEnv_t(env);
	e->fSize = PCont_t(e->fObject)->size();	e->fSize = PCont_t(e->fObject)->size();
	return &e->fSize;	return &e->fSize;

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

	TDCacheFile.h	TDCacheFile.h

	// @(#)root/dcache:$Id: TDCacheFile.h 34444 2010-07-16 02:17:39Z pcanal $	// @(#)root/dcache:$Id: TDCacheFile.h 43512 2012-03-27 20:26:50Z pcanal $
	// Author: Grzegorz Mazur 20/01/2002	// Author: Grzegorz Mazur 20/01/2002
	// Updated: William Tanenbaum 21/11/2003	// Updated: William Tanenbaum 21/11/2003
	// Updated: Tgiran Mkrtchyan 28/06/2004	// Updated: Tgiran Mkrtchyan 28/06/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *

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

	Bool_t ReadBuffers(char buf, Long64_t pos, Int_t *len, Int_t nbuf);	Bool_t ReadBuffers(char buf, Long64_t pos, Int_t *len, Int_t nbuf);

	void ResetErrno() const;	void ResetErrno() const;

	static Bool_t Stage(const char *path, UInt_t secs,	static Bool_t Stage(const char *path, UInt_t secs,
	const char *location = 0);	const char *location = 0);
	static Bool_t CheckFile(const char path, const char location = 0);	static Bool_t CheckFile(const char path, const char location = 0);

	// Note: This must be kept in sync with values #defined in dcap.h	// Note: This must be kept in sync with values #defined in dcap.h

	enum OnErrorAction {	enum EOnErrorAction {
	kOnErrorRetry = 1,	kOnErrorRetry = 1,
	kOnErrorFail = 0,	kOnErrorFail = 0,
	kOnErrorDefault = -1	kOnErrorDefault = -1
	};	};

	static void SetOpenTimeout(UInt_t secs);	static void SetOpenTimeout(UInt_t secs);

	static void SetOnError(OnErrorAction = kOnErrorDefault);	static void SetOnError(EOnErrorAction = kOnErrorDefault);

	static void SetReplyHostName(const char *host_name);	static void SetReplyHostName(const char *host_name);
	static const char *GetDcapVersion();	static const char *GetDcapVersion();
	static TString GetDcapPath(const char *path);	static TString GetDcapPath(const char *path);

	ClassDef(TDCacheFile,1) //A ROOT file that reads/writes via a dCache se rver	ClassDef(TDCacheFile,1) //A ROOT file that reads/writes via a dCache se rver
	};	};

	class TDCacheSystem : public TSystem {	class TDCacheSystem : public TSystem {


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

	TDSet.h	TDSet.h

	// @(#)root/proof:$Id: TDSet.h 43044 2012-02-17 14:34:52Z ganis $	// @(#)root/proof:$Id: TDSet.h 44010 2012-04-29 23:07:48Z ganis $
	// Author: Fons Rademakers 11/01/02	// Author: Fons Rademakers 11/01/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 156	skipping to change at line 156

	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
	kSomeInvalid = BIT(19), // Set if at least one element is invali d	kSomeInvalid = BIT(19), // Set if at least one element is invali d

	kMultiDSet = BIT(20) // Set if fElements is a list of dataset	kMultiDSet = BIT(20), // Set if fElements is a list of datase
	s	ts
		kIsLocal = BIT(21) // Set if local, non-PROOF, processing
	};	};

	private:	private:
	Bool_t fIsTree; // true if type is a TTree (or TTree derive d)	Bool_t fIsTree; // true if type is a TTree (or TTree derive d)
	TObject *fEntryList; //! entry (or event) list for processing	TObject *fEntryList; //! entry (or event) list for processing
	TProofChain *fProofChain; //! for browsing purposes	TProofChain *fProofChain; //! for browsing purposes

	void SplitEntryList(); //Split entry list between elements	void SplitEntryList(); //Split entry list between elements

	TDSet(const TDSet &); // not implemented	TDSet(const TDSet &); // not implemented

	skipping to change at line 255	skipping to change at line 256
	void Validate();	void Validate();
	void Validate(TDSet *dset);	void Validate(TDSet *dset);

	void Lookup(Bool_t removeMissing = kFALSE, TList **miss ingFiles = 0);	void Lookup(Bool_t removeMissing = kFALSE, TList **miss ingFiles = 0);
	void SetLookedUp();	void SetLookedUp();

	void SetSrvMaps(TList *srvmaps = 0);	void SetSrvMaps(TList *srvmaps = 0);

	void SetWriteV3(Bool_t on = kTRUE);	void SetWriteV3(Bool_t on = kTRUE);


	ClassDef(TDSet,8) // Data set for remote processing (PROOF)	ClassDef(TDSet,9) // Data set for remote processing (PROOF)
	};	};

	#endif	#endif

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

	TDataMember.h	TDataMember.h

	// @(#)root/meta:$Id: TDataMember.h 24077 2008-05-31 19:39:09Z brun $	// @(#)root/meta:$Id: TDataMember.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Fons Rademakers 04/02/95	// Author: Fons Rademakers 04/02/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 93	skipping to change at line 93
	Int_t IsSTLContainer();	Int_t IsSTLContainer();
	Long_t Property() const;	Long_t Property() const;
	ClassDef(TDataMember,0) //Dictionary for a class data member	ClassDef(TDataMember,0) //Dictionary for a class data member
	};	};

	// This class implements one option in options list. All Data members are p ublic	// This class implements one option in options list. All Data members are p ublic
	// for cenvenience reasons.	// for cenvenience reasons.

	class TOptionListItem : public TObject {	class TOptionListItem : public TObject {


	protected:
	TOptionListItem(const TOptionListItem&);
	TOptionListItem& operator=(const TOptionListItem&);

	public:	public:
	TDataMember *fDataMember; //Data member to which this option bel ongs	TDataMember *fDataMember; //Data member to which this option bel ongs
	Long_t fValue; //Numerical value assigned to option	Long_t fValue; //Numerical value assigned to option
	Long_t fValueMaskBit; //Not used yet: bitmask used when opti on is a toggle group	Long_t fValueMaskBit; //Not used yet: bitmask used when opti on is a toggle group
	Long_t fToggleMaskBit; //Not used yet: bitmask used when togg ling value	Long_t fToggleMaskBit; //Not used yet: bitmask used when togg ling value

	char *fOptName; //Text assigned to option which appear	TString fOptName; //Text assigned to option which appear
	s in option menu	s in option menu
	char *fOptLabel; //Text (or enum) value assigned to opt	TString fOptLabel; //Text (or enum) value assigned to opt
	ion.	ion.

	TOptionListItem(TDataMember *m,Long_t val, Long_t valmask, Long_t tglmas k,	TOptionListItem(TDataMember *m,Long_t val, Long_t valmask, Long_t tglmas k,
	const char name, const char label);	const char name, const char label);

	~TOptionListItem();
	};	};

	#endif	#endif

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

	TDatabasePDG.h	TDatabasePDG.h

	// @(#)root/eg:$Id: TDatabasePDG.h 29092 2009-06-19 09:31:49Z brun $	// @(#)root/eg:$Id: TDatabasePDG.h 43982 2012-04-27 11:01:54Z pcanal $
	// Author: Pasha Murat 12/02/99	// Author: Pasha Murat 12/02/99

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 61	skipping to change at line 61
	const char* Title,	const char* Title,
	Double_t Mass,	Double_t Mass,
	Bool_t Stable,	Bool_t Stable,
	Double_t DecayWidth,	Double_t DecayWidth,
	Double_t Charge,	Double_t Charge,
	const char* ParticleClass,	const char* ParticleClass,
	Int_t PdgCode,	Int_t PdgCode,
	Int_t Anti=-1,	Int_t Anti=-1,
	Int_t TrackingCode=0);	Int_t TrackingCode=0);


	virtual Int_t ConvertGeant3ToPdg(Int_t Geant3Number);	virtual Int_t ConvertGeant3ToPdg(Int_t Geant3Number) const;
	virtual Int_t ConvertPdgToGeant3(Int_t pdgNumber);	virtual Int_t ConvertPdgToGeant3(Int_t pdgNumber) const;
	virtual Int_t ConvertIsajetToPdg(Int_t isaNumber);	virtual Int_t ConvertIsajetToPdg(Int_t isaNumber) const;

	virtual TParticlePDG* AddAntiParticle(const char* Name, Int_t PdgCode);	virtual TParticlePDG* AddAntiParticle(const char* Name, Int_t PdgCode);

	TParticlePDG *GetParticle(Int_t pdgCode) const;	TParticlePDG *GetParticle(Int_t pdgCode) const;
	TParticlePDG GetParticle(const char name) const;	TParticlePDG GetParticle(const char name) const;

	TParticleClassPDG* GetParticleClass(const char* name) {	TParticleClassPDG* GetParticleClass(const char* name) {
	if (fParticleList == 0) ((TDatabasePDG*)this)->ReadPDGTable();	if (fParticleList == 0) ((TDatabasePDG*)this)->ReadPDGTable();
	return (TParticleClassPDG*) fListOfClasses->FindObject(name);	return (TParticleClassPDG*) fListOfClasses->FindObject(name);
	}	}

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

	TDrawFeedback.h	TDrawFeedback.h

	// @(#)root/proofplayer:$Id: TDrawFeedback.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/proofplayer:$Id: TDrawFeedback.h 44046 2012-05-01 11:34:04Z gan is $
	// Author: Maarten Ballintijn 28/10/2003	// Author: Maarten Ballintijn 28/10/2003

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TDrawFeedback	#ifndef ROOT_TDrawFeedback
	#define ROOT_TDrawFeedback	#define ROOT_TDrawFeedback

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// TDrawFeedback //	// TDrawFeedback //
	// //	// //
	// Utility class to draw objects in the feedback list during queries. //	// Utility class to draw objects in the feedback list during queries. //

		// Draws histograms in separated canvases and user-defined objects via //
		// Draw(). Users requiring advanced treatment should implement their //
		// own version following this example. See also TStatsFeedback. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TQObject	#ifndef ROOT_TQObject
	#include "TQObject.h"	#include "TQObject.h"
	#endif	#endif
	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif

	class TProof;	class TProof;
	class TProof;	class TProof;
	class THashList;	class THashList;
	class TSeqCollection;	class TSeqCollection;

	class TDrawFeedback : public TObject, public TQObject {	class TDrawFeedback : public TObject, public TQObject {
	private:	private:

		TString fName; // Identfier for this object
	Bool_t fAll; //draw all or selected objects	Bool_t fAll; //draw all or selected objects
	THashList *fNames; //selected objects	THashList *fNames; //selected objects

	protected:	protected:
	Option_t *fOption; //draw option	Option_t *fOption; //draw option
	TProof *fProof; //handle to PROOF session	TProof *fProof; //handle to PROOF session

	public:	public:
	TDrawFeedback(TProof proof = 0, TSeqCollection names = 0);	TDrawFeedback(TProof proof = 0, TSeqCollection names = 0);
	~TDrawFeedback();	~TDrawFeedback();

	void Feedback(TList *objs);	void Feedback(TList *objs);

		const char *GetName() const { return fName.Data(); }
		ULong_t Hash() const { return fName.Hash(); }
	void SetOption(Option_t *option) { fOption = option; }	void SetOption(Option_t *option) { fOption = option; }

	ClassDef(TDrawFeedback,0) // Present PROOF query feedback	ClassDef(TDrawFeedback,0) // Present PROOF query feedback
	};	};

	#endif	#endif

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

	TEmulatedCollectionProxy.h	TEmulatedCollectionProxy.h

	// @(#)root/io:$Id: TEmulatedCollectionProxy.h 41102 2011-10-03 21:42:02Z p canal $	// @(#)root/io:$Id: TEmulatedCollectionProxy.h 43271 2012-03-07 05:53:52Z p canal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TEmulatedCollectionProxy	#ifndef ROOT_TEmulatedCollectionProxy

	skipping to change at line 58	skipping to change at line 58

	// Object output streamer	// Object output streamer
	void WriteItems(int nElements, TBuffer &b);	void WriteItems(int nElements, TBuffer &b);

	// Shrink the container	// Shrink the container
	void Shrink(UInt_t nCurr, UInt_t left, Bool_t force);	void Shrink(UInt_t nCurr, UInt_t left, Bool_t force);

	// Expand the container	// Expand the container
	void Expand(UInt_t nCurr, UInt_t left);	void Expand(UInt_t nCurr, UInt_t left);


		private:
		TEmulatedCollectionProxy &operator=(const TEmulatedCollectionProxy &); /
		/ Not implemented.

	public:	public:
	// Virtual copy constructor	// Virtual copy constructor
	virtual TVirtualCollectionProxy* Generate() const;	virtual TVirtualCollectionProxy* Generate() const;

	// Copy constructor	// Copy constructor
	TEmulatedCollectionProxy(const TEmulatedCollectionProxy& copy);	TEmulatedCollectionProxy(const TEmulatedCollectionProxy& copy);

	// Initializing constructor	// Initializing constructor
	TEmulatedCollectionProxy(const char* cl_name, Bool_t silent);	TEmulatedCollectionProxy(const char* cl_name, Bool_t silent);


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

	TEmulatedMapProxy.h	TEmulatedMapProxy.h

	// @(#)root/io:$Id: TEmulatedMapProxy.h 41102 2011-10-03 21:42:02Z pcanal $	// @(#)root/io:$Id: TEmulatedMapProxy.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TEmulatedMapProxy	#ifndef ROOT_TEmulatedMapProxy

	skipping to change at line 33	skipping to change at line 33
	#include "TEmulatedCollectionProxy.h"	#include "TEmulatedCollectionProxy.h"

	class TEmulatedMapProxy : public TEmulatedCollectionProxy {	class TEmulatedMapProxy : public TEmulatedCollectionProxy {

	protected:	protected:
	// Map input streamer	// Map input streamer
	void ReadMap(int nElements, TBuffer &b);	void ReadMap(int nElements, TBuffer &b);

	// Map output streamer	// Map output streamer
	void WriteMap(int nElements, TBuffer &b);	void WriteMap(int nElements, TBuffer &b);

		private:
		TEmulatedMapProxy &operator=(const TEmulatedMapProxy &rhs); // Not imple
		mented.

	public:	public:
	// Virtual copy constructor	// Virtual copy constructor
	virtual TVirtualCollectionProxy* Generate() const;	virtual TVirtualCollectionProxy* Generate() const;

	// Copy constructor	// Copy constructor
	TEmulatedMapProxy(const TEmulatedMapProxy& copy);	TEmulatedMapProxy(const TEmulatedMapProxy& copy);

	// Initializing constructor	// Initializing constructor
	TEmulatedMapProxy(const char* cl_name, Bool_t silent);	TEmulatedMapProxy(const char* cl_name, Bool_t silent);

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

	TEntryListBlock.h	TEntryListBlock.h

	// @(#)root/tree:$Id: TEntryListBlock.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/tree:$Id: TEntryListBlock.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Anna Kreshuk 27/10/2006	// Author: Anna Kreshuk 27/10/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 67	skipping to change at line 67
	Int_t fLastIndexReturned; //! to optimize GetEntry() in a loop	Int_t fLastIndexReturned; //! to optimize GetEntry() in a loop

	void Transform(Bool_t dir, UShort_t *indexnew);	void Transform(Bool_t dir, UShort_t *indexnew);

	public:	public:

	enum { kBlockSize = 4000 }; //size of the block, 4000 UShort_ts	enum { kBlockSize = 4000 }; //size of the block, 4000 UShort_ts
	TEntryListBlock();	TEntryListBlock();
	TEntryListBlock(const TEntryListBlock &eblock);	TEntryListBlock(const TEntryListBlock &eblock);
	~TEntryListBlock();	~TEntryListBlock();

		TEntryListBlock &operator=(const TEntryListBlock &rhs);

	Bool_t Enter(Int_t entry);	Bool_t Enter(Int_t entry);
	Bool_t Remove(Int_t entry);	Bool_t Remove(Int_t entry);
	Int_t Contains(Int_t entry);	Int_t Contains(Int_t entry);
	void OptimizeStorage();	void OptimizeStorage();
	Int_t Merge(TEntryListBlock *block);	Int_t Merge(TEntryListBlock *block);
	Int_t Next();	Int_t Next();
	Int_t GetEntry(Int_t entry);	Int_t GetEntry(Int_t entry);
	void ResetIndices() {fLastIndexQueried = -1, fLastIndexReturned = -1; }	void ResetIndices() {fLastIndexQueried = -1, fLastIndexReturned = -1; }
	Int_t GetType() { return fType; }	Int_t GetType() { return fType; }

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

	TEntryListFromFile.h	TEntryListFromFile.h

	// @(#)root/tree:$Id: TEntryListFromFile.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/tree:$Id: TEntryListFromFile.h 43276 2012-03-07 17:13:42Z pcana l $
	// Author: Anna Kreshuk 17/03/2007	// Author: Anna Kreshuk 17/03/2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 42	skipping to change at line 42
	// If one of the list files can't be opened, or there is an error reading a list	// If one of the list files can't be opened, or there is an error reading a list
	// from the file, this list is skipped and the entry loop continues on the next	// from the file, this list is skipped and the entry loop continues on the next
	// list.	// list.

	#include "TEntryList.h"	#include "TEntryList.h"

	class TFile;	class TFile;

	class TEntryListFromFile: public TEntryList	class TEntryListFromFile: public TEntryList
	{	{

	protected:	protected:
	TString fListFileName; //from this string names of all files can be found	TString fListFileName; //from this string names of all files can be found
	TString fListName; //name of the list	TString fListName; //name of the list
	Int_t fNFiles; //total number of files	Int_t fNFiles; //total number of files
	Long64_t *fListOffset; //[fNFiles] numbers of entries in ind. lists	Long64_t *fListOffset; //[fNFiles] numbers of entries in ind. lists
	TFile *fFile; //currently open file	TFile *fFile; //currently open file
	//fCurrent points to the currently open list	//fCurrent points to the currently open list
	TObjArray *fFileNames; //! points to the fFiles data member of the c orresponding chain	TObjArray *fFileNames; //! points to the fFiles data member of the c orresponding chain


	public:	private:
		TEntryListFromFile(const TEntryListFromFile&); // Not impleme
		nted.
		TEntryListFromFile &operator=(const TEntryListFromFile&); // Not impleme
		nted.

		public:

	enum {	enum {
	kBigNumber = 1234567890	kBigNumber = 1234567890
	};	};

	TEntryListFromFile();	TEntryListFromFile();
	TEntryListFromFile(const char filename, const char listname, Int_t nfi les);	TEntryListFromFile(const char filename, const char listname, Int_t nfi les);
	virtual ~TEntryListFromFile();	virtual ~TEntryListFromFile();
	virtual void Add(const TEntryList * /elist/){};	virtual void Add(const TEntryList * /elist/){};
	virtual Int_t Contains(Long64_t /entry/, TTree * /tree = 0/) {return 0;};	virtual Int_t Contains(Long64_t /entry/, TTree * /tree = 0/) {return 0;};

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

	TEveRGBAPalette.h	TEveRGBAPalette.h

	// @(#)root/eve:$Id: TEveRGBAPalette.h 30823 2009-10-21 13:58:59Z matevz $	// @(#)root/eve:$Id: TEveRGBAPalette.h 43602 2012-04-02 05:21:43Z matevz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TEveRGBAPalette	#ifndef ROOT_TEveRGBAPalette
	#define ROOT_TEveRGBAPalette	#define ROOT_TEveRGBAPalette

	#include "TEveUtil.h"	#include "TEveUtil.h"

	#include "TObject.h"	#include "TObject.h"
	#include "TQObject.h"	#include "TQObject.h"


		#include "TMath.h"

	class TEveRGBAPalette : public TObject,	class TEveRGBAPalette : public TObject,
	public TQObject,	public TQObject,
	public TEveRefCnt	public TEveRefCnt
	{	{
	friend class TEveRGBAPaletteEditor;	friend class TEveRGBAPaletteEditor;
	friend class TEveRGBAPaletteSubEditor;	friend class TEveRGBAPaletteSubEditor;


		friend class TEveRGBAPaletteOverlay;

	public:	public:
	enum ELimitAction_e { kLA_Cut, kLA_Mark, kLA_Clip, kLA_Wrap };	enum ELimitAction_e { kLA_Cut, kLA_Mark, kLA_Clip, kLA_Wrap };

	private:	private:
	TEveRGBAPalette(const TEveRGBAPalette&); // Not implemented	TEveRGBAPalette(const TEveRGBAPalette&); // Not implemented
	TEveRGBAPalette& operator=(const TEveRGBAPalette&); // Not implemented	TEveRGBAPalette& operator=(const TEveRGBAPalette&); // Not implemented

	protected:	protected:

		Double_t fUIf; // UI representation calculated as: d = fUIf*i + f
		UIc
		Double_t fUIc; // UI representation calculated as: d = fUIf*i + f
		UIc

	Int_t fLowLimit; // Low limit for Min/Max values (used by editor)	Int_t fLowLimit; // Low limit for Min/Max values (used by editor)
	Int_t fHighLimit; // High limit for Min/Max values (used by editor)	Int_t fHighLimit; // High limit for Min/Max values (used by editor)
	Int_t fMinVal;	Int_t fMinVal;
	Int_t fMaxVal;	Int_t fMaxVal;


		Bool_t fUIDoubleRep; // Represent UI parts with real values.
	Bool_t fInterpolate; // Interpolate colors for signal values.	Bool_t fInterpolate; // Interpolate colors for signal values.
	Bool_t fShowDefValue; // Flags whether signals with default value s hould be shown.	Bool_t fShowDefValue; // Flags whether signals with default value s hould be shown.
	Bool_t fFixColorRange; // If true, map palette to low/high limit oth erwise to min/max value.	Bool_t fFixColorRange; // If true, map palette to low/high limit oth erwise to min/max value.
	Int_t fUnderflowAction;	Int_t fUnderflowAction;
	Int_t fOverflowAction;	Int_t fOverflowAction;

	Color_t fDefaultColor; // Color for when value is not specified	Color_t fDefaultColor; // Color for when value is not specified
	UChar_t fDefaultRGBA[4];	UChar_t fDefaultRGBA[4];
	Color_t fUnderColor; // Underflow color	Color_t fUnderColor; // Underflow color
	UChar_t fUnderRGBA[4];	UChar_t fUnderRGBA[4];
	Color_t fOverColor; // Overflow color	Color_t fOverColor; // Overflow color
	UChar_t fOverRGBA[4];	UChar_t fOverRGBA[4];

	mutable Int_t fNBins; // Number of signal-color entries.	mutable Int_t fNBins; // Number of signal-color entries.
	mutable Int_t fCAMin; // Minimal signal in color-array.	mutable Int_t fCAMin; // Minimal signal in color-array.
	mutable Int_t fCAMax; // Maximal signal in color-array.	mutable Int_t fCAMax; // Maximal signal in color-array.
	mutable UChar_t* fColorArray; //[4*fNBins]	mutable UChar_t* fColorArray; //[4*fNBins]

	void SetupColor(Int_t val, UChar_t* pix) const;	void SetupColor(Int_t val, UChar_t* pix) const;


		Double_t IntToDouble(Int_t i) const { return fUIf*i + fUIc; }
		Int_t DoubleToInt(Double_t d) const { return TMath::Nint((d - fUIc) /
		fUIf); }

		Double_t GetCAMinAsDouble() const { return IntToDouble(fCAMin); }
		Double_t GetCAMaxAsDouble() const { return IntToDouble(fCAMax); }

	static TEveRGBAPalette* fgDefaultPalette;	static TEveRGBAPalette* fgDefaultPalette;

	public:	public:
	TEveRGBAPalette();	TEveRGBAPalette();
	TEveRGBAPalette(Int_t min, Int_t max, Bool_t interp=kTRUE,	TEveRGBAPalette(Int_t min, Int_t max, Bool_t interp=kTRUE,
	Bool_t showdef=kTRUE, Bool_t fixcolrng=kFALSE);	Bool_t showdef=kTRUE, Bool_t fixcolrng=kFALSE);
	virtual ~TEveRGBAPalette();	virtual ~TEveRGBAPalette();

	void SetupColorArray() const;	void SetupColorArray() const;
	void ClearColorArray();	void ClearColorArray();

	skipping to change at line 90	skipping to change at line 104
	void SetLimitsScaleMinMax(Int_t low, Int_t high);	void SetLimitsScaleMinMax(Int_t low, Int_t high);
	void SetMinMax(Int_t min, Int_t max);	void SetMinMax(Int_t min, Int_t max);
	void SetMin(Int_t min);	void SetMin(Int_t min);
	void SetMax(Int_t max);	void SetMax(Int_t max);

	Int_t GetLowLimit() const { return fLowLimit; }	Int_t GetLowLimit() const { return fLowLimit; }
	Int_t GetHighLimit() const { return fHighLimit; }	Int_t GetHighLimit() const { return fHighLimit; }

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


		Bool_t GetUIDoubleRep() const { return fUIDoubleRep; }
		void SetUIDoubleRep(Bool_t b, Double_t f=1, Double_t c=0);

	Bool_t GetInterpolate() const { return fInterpolate; }	Bool_t GetInterpolate() const { return fInterpolate; }
	void SetInterpolate(Bool_t b);	void SetInterpolate(Bool_t b);

	Bool_t GetShowDefValue() const { return fShowDefValue; }	Bool_t GetShowDefValue() const { return fShowDefValue; }
	void SetShowDefValue(Bool_t v) { fShowDefValue = v; }	void SetShowDefValue(Bool_t v) { fShowDefValue = v; }

	Bool_t GetFixColorRange() const { return fFixColorRange; }	Bool_t GetFixColorRange() const { return fFixColorRange; }
	void SetFixColorRange(Bool_t v);	void SetFixColorRange(Bool_t v);

	Int_t GetUnderflowAction() const { return fUnderflowAction; }	Int_t GetUnderflowAction() const { return fUnderflowAction; }

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

	TEveRGBAPaletteEditor.h	TEveRGBAPaletteEditor.h

	// @(#)root/eve:$Id: TEveRGBAPaletteEditor.h 29357 2009-07-06 17:53:36Z mat evz $	// @(#)root/eve:$Id: TEveRGBAPaletteEditor.h 43602 2012-04-02 05:21:43Z mat evz $
	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007	// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2007, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40

	protected:	protected:
	TEveRGBAPalette *fM;	TEveRGBAPalette *fM;

	TGComboBox *fUnderflowAction;	TGComboBox *fUnderflowAction;
	TGColorSelect *fUnderColor;	TGColorSelect *fUnderColor;
	TGComboBox *fOverflowAction;	TGComboBox *fOverflowAction;
	TGColorSelect *fOverColor;	TGColorSelect *fOverColor;

	TEveGDoubleValuator *fMinMax;	TEveGDoubleValuator *fMinMax;

		Double_t fOldMin;
		Double_t fOldMax;

	TGCheckButton *fInterpolate;	TGCheckButton *fInterpolate;
	TGCheckButton *fShowDefValue;	TGCheckButton *fShowDefValue;
	TGColorSelect *fDefaultColor;	TGColorSelect *fDefaultColor;
	TGCheckButton *fFixColorRange;	TGCheckButton *fFixColorRange;

	public:	public:
	TEveRGBAPaletteSubEditor(const TGWindow* p);	TEveRGBAPaletteSubEditor(const TGWindow* p);
	virtual ~TEveRGBAPaletteSubEditor() {}	virtual ~TEveRGBAPaletteSubEditor() {}


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

	TEventIter.h	TEventIter.h

	// @(#)root/proofplayer:$Id: TEventIter.h 38810 2011-04-12 16:22:59Z ganis $	// @(#)root/proofplayer:$Id: TEventIter.h 44010 2012-04-29 23:07:48Z ganis $
	// Author: Maarten Ballintijn 07/01/02	// Author: Maarten Ballintijn 07/01/02
	// Modified: Long Tran-Thanh 04/09/07 (Addition of TEventIterUnit)	// Modified: Long Tran-Thanh 04/09/07 (Addition of TEventIterUnit)

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2001, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	skipping to change at line 48	skipping to change at line 48
	class TIter;	class TIter;
	class TTree;	class TTree;
	class TTreeCache;	class TTreeCache;
	class TEventList;	class TEventList;
	class TEntryList;	class TEntryList;

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

	class TEventIter : public TObject {	class TEventIter : public TObject {


		public:
		enum EIterType { kData = 15}; // True if iterating over data

	protected:	protected:
	TDSet *fDSet; // data set over which to iterate	TDSet *fDSet; // data set over which to iterate

	TDSetElement *fElem; // Current Element	TDSetElement *fElem; // Current Element

	TString fFilename; // Name of the current file	TString fFilename; // Name of the current file
	TFile *fFile; // Current file	TFile *fFile; // Current file
	Long64_t fOldBytesRead; // last reported number of bytes read	Long64_t fOldBytesRead; // last reported number of bytes read
	TString fPath; // Path to current TDirectory	TString fPath; // Path to current TDirectory
	TDirectory *fDir; // directory containing the objects or the TTree	TDirectory *fDir; // directory containing the objects or the TTree

	skipping to change at line 82	skipping to change at line 85
	Int_t LoadDir(); // Load the directory pointed to by fElem	Int_t LoadDir(); // Load the directory pointed to by fElem

	public:	public:
	TEventIter();	TEventIter();
	TEventIter(TDSet dset, TSelector sel, Long64_t first, Long64_t num);	TEventIter(TDSet dset, TSelector sel, Long64_t first, Long64_t num);
	virtual ~TEventIter();	virtual ~TEventIter();

	virtual Long64_t GetCacheSize() = 0;	virtual Long64_t GetCacheSize() = 0;
	virtual Int_t GetLearnEntries() = 0;	virtual Int_t GetLearnEntries() = 0;
	virtual Long64_t GetNextEvent() = 0;	virtual Long64_t GetNextEvent() = 0;

		virtual Int_t GetNextPacket(Long64_t &first, Long64_t &num,
		TEntryList enl = 0, TEventList evl =
		0) = 0;
	virtual void InvalidatePacket();	virtual void InvalidatePacket();

		virtual void PreProcessEvent(Long64_t) = 0;
	virtual void StopProcess(Bool_t abort);	virtual void StopProcess(Bool_t abort);

	static TEventIter Create(TDSet dset, TSelector *sel, Long64_t first, L ong64_t num);	static TEventIter Create(TDSet dset, TSelector *sel, Long64_t first, L ong64_t num);

	ClassDef(TEventIter,0) // Event iterator used by TProofPlayer's	ClassDef(TEventIter,0) // Event iterator used by TProofPlayer's
	};	};

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

	class TEventIterUnit : public TEventIter {	class TEventIterUnit : public TEventIter {

	skipping to change at line 106	skipping to change at line 112
	Long64_t fCurrent;	Long64_t fCurrent;

	public:	public:
	TEventIterUnit();	TEventIterUnit();
	TEventIterUnit(TDSet dset, TSelector sel, Long64_t num);	TEventIterUnit(TDSet dset, TSelector sel, Long64_t num);
	~TEventIterUnit() { }	~TEventIterUnit() { }

	Long64_t GetCacheSize() {return -1;}	Long64_t GetCacheSize() {return -1;}
	Int_t GetLearnEntries() {return -1;}	Int_t GetLearnEntries() {return -1;}
	Long64_t GetNextEvent();	Long64_t GetNextEvent();

		Int_t GetNextPacket(Long64_t &first, Long64_t &num,
		TEntryList enl = 0, TEventList evl = 0);
		inline void PreProcessEvent(Long64_t) { };

	ClassDef(TEventIterUnit,0) // Event iterator for objects	ClassDef(TEventIterUnit,0) // Event iterator for objects
	};	};

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

	class TEventIterObj : public TEventIter {	class TEventIterObj : public TEventIter {

	private:	private:
	TString fClassName; // class name of objects to iterate over	TString fClassName; // class name of objects to iterate over

	skipping to change at line 128	skipping to change at line 137
	TObject *fObj; // object found	TObject *fObj; // object found

	public:	public:
	TEventIterObj();	TEventIterObj();
	TEventIterObj(TDSet dset, TSelector sel, Long64_t first, Long64_t num) ;	TEventIterObj(TDSet dset, TSelector sel, Long64_t first, Long64_t num) ;
	~TEventIterObj();	~TEventIterObj();

	Long64_t GetCacheSize() {return -1;}	Long64_t GetCacheSize() {return -1;}
	Int_t GetLearnEntries() {return -1;}	Int_t GetLearnEntries() {return -1;}
	Long64_t GetNextEvent();	Long64_t GetNextEvent();

		Int_t GetNextPacket(Long64_t &first, Long64_t &num,
		TEntryList enl = 0, TEventList evl = 0);
		void PreProcessEvent(Long64_t);

	ClassDef(TEventIterObj,0) // Event iterator for objects	ClassDef(TEventIterObj,0) // Event iterator for objects
	};	};

	//------------------------------------------------------------------------	//------------------------------------------------------------------------
	class TEventIterTree : public TEventIter {	class TEventIterTree : public TEventIter {

	private:	private:
	TString fTreeName; // name of the tree object to iterate over	TString fTreeName; // name of the tree object to iterate over
	TTree *fTree; // tree we are iterating over	TTree *fTree; // tree we are iterating over

	skipping to change at line 167	skipping to change at line 179
	TTree* Load(TDSetElement *elem, Bool_t &localfile);	TTree* Load(TDSetElement *elem, Bool_t &localfile);
	TTree* GetTrees(TDSetElement *elem);	TTree* GetTrees(TDSetElement *elem);
	public:	public:
	TEventIterTree();	TEventIterTree();
	TEventIterTree(TDSet dset, TSelector sel, Long64_t first, Long64_t num );	TEventIterTree(TDSet dset, TSelector sel, Long64_t first, Long64_t num );
	~TEventIterTree();	~TEventIterTree();

	Long64_t GetCacheSize();	Long64_t GetCacheSize();
	Int_t GetLearnEntries();	Int_t GetLearnEntries();
	Long64_t GetNextEvent();	Long64_t GetNextEvent();

		Int_t GetNextPacket(Long64_t &first, Long64_t &num,
		TEntryList enl = 0, TEventList evl = 0);
		void PreProcessEvent(Long64_t ent);

	ClassDef(TEventIterTree,0) // Event iterator for Trees	ClassDef(TEventIterTree,0) // Event iterator for Trees
	};	};

	#endif	#endif

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

	TFPBlock.h	TFPBlock.h

	// @(#)root/io:$Id: TFPBlock.h 41698 2011-11-01 21:22:54Z pcanal $	// @(#)root/io:$Id: TFPBlock.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Elvin Sindrilaru 19/05/2011	// Author: Elvin Sindrilaru 19/05/2011

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2011, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2011, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40

	class TFPBlock : public TObject{	class TFPBlock : public TObject{

	private:	private:
	char *fBuffer; // content of the block	char *fBuffer; // content of the block
	Int_t fNblock; // number of segment in the block	Int_t fNblock; // number of segment in the block
	Int_t fFullSize; // total size of segments that make up the bloc k	Int_t fFullSize; // total size of segments that make up the bloc k
	Int_t *fLen; // array of lengths of each segment	Int_t *fLen; // array of lengths of each segment
	Long64_t *fPos; // array of positions of each segment	Long64_t *fPos; // array of positions of each segment


		TFPBlock(const TFPBlock&); // Not implemented.
		TFPBlock &operator=(const TFPBlock&); // Not implemented.

	public:	public:
	TFPBlock(Long64_t, Int_t, Int_t);	TFPBlock(Long64_t, Int_t, Int_t);
	virtual ~TFPBlock();	virtual ~TFPBlock();

	Long64_t GetPos(Int_t) const;	Long64_t GetPos(Int_t) const;
	Int_t GetLen(Int_t) const;	Int_t GetLen(Int_t) const;

	Long64_t *GetPos() const;	Long64_t *GetPos() const;
	Int_t *GetLen() const;	Int_t *GetLen() const;
	Int_t GetFullSize() const;	Int_t GetFullSize() const;

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

	TFormLeafInfoReference.h	TFormLeafInfoReference.h

	// @(#)root/treeplayer:$Id: TFormLeafInfoReference.h 20882 2007-11-19 11:31 :26Z rdm $	// @(#)root/treeplayer:$Id: TFormLeafInfoReference.h 43271 2012-03-07 05:53 :52Z pcanal $
	// Author: Markus Frank 01/02/2006	// Author: Markus Frank 01/02/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers and al. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers and al. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 44	skipping to change at line 44
	public:	public:
	Proxy* fProxy; //! Cached pointer to reference proxy	Proxy* fProxy; //! Cached pointer to reference proxy
	TBranch* fBranch; //! Cached pointer to branch object	TBranch* fBranch; //! Cached pointer to branch object
	public:	public:
	// Initializing constructor	// Initializing constructor
	TFormLeafInfoReference(TClass* classptr, TStreamerElement* element, int off);	TFormLeafInfoReference(TClass* classptr, TStreamerElement* element, int off);
	// Copy constructor	// Copy constructor
	TFormLeafInfoReference(const TFormLeafInfoReference& orig);	TFormLeafInfoReference(const TFormLeafInfoReference& orig);
	// Default destructor	// Default destructor
	virtual ~TFormLeafInfoReference();	virtual ~TFormLeafInfoReference();

		// Exception safe swap.
		void Swap(TFormLeafInfoReference &other);
		// Exception safe assignment operator.
		TFormLeafInfoReference &operator=(const TFormLeafInfoReference &orig);
	// Virtual copy constructor	// Virtual copy constructor
	virtual TFormLeafInfo* DeepCopy() const;	virtual TFormLeafInfo* DeepCopy() const;

	// Access to the info's proxy	// Access to the info's proxy
	Proxy* GetProxy() const { return fProxy; }	Proxy* GetProxy() const { return fProxy; }
	// Access to the info's connected branch	// Access to the info's connected branch
	TBranch* GetBranch() const { return fBranch; }	TBranch* GetBranch() const { return fBranch; }
	// Access to the info's connected branch	// Access to the info's connected branch
	void SetBranch(TBranch* branch)	void SetBranch(TBranch* branch)
	{ fBranch = branch; if ( fNext ) fNext->SetBranch(branch); }	{ fBranch = branch; if ( fNext ) fNext->SetBranch(branch); }

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

	TGHtml.h	TGHtml.h

	skipping to change at line 282	skipping to change at line 282
	#define HTML_NewLine 0x02 // type == Html_Space and ends with newline	#define HTML_NewLine 0x02 // type == Html_Space and ends with newline
	#define HTML_Selected 0x04 // Some or all of this Html_Block is selected	#define HTML_Selected 0x04 // Some or all of this Html_Block is selected
	// Used by Html_Block elements only.	// Used by Html_Block elements only.

	// Each text element holds additional information as shown here. Notice tha t	// Each text element holds additional information as shown here. Notice tha t
	// extra space is allocated so that zText[] will be large enough to hold th e	// extra space is allocated so that zText[] will be large enough to hold th e
	// complete text of the element. X and y coordinates are relative to the	// complete text of the element. X and y coordinates are relative to the
	// virtual canvas. The y coordinate refers to the baseline.	// virtual canvas. The y coordinate refers to the baseline.

	class TGHtmlTextElement : public TGHtmlElement {	class TGHtmlTextElement : public TGHtmlElement {

		private:
		TGHtmlTextElement(const TGHtmlTextElement&); // Not implement
		ed.
		TGHtmlTextElement &operator=(const TGHtmlTextElement&); // Not implement
		ed.

	public:	public:
	TGHtmlTextElement(int size);	TGHtmlTextElement(int size);
	virtual ~TGHtmlTextElement();	virtual ~TGHtmlTextElement();

	Html_32_t fY; // y coordinate where text should be ren dered	Html_32_t fY; // y coordinate where text should be ren dered
	Html_16_t fX; // x coordinate where text should be ren dered	Html_16_t fX; // x coordinate where text should be ren dered
	Html_16_t fW; // width of this token in pixels	Html_16_t fW; // width of this token in pixels
	Html_u8_t fAscent; // height above the baseline	Html_u8_t fAscent; // height above the baseline
	Html_u8_t fDescent; // depth below the baseline	Html_u8_t fDescent; // depth below the baseline
	Html_u8_t fSpaceWidth; // Width of one space in the current fon t	Html_u8_t fSpaceWidth; // Width of one space in the current fon t

	skipping to change at line 488	skipping to change at line 492
	// TGHtmlImageMarkup object below. There is one TGHtmlImageMarkup for each	// TGHtmlImageMarkup object below. There is one TGHtmlImageMarkup for each
	// <IMG> in the source HTML. There is one of these objects for each unique	// <IMG> in the source HTML. There is one of these objects for each unique
	// image loaded. (If two <IMG> specify the same image, there are still two	// image loaded. (If two <IMG> specify the same image, there are still two
	// TGHtmlImageMarkup objects but only one TGHtmlImage object that is shared	// TGHtmlImageMarkup objects but only one TGHtmlImage object that is shared
	// between them.)	// between them.)

	class TGHtml;	class TGHtml;
	class TGHtmlImageMarkup;	class TGHtmlImageMarkup;

	class TGHtmlImage : public TObject {	class TGHtmlImage : public TObject {

		private:
		TGHtmlImage(const TGHtmlImage&); // Not implemented.
		TGHtmlImage &operator=(const TGHtmlImage&); // Not implemented.

	public:	public:
	TGHtmlImage(TGHtml htm, const char url, const char *width,	TGHtmlImage(TGHtml htm, const char url, const char *width,
	const char *height);	const char *height);
	virtual ~TGHtmlImage();	virtual ~TGHtmlImage();

	public:	public:
	TGHtml *fHtml; // The owner of this image	TGHtml *fHtml; // The owner of this image
	TImage *fImage; // The image token	TImage *fImage; // The image token
	Html_32_t fW; // Requested width of this image (0 if none)	Html_32_t fW; // Requested width of this image (0 if none)
	Html_32_t fH; // Requested height of this image (0 if none)	Html_32_t fH; // Requested height of this image (0 if none)

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

	TGHtmlUri.h	TGHtmlUri.h

	skipping to change at line 58	skipping to change at line 58
	URI_PATH_MASK \| URI_QUERY_MASK \| \	URI_PATH_MASK \| URI_QUERY_MASK \| \
	URI_FRAGMENT_MASK)	URI_FRAGMENT_MASK)

	//----------------------------------------------------------------------	//----------------------------------------------------------------------
	// A parsed URI is held in an instance of the following class.	// A parsed URI is held in an instance of the following class.
	//	//
	// The examples are from the URI	// The examples are from the URI
	// http://192.168.1.1:8080/cgi-bin/printenv?name=xyzzy&addr=none#frag	// http://192.168.1.1:8080/cgi-bin/printenv?name=xyzzy&addr=none#frag

	class TGHtmlUri : public TObject {	class TGHtmlUri : public TObject {

		private:
		TGHtmlUri(const TGHtmlUri&); // Not implemented.
		TGHtmlUri &operator=(const TGHtmlUri&); // Not implemented.

	public:	public:
	TGHtmlUri(const char *zUri = 0);	TGHtmlUri(const char *zUri = 0);
	TGHtmlUri(const TGHtmlUri *uri);	TGHtmlUri(const TGHtmlUri *uri);
	virtual ~TGHtmlUri();	virtual ~TGHtmlUri();

	char *BuildUri();	char *BuildUri();
	int EqualsUri(const TGHtmlUri *uri, int field_mask = URI_FULL_MASK);	int EqualsUri(const TGHtmlUri *uri, int field_mask = URI_FULL_MASK);

	public:	public:
	int ComponentLength(const char z, const char zInit, const char *zTerm) ;	int ComponentLength(const char z, const char zInit, const char *zTerm) ;

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

	TGRedirectOutputGuard.h	TGRedirectOutputGuard.h

	// @(#)root/gui:$Id: TGRedirectOutputGuard.h 23115 2008-04-10 13:35:37Z rdm $	// @(#)root/gui:$Id: TGRedirectOutputGuard.h 43282 2012-03-08 10:01:56Z bel lenot $
	// Author: G. Ganis 10/10/2005	// Author: G. Ganis 10/10/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 54	skipping to change at line 54
	class TGTextView;	class TGTextView;

	class TGRedirectOutputGuard {	class TGRedirectOutputGuard {

	private:	private:
	TString fLogFile;	TString fLogFile;
	Bool_t fTmpFile;	Bool_t fTmpFile;
	TGTextView *fTextView;	TGTextView *fTextView;
	FILE *fLogFileRead;	FILE *fLogFileRead;


		private:
		TGRedirectOutputGuard(const TGRedirectOutputGuard&); // Not i
		mplemented.
		TGRedirectOutputGuard &operator=(const TGRedirectOutputGuard&); // Not i
		mplemented.

	public:	public:
	TGRedirectOutputGuard(TGTextView *tv,	TGRedirectOutputGuard(TGTextView *tv,
	const char flog = 0, const char mode = "a");	const char flog = 0, const char mode = "a");
	virtual ~TGRedirectOutputGuard();	virtual ~TGRedirectOutputGuard();

	void Update(); // Update window with file content	void Update(); // Update window with file content

	ClassDef(TGRedirectOutputGuard,0) // Exception safe output redirection	ClassDef(TGRedirectOutputGuard,0) // Exception safe output redirection
	};	};


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

	TGenCollectionProxy.h	TGenCollectionProxy.h

	// @(#)root/io:$Id: TGenCollectionProxy.h 42890 2012-02-06 18:14:01Z pcanal $	// @(#)root/io:$Id: TGenCollectionProxy.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Markus Frank 28/10/04	// Author: Markus Frank 28/10/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TGenCollectionProxy	#ifndef ROOT_TGenCollectionProxy

	skipping to change at line 87	skipping to change at line 87
	struct Value {	struct Value {
	ROOT::NewFunc_t fCtor; // Method cache for containee constructo r	ROOT::NewFunc_t fCtor; // Method cache for containee constructo r
	ROOT::DesFunc_t fDtor; // Method cache for containee destructor	ROOT::DesFunc_t fDtor; // Method cache for containee destructor
	ROOT::DelFunc_t fDelete; // Method cache for containee delete	ROOT::DelFunc_t fDelete; // Method cache for containee delete
	UInt_t fCase; // type of data of Value_type	UInt_t fCase; // type of data of Value_type
	UInt_t fProperties; // Additional properties of the value ty pe (kNeedDelete)	UInt_t fProperties; // Additional properties of the value ty pe (kNeedDelete)
	TClassRef fType; // TClass reference of Value_type in col lection	TClassRef fType; // TClass reference of Value_type in col lection
	EDataType fKind; // kind of ROOT-fundamental type	EDataType fKind; // kind of ROOT-fundamental type
	size_t fSize; // fSize of the contained object	size_t fSize; // fSize of the contained object


	// Copy constructor	// Default copy constructor has the correct implementation.
	Value(const Value& inside);
	// Initializing constructor	// Initializing constructor
	Value(const std::string& info, Bool_t silent);	Value(const std::string& info, Bool_t silent);
	// Delete individual item from STL container	// Delete individual item from STL container
	void DeleteItem(void* ptr);	void DeleteItem(void* ptr);

	Bool_t IsValid();	Bool_t IsValid();
	};	};

	/**@class StreamHelper	/**@class StreamHelper
	*	*

	skipping to change at line 217	skipping to change at line 217
	* @version 1.0	* @version 1.0
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	class Method {	class Method {
	public:	public:
	typedef void* (Call_t)(void);	typedef void* (Call_t)(void);
	Call_t call;	Call_t call;
	Method() : call(0) { }	Method() : call(0) { }
	Method(Call_t c) : call(c) { }	Method(Call_t c) : call(c) { }
	Method(const Method& m) : call(m.call) { }	Method(const Method& m) : call(m.call) { }

		Method &operator=(const Method& m) { call = m.call; return *this; }
	void* invoke(void* obj) const { return (*call)(obj); }	void* invoke(void* obj) const { return (*call)(obj); }
	};	};

	/** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollect ionProxy.h	/** @class TGenCollectionProxy::Method TGenCollectionProxy.h TGenCollect ionProxy.h
	*	*
	* Small helper to execute (compiler) generated function for the	* Small helper to execute (compiler) generated function for the
	* access to STL or other containers.	* access to STL or other containers.
	*	*
	* @author M.Frank	* @author M.Frank
	* @version 1.0	* @version 1.0
	* @date 10/10/2004	* @date 10/10/2004
	*/	*/
	class Method0 {	class Method0 {
	public:	public:
	typedef void* (*Call_t)();	typedef void* (*Call_t)();
	Call_t call;	Call_t call;
	Method0() : call(0) { }	Method0() : call(0) { }
	Method0(Call_t c) : call(c) { }	Method0(Call_t c) : call(c) { }
	Method0(const Method0& m) : call(m.call) { }	Method0(const Method0& m) : call(m.call) { }

		Method0 &operator=(const Method0& m) { call = m.call; return *this; }
	void* invoke() const { return (*call)(); }	void* invoke() const { return (*call)(); }
	};	};

	/** @class TGenCollectionProxy::TStaging	/** @class TGenCollectionProxy::TStaging
	*	*
	* Small helper to stage the content of an associative	* Small helper to stage the content of an associative
	* container when reading and before inserting it in the	* container when reading and before inserting it in the
	* actual collection.	* actual collection.
	*	*
	* @author Ph.Canal	* @author Ph.Canal
	* @version 1.0	* @version 1.0
	* @date 20/08/2010	* @date 20/08/2010
	*/	*/
	class TStaging {	class TStaging {
	void *fTarget; // Pointer to the collection we are staging for.	void *fTarget; // Pointer to the collection we are staging for.
	void *fContent; // Pointer to the content	void *fContent; // Pointer to the content
	size_t fReserved; // Amount of space already reserved.	size_t fReserved; // Amount of space already reserved.
	size_t fSize; // Number of elements	size_t fSize; // Number of elements
	size_t fSizeOf; // size of each elements	size_t fSizeOf; // size of each elements


		TStaging(const TStaging&); // Not implemented.
		TStaging &operator=(const TStaging&); // Not implemented.

	public:	public:
	TStaging(size_t size, size_t size_of) : fTarget(0), fContent(0), fRes erved(0), fSize(size), fSizeOf(size_of)	TStaging(size_t size, size_t size_of) : fTarget(0), fContent(0), fRes erved(0), fSize(size), fSizeOf(size_of)
	{	{
	// Usual constructor. Reserves the required number of elements.	// Usual constructor. Reserves the required number of elements.
	fReserved = fSize;	fReserved = fSize;
	fContent = ::malloc(fReserved * fSizeOf);	fContent = ::malloc(fReserved * fSizeOf);
	}	}

	~TStaging() {	~TStaging() {
	// Usual destructor	// Usual destructor

	skipping to change at line 356	skipping to change at line 362
	TGenCollectionProxy(); // not implemented on purpose.	TGenCollectionProxy(); // not implemented on purpose.

	public:	public:

	// Virtual copy constructor.	// Virtual copy constructor.
	virtual TVirtualCollectionProxy* Generate() const;	virtual TVirtualCollectionProxy* Generate() const;

	// Copy constructor.	// Copy constructor.
	TGenCollectionProxy(const TGenCollectionProxy& copy);	TGenCollectionProxy(const TGenCollectionProxy& copy);


		private:
		// Assignment operator
		TGenCollectionProxy &operator=(const TGenCollectionProxy&); // Not Imple
		mented

		public:
	// Initializing constructor	// Initializing constructor
	TGenCollectionProxy(Info_t typ, size_t iter_size);	TGenCollectionProxy(Info_t typ, size_t iter_size);
	TGenCollectionProxy(const ROOT::TCollectionProxyInfo &info, TClass *cl);	TGenCollectionProxy(const ROOT::TCollectionProxyInfo &info, TClass *cl);

	// Standard destructor.	// Standard destructor.
	virtual ~TGenCollectionProxy();	virtual ~TGenCollectionProxy();

	// Return a pointer to the TClass representing the container.	// Return a pointer to the TClass representing the container.
	virtual TClass *GetCollectionClass();	virtual TClass *GetCollectionClass();


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

	TGenPhaseSpace.h	TGenPhaseSpace.h

	// @(#)root/physics:$Id: TGenPhaseSpace.h 42733 2012-01-19 15:30:13Z axel $	// @(#)root/physics:$Id: TGenPhaseSpace.h 44084 2012-05-03 09:55:25Z axel $
	// Author: Rene Brun , Valerio Filippini 06/09/2000	// Author: Rene Brun , Valerio Filippini 06/09/2000

	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////
	// //	// //
	// Phase Space Generator, based on the GENBOD routine of CERNLIB //	// Phase Space Generator, based on the GENBOD routine of CERNLIB //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ////	/////////////////////////////////////////////////////////////////////////// ////

	#ifndef ROOT_TGenPhaseSpace	#ifndef ROOT_TGenPhaseSpace
	#define ROOT_TGenPhaseSpace	#define ROOT_TGenPhaseSpace

	skipping to change at line 30	skipping to change at line 30
	Double_t fTeCmTm; // total energy in the C.M. minus the tota l mass	Double_t fTeCmTm; // total energy in the C.M. minus the tota l mass
	Double_t fWtMax; // maximum weigth	Double_t fWtMax; // maximum weigth
	TLorentzVector fDecPro[18]; //kinematics of the generated particles	TLorentzVector fDecPro[18]; //kinematics of the generated particles

	Double_t PDK(Double_t a, Double_t b, Double_t c);	Double_t PDK(Double_t a, Double_t b, Double_t c);

	public:	public:
	TGenPhaseSpace(): fNt(0), fMass(), fBeta(), fTeCmTm(0.), fWtMax(0.) {}	TGenPhaseSpace(): fNt(0), fMass(), fBeta(), fTeCmTm(0.), fWtMax(0.) {}
	TGenPhaseSpace(const TGenPhaseSpace &gen);	TGenPhaseSpace(const TGenPhaseSpace &gen);
	virtual ~TGenPhaseSpace() {}	virtual ~TGenPhaseSpace() {}

		TGenPhaseSpace& operator=(const TGenPhaseSpace &gen);

	Bool_t SetDecay(TLorentzVector &P, Int_t nt, const Double_t ma ss, Option_t opt="");	Bool_t SetDecay(TLorentzVector &P, Int_t nt, const Double_t ma ss, Option_t opt="");
	Double_t Generate();	Double_t Generate();
	TLorentzVector *GetDecay(Int_t n);	TLorentzVector *GetDecay(Int_t n);

	Int_t GetNt() const { return fNt;}	Int_t GetNt() const { return fNt;}
	Double_t GetWtMax() const { return fWtMax;}	Double_t GetWtMax() const { return fWtMax;}

	ClassDef(TGenPhaseSpace,1) //Simple Phase Space Generator	ClassDef(TGenPhaseSpace,1) //Simple Phase Space Generator
	};	};

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

	TGeoPatternFinder.h	TGeoPatternFinder.h

	// @(#)root/geom:$Id: TGeoPatternFinder.h 42999 2012-02-14 13:42:55Z agheat a $	// @(#)root/geom:$Id: TGeoPatternFinder.h 43564 2012-03-30 07:09:37Z agheat a $
	// Author: Andrei Gheata 30/10/01	// Author: Andrei Gheata 30/10/01

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 122	skipping to change at line 122
	class TGeoTranslation;	class TGeoTranslation;

	class TGeoPatternX : public TGeoPatternFinder	class TGeoPatternX : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternX();	TGeoPatternX();
	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);	TGeoPatternX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);

		TGeoPatternX(const TGeoPatternX &pf);
		TGeoPatternX& operator=(const TGeoPatternX&);

	// destructor	// destructor
	virtual ~TGeoPatternX();	virtual ~TGeoPatternX();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);
	virtual Int_t GetDivAxis() {return 1;}	virtual Int_t GetDivAxis() {return 1;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;

	skipping to change at line 154	skipping to change at line 156
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternY : public TGeoPatternFinder	class TGeoPatternY : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternY();	TGeoPatternY();
	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);	TGeoPatternY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);

		TGeoPatternY(const TGeoPatternY &pf);
		TGeoPatternY& operator=(const TGeoPatternY&);
	// destructor	// destructor
	virtual ~TGeoPatternY();	virtual ~TGeoPatternY();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);
	virtual Int_t GetDivAxis() {return 2;}	virtual Int_t GetDivAxis() {return 2;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual

	skipping to change at line 185	skipping to change at line 189
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternZ : public TGeoPatternFinder	class TGeoPatternZ : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternZ();	TGeoPatternZ();
	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);	TGeoPatternZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Double_t end);

		TGeoPatternZ(const TGeoPatternZ &pf);
		TGeoPatternZ& operator=(const TGeoPatternZ&);
	// destructor	// destructor
	virtual ~TGeoPatternZ();	virtual ~TGeoPatternZ();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);	virtual Double_t FindNextBoundary(Double_t point, Double_t dir, Int _t &indnext);
	virtual Int_t GetDivAxis() {return 3;}	virtual Int_t GetDivAxis() {return 3;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual

	skipping to change at line 216	skipping to change at line 222
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternParaX : public TGeoPatternFinder	class TGeoPatternParaX : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternParaX();	TGeoPatternParaX();
	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);	TGeoPatternParaX(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);

		TGeoPatternParaX(const TGeoPatternParaX &pf);
		TGeoPatternParaX& operator=(const TGeoPatternParaX&);

	// destructor	// destructor
	virtual ~TGeoPatternParaX();	virtual ~TGeoPatternParaX();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 1;}	virtual Int_t GetDivAxis() {return 1;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual

	skipping to change at line 250	skipping to change at line 258
	{	{
	private :	private :
	// data members	// data members
	Double_t fTxy; // tangent of alpha	Double_t fTxy; // tangent of alpha
	public:	public:
	// constructors	// constructors
	TGeoPatternParaY();	TGeoPatternParaY();
	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);	TGeoPatternParaY(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);

		TGeoPatternParaY(const TGeoPatternParaY &pf);
		TGeoPatternParaY& operator=(const TGeoPatternParaY&);

	// destructor	// destructor
	virtual ~TGeoPatternParaY();	virtual ~TGeoPatternParaY();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 2;}	virtual Int_t GetDivAxis() {return 2;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual

	skipping to change at line 285	skipping to change at line 295
	private :	private :
	// data members	// data members
	Double_t fTxz; // tangent of alpha xz	Double_t fTxz; // tangent of alpha xz
	Double_t fTyz; // tangent of alpha yz	Double_t fTyz; // tangent of alpha yz
	public:	public:
	// constructors	// constructors
	TGeoPatternParaZ();	TGeoPatternParaZ();
	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);	TGeoPatternParaZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);

		TGeoPatternParaZ(const TGeoPatternParaZ &pf);
		TGeoPatternParaZ& operator=(const TGeoPatternParaZ&);

	// destructor	// destructor
	virtual ~TGeoPatternParaZ();	virtual ~TGeoPatternParaZ();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 3;}	virtual Int_t GetDivAxis() {return 3;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual

	skipping to change at line 320	skipping to change at line 332
	private :	private :
	// data members	// data members
	Double_t fTxz; // tangent of alpha xz	Double_t fTxz; // tangent of alpha xz
	Double_t fTyz; // tangent of alpha yz	Double_t fTyz; // tangent of alpha yz
	public:	public:
	// constructors	// constructors
	TGeoPatternTrapZ();	TGeoPatternTrapZ();
	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);	TGeoPatternTrapZ(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doub le_t end);

		TGeoPatternTrapZ(const TGeoPatternTrapZ &pf);
		TGeoPatternTrapZ& operator=(const TGeoPatternTrapZ&);

	// destructor	// destructor
	virtual ~TGeoPatternTrapZ();	virtual ~TGeoPatternTrapZ();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	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 cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 3;}	virtual Int_t GetDivAxis() {return 3;}

	skipping to change at line 353	skipping to change at line 367
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternCylR : public TGeoPatternFinder	class TGeoPatternCylR : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternCylR();	TGeoPatternCylR();
	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doubl e_t end);	TGeoPatternCylR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doubl e_t end);

		TGeoPatternCylR(const TGeoPatternCylR &pf);
		TGeoPatternCylR& operator=(const TGeoPatternCylR&);
	// destructor	// destructor
	virtual ~TGeoPatternCylR();	virtual ~TGeoPatternCylR();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 1;}	virtual Int_t GetDivAxis() {return 1;}
	virtual Bool_t IsOnBoundary(const Double_t *point) const;	virtual Bool_t IsOnBoundary(const Double_t *point) const;
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);

	skipping to change at line 383	skipping to change at line 399
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternCylPhi : public TGeoPatternFinder	class TGeoPatternCylPhi : public TGeoPatternFinder
	{	{
	private :	private :
	// data members	// data members
	Double_t fSinCos; //![2fNdivisions] table of sines/ cosines	Double_t fSinCos; //![2fNdivisions] table of sines/ cosines

	protected:	protected:
	TGeoPatternCylPhi(const TGeoPatternCylPhi& pfc)	TGeoPatternCylPhi(const TGeoPatternCylPhi& pfc)

	: TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) { }	: TGeoPatternFinder(pfc), fSinCos(pfc.fSinCos) {CreateThreadData(1);}
	TGeoPatternCylPhi& operator=(const TGeoPatternCylPhi& pfc)	TGeoPatternCylPhi& operator=(const TGeoPatternCylPhi& pfc)

	{if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCo s;}	{if(this!=&pfc) {TGeoPatternFinder::operator=(pfc); fSinCos=pfc.fSinCo s; CreateThreadData(1);}
	return *this;}	return *this;}

	public:	public:
	// constructors	// constructors
	TGeoPatternCylPhi();	TGeoPatternCylPhi();
	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);	TGeoPatternCylPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);
	// destructor	// destructor
	virtual ~TGeoPatternCylPhi();	virtual ~TGeoPatternCylPhi();

	skipping to change at line 424	skipping to change at line 440
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternSphR : public TGeoPatternFinder	class TGeoPatternSphR : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternSphR();	TGeoPatternSphR();
	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doubl e_t end);	TGeoPatternSphR(TGeoVolume *vol, Int_t ndivisions, Double_t start, Doubl e_t end);

		TGeoPatternSphR(const TGeoPatternSphR &pf);
		TGeoPatternSphR& operator=(const TGeoPatternSphR&);
	// destructor	// destructor
	virtual ~TGeoPatternSphR();	virtual ~TGeoPatternSphR();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 1;}	virtual Int_t GetDivAxis() {return 1;}
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");

	skipping to change at line 453	skipping to change at line 471
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternSphTheta : public TGeoPatternFinder	class TGeoPatternSphTheta : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternSphTheta();	TGeoPatternSphTheta();
	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, D ouble_t end);	TGeoPatternSphTheta(TGeoVolume *vol, Int_t ndivisions, Double_t start, D ouble_t end);

		TGeoPatternSphTheta(const TGeoPatternSphTheta &pf);
		TGeoPatternSphTheta& operator=(const TGeoPatternSphTheta&);
	// destructor	// destructor
	virtual ~TGeoPatternSphTheta();	virtual ~TGeoPatternSphTheta();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 2;}	virtual Int_t GetDivAxis() {return 2;}
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");

	skipping to change at line 482	skipping to change at line 502
	/////////////////////////////////////////////////////////////////////////// /	/////////////////////////////////////////////////////////////////////////// /

	class TGeoPatternSphPhi : public TGeoPatternFinder	class TGeoPatternSphPhi : public TGeoPatternFinder
	{	{
	public:	public:
	// constructors	// constructors
	TGeoPatternSphPhi();	TGeoPatternSphPhi();
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions);
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t step);
	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);	TGeoPatternSphPhi(TGeoVolume *vol, Int_t ndivisions, Double_t start, Dou ble_t end);

		TGeoPatternSphPhi(const TGeoPatternSphPhi &pf);
		TGeoPatternSphPhi& operator=(const TGeoPatternSphPhi&);
	// destructor	// destructor
	virtual ~TGeoPatternSphPhi();	virtual ~TGeoPatternSphPhi();
	// methods	// methods
	virtual TGeoMatrix* CreateMatrix() const;	virtual TGeoMatrix* CreateMatrix() const;
	virtual void cd(Int_t idiv);	virtual void cd(Int_t idiv);
	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);	virtual TGeoNode FindNode(Double_t point, const Double_t *dir=0);
	virtual Int_t GetDivAxis() {return 3;}	virtual Int_t GetDivAxis() {return 3;}
	virtual	virtual
	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);	TGeoPatternFinder *MakeCopy(Bool_t reflect=kFALSE);
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");

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

	TH3.h	TH3.h

	// @(#)root/hist:$Id: TH3.h 42958 2012-02-10 14:47:09Z moneta $	// @(#)root/hist:$Id: TH3.h 44515 2012-06-04 14:16:56Z moneta $
	// Author: Rene Brun 27/10/95	// Author: Rene Brun 27/10/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 55	skipping to change at line 55
	TH3();	TH3();
	TH3(const char name,const char title,Int_t nbinsx,Double_t xlow,Double _t xup	TH3(const char name,const char title,Int_t nbinsx,Double_t xlow,Double _t xup
	,Int_t nbinsy,Double_t ylow,Double_t yup	,Int_t nbinsy,Double_t ylow,Double_t yup
	,Int_t nbinsz,Double_t zlow,Double_t zup) ;	,Int_t nbinsz,Double_t zlow,Double_t zup) ;
	TH3(const char name,const char title,Int_t nbinsx,const Float_t *xbins	TH3(const char name,const char title,Int_t nbinsx,const Float_t *xbins
	,Int_t nbinsy,const Float_t *ybins	,Int_t nbinsy,const Float_t *ybins
	,Int_t nbinsz,const Float_t *zbins );	,Int_t nbinsz,const Float_t *zbins );
	TH3(const char name,const char title,Int_t nbinsx,const Double_t *xbin s	TH3(const char name,const char title,Int_t nbinsx,const Double_t *xbin s
	,Int_t nbinsy,const Double_t *ybin s	,Int_t nbinsy,const Double_t *ybin s
	,Int_t nbinsz,const Double_t *zbin s);	,Int_t nbinsz,const Double_t *zbin s);

	virtual Int_t BufferFill(Double_t, Double_t) {return -2;} //may not u
	se
	virtual Int_t BufferFill(Double_t, Double_t, Double_t) {return -2;} /
	/may not use
	virtual Int_t BufferFill(Double_t x, Double_t y, Double_t z, Double_t w);	virtual Int_t BufferFill(Double_t x, Double_t y, Double_t z, Double_t w);

	void DoFillProfileProjection(TProfile2D * p2, const TAxis & a1, const TA xis & a2, const TAxis & a3, Int_t bin1, Int_t bin2, Int_t bin3, Int_t inBin , Bool_t useWeights) const;	void DoFillProfileProjection(TProfile2D * p2, const TAxis & a1, const TA xis & a2, const TAxis & a3, Int_t bin1, Int_t bin2, Int_t bin3, Int_t inBin , Bool_t useWeights) const;


		virtual Int_t BufferFill(Double_t, Double_t) {return -2;} //may not u
		se
		virtual Int_t BufferFill(Double_t, Double_t, Double_t) {return -2;} /
		/may not use
		Int_t Fill(Double_t); //MayNotUse
		Int_t Fill(Double_t,Double_t) {return Fill(0.);} //MayNotUse
		Int_t Fill(const char*, Double_t) {return Fill(0);} //MayNotUse
		Int_t Fill(Double_t,const char*,Double_t) {return Fill(0);} //MayNotU
		se
		Int_t Fill(const char*,Double_t,Double_t) {return Fill(0);} //MayNotU
		se
		Int_t Fill(const char,const char,Double_t) {return Fill(0);} //MayN
		otUse

	public:	public:
	TH3(const TH3&);	TH3(const TH3&);
	virtual ~TH3();	virtual ~TH3();
	virtual Int_t BufferEmpty(Int_t action=0);	virtual Int_t BufferEmpty(Int_t action=0);
	virtual void Copy(TObject &hnew) const;	virtual void Copy(TObject &hnew) const;

	Int_t Fill(Double_t) {return -1;} //MayNotUse
	Int_t Fill(Double_t,Double_t) {return -1;} //MayNotUse
	Int_t Fill(const char*, Double_t) {return -1;} //MayNotUse
	Int_t Fill(Double_t,const char*,Double_t) {return -1;} //MayN
	otUse
	Int_t Fill(const char*,Double_t,Double_t) {return -1;} //MayN
	otUse
	Int_t Fill(const char,const char,Double_t) {return -1;} //M
	ayNotUse
	virtual Int_t Fill(Double_t x, Double_t y, Double_t z);	virtual Int_t Fill(Double_t x, Double_t y, Double_t z);
	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t w);	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t w);

	virtual Int_t Fill(const char namex, const char namey, const char * namez, Double_t w);	virtual Int_t Fill(const char namex, const char namey, const char * namez, Double_t w);
	virtual Int_t Fill(const char namex, Double_t y, const char namez, Double_t w);	virtual Int_t Fill(const char namex, Double_t y, const char namez, Double_t w);
	virtual Int_t Fill(const char namex, const char namey, Double_t z, Double_t w);	virtual Int_t Fill(const char namex, const char namey, Double_t z, Double_t w);
	virtual Int_t Fill(Double_t x, const char namey, const char namez, Double_t w);	virtual Int_t Fill(Double_t x, const char namey, const char namez, Double_t w);
	virtual Int_t Fill(Double_t x, const char *namey, Double_t z, Double_ t w);	virtual Int_t Fill(Double_t x, const char *namey, Double_t z, Double_ t w);
	virtual Int_t Fill(Double_t x, Double_t y, const char *namez, Double_ t w);	virtual Int_t Fill(Double_t x, Double_t y, const char *namez, Double_ t w);


	skipping to change at line 116	skipping to change at line 117
	virtual Long64_t Merge(TCollection *list);	virtual Long64_t Merge(TCollection *list);
	TH1D ProjectionX(const char name="_px", Int_t firstybin=0, Int_t lastybin=-1, Int_t firstzbin=0,	TH1D ProjectionX(const char name="_px", Int_t firstybin=0, Int_t lastybin=-1, Int_t firstzbin=0,
	Int_t lastzbin=-1, Option_t option="") con st; // MENU*	Int_t lastzbin=-1, Option_t option="") con st; // MENU*
	TH1D ProjectionY(const char name="_py", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstzbin=0,	TH1D ProjectionY(const char name="_py", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstzbin=0,
	Int_t lastzbin=-1, Option_t option="") con st; // MENU*	Int_t lastzbin=-1, Option_t option="") con st; // MENU*
	TH1D ProjectionZ(const char name="_pz", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstybin=0,	TH1D ProjectionZ(const char name="_pz", Int_t firstxbin=0, Int_t lastxbin=-1, Int_t firstybin=0,
	Int_t lastybin=-1, Option_t option="") con st; // MENU*	Int_t lastybin=-1, Option_t option="") con st; // MENU*
	TH1 Project3D(Option_t option="x") const; // MENU	TH1 Project3D(Option_t option="x") const; // MENU
	TProfile2D Project3DProfile(Option_t option="xy") const; // MENU	TProfile2D Project3DProfile(Option_t option="xy") const; // MENU
	virtual void PutStats(Double_t *stats);	virtual void PutStats(Double_t *stats);

	virtual TH3 RebinX(Int_t ngroup, const char newname);	virtual TH3 RebinX(Int_t ngroup = 2, const char newname = "");
	virtual TH3 RebinY(Int_t ngroup, const char newname);	virtual TH3 RebinY(Int_t ngroup = 2, const char newname = "");
	virtual TH3 RebinZ(Int_t ngroup, const char newname);	virtual TH3 RebinZ(Int_t ngroup = 2, const char newname = "");
	virtual TH3 *Rebin3D(Int_t nxgroup, Int_t nygroup, Int_t nzgroup, co	virtual TH3 *Rebin3D(Int_t nxgroup = 2, Int_t nygroup = 2, Int_t nzg
	nst char *newname);	roup = 2, const char *newname = "");
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual void SetShowProjection(const char option="xy",Int_t nbins=1 ); // MENU*	virtual void SetShowProjection(const char option="xy",Int_t nbins=1 ); // MENU*

	protected:	protected:
	TH1D DoProject1D(const char name, const char * title, TAxis* pr ojX,	TH1D DoProject1D(const char name, const char * title, TAxis* pr ojX,
	bool computeErrors, bool originalRange,	bool computeErrors, bool originalRange,
	bool useUF, bool useOF) const;	bool useUF, bool useOF) const;
	TH2D DoProject2D(const char name, const char * title, TAxis* pr ojX, TAxis* projY,	TH2D DoProject2D(const char name, const char * title, TAxis* pr ojX, TAxis* projY,
	bool computeErrors, bool originalRange,	bool computeErrors, bool originalRange,
	bool useUF, bool useOF) const;	bool useUF, bool useOF) const;

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

	THn.h	THn.h

	// @(#)root/hist:$Id: THn.h 42995 2012-02-14 10:16:31Z axel $	// @(#)root/hist:$Id: THn.h 43495 2012-03-27 10:31:41Z axel $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2012, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2012, 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_THN	#ifndef ROOT_THN
	#define ROOT_THN	#define ROOT_THN

	skipping to change at line 60	skipping to change at line 60
	void FillBin(Long64_t bin, Double_t w) {	void FillBin(Long64_t bin, Double_t w) {
	// Increment the bin content of "bin" by "w",	// Increment the bin content of "bin" by "w",
	// return the bin index.	// return the bin index.
	GetArray().AddAt(bin, w);	GetArray().AddAt(bin, w);
	if (GetCalculateErrors()) {	if (GetCalculateErrors()) {
	fSumw2.AddAt(bin, w * w);	fSumw2.AddAt(bin, w * w);
	}	}
	FillBinBase(w);	FillBinBase(w);
	}	}


		void AllocCoordBuf() const;
	void InitStorage(Int_t* nbins, Int_t chunkSize);	void InitStorage(Int_t* nbins, Int_t chunkSize);

	THn(): fCoordBuf() {}	THn(): fCoordBuf() {}
	THn(const char* name, const char* title, Int_t dim, const Int_t* nbins,	THn(const char* name, const char* title, Int_t dim, const Int_t* nbins,
	const Double_t* xmin, const Double_t* xmax);	const Double_t* xmin, const Double_t* xmax);

	public:	public:
	virtual ~THn();	virtual ~THn();

	static THn* CreateHn(const char* name, const char* title, const TH1* h1) {	static THn* CreateHn(const char* name, const char* title, const TH1* h1) {

	skipping to change at line 83	skipping to change at line 84
	return (THn) CreateHnAny(name, title, hn, kFALSE /THn*/, -1);	return (THn) CreateHnAny(name, title, hn, kFALSE /THn*/, -1);
	}	}

	ROOT::THnBaseBinIter* CreateIter(Bool_t respectAxisRange) const;	ROOT::THnBaseBinIter* CreateIter(Bool_t respectAxisRange) const;
	Long64_t GetNbins() const { return GetArray().GetNbins(); }	Long64_t GetNbins() const { return GetArray().GetNbins(); }

	Long64_t GetBin(const Int_t* idx) const {	Long64_t GetBin(const Int_t* idx) const {
	return GetArray().GetBin(idx);	return GetArray().GetBin(idx);
	}	}
	Long64_t GetBin(const Double_t* x) const {	Long64_t GetBin(const Double_t* x) const {

		if (!fCoordBuf) AllocCoordBuf();
	for (Int_t d = 0; d < fNdimensions; ++d) {	for (Int_t d = 0; d < fNdimensions; ++d) {
	fCoordBuf[d] = GetAxis(d)->FindFixBin(x[d]);	fCoordBuf[d] = GetAxis(d)->FindFixBin(x[d]);
	}	}
	return GetArray().GetBin(fCoordBuf);	return GetArray().GetBin(fCoordBuf);
	}	}
	Long64_t GetBin(const char* name[]) const {	Long64_t GetBin(const char* name[]) const {

		if (!fCoordBuf) AllocCoordBuf();
	for (Int_t d = 0; d < fNdimensions; ++d) {	for (Int_t d = 0; d < fNdimensions; ++d) {
	fCoordBuf[d] = GetAxis(d)->FindBin(name[d]);	fCoordBuf[d] = GetAxis(d)->FindBin(name[d]);
	}	}
	return GetArray().GetBin(fCoordBuf);	return GetArray().GetBin(fCoordBuf);
	}	}

	Long64_t GetBin(const Int_t* idx, Bool_t /allocate/ = kTRUE) {	Long64_t GetBin(const Int_t* idx, Bool_t /allocate/ = kTRUE) {
	return const_cast<const THn*>(this)->GetBin(idx);	return const_cast<const THn*>(this)->GetBin(idx);
	}	}
	Long64_t GetBin(const Double_t* x, Bool_t /allocate/ = kTRUE) {	Long64_t GetBin(const Double_t* x, Bool_t /allocate/ = kTRUE) {

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

	TIterator.h	TIterator.h

	// @(#)root/cont:$Id: TIterator.h 23212 2008-04-14 15:30:20Z rdm $	// @(#)root/cont:$Id: TIterator.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Fons Rademakers 13/08/95	// Author: Fons Rademakers 13/08/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 45	skipping to change at line 45
	TIterator(const TIterator &) { }	TIterator(const TIterator &) { }

	public:	public:
	virtual TIterator &operator=(const TIterator &) { return *this; }	virtual TIterator &operator=(const TIterator &) { return *this; }
	virtual ~TIterator() { }	virtual ~TIterator() { }
	virtual const TCollection *GetCollection() const = 0;	virtual const TCollection *GetCollection() const = 0;
	virtual Option_t *GetOption() const { return ""; }	virtual Option_t *GetOption() const { return ""; }
	virtual TObject *Next() = 0;	virtual TObject *Next() = 0;
	virtual void Reset() = 0;	virtual void Reset() = 0;
	TObject *operator()() { return Next(); }	TObject *operator()() { return Next(); }

	virtual bool operator!=(const TIterator &) const;	virtual Bool_t operator!=(const TIterator &) const;
	virtual TObject operator() const;	virtual TObject operator() const;

	ClassDef(TIterator,0) //Iterator abstract base class	ClassDef(TIterator,0) //Iterator abstract base class
	};	};

	#endif	#endif

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

	TMap.h	TMap.h

	// @(#)root/cont:$Id: TMap.h 34744 2010-08-07 06:16:36Z brun $	// @(#)root/cont:$Id: TMap.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Fons Rademakers 12/11/95	// Author: Fons Rademakers 12/11/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 163	skipping to change at line 163
	public:	public:
	TMapIter(const TMap *map, Bool_t dir = kIterForward);	TMapIter(const TMap *map, Bool_t dir = kIterForward);
	TMapIter(const TMapIter &iter);	TMapIter(const TMapIter &iter);
	~TMapIter();	~TMapIter();
	TIterator &operator=(const TIterator &rhs);	TIterator &operator=(const TIterator &rhs);
	TMapIter &operator=(const TMapIter &rhs);	TMapIter &operator=(const TMapIter &rhs);

	const TCollection *GetCollection() const { return fMap; }	const TCollection *GetCollection() const { return fMap; }
	TObject *Next();	TObject *Next();
	void Reset();	void Reset();

	bool operator!=(const TIterator &aIter) const;	Bool_t operator!=(const TIterator &aIter) const;
	bool operator!=(const TMapIter &aIter) const;	Bool_t operator!=(const TMapIter &aIter) const;
	TObject operator() const;	TObject operator() const;

	ClassDef(TMapIter,0) //Map iterator	ClassDef(TMapIter,0) //Map iterator
	};	};

	#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 4060 0	#if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 4060 0
	#pragma GCC diagnostic pop	#pragma GCC diagnostic pop
	#endif	#endif

	#endif	#endif

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

	TMatrixTLazy.h	TMatrixTLazy.h

	// @(#)root/matrix:$Id: TMatrixTLazy.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/matrix:$Id: TMatrixTLazy.h 44144 2012-05-06 20:46:51Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TMatrixTLazy	#ifndef ROOT_TMatrixTLazy
	#define ROOT_TMatrixTLazy	#define ROOT_TMatrixTLazy

	skipping to change at line 55	skipping to change at line 55
	friend class TMatrixTBase<Element>;	friend class TMatrixTBase<Element>;
	friend class TMatrixT <Element>;	friend class TMatrixT <Element>;
	friend class TVectorT <Element>;	friend class TVectorT <Element>;

	protected:	protected:
	Int_t fRowUpb;	Int_t fRowUpb;
	Int_t fRowLwb;	Int_t fRowLwb;
	Int_t fColUpb;	Int_t fColUpb;
	Int_t fColLwb;	Int_t fColLwb;


	TMatrixTLazy(const TMatrixTLazy<Element> &) : TObject() { }	TMatrixTLazy(const TMatrixTLazy<Element> &) : TObject(), fRowUpb(0),fRow Lwb(0),fColUpb(0),fColLwb(0) { }
	void operator=(const TMatrixTLazy<Element> &) { }	void operator=(const TMatrixTLazy<Element> &) { }

	private:	private:
	virtual void FillIn(TMatrixT<Element> &m) const = 0;	virtual void FillIn(TMatrixT<Element> &m) const = 0;

	public:	public:
	TMatrixTLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }	TMatrixTLazy() { fRowUpb = fRowLwb = fColUpb = fColLwb = 0; }
	TMatrixTLazy(Int_t nrows, Int_t ncols)	TMatrixTLazy(Int_t nrows, Int_t ncols)
	: fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }	: fRowUpb(nrows-1),fRowLwb(0),fColUpb(ncols-1),fColLwb(0) { }
	TMatrixTLazy(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)	TMatrixTLazy(Int_t row_lwb,Int_t row_upb,Int_t col_lwb,Int_t col_upb)

	skipping to change at line 96	skipping to change at line 96
	template<class Element> class TMatrixTSymLazy : public TObject {	template<class Element> class TMatrixTSymLazy : public TObject {

	friend class TMatrixTBase<Element>;	friend class TMatrixTBase<Element>;
	friend class TMatrixTSym <Element>;	friend class TMatrixTSym <Element>;
	friend class TVectorT <Element>;	friend class TVectorT <Element>;

	protected:	protected:
	Int_t fRowUpb;	Int_t fRowUpb;
	Int_t fRowLwb;	Int_t fRowLwb;


	TMatrixTSymLazy(const TMatrixTSymLazy<Element> &) : TObject() { }	TMatrixTSymLazy(const TMatrixTSymLazy<Element> &) : TObject(), fRowUpb(0 ),fRowLwb(0) { }
	void operator=(const TMatrixTSymLazy<Element> &) { }	void operator=(const TMatrixTSymLazy<Element> &) { }

	private:	private:
	virtual void FillIn(TMatrixTSym<Element> &m) const = 0;	virtual void FillIn(TMatrixTSym<Element> &m) const = 0;

	public:	public:
	TMatrixTSymLazy() { fRowUpb = fRowLwb = 0; }	TMatrixTSymLazy() { fRowUpb = fRowLwb = 0; }
	TMatrixTSymLazy(Int_t nrows)	TMatrixTSymLazy(Int_t nrows)
	: fRowUpb(nrows-1),fRowLwb(0) { }	: fRowUpb(nrows-1),fRowLwb(0) { }
	TMatrixTSymLazy(Int_t row_lwb,Int_t row_upb)	TMatrixTSymLazy(Int_t row_lwb,Int_t row_upb)

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

	TMemFile.h	TMemFile.h

	// @(#)root/io:$Id: TMemFile.h 41423 2011-10-17 17:30:33Z pcanal $	// @(#)root/io:$Id: TMemFile.h 43276 2012-03-07 17:13:42Z pcanal $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2009, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TMemFile	#ifndef ROOT_TMemFile
	#define ROOT_TMemFile	#define ROOT_TMemFile

	skipping to change at line 30	skipping to change at line 30
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TFile	#ifndef ROOT_TFile
	#include "TFile.h"	#include "TFile.h"
	#endif	#endif

	class TMemFile : public TFile {	class TMemFile : public TFile {

	private:	private:
	struct TMemBlock {	struct TMemBlock {

		private:
		TMemBlock(const TMemBlock&); // Not implemented
		TMemBlock &operator=(const TMemBlock&); // Not implemented.
		public:
	TMemBlock();	TMemBlock();
	TMemBlock(Long64_t size, TMemBlock *previous = 0);	TMemBlock(Long64_t size, TMemBlock *previous = 0);
	~TMemBlock();	~TMemBlock();

	void CreateNext(Long64_t size);	void CreateNext(Long64_t size);

	TMemBlock *fPrevious;	TMemBlock *fPrevious;
	TMemBlock *fNext;	TMemBlock *fNext;
	UChar_t *fBuffer;	UChar_t *fBuffer;
	Long64_t fSize;	Long64_t fSize;

	skipping to change at line 62	skipping to change at line 66
	Int_t SysOpen(const char *pathname, Int_t flags, UInt_t mode);	Int_t SysOpen(const char *pathname, Int_t flags, UInt_t mode);
	Int_t SysClose(Int_t fd);	Int_t SysClose(Int_t fd);
	Int_t SysRead(Int_t fd, void *buf, Int_t len);	Int_t SysRead(Int_t fd, void *buf, Int_t len);
	Int_t SysWrite(Int_t fd, const void *buf, Int_t len);	Int_t SysWrite(Int_t fd, const void *buf, Int_t len);
	Long64_t SysSeek(Int_t fd, Long64_t offset, Int_t whence);	Long64_t SysSeek(Int_t fd, Long64_t offset, Int_t whence);
	Int_t SysStat(Int_t fd, Long_t id, Long64_t size, Long_t flags, Lo ng_t modtime);	Int_t SysStat(Int_t fd, Long_t id, Long64_t size, Long_t flags, Lo ng_t modtime);
	Int_t SysSync(Int_t fd);	Int_t SysSync(Int_t fd);

	void ResetObjects(TDirectoryFile , TFileMergeInfo ) const;	void ResetObjects(TDirectoryFile , TFileMergeInfo ) const;


		TMemFile &operator=(const TMemFile&); // Not implemented.

	public:	public:
	TMemFile(const char name, Option_t option="", const char *ftitle="", I nt_t compress=1);	TMemFile(const char name, Option_t option="", const char *ftitle="", I nt_t compress=1);
	TMemFile(const char name, char buffer, Long64_t size, Option_t option ="", const char ftitle="", Int_t compress=1);	TMemFile(const char name, char buffer, Long64_t size, Option_t option ="", const char ftitle="", Int_t compress=1);
	TMemFile(const TMemFile &orig);	TMemFile(const TMemFile &orig);
	virtual ~TMemFile();	virtual ~TMemFile();

	virtual Long64_t CopyTo(void *to, Long64_t maxsize) const;	virtual Long64_t CopyTo(void *to, Long64_t maxsize) const;
	virtual void CopyTo(TBuffer &tobuf) const;	virtual void CopyTo(TBuffer &tobuf) const;
	virtual Long64_t GetSize() const;	virtual Long64_t GetSize() const;


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

	TMemberInspector.h	TMemberInspector.h

	// @(#)root/base:$Id: TMemberInspector.h 35394 2010-09-17 19:40:12Z pcanal $	// @(#)root/base:$Id: TMemberInspector.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Fons Rademakers 15/07/96	// Author: Fons Rademakers 15/07/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 36	skipping to change at line 36
	#include "Rtypes.h"	#include "Rtypes.h"

	class TObject;	class TObject;
	class TClass;	class TClass;

	class TMemberInspector {	class TMemberInspector {
	private:	private:
	class TParentBuf;	class TParentBuf;
	TParentBuf* fParent; // current inspection "path"	TParentBuf* fParent; // current inspection "path"


		TMemberInspector(const TMemberInspector&); // Not implemented
		.
		TMemberInspector &operator=(const TMemberInspector&); // Not implemented
		.

	public:	public:
	TMemberInspector();	TMemberInspector();
	virtual ~TMemberInspector();	virtual ~TMemberInspector();

	virtual void Inspect(TClass cl, const char parent, const char name, c onst void addr) = 0;	virtual void Inspect(TClass cl, const char parent, const char name, c onst void addr) = 0;

	const char* GetParent() const;	const char* GetParent() const;
	Ssiz_t GetParentLen() const;	Ssiz_t GetParentLen() const;
	void AddToParent(const char* name);	void AddToParent(const char* name);
	void RemoveFromParent(Ssiz_t startingAt);	void RemoveFromParent(Ssiz_t startingAt);

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

	TMemberStreamer.h	TMemberStreamer.h

	// @(#)root/base:$Id: TMemberStreamer.h 25450 2008-09-18 21:13:42Z pcanal $	// @(#)root/meta:$Id: TMemberStreamer.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Victor Perev and Philippe Canal 08/05/02	// Author: Victor Perev and Philippe Canal 08/05/02

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2003, Rene Brun, Fons Rademakers and al. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 34	skipping to change at line 34
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	class TMemberStreamer {	class TMemberStreamer {
	protected:	protected:
	TMemberStreamer() : fStreamer(0) {};	TMemberStreamer() : fStreamer(0) {};

	public:	public:
	TMemberStreamer(MemberStreamerFunc_t pointer) : fStreamer(pointer) {};	TMemberStreamer(MemberStreamerFunc_t pointer) : fStreamer(pointer) {};
	TMemberStreamer(const TMemberStreamer &rhs) : fStreamer(rhs.fStreamer) { };	TMemberStreamer(const TMemberStreamer &rhs) : fStreamer(rhs.fStreamer) { };

		TMemberStreamer &operator=(const TMemberStreamer &rhs) { fStreamer = rhs .fStreamer; return *this; }

	virtual ~TMemberStreamer(){};	virtual ~TMemberStreamer(){};

	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }	virtual void SetOnFileClass( const TClass* cl ) { fOnFileClass = const_c ast<TClass*>(cl); }
	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }	virtual const TClass* GetOnFileClass() const { return fOnFileClass; }

	virtual void operator()(TBuffer &b, void *pmember, Int_t size=0)	virtual void operator()(TBuffer &b, void *pmember, Int_t size=0)
	{	{
	// The address passed to operator() will be the address of the data m ember.	// The address passed to operator() will be the address of the data m ember.
	// If the data member is a variable size array, 'size' is the number of elements	// If the data member is a variable size array, 'size' is the number of elements

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

	TMessage.h	TMessage.h

	// @(#)root/net:$Id: TMessage.h 41637 2011-10-28 15:34:35Z rdm $	// @(#)root/net:$Id: TMessage.h 44489 2012-06-04 00:52:12Z rdm $
	// Author: Fons Rademakers 19/12/96	// Author: Fons Rademakers 19/12/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


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

	class TMessage : public TBufferFile {	class TMessage : public TBufferFile {

	friend class TAuthenticate;	friend class TAuthenticate;
	friend class TSocket;	friend class TSocket;
	friend class TUDPSocket;	friend class TUDPSocket;
	friend class TPSocket;	friend class TPSocket;
	friend class TXSocket;	friend class TXSocket;

	private:	private:

	TList *fInfos; //Array of TStreamerInfo used in WriteObject	TList *fInfos; //List of TStreamerInfo used in WriteObject
	TBits fBitsPIDs; //Array of bits to mark the TProcessIDs uids writ ten to the message	TBits fBitsPIDs; //Array of bits to mark the TProcessIDs uids writ ten to the message
	UInt_t fWhat; //Message type	UInt_t fWhat; //Message type
	TClass *fClass; //If message is kMESS_OBJECT pointer to object's class	TClass *fClass; //If message is kMESS_OBJECT pointer to object's class
	Int_t fCompress; //Compression level and algorithm	Int_t fCompress; //Compression level and algorithm
	char *fBufComp; //Compressed buffer	char *fBufComp; //Compressed buffer
	char *fBufCompCur; //Current position in compressed buffer	char *fBufCompCur; //Current position in compressed buffer
	char *fCompPos; //Position of fBufCur when message was compressed	char *fCompPos; //Position of fBufCur when message was compressed
	Bool_t fEvolution; //True if support for schema evolution required	Bool_t fEvolution; //True if support for schema evolution required

	static Bool_t fgEvolution; //True if global support for schema evolutio n required	static Bool_t fgEvolution; //True if global support for schema evolutio n required

	skipping to change at line 84	skipping to change at line 84
	void Forward();	void Forward();
	TClass *GetClass() const { return fClass;}	TClass *GetClass() const { return fClass;}
	void TagStreamerInfo(TVirtualStreamerInfo* info);	void TagStreamerInfo(TVirtualStreamerInfo* info);
	void Reset();	void Reset();
	void Reset(UInt_t what) { SetWhat(what); Reset(); }	void Reset(UInt_t what) { SetWhat(what); Reset(); }
	UInt_t What() const { return fWhat; }	UInt_t What() const { return fWhat; }
	void SetWhat(UInt_t what);	void SetWhat(UInt_t what);

	void EnableSchemaEvolution(Bool_t enable = kTRUE) { fEvolution = ena ble; }	void EnableSchemaEvolution(Bool_t enable = kTRUE) { fEvolution = ena ble; }
	Bool_t UsesSchemaEvolution() const { return fEvolution; }	Bool_t UsesSchemaEvolution() const { return fEvolution; }

		TList *GetStreamerInfos() const { return fInfos; }
	Int_t GetCompressionAlgorithm() const;	Int_t GetCompressionAlgorithm() const;
	Int_t GetCompressionLevel() const;	Int_t GetCompressionLevel() const;
	Int_t GetCompressionSettings() const;	Int_t GetCompressionSettings() const;
	void SetCompressionAlgorithm(Int_t algorithm=0);	void SetCompressionAlgorithm(Int_t algorithm=0);
	void SetCompressionLevel(Int_t level=1);	void SetCompressionLevel(Int_t level=1);
	void SetCompressionSettings(Int_t settings=1);	void SetCompressionSettings(Int_t settings=1);
	Int_t Compress();	Int_t Compress();
	Int_t Uncompress();	Int_t Uncompress();
	char *CompBuffer() const { return fBufComp; }	char *CompBuffer() const { return fBufComp; }
	Int_t CompLength() const { return (Int_t)(fBufCompCur - fBufComp); }	Int_t CompLength() const { return (Int_t)(fBufCompCur - fBufComp); }

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

	TOracleResult.h	TOracleResult.h

	// @(#)root/physics:$Id: TOracleResult.h 23102 2008-04-09 22:18:41Z pcanal $	// @(#)root/physics:$Id: TOracleResult.h 44342 2012-05-29 15:17:27Z axel $
	// Author: Yan Liu and Shaowen Wang 23/11/04	// Author: Yan Liu and Shaowen Wang 23/11/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 26	skipping to change at line 26
	#include "TSQLResult.h"	#include "TSQLResult.h"
	#endif	#endif

	#include <vector>	#include <vector>

	#if !defined(__CINT__)	#if !defined(__CINT__)
	#ifndef R__WIN32	#ifndef R__WIN32
	#include <sys/time.h>	#include <sys/time.h>
	#endif	#endif
	#include <occi.h>	#include <occi.h>

	using namespace oracle::occi;
	#ifdef CONST	#ifdef CONST
	#undef CONST	#undef CONST
	#endif	#endif
	#else	#else

		namespace oracle { namespace occi {
	class Connection;	class Connection;
	class Statement;	class Statement;
	class ResultSet;	class ResultSet;
	class MetaData;	class MetaData;

		}}
	#endif	#endif

	class TList;	class TList;

	class TOracleResult : public TSQLResult {	class TOracleResult : public TSQLResult {

	private:	private:

	Connection *fConn; // connection to Oracle	oracle::occi::Connection*fConn; // connection to Oracle
	Statement *fStmt; // executed statement	oracle::occi::Statement *fStmt; // executed statement
	ResultSet *fResult; // query result (rows)	oracle::occi::ResultSet *fResult; // query result (rows)
	std::vector<MetaData> *fFieldInfo; // info for each field in the row	std::vector<oracle::occi::MetaData> *fFieldInfo; // info for each fiel
		d in the row
	Int_t fFieldCount; // num of fields in resultset	Int_t fFieldCount; // num of fields in resultset
	UInt_t fUpdateCount; // for dml query, mutual exclusive with above	UInt_t fUpdateCount; // for dml query, mutual exclusive with above
	Int_t fResultType; // 0 - nothing; 1 - Select; 2 - tab le metainfo, 3 - update counter	Int_t fResultType; // 0 - nothing; 1 - Select; 2 - tab le metainfo, 3 - update counter
	TList *fPool; // array of results, produced when number of rows are requested	TList *fPool; // array of results, produced when number of rows are requested
	std::string fNameBuffer; // buffer for GetFieldName() argument	std::string fNameBuffer; // buffer for GetFieldName() argument

	Bool_t IsValid(Int_t field);	Bool_t IsValid(Int_t field);


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

	protected:	protected:

	void initResultSet(Statement *stmt);	void initResultSet(oracle::occi::Statement *stmt);
	void ProducePool();	void ProducePool();

	public:	public:

	TOracleResult(Connection conn, Statement stmt);	TOracleResult(oracle::occi::Connection conn, oracle::occi::Statement s
	TOracleResult(Connection conn, const char tableName);	tmt);
		TOracleResult(oracle::occi::Connection conn, const char tableName);
	~TOracleResult();	~TOracleResult();

	void Close(Option_t *opt="");	void Close(Option_t *opt="");
	Int_t GetFieldCount();	Int_t GetFieldCount();
	const char *GetFieldName(Int_t field);	const char *GetFieldName(Int_t field);
	virtual Int_t GetRowCount() const;	virtual Int_t GetRowCount() const;
	TSQLRow *Next();	TSQLRow *Next();

	Int_t GetUpdateCount() { return fUpdateCount; }	Int_t GetUpdateCount() { return fUpdateCount; }


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

	TOracleRow.h	TOracleRow.h

	// @(#)root/physics:$Id: TOracleRow.h 23102 2008-04-09 22:18:41Z pcanal $	// @(#)root/physics:$Id: TOracleRow.h 44342 2012-05-29 15:17:27Z axel $
	// Author: Yan Liu and Shaowen Wang 23/11/04	// Author: Yan Liu and Shaowen Wang 23/11/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 24	skipping to change at line 24

	#ifndef ROOT_TSQLRow	#ifndef ROOT_TSQLRow
	#include "TSQLRow.h"	#include "TSQLRow.h"
	#endif	#endif

	#if !defined(__CINT__)	#if !defined(__CINT__)
	#ifndef R__WIN32	#ifndef R__WIN32
	#include <sys/time.h>	#include <sys/time.h>
	#endif	#endif
	#include <occi.h>	#include <occi.h>

	using namespace oracle::occi;
	#ifdef CONST	#ifdef CONST
	#undef CONST	#undef CONST
	#endif	#endif
	#else	#else

		namespace oracle { namespace occi {
	class ResultSet;	class ResultSet;
	class MetaData;	class MetaData;

		}}
	#endif	#endif

	class TOracleRow : public TSQLRow {	class TOracleRow : public TSQLRow {

	private:	private:

	ResultSet *fResult; // current result set	oracle::occi::ResultSet *fResult; // current result set
	std::vector<MetaData> *fFieldInfo; // metadata for columns	std::vector<oracle::occi::MetaData> *fFieldInfo; // metadata for colum
	Int_t fFieldCount;	ns
	char **fFieldsBuffer;	Int_t fFieldCount;
		char **fFieldsBuffer;

	Bool_t IsValid(Int_t field);	Bool_t IsValid(Int_t field);


		TOracleRow(const TOracleRow&); // Not implemented.
		TOracleRow &operator=(const TOracleRow&); // Not implemented.

	protected:	protected:
	void GetRowData();	void GetRowData();

	public:	public:

	TOracleRow(ResultSet rs, std::vector<MetaData> fieldMetaData);	TOracleRow(oracle::occi::ResultSet *rs,
		std::vector<oracle::occi::MetaData> *fieldMetaData);
	~TOracleRow();	~TOracleRow();

	void Close(Option_t *opt="");	void Close(Option_t *opt="");
	ULong_t GetFieldLength(Int_t field);	ULong_t GetFieldLength(Int_t field);
	const char *GetField(Int_t field);	const char *GetField(Int_t field);

	ClassDef(TOracleRow,0) // One row of Oracle query result	ClassDef(TOracleRow,0) // One row of Oracle query result
	};	};

	#endif	#endif

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

	TOracleServer.h	TOracleServer.h

	// @(#)root/physics:$Id: TOracleServer.h 29321 2009-07-03 10:42:10Z brun $	// @(#)root/physics:$Id: TOracleServer.h 44342 2012-05-29 15:17:27Z axel $
	// Author: Yan Liu and Shaowen Wang 23/11/04	// Author: Yan Liu and Shaowen Wang 23/11/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 24	skipping to change at line 24

	#ifndef ROOT_TSQLServer	#ifndef ROOT_TSQLServer
	#include "TSQLServer.h"	#include "TSQLServer.h"
	#endif	#endif

	#if !defined(__CINT__)	#if !defined(__CINT__)
	#ifndef R__WIN32	#ifndef R__WIN32
	#include <sys/time.h>	#include <sys/time.h>
	#endif	#endif
	#include <occi.h>	#include <occi.h>

	using namespace std;
	using namespace oracle::occi;
	#ifdef CONST	#ifdef CONST
	#undef CONST	#undef CONST
	#endif	#endif
	#else	#else

		namespace oracle { namespace occi {
	class Environment;	class Environment;
	class Connection;	class Connection;

		}}
	#endif	#endif

	class TOracleServer : public TSQLServer {	class TOracleServer : public TSQLServer {

	private:	private:

	Environment *fEnv; // environment of Oracle access	oracle::occi::Environment *fEnv; // environment of Oracle access
	Connection *fConn; // connection to Oracle server	oracle::occi::Connection *fConn; // connection to Oracle server
	TString fInfo; // info string with Oracle version information	TString fInfo; // info string with Oracle version information

	static const char* fgDatimeFormat; //! format for converting date and ti me stamps into string	static const char* fgDatimeFormat; //! format for converting date and ti me stamps into string

	public:	public:
	TOracleServer(const char db, const char uid, const char *pw);	TOracleServer(const char db, const char uid, const char *pw);
	~TOracleServer();	~TOracleServer();

	void Close(Option_t *opt="");	void Close(Option_t *opt="");
	TSQLResult Query(const char sql);	TSQLResult Query(const char sql);

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

	TOracleStatement.h	TOracleStatement.h

	// @(#)root/oracle:$Id: TOracleStatement.h 27990 2009-03-30 14:33:07Z brun $	// @(#)root/oracle:$Id: TOracleStatement.h 44342 2012-05-29 15:17:27Z axel $
	// Author: Sergey Linev 6/02/2006	// Author: Sergey Linev 6/02/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2006, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TOracleStatement	#ifndef ROOT_TOracleStatement
	#define ROOT_TOracleStatement	#define ROOT_TOracleStatement

	#ifndef ROOT_TSQLStatement	#ifndef ROOT_TSQLStatement
	#include "TSQLStatement.h"	#include "TSQLStatement.h"
	#endif	#endif

	#if !defined(__CINT__)	#if !defined(__CINT__)
	#include <occi.h>	#include <occi.h>

	using namespace oracle::occi;
	#ifdef CONST	#ifdef CONST
	#undef CONST	#undef CONST
	#endif	#endif
	#else	#else

		namespace oracle { namespace occi {
	class Environment;	class Environment;
	class Connection;	class Connection;
	class Statement;	class Statement;
	class ResultSet;	class ResultSet;
	class MetaData;	class MetaData;

		}}
	#endif	#endif

	class TOracleStatement : public TSQLStatement {	class TOracleStatement : public TSQLStatement {

	protected:	protected:

	struct TBufferRec {	struct TBufferRec {
	char* strbuf;	char* strbuf;
	Long_t strbufsize;	Long_t strbufsize;
	char* namebuf;	char* namebuf;
	};	};


	Environment *fEnv; // enviroment	oracle::occi::Environment *fEnv; // enviroment
	Connection *fConn; // connection to Oracle	oracle::occi::Connection *fConn; // connection to Oracle
	Statement *fStmt; // executed statement	oracle::occi::Statement *fStmt; // executed statement
	ResultSet *fResult; // query result (rows)	oracle::occi::ResultSet *fResult; // query result (rows)
	std::vector<MetaData> *fFieldInfo; // info for each field in the row	std::vector<oracle::occi::MetaData> *fFieldInfo; // info for each fiel
		d in the row
	TBufferRec *fBuffer; // buffer of values and field name s	TBufferRec *fBuffer; // buffer of values and field name s
	Int_t fBufferSize; // size of fBuffer	Int_t fBufferSize; // size of fBuffer
	Int_t fNumIterations; // size of internal statement bu ffer	Int_t fNumIterations; // size of internal statement bu ffer
	Int_t fIterCounter; //counts nextiteration calls and pr ocess iterations, if required	Int_t fIterCounter; //counts nextiteration calls and pr ocess iterations, if required
	Int_t fWorkingMode; // 1 - settingpars, 2 - getting res ults	Int_t fWorkingMode; // 1 - settingpars, 2 - getting res ults
	TString fTimeFmt; // format for date to string conver sion, default "MM/DD/YYYY, HH24:MI:SS"	TString fTimeFmt; // format for date to string conver sion, default "MM/DD/YYYY, HH24:MI:SS"

	Bool_t IsParSettMode() const { return fWorkingMode==1; }	Bool_t IsParSettMode() const { return fWorkingMode==1; }
	Bool_t IsResultSet() const { return (fWorkingMode==2) && (fResult!= 0); }	Bool_t IsResultSet() const { return (fWorkingMode==2) && (fResult!= 0); }

	void SetBufferSize(Int_t size);	void SetBufferSize(Int_t size);
	void CloseBuffer();	void CloseBuffer();

	public:	public:

	TOracleStatement(Environment* env, Connection* conn, Statement* stmt, In	TOracleStatement(oracle::occi::Environment* env,
	t_t niter, Bool_t errout = kTRUE);	oracle::occi::Connection* conn,
		oracle::occi::Statement* stmt,
		Int_t niter, Bool_t errout = kTRUE);
	virtual ~TOracleStatement();	virtual ~TOracleStatement();

	virtual void Close(Option_t * = "");	virtual void Close(Option_t * = "");

	virtual Int_t GetBufferLength() const { return fNumIterations; }	virtual Int_t GetBufferLength() const { return fNumIterations; }
	virtual Int_t GetNumParameters();	virtual Int_t GetNumParameters();

	virtual Bool_t SetNull(Int_t npar);	virtual Bool_t SetNull(Int_t npar);
	virtual Bool_t SetInt(Int_t npar, Int_t value);	virtual Bool_t SetInt(Int_t npar, Int_t value);
	virtual Bool_t SetUInt(Int_t npar, UInt_t value);	virtual Bool_t SetUInt(Int_t npar, UInt_t value);

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

	TPDF.h	TPDF.h

	skipping to change at line 26	skipping to change at line 26
	// //	// //
	// TPDF //	// TPDF //
	// //	// //
	// PDF driver. //	// PDF driver. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TVirtualPS	#ifndef ROOT_TVirtualPS
	#include "TVirtualPS.h"	#include "TVirtualPS.h"
	#endif	#endif

		#include <vector>

	class TPoints;	class TPoints;

	class TPDF : public TVirtualPS {	class TPDF : public TVirtualPS {

	protected:	protected:

	Float_t fRed; //Per cent of red	Float_t fRed; //Per cent of red
	Float_t fGreen; //Per cent of green	Float_t fGreen; //Per cent of green
	Float_t fBlue; //Per cent of blue	Float_t fBlue; //Per cent of blue
	Float_t fXsize; //Page size along X	Float_t fAlpha; //Per cent of transparency
	Float_t fYsize; //Page size along Y	std::vector<float> fAlphas; //List of alpha values used
	Int_t fType; //Workstation type used to know if the PDF is	Float_t fXsize; //Page size along X
	open	Float_t fYsize; //Page size along Y
	Int_t fPageFormat; //Page format (A4, Letter etc ...)	Int_t fType; //Workstation type used to know if
	Int_t fPageOrientation; //Page orientation (Portrait, Landscape)	the PDF is open
	Int_t fStartStream; //	Int_t fPageFormat; //Page format (A4, Letter etc ...)
	Float_t fLineScale; //Line width scale factor	Int_t fPageOrientation; //Page orientation (Portrait, Lands
	Int_t *fObjPos; //Objets position	cape)
	Int_t fObjPosSize; //Real size of fObjPos	Int_t fStartStream; //
	Int_t fNbObj; //Number of objects	Float_t fLineScale; //Line width scale factor
	Int_t fNbPage; //Number of pages	Int_t *fObjPos; //Objets position
	Bool_t fPageNotEmpty; //True if the current page is not empty	Int_t fObjPosSize; //Real size of fObjPos
	Bool_t fCompress; //True when fBuffer must be compressed	Int_t fNbObj; //Number of objects
	Bool_t fRange; //True when a range has been defined	Int_t fNbPage; //Number of pages
		Bool_t fPageNotEmpty; //True if the current page is not e
		mpty
		Bool_t fCompress; //True when fBuffer must be compres
		sed
		Bool_t fRange; //True when a range has been define
		d

	public:	public:
	TPDF();	TPDF();
	TPDF(const char *filename, Int_t type=-111);	TPDF(const char *filename, Int_t type=-111);
	virtual ~TPDF();	virtual ~TPDF();

	void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2, Doub le_t y1, Double_t y2);	void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2, Doub le_t y1, Double_t y2);
	void CellArrayFill(Int_t r, Int_t g, Int_t b);	void CellArrayFill(Int_t r, Int_t g, Int_t b);
	void CellArrayEnd();	void CellArrayEnd();
	void Close(Option_t *opt="");	void Close(Option_t *opt="");

	skipping to change at line 83	skipping to change at line 86
	void FontEncode();	void FontEncode();
	void NewObject(Int_t n);	void NewObject(Int_t n);
	void NewPage();	void NewPage();
	void Off();	void Off();
	void On();	void On();
	void Open(const char *filename, Int_t type=-111);	void Open(const char *filename, Int_t type=-111);
	void PatternEncode();	void PatternEncode();
	void PrintFast(Int_t nch, const char *string="");	void PrintFast(Int_t nch, const char *string="");
	void PrintStr(const char *string="");	void PrintStr(const char *string="");
	void Range(Float_t xrange, Float_t yrange);	void Range(Float_t xrange, Float_t yrange);

		void SetAlpha(Float_t alpha = 1.);
	void SetColor(Int_t color = 1);	void SetColor(Int_t color = 1);
	void SetColor(Float_t r, Float_t g, Float_t b);	void SetColor(Float_t r, Float_t g, Float_t b);
	void SetFillColor( Color_t cindex=1);	void SetFillColor( Color_t cindex=1);
	void SetFillPatterns(Int_t ipat, Int_t color);	void SetFillPatterns(Int_t ipat, Int_t color);
	void SetLineColor( Color_t cindex=1);	void SetLineColor( Color_t cindex=1);
	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);

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

	TPerfStats.h	TPerfStats.h

	// @(#)root/proofplayer:$Id: TPerfStats.h 40699 2011-08-25 10:36:29Z rdm $	// @(#)root/proofplayer:$Id: TPerfStats.h 44046 2012-05-01 11:34:04Z ganis $
	// Author: Kristjan Gulbrandsen 11/05/04	// Author: Kristjan Gulbrandsen 11/05/04

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 42	skipping to change at line 42
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif
	#ifndef ROOT_TVirtualPerfStats	#ifndef ROOT_TVirtualPerfStats
	#include "TVirtualPerfStats.h"	#include "TVirtualPerfStats.h"
	#endif	#endif

	class TDSet;	class TDSet;
	class TH1D;	class TH1D;

		class TH1I;
	class TH2D;	class TH2D;
	class TList;	class TList;
	class TTree;	class TTree;

	class TPerfEvent : public TObject {	class TPerfEvent : public TObject {

	public:	public:
	TString fEvtNode; // node on which the event was generated	TString fEvtNode; // node on which the event was generated
	TTimeStamp fTimeStamp; // time offset from start of r un	TTimeStamp fTimeStamp; // time offset from start of r un
	TVirtualPerfStats::EEventType fType;	TVirtualPerfStats::EEventType fType;

	skipping to change at line 85	skipping to change at line 86

	class TPerfStats : public TVirtualPerfStats {	class TPerfStats : public TVirtualPerfStats {

	friend class TProofMonSender;	friend class TProofMonSender;

	private:	private:
	TTree *fTrace; //!TTree with trace events	TTree *fTrace; //!TTree with trace events
	TTimeStamp fTzero; //!start time of this run	TTimeStamp fTzero; //!start time of this run
	TPerfEvent *fPerfEvent; //!TPerfEvent used to fill tree	TPerfEvent *fPerfEvent; //!TPerfEvent used to fill tree
	TH1D *fPacketsHist; //!histogram of packets processed per slav e	TH1D *fPacketsHist; //!histogram of packets processed per slav e

		TH1I *fProcPcktHist; //!histogram of packets being processed pe r slave
	TH1D *fEventsHist; //!histogram of events processed per slave	TH1D *fEventsHist; //!histogram of events processed per slave
	TH1D *fNodeHist; //!histogram of slaves per file serving no de	TH1D *fNodeHist; //!histogram of slaves per file serving no de
	TH2D *fLatencyHist; //!histogram of latency due to packet requ ests	TH2D *fLatencyHist; //!histogram of latency due to packet requ ests
	TH2D *fProcTimeHist; //!histogram of real time spent processing packets	TH2D *fProcTimeHist; //!histogram of real time spent processing packets
	TH2D *fCpuTimeHist; //!histogram of cpu time spent processing packets	TH2D *fCpuTimeHist; //!histogram of cpu time spent processing packets
	Long64_t fBytesRead; //!track bytes read of main file	Long64_t fBytesRead; //!track bytes read of main file
	Double_t fTotCpuTime; //!total cpu time of all slaves	Double_t fTotCpuTime; //!total cpu time of all slaves
	Long64_t fTotBytesRead; //!total bytes read on all slaves	Long64_t fTotBytesRead; //!total bytes read on all slaves
	Long64_t fTotEvents; //!total number of events processed	Long64_t fTotEvents; //!total number of events processed
	Long64_t fNumEvents; //!total number of events to be processed	Long64_t fNumEvents; //!total number of events to be processed

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

	TProfile3D.h	TProfile3D.h

	// @(#)root/hist:$Id: TProfile3D.h 41358 2011-10-12 13:15:35Z moneta $	// @(#)root/hist:$Id: TProfile3D.h 44515 2012-06-04 14:16:56Z moneta $
	// Author: Rene Brun 17/05/2006	// Author: Rene Brun 17/05/2006

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 57	skipping to change at line 57
	virtual Int_t BufferFill(Double_t, Double_t, Double_t) {return -2;} / /may not use	virtual Int_t BufferFill(Double_t, Double_t, Double_t) {return -2;} / /may not use
	virtual Int_t BufferFill(Double_t, Double_t, Double_t, Double_t) {ret urn -2;} //may not use	virtual Int_t BufferFill(Double_t, Double_t, Double_t, Double_t) {ret urn -2;} //may not use
	virtual Int_t BufferFill(Double_t x, Double_t y, Double_t z, Double_t t, Double_t w);	virtual Int_t BufferFill(Double_t x, Double_t y, Double_t z, Double_t t, Double_t w);

	// helper methods for the Merge unification in TProfileHelper	// helper methods for the Merge unification in TProfileHelper
	void SetBins(const Int_t* nbins,const Double_t* range) { SetBins(nbins[0 ], range[0], range[1],	void SetBins(const Int_t* nbins,const Double_t* range) { SetBins(nbins[0 ], range[0], range[1],
	nbins[1 ], range[2], range[3],	nbins[1 ], range[2], range[3],
	nbins[2 ], range[4], range[5]); };	nbins[2 ], range[4], range[5]); };
	Int_t Fill(const Double_t* v) { return Fill(v[0], v[1], v[2], v[3], v[4] ); };	Int_t Fill(const Double_t* v) { return Fill(v[0], v[1], v[2], v[3], v[4] ); };


		using TH3::Fill;
		Int_t Fill(Double_t, Double_t,Double_t) {return TH3::Fill(0)
		; } //MayNotUse
		Int_t Fill(const char , const char , const char *, Double_
		t) {return TH3::Fill(0); } //MayNotUse
		Int_t Fill(const char , Double_t , const char , Double_t)
		{return TH3::Fill(0); } //MayNotUse
		Int_t Fill(const char , const char , Double_t, Double_t) {
		return TH3::Fill(0); } //MayNotUse
		Int_t Fill(Double_t, const char , const char , Double_t) {
		return TH3::Fill(0); } //MayNotUse
		Int_t Fill(Double_t, const char *, Double_t, Double_t) {retu
		rn TH3::Fill(0); } //MayNotUse
		Int_t Fill(Double_t, Double_t, const char *, Double_t) {retu
		rn TH3::Fill(0); } //MayNotUse

	private:	private:
	Double_t *GetB() {return &fBinEntries.fArray[0];}	Double_t *GetB() {return &fBinEntries.fArray[0];}
	Double_t *GetB2() {return (fBinSumw2.fN ? &fBinSumw2.fArray[0] : 0 ); }	Double_t *GetB2() {return (fBinSumw2.fN ? &fBinSumw2.fArray[0] : 0 ); }
	Double_t *GetW() {return &fArray[0];}	Double_t *GetW() {return &fArray[0];}
	Double_t *GetW2() {return &fSumw2.fArray[0];}	Double_t *GetW2() {return &fSumw2.fArray[0];}
	void SetBins(Int_t, Double_t, Double_t)	void SetBins(Int_t, Double_t, Double_t)
	{ MayNotUse("SetBins(Int_t, Double_t, Double_t"); }	{ MayNotUse("SetBins(Int_t, Double_t, Double_t"); }
	void SetBins(Int_t, const Double_t*)	void SetBins(Int_t, const Double_t*)
	{ MayNotUse("SetBins(Int_t, const Double_t*"); }	{ MayNotUse("SetBins(Int_t, const Double_t*"); }
	void SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t)	void SetBins(Int_t, Double_t, Double_t, Int_t, Double_t, Double_t)

	skipping to change at line 81	skipping to change at line 90
	public:	public:
	TProfile3D();	TProfile3D();
	TProfile3D(const char name,const char title,Int_t nbinsx,Double_t xlow ,Double_t xup	TProfile3D(const char name,const char title,Int_t nbinsx,Double_t xlow ,Double_t xup
	,Int_t nbinsy,Double_t ylow ,Double_t yup	,Int_t nbinsy,Double_t ylow ,Double_t yup
	,Int_t nbinsz,Double_t zlow ,Double_t zup, Option_t *option="");	,Int_t nbinsz,Double_t zlow ,Double_t zup, Option_t *option="");
	TProfile3D(const char name,const char title,Int_t nbinsx,const Double_ t *xbins	TProfile3D(const char name,const char title,Int_t nbinsx,const Double_ t *xbins
	,Int_t nbinsy,const Double_ t *ybins	,Int_t nbinsy,const Double_ t *ybins
	,Int_t nbinsz,const Double_ t zbins,Option_t option="");	,Int_t nbinsz,const Double_ t zbins,Option_t option="");
	TProfile3D(const TProfile3D &profile);	TProfile3D(const TProfile3D &profile);
	virtual ~TProfile3D();	virtual ~TProfile3D();

	virtual void Add(TF1 h1, Double_t c1=1, Option_t option="");	virtual Bool_t Add(TF1 h1, Double_t c1=1, Option_t option="");
	virtual void Add(const TH1 *h1, Double_t c1=1);	virtual Bool_t Add(const TH1 *h1, Double_t c1=1);
	virtual void Add(const TH1 h1, const TH1 h2, Double_t c1=1, Doubl	virtual Bool_t Add(const TH1 h1, const TH1 h2, Double_t c1=1, Doubl
	e_t c2=1); // MENU	e_t c2=1); // MENU
	static void Approximate(Bool_t approx=kTRUE);	static void Approximate(Bool_t approx=kTRUE);
	void BuildOptions(Double_t tmin, Double_t tmax, Option_t *o ption);	void BuildOptions(Double_t tmin, Double_t tmax, Option_t *o ption);
	virtual Int_t BufferEmpty(Int_t action=0);	virtual Int_t BufferEmpty(Int_t action=0);
	virtual void Copy(TObject &hnew) const;	virtual void Copy(TObject &hnew) const;

	virtual void Divide(TF1 *h1, Double_t c1=1);	virtual Bool_t Divide(TF1 *h1, Double_t c1=1);
	virtual void Divide(const TH1 *h1);	virtual Bool_t Divide(const TH1 *h1);
	virtual void Divide(const TH1 h1, const TH1 h2, Double_t c1=1, Do	virtual Bool_t Divide(const TH1 h1, const TH1 h2, Double_t c1=1, Do
	uble_t c2=1, Option_t option=""); // MENU*	uble_t c2=1, Option_t option=""); // MENU*
	virtual TH1 DrawCopy(Option_t option="") const;	virtual TH1 DrawCopy(Option_t option="") const;

	Int_t Fill(Double_t) {return -1;} //MayNotUse
	Int_t Fill(const char*, Double_t) {return -1;} //MayNotUse
	Int_t Fill(Double_t, Double_t) {return -1; } //MayNotUse
	Int_t Fill(Double_t, Double_t,Double_t) {return -1; } //MayN
	otUse
	Int_t Fill(const char , const char , const char *, Double_
	t) {return -1; } //MayNotUse
	Int_t Fill(const char , Double_t , const char , Double_t)
	{return -1; } //MayNotUse
	Int_t Fill(const char , const char , Double_t, Double_t) {
	return -1; } //MayNotUse
	Int_t Fill(Double_t, const char , const char , Double_t) {
	return -1; } //MayNotUse
	Int_t Fill(Double_t, const char *, Double_t, Double_t) {retu
	rn -1; } //MayNotUse
	Int_t Fill(Double_t, Double_t, const char *, Double_t) {retu
	rn -1; } //MayNotUse
	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t t);	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t t);
	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t t, D ouble_t w);	virtual Int_t Fill(Double_t x, Double_t y, Double_t z, Double_t t, D ouble_t w);
	virtual Double_t GetBinContent(Int_t bin) const;	virtual Double_t GetBinContent(Int_t bin) const;
	virtual Double_t GetBinContent(Int_t,Int_t) const	virtual Double_t GetBinContent(Int_t,Int_t) const
	{ MayNotUse("GetBinContent(Int_t, Int_t"); return -1; }	{ MayNotUse("GetBinContent(Int_t, Int_t"); return -1; }
	virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) cons t {return GetBinContent(GetBin(binx,biny,binz));}	virtual Double_t GetBinContent(Int_t binx, Int_t biny, Int_t binz) cons t {return GetBinContent(GetBin(binx,biny,binz));}
	virtual Double_t GetBinError(Int_t bin) const;	virtual Double_t GetBinError(Int_t bin) const;
	virtual Double_t GetBinError(Int_t,Int_t) const	virtual Double_t GetBinError(Int_t,Int_t) const
	{ MayNotUse("GetBinError(Int_t, Int_t"); return -1; }	{ MayNotUse("GetBinError(Int_t, Int_t"); return -1; }
	virtual Double_t GetBinError(Int_t binx, Int_t biny, Int_t binz) const {return GetBinError(GetBin(binx,biny,binz));}	virtual Double_t GetBinError(Int_t binx, Int_t biny, Int_t binz) const {return GetBinError(GetBin(binx,biny,binz));}
	virtual Double_t GetBinEntries(Int_t bin) const;	virtual Double_t GetBinEntries(Int_t bin) const;
	virtual Double_t GetBinEffectiveEntries(Int_t bin);	virtual Double_t GetBinEffectiveEntries(Int_t bin);
	virtual TArrayD *GetBinSumw2() {return &fBinSumw2;}	virtual TArrayD *GetBinSumw2() {return &fBinSumw2;}
	virtual const TArrayD *GetBinSumw2() const {return &fBinSumw2;}	virtual const TArrayD *GetBinSumw2() const {return &fBinSumw2;}
	Option_t *GetErrorOption() const;	Option_t *GetErrorOption() const;
	virtual void GetStats(Double_t *stats) const;	virtual void GetStats(Double_t *stats) const;
	virtual Double_t GetTmin() const {return fTmin;}	virtual Double_t GetTmin() const {return fTmin;}
	virtual Double_t GetTmax() const {return fTmax;}	virtual Double_t GetTmax() const {return fTmax;}
	virtual Long64_t Merge(TCollection *list);	virtual Long64_t Merge(TCollection *list);

	virtual void Multiply(TF1 *h1, Double_t c1=1);	virtual Bool_t Multiply(TF1 *h1, Double_t c1=1);
	virtual void Multiply(const TH1 *h1);	virtual Bool_t Multiply(const TH1 *h1);
	virtual void Multiply(const TH1 h1, const TH1 h2, Double_t c1=1,	virtual Bool_t Multiply(const TH1 h1, const TH1 h2, Double_t c1=1,
	Double_t c2=1, Option_t option=""); // MENU*	Double_t c2=1, Option_t option=""); // MENU*
	TH3D ProjectionXYZ(const char name="_pxyz", Option_t *opti on="e") const;	TH3D ProjectionXYZ(const char name="_pxyz", Option_t *opti on="e") const;
	virtual void PutStats(Double_t *stats);	virtual void PutStats(Double_t *stats);
	virtual void Reset(Option_t *option="");	virtual void Reset(Option_t *option="");
	virtual void RebinAxis(Double_t x, TAxis *axis);	virtual void RebinAxis(Double_t x, TAxis *axis);
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");
	virtual void Scale(Double_t c1=1, Option_t *option="");	virtual void Scale(Double_t c1=1, Option_t *option="");
	virtual void SetBinEntries(Int_t bin, Double_t w);	virtual void SetBinEntries(Int_t bin, Double_t w);
	virtual void SetBins(Int_t nbinsx, Double_t xmin, Double_t xmax,	virtual void SetBins(Int_t nbinsx, Double_t xmin, Double_t xmax,
	Int_t nbinsy, Double_t ymin, Double_t ymax,	Int_t nbinsy, Double_t ymin, Double_t ymax,
	Int_t nbinsz, Double_t zmin, Double_t zmax);	Int_t nbinsz, Double_t zmin, Double_t zmax);

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

	TProofChain.h	TProofChain.h

	// @(#)root/proof:$Id: TProofChain.h 30069 2009-09-08 15:23:21Z ganis $	// @(#)root/proof:$Id: TProofChain.h 44048 2012-05-01 15:17:00Z ganis $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TProofChain	#ifndef ROOT_TProofChain
	#define ROOT_TProofChain	#define ROOT_TProofChain

	skipping to change at line 27	skipping to change at line 27
	// A TChain proxy on PROOF. //	// A TChain proxy on PROOF. //
	// Uses an internal TDSet to handle processing. //	// Uses an internal TDSet to handle processing. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TChain	#ifndef ROOT_TChain
	#include "TChain.h"	#include "TChain.h"
	#endif	#endif

	class TDSet;	class TDSet;

	class TDrawFeedback;
	class TList;	class TList;
	class TProof;	class TProof;

	class TProofChain : public TChain {	class TProofChain : public TChain {

	public:	public:
	// TProofChain constants	// TProofChain constants
	enum { kOwnsChain = BIT(19) };	enum { kOwnsChain = BIT(19) };

	private:	private:
	void FillDrawAttributes(TProof *p);	void FillDrawAttributes(TProof *p);

	protected:	protected:
	TChain *fChain; // mother chain: needed for the browsi ng list	TChain *fChain; // mother chain: needed for the browsi ng list
	TDSet *fSet; // TDSet	TDSet *fSet; // TDSet

	TDrawFeedback *fDrawFeedback; // feedback handler

	public:	public:
	TProofChain();	TProofChain();
	TProofChain(TChain *chain, Bool_t gettreeheader);	TProofChain(TChain *chain, Bool_t gettreeheader);
	TProofChain(TDSet *dset, Bool_t gettreeheader);	TProofChain(TDSet *dset, Bool_t gettreeheader);
	virtual ~TProofChain();	virtual ~TProofChain();

	virtual void Browse(TBrowser *b);	virtual void Browse(TBrowser *b);
	Int_t Debug() const {return fDebug;}	Int_t Debug() const {return fDebug;}
	virtual Long64_t Draw(const char varexp, const TCut &selection, Opt ion_t option=""	virtual Long64_t Draw(const char varexp, const TCut &selection, Opt ion_t option=""

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

	TProofProgressStatus.h	TProofProgressStatus.h

	// @(#)root/proof:$Id: TProofProgressStatus.h 38810 2011-04-12 16:22:59Z ga nis $	// @(#)root/proof:$Id: TProofProgressStatus.h 44010 2012-04-29 23:07:48Z ga nis $
	// Author: Jan Iwaszkiewicz 08/08/08	// Author: Jan Iwaszkiewicz 08/08/08

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 49	skipping to change at line 49
	Double_t fProcTime; // the wallclock time	Double_t fProcTime; // the wallclock time
	Double_t fCPUTime;	Double_t fCPUTime;
	Double_t fLastUpdate; // Timestamp of last change	Double_t fLastUpdate; // Timestamp of last change
	public:	public:
	TProofProgressStatus(Long64_t fEntries = 0, Long64_t fBytesRead = 0,	TProofProgressStatus(Long64_t fEntries = 0, Long64_t fBytesRead = 0,
	Long64_t fReadCalls = 0,	Long64_t fReadCalls = 0,
	Double_t fProcTime = 0, Double_t fCPUTime = 0);	Double_t fProcTime = 0, Double_t fCPUTime = 0);
	void Reset() { fEntries = 0,	void Reset() { fEntries = 0,
	fBytesRead = 0, fProcTime = 0, fCPUTime = 0; SetLastU pdate();}	fBytesRead = 0, fProcTime = 0, fCPUTime = 0; SetLastU pdate();}


	Long64_t GetEntries() const { return fEntries; }	inline Long64_t GetEntries() const { return fEntries; }
	Long64_t GetBytesRead() const { return fBytesRead; }	inline Long64_t GetBytesRead() const { return fBytesRead; }
	Long64_t GetReadCalls() const { return fReadCalls; }	inline Long64_t GetReadCalls() const { return fReadCalls; }
	Double_t GetLearnTime() const { return fLearnTime; }	inline Double_t GetLearnTime() const { return fLearnTime; }
	Double_t GetProcTime() const { return fProcTime; }	inline Double_t GetProcTime() const { return fProcTime; }
	Double_t GetCPUTime() const { return fCPUTime; }	inline Double_t GetCPUTime() const { return fCPUTime; }
	Double_t GetLastUpdate() const { return fLastUpdate; }	inline Double_t GetLastUpdate() const { return fLastUpdate; }
	Double_t GetRate() const { return ((fProcTime > 0) ? fEntries/fProcTime	inline Double_t GetRate() const { return ((fProcTime > 0) ? fEntries/fPr
	: 0); }	ocTime : 0); }
	Double_t GetCurrentRate() const;	Double_t GetCurrentRate() const;

	void SetLastEntries(Long64_t entries) { fLastEntries = entries;}	inline void SetLastEntries(Long64_t entries) { fLastEntries = entrie
	void SetEntries(Long64_t entries) { fEntries = entries; SetLastUpdat	s; }
	e();}	inline void SetEntries(Long64_t entries) { fEntries = entries; }
	void IncEntries(Long64_t entries = 1) { fLastEntries = entries; fEnt	inline void IncEntries(Long64_t entries = 1) { fLastEntries = entrie
	ries += entries; SetLastUpdate();}	s; fEntries += entries; }
	void IncBytesRead(Long64_t bytesRead) { fBytesRead += bytesRead; Set	inline void IncBytesRead(Long64_t bytesRead) { fBytesRead += bytesRe
	LastUpdate();}	ad; }
	void SetBytesRead(Long64_t bytesRead) { fBytesRead = bytesRead; SetL	inline void SetBytesRead(Long64_t bytesRead) { fBytesRead = bytesRea
	astUpdate();}	d; }
	void IncReadCalls(Long64_t readCalls) { fReadCalls += readCalls; Set	inline void IncReadCalls(Long64_t readCalls) { fReadCalls += readCal
	LastUpdate();}	ls; }
	void SetReadCalls(Long64_t readCalls) { fReadCalls = readCalls; SetL	inline void SetReadCalls(Long64_t readCalls) { fReadCalls = readCall
	astUpdate();}	s; }
	void SetLearnTime(Double_t learnTime) { fLearnTime = learnTime; }	inline void SetLearnTime(Double_t learnTime) { fLearnTime = learnTim
	void SetLastProcTime(Double_t procTime) { fLastProcTime = procTime;	e; }
	}	inline void SetLastProcTime(Double_t procTime) { fLastProcTime = pro
	void SetProcTime(Double_t procTime) { fProcTime = procTime; }	cTime; }
	void IncProcTime(Double_t procTime) { fLastProcTime = procTime; fPro	inline void SetProcTime(Double_t procTime) { fProcTime = procTime; }
	cTime += procTime; }	inline void IncProcTime(Double_t procTime) { fLastProcTime = procTim
	void SetCPUTime(Double_t procTime) { fCPUTime = procTime; }	e; fProcTime += procTime; }
	void IncCPUTime(Double_t procTime) { fCPUTime += procTime; }	inline void SetCPUTime(Double_t procTime) { fCPUTime = procTime; }
		inline void IncCPUTime(Double_t procTime) { fCPUTime += procTime; }
	void SetLastUpdate(Double_t updtTime = 0);	void SetLastUpdate(Double_t updtTime = 0);
	void Print(Option_t* option = "") const;	void Print(Option_t* option = "") const;

	TProofProgressStatus operator-(TProofProgressStatus &st);	TProofProgressStatus operator-(TProofProgressStatus &st);
	TProofProgressStatus &operator+=(const TProofProgressStatus &st);	TProofProgressStatus &operator+=(const TProofProgressStatus &st);
	TProofProgressStatus &operator-=(const TProofProgressStatus &st);	TProofProgressStatus &operator-=(const TProofProgressStatus &st);

	ClassDef(TProofProgressStatus,2) // Proof progress status class	ClassDef(TProofProgressStatus,2) // Proof progress status class
	};	};


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

	TProofServ.h	TProofServ.h

	// @(#)root/proof:$Id: TProofServ.h 42882 2012-02-06 11:10:21Z ganis $	// @(#)root/proof:$Id: TProofServ.h 44010 2012-04-29 23:07:48Z ganis $
	// Author: Fons Rademakers 16/02/97	// Author: Fons Rademakers 16/02/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 239	skipping to change at line 239
	Int_t SetupCommon();	Int_t SetupCommon();
	virtual void MakePlayer();	virtual void MakePlayer();
	virtual void DeletePlayer();	virtual void DeletePlayer();

	virtual Int_t Fork();	virtual Int_t Fork();
	Int_t GetSessionStatus();	Int_t GetSessionStatus();
	Bool_t IsIdle();	Bool_t IsIdle();
	Bool_t UnlinkDataDir(const char *path);	Bool_t UnlinkDataDir(const char *path);

	static TString fgLastMsg; // Message about status before exception	static TString fgLastMsg; // Message about status before exception

		static Long64_t fgLastEntry; // Last entry before exception

	public:	public:
	TProofServ(Int_t argc, char argv, FILE flog = 0);	TProofServ(Int_t argc, char argv, FILE flog = 0);
	virtual ~TProofServ();	virtual ~TProofServ();

	virtual Int_t CreateServer();	virtual Int_t CreateServer();

	TProof *GetProof() const { return fProof; }	TProof *GetProof() const { return fProof; }
	const char *GetService() const { return fService; }	const char *GetService() const { return fService; }
	const char *GetConfDir() const { return fConfDir; }	const char *GetConfDir() const { return fConfDir; }

	skipping to change at line 341	skipping to change at line 342
	// Log control	// Log control
	void LogToMaster(Bool_t on = kTRUE) { fSendLogToMaster = on; }	void LogToMaster(Bool_t on = kTRUE) { fSendLogToMaster = on; }

	static FILE SetErrorHandlerFile(FILE ferr);	static FILE SetErrorHandlerFile(FILE ferr);
	static void ErrorHandler(Int_t level, Bool_t abort, const char *locat ion,	static void ErrorHandler(Int_t level, Bool_t abort, const char *locat ion,
	const char *msg);	const char *msg);

	static void ResolveKeywords(TString &fname, const char *path = 0);	static void ResolveKeywords(TString &fname, const char *path = 0);

	static void SetLastMsg(const char *lastmsg);	static void SetLastMsg(const char *lastmsg);

		static void SetLastEntry(Long64_t lastentry);

	static Bool_t IsActive();	static Bool_t IsActive();
	static TProofServ *This();	static TProofServ *This();

	ClassDef(TProofServ,0) //PROOF Server Application Interface	ClassDef(TProofServ,0) //PROOF Server Application Interface
	};	};

	R__EXTERN TProofServ *gProofServ;	R__EXTERN TProofServ *gProofServ;

	class TProofLockPath : public TNamed {	class TProofLockPath : public TNamed {

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

	TQConnection.h	TQConnection.h

	// @(#)root/base:$Id: TQConnection.h 25128 2008-08-12 17:59:19Z pcanal $	// @(#)root/base:$Id: TQConnection.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Valeriy Onuchin & Fons Rademakers 15/10/2000	// Author: Valeriy Onuchin & Fons Rademakers 15/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 51	skipping to change at line 51

	class TQConnection : public TList, public TQObject {	class TQConnection : public TList, public TQObject {

	protected:	protected:
	TQSlot *fSlot; // slot-method calling interface	TQSlot *fSlot; // slot-method calling interface
	void *fReceiver; // ptr to object to which slot is applied	void *fReceiver; // ptr to object to which slot is applied
	TString fClassName; // class name of the receiver	TString fClassName; // class name of the receiver

	virtual void PrintCollectionHeader(Option_t* option) const;	virtual void PrintCollectionHeader(Option_t* option) const;


		private:
		TQConnection &operator=(const TQConnection &); // Not yet implemented.

	public:	public:
	TQConnection();	TQConnection();
	TQConnection(TClass* cl, void receiver, const char method_name);	TQConnection(TClass* cl, void receiver, const char method_name);
	TQConnection(const char class_name, void receiver,	TQConnection(const char class_name, void receiver,
	const char *method_name);	const char *method_name);
	TQConnection(const TQConnection &con);	TQConnection(const TQConnection &con);
	virtual ~TQConnection();	virtual ~TQConnection();

	const char *GetName() const;	const char *GetName() const;
	void *GetReceiver() const { return fReceiver; }	void *GetReceiver() const { return fReceiver; }

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

	TQRootDialog.h	TQRootDialog.h

	// @(#)root/qtgsi:$Id: TQRootDialog.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/qtgsi:$Id: TQRootDialog.h 43381 2012-03-19 15:24:46Z bellenot $
	// Author: Denis Bertini, M. Al-Turany 01/11/2000	// Author: Denis Bertini, M. Al-Turany 01/11/2000

	/*************************************************************************	/*************************************************************************
	* 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 46	skipping to change at line 46
	# endif	# endif
	#endif	#endif

	#ifndef ROOT_TObject	#ifndef ROOT_TObject
	#include "TObject.h"	#include "TObject.h"
	#endif	#endif

	class TMethod;	class TMethod;
	class TCanvas;	class TCanvas;


		class QCloseEvent;
	class QLineEdit;	class QLineEdit;
	class QWidget;	class QWidget;
	#ifdef __CINT__	#ifdef __CINT__
	template <typename T> class QList;	template <typename T> class QList;
	class QLineEdit;	class QLineEdit;
	class QList<QLineEdit*>;	class QList<QLineEdit*>;
	class QVBox;	class QVBox;
	#if QTVERS > 3	#if QTVERS > 3
	class WindowFlags;	class WindowFlags;
	typedef WindowFlags WFlags;	typedef WindowFlags WFlags;

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

	TQuaternion.h	TQuaternion.h

	// @(#)root/physics:$Id: TQuaternion.h 30815 2009-10-20 13:49:22Z rdm $	// @(#)root/physics:$Id: TQuaternion.h 44032 2012-04-30 14:49:20Z axel $
	// Author: Eric Anciant 28/06/2005	// Author: Eric Anciant 28/06/2005

	#ifndef ROOT_TQuaternion	#ifndef ROOT_TQuaternion
	#define ROOT_TQuaternion	#define ROOT_TQuaternion

	#ifndef ROOT_TVector3	#ifndef ROOT_TVector3
	#include "TVector3.h"	#include "TVector3.h"
	#endif	#endif
	#ifndef ROOT_TMath	#ifndef ROOT_TMath
	#include "TMath.h"	#include "TMath.h"

	skipping to change at line 237	skipping to change at line 237

	inline Bool_t TQuaternion::operator == (const TQuaternion& Q) const {	inline Bool_t TQuaternion::operator == (const TQuaternion& Q) const {
	return (fVectorPart == Q.fVectorPart && fRealPart == Q.fRealPart) ? kTRU E : kFALSE;	return (fVectorPart == Q.fVectorPart && fRealPart == Q.fRealPart) ? kTRU E : kFALSE;
	}	}

	inline Bool_t TQuaternion::operator != (const TQuaternion& Q) const {	inline Bool_t TQuaternion::operator != (const TQuaternion& Q) const {
	return (fVectorPart != Q.fVectorPart \|\| fRealPart != Q.fRealPart) ? kTRU E : kFALSE;	return (fVectorPart != Q.fVectorPart \|\| fRealPart != Q.fRealPart) ? kTRU E : kFALSE;
	}	}

	inline TQuaternion& TQuaternion::operator=(const TQuaternion& quat) {	inline TQuaternion& TQuaternion::operator=(const TQuaternion& quat) {

	fRealPart = quat.fRealPart;	if (&quat != this) {
	fVectorPart.SetXYZ(quat.fVectorPart.X(),quat.fVectorPart.Y(),quat.fVecto	fRealPart = quat.fRealPart;
	rPart.Z());	fVectorPart.SetXYZ(quat.fVectorPart.X(),quat.fVectorPart.Y(),quat.fVe
		ctorPart.Z());
		}
	return (*this);	return (*this);
	}	}

	inline TQuaternion& TQuaternion::operator+=(const TQuaternion &quaternion) {	inline TQuaternion& TQuaternion::operator+=(const TQuaternion &quaternion) {
	fVectorPart += quaternion.fVectorPart;	fVectorPart += quaternion.fVectorPart;
	fRealPart += quaternion.fRealPart;	fRealPart += quaternion.fRealPart;
	return (*this);	return (*this);
	}	}

	inline TQuaternion& TQuaternion::operator-=(const TQuaternion &quaternion) {	inline TQuaternion& TQuaternion::operator-=(const TQuaternion &quaternion) {

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

	TRecorder.h	TRecorder.h

	// @(#)root/gui:$Id: TRecorder.h 35206 2010-09-08 14:01:27Z bellenot $	// @(#)root/gui:$Id: TRecorder.h 43282 2012-03-08 10:01:56Z bellenot $
	// Author: Katerina Opocenska 11/09/2008	// Author: Katerina Opocenska 11/09/2008

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 443	skipping to change at line 443
	// replaying) //	// replaying) //
	// //	// //
	// [TRecorderStates.JPG] //	// [TRecorderStates.JPG] //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	class TRecorder : public TObject	class TRecorder : public TObject
	{	{
	private:	private:
	TRecorderState *fRecorderState; //! Current state of recorder	TRecorderState *fRecorderState; //! Current state of recorder


		TRecorder(const TRecorder&); // Not implemented.
		TRecorder &operator=(const TRecorder&); // Not implemented.

	protected:	protected:
	friend class TRecorderState;	friend class TRecorderState;
	friend class TRecorderInactive;	friend class TRecorderInactive;
	friend class TRecorderPaused;	friend class TRecorderPaused;
	friend class TRecorderRecording;	friend class TRecorderRecording;
	friend class TRecorderReplaying;	friend class TRecorderReplaying;

	TString fFilename; // Events file name	TString fFilename; // Events file name
	// Changes state to the new one.	// Changes state to the new one.
	// See class documentation for information about state changing.	// See class documentation for information about state changing.

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

	TRefArrayProxy.h	TRefArrayProxy.h

	// @(#)root/meta:$Id: TRefArrayProxy.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/treeplayer:$Id: TRefArrayProxy.h 43271 2012-03-07 05:53:52Z pca nal $
	// Author: Markus Frank 20/05/2005	// Author: Markus Frank 20/05/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 26	skipping to change at line 26
	#endif	#endif

	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	//	//
	// TRefArrayProxy is a container proxy, which allows to access references s tored	// TRefArrayProxy is a container proxy, which allows to access references s tored
	// in a TRefArray from TTree::Draw	// in a TRefArray from TTree::Draw
	//	//
	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	class TRefArrayProxy : public TRefProxy {	class TRefArrayProxy : public TRefProxy {
	public:	public:

	// Default constructor	// The implicit's constructor and destructor have the correct implementa
	TRefArrayProxy() : TRefProxy() {}	tion.
	// Copy constructor
	TRefArrayProxy(const TRefArrayProxy& c) : TRefProxy(c) {}
	// Standard destructor
	virtual ~TRefArrayProxy() {}
	// TVirtualRefProxy overload: Clone the reference proxy (virtual constru ctor)	// TVirtualRefProxy overload: Clone the reference proxy (virtual constru ctor)
	virtual TVirtualRefProxy* Clone() const { return new TRefArrayPro xy(*this);}	virtual TVirtualRefProxy* Clone() const { return new TRefArrayPro xy(*this);}
	// TVirtualRefProxy overload: Flag to indicate if this is a container re ference	// TVirtualRefProxy overload: Flag to indicate if this is a container re ference
	virtual Bool_t HasCounter() const { return kTRUE; }	virtual Bool_t HasCounter() const { return kTRUE; }
	// TVirtualRefProxy overload: Access referenced object(-data)	// TVirtualRefProxy overload: Access referenced object(-data)
	virtual void* GetObject(TFormLeafInfoReference* info, void* data, Int_t instance);	virtual void* GetObject(TFormLeafInfoReference* info, void* data, Int_t instance);
	// TVirtualRefProxy overload: Access to container size (if container ref erence (ie TRefArray) etc)	// TVirtualRefProxy overload: Access to container size (if container ref erence (ie TRefArray) etc)
	virtual Int_t GetCounterValue(TFormLeafInfoReference* info, void *data) ;	virtual Int_t GetCounterValue(TFormLeafInfoReference* info, void *data) ;
	};	};
	#endif // ROOT_TRefArrayProxy	#endif // ROOT_TRefArrayProxy

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

	TSVDUnfold.h	TSVDUnfold.h

	skipping to change at line 108	skipping to change at line 108

	// Obtain the distribution of singular values	// Obtain the distribution of singular values
	TH1D* GetSV() const;	TH1D* GetSV() const;

	// Obtain the computed regularized covariance matrix	// Obtain the computed regularized covariance matrix
	TH2D* GetXtau() const;	TH2D* GetXtau() const;

	// Obtain the computed inverse of the covariance matrix	// Obtain the computed inverse of the covariance matrix
	TH2D* GetXinv() const;	TH2D* GetXinv() const;


		//Obtain the covariance matrix on the data
		TH2D* GetBCov() const;

	// Helper functions	// Helper functions
	Double_t ComputeChiSquared( const TH1D& truspec, const TH1D& unfspec );	Double_t ComputeChiSquared( const TH1D& truspec, const TH1D& unfspec );

	private:	private:

	// Helper functions for vector and matrix operations	// Helper functions for vector and matrix operations
	void FillCurvatureMatrix( TMatrixD& tCurv, TMatrixD& tC ) con st;	void FillCurvatureMatrix( TMatrixD& tCurv, TMatrixD& tC ) con st;
	static Double_t GetCurvature ( const TVectorD& vec, const TMatrixD & curv );	static Double_t GetCurvature ( const TVectorD& vec, const TMatrixD & curv );

	void InitHistos ( );	void InitHistos ( );

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

	TSchemaHelper.h	TSchemaHelper.h

	// @(#)root/core:$Id: TSchemaHelper.h 42145 2011-11-20 05:49:57Z pcanal $	// @(#)root/core:$Id: TSchemaHelper.h 43515 2012-03-27 21:15:53Z pcanal $
	// author: Lukasz Janyst <ljanyst@cern.ch>	// author: Lukasz Janyst <ljanyst@cern.ch>

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2010, Rene Brun, Fons Rademakers and al. *	* Copyright (C) 1995-2010, Rene Brun, Fons Rademakers and al. *
	* 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 42	skipping to change at line 42
	fSource(), fCode(), fVersion(), fChecksum(),	fSource(), fCode(), fVersion(), fChecksum(),
	fInclude(), fEmbed(kTRUE), fFunctionPtr( 0 ),	fInclude(), fEmbed(kTRUE), fFunctionPtr( 0 ),
	fAttributes() {}	fAttributes() {}
	std::string fTarget;	std::string fTarget;
	std::string fSourceClass;	std::string fSourceClass;
	std::string fSource;	std::string fSource;
	std::string fCode;	std::string fCode;
	std::string fVersion;	std::string fVersion;
	std::string fChecksum;	std::string fChecksum;
	std::string fInclude;	std::string fInclude;

	bool fEmbed;	Bool_t fEmbed;
	void* fFunctionPtr;	void* fFunctionPtr;
	std::string fAttributes;	std::string fAttributes;

	TSchemaHelper(const TSchemaHelper &tsh) :	TSchemaHelper(const TSchemaHelper &tsh) :
	fTarget(tsh.fTarget), fSourceClass(tsh.fSourceClass),	fTarget(tsh.fTarget), fSourceClass(tsh.fSourceClass),
	fSource(tsh.fSource), fCode(tsh.fCode), fVersion(tsh.fVersion),fChec ksum(tsh.fChecksum),	fSource(tsh.fSource), fCode(tsh.fCode), fVersion(tsh.fVersion),fChec ksum(tsh.fChecksum),
	fInclude(tsh.fInclude), fEmbed(tsh.fEmbed), fFunctionPtr(tsh.fFuncti onPtr),	fInclude(tsh.fInclude), fEmbed(tsh.fEmbed), fFunctionPtr(tsh.fFuncti onPtr),
	fAttributes(tsh.fAttributes) {}	fAttributes(tsh.fAttributes) {}

	TSchemaHelper& operator=(const TSchemaHelper &) {return *this;} // No t implemented	TSchemaHelper& operator=(const TSchemaHelper &) {return *this;} // No t implemented

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

	TSelVerifyDataSet.h	TSelVerifyDataSet.h

	skipping to change at line 71	skipping to change at line 71
	TString fMss;	TString fMss;
	TString fStageopts;	TString fStageopts;

	Bool_t fChangedDs;	Bool_t fChangedDs;
	Int_t fTouched;	Int_t fTouched;
	Int_t fOpened;	Int_t fOpened;
	Int_t fDisappeared;	Int_t fDisappeared;

	TFileCollection *fSubDataSet; // Sub-dataset being verified	TFileCollection *fSubDataSet; // Sub-dataset being verified


		void InitMembers();

	public :	public :

	TSelVerifyDataSet(TTree *);	TSelVerifyDataSet(TTree *);
	TSelVerifyDataSet();	TSelVerifyDataSet();
	virtual ~TSelVerifyDataSet() {}	virtual ~TSelVerifyDataSet() {}
	virtual Int_t Version() const {return 1;}	virtual Int_t Version() const {return 1;}

	virtual void Begin(TTree *);	virtual void Begin(TTree *) { }
	virtual void SlaveBegin(TTree *tree);	virtual void SlaveBegin(TTree *tree);

	virtual void Init(TTree *tree);	virtual void Init(TTree *) { }
	virtual Bool_t Notify();	virtual Bool_t Notify() { return kTRUE; }
	virtual Bool_t Process(Long64_t entry);	virtual Bool_t Process(Long64_t entry);
	virtual void SetOption(const char *option) { fOption = option; }	virtual void SetOption(const char *option) { fOption = option; }
	virtual void SetObject(TObject *obj) { fObject = obj; }	virtual void SetObject(TObject *obj) { fObject = obj; }
	virtual void SetInputList(TList *input) {fInput = input;}	virtual void SetInputList(TList *input) {fInput = input;}
	virtual TList *GetOutputList() const { return fOutput; }	virtual TList *GetOutputList() const { return fOutput; }
	virtual void SlaveTerminate();	virtual void SlaveTerminate();

	virtual void Terminate();	virtual void Terminate() { }

	ClassDef(TSelVerifyDataSet,0) //PROOF selector for parallel dataset veri fication	ClassDef(TSelVerifyDataSet,0) //PROOF selector for parallel dataset veri fication
	};	};

	#endif	#endif


	#ifdef TSelVerifyDataSet_cxx
	void TSelVerifyDataSet::Init(TTree *)
	{
	fFopt = -1;
	fSopt = 0;
	fRopt = 0;

	fAllf = 0;
	fCheckstg = 0;
	fNonStgf = 0;
	fReopen = 0;
	fTouch = 0;
	fStgf = 0;
	fNoaction = 0;
	fFullproc = 0;
	fLocateonly = 0;
	fStageonly = 0;
	fDoall = 0;
	fGetlistonly = 0;
	fScanlist = 0;
	fDbg = 0;

	fChangedDs = kFALSE;
	fTouched = 0;
	fOpened = 0;
	fDisappeared = 0;
	fSubDataSet = 0;
	}

	Bool_t TSelVerifyDataSet::Notify()
	{
	return kTRUE;
	}
	#endif // #ifdef TSelVerifyDataSet_cxx

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

	TStatus.h	TStatus.h

	// @(#)root/proofplayer:$Id: TStatus.h 40186 2011-07-11 12:00:50Z ganis $	// @(#)root/proofplayer:$Id: TStatus.h 44010 2012-04-29 23:07:48Z ganis $
	// Author: Maarten Ballintijn 12/03/2004	// Author: Maarten Ballintijn 12/03/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 29	skipping to change at line 29
	// This class holds the status of a ongoing operation and collects //	// This class holds the status of a ongoing operation and collects //
	// error messages. It provides a Merge() operation allowing it to //	// error messages. It provides a Merge() operation allowing it to //
	// be used in PROOF to monitor status in the slaves. //	// be used in PROOF to monitor status in the slaves. //
	// No messages indicates success. //	// No messages indicates success. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

		#ifndef ROOT_THashList
		#include "THashList.h"
		#endif

	#include <set>	#include <set>
	#include <string>	#include <string>
	#ifdef R__GLOBALSTL	#ifdef R__GLOBALSTL
	namespace std { using ::set; using ::string; }	namespace std { using ::set; using ::string; }
	#endif	#endif


	class TCollection;

	class TStatus : public TNamed {	class TStatus : public TNamed {


		public:
		enum EProcStatus { kNotOk = 15}; // True if status of things are not OK

	private:	private:

	typedef std::set<std::string> MsgSet_t;	TList fMsgs; // list of error messages
	typedef std::set<std::string>::const_iterator MsgIter_t;	TIter fIter; //!iterator in messages
	MsgSet_t fMsgs; // list of error messages	THashList fInfoMsgs; // list of info messages
	MsgIter_t fIter; //!iterator in messages

	Int_t fExitStatus; // Query exit status ((Int_t)TVirtualProofPlay er::EExitStatus or -1);	Int_t fExitStatus; // Query exit status ((Int_t)TVirtualProofPlay er::EExitStatus or -1);
	Long_t fVirtMemMax; // Max virtual memory used by the worker	Long_t fVirtMemMax; // Max virtual memory used by the worker
	Long_t fResMemMax; // Max resident memory used by the worker	Long_t fResMemMax; // Max resident memory used by the worker
	Long_t fVirtMaxMst; // Max virtual memory used by the master	Long_t fVirtMaxMst; // Max virtual memory used by the master
	Long_t fResMaxMst; // Max resident memory used by the master	Long_t fResMaxMst; // Max resident memory used by the master

	public:	public:
	TStatus();	TStatus();
	virtual ~TStatus() { }	virtual ~TStatus() { }


	Bool_t IsOk() const { return fMsgs.empty(); }	inline Bool_t IsOk() const { return TestBit(kNotOk) ? kFALSE : kTRUE; }
	void Add(const char *mesg);	void Add(const char *mesg);

		void AddInfo(const char *mesg);
	virtual Int_t Merge(TCollection *list);	virtual Int_t Merge(TCollection *list);
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;
	void Reset();	void Reset();
	const char *NextMesg();	const char *NextMesg();

	Int_t GetExitStatus() const { return fExitStatus; }	Int_t GetExitStatus() const { return fExitStatus; }
	Long_t GetResMemMax(Bool_t master = kFALSE) const { return ((mas ter) ? fResMaxMst : fResMemMax); }	Long_t GetResMemMax(Bool_t master = kFALSE) const { return ((mas ter) ? fResMaxMst : fResMemMax); }
	Long_t GetVirtMemMax(Bool_t master = kFALSE) const { return ((ma ster) ? fVirtMaxMst : fVirtMemMax); }	Long_t GetVirtMemMax(Bool_t master = kFALSE) const { return ((ma ster) ? fVirtMaxMst : fVirtMemMax); }

	void SetExitStatus(Int_t est) { fExitStatus = est; }	void SetExitStatus(Int_t est) { fExitStatus = est; }
	void SetMemValues(Long_t vmem = -1, Long_t rmem = -1, Bool_t m aster = kFALSE);	void SetMemValues(Long_t vmem = -1, Long_t rmem = -1, Bool_t m aster = kFALSE);


	ClassDef(TStatus,4); // Status class	ClassDef(TStatus,5); // Status class
	};	};

	#endif	#endif

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

	TStreamerInfoActions.h	TStreamerInfoActions.h

	// @(#)root/io:$Id: TStreamerInfoActions.h 40872 2011-09-13 21:33:33Z pcana l $	// @(#)root/io:$Id: TStreamerInfoActions.h 43271 2012-03-07 05:53:52Z pcana l $
	// Author: Philippe Canal 05/2010	// Author: Philippe Canal 05/2010

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TStreamerInfoActions	#ifndef ROOT_TStreamerInfoActions
	#define ROOT_TStreamerInfoActions	#define ROOT_TStreamerInfoActions

	#include <vector>	#include <vector>

	#include "TStreamerInfo.h"	#include "TStreamerInfo.h"

		#include <assert.h>

	namespace TStreamerInfoActions {	namespace TStreamerInfoActions {

	class TConfiguration {	class TConfiguration {
	// Base class of the Configurations.	// Base class of the Configurations.
	protected:	protected:
	public:	public:
	TVirtualStreamerInfo *fInfo; // TStreamerInfo form which the actio n is derived	TVirtualStreamerInfo *fInfo; // TStreamerInfo form which the actio n is derived
	UInt_t fElemId; // Identifier of the TStreamerElement	UInt_t fElemId; // Identifier of the TStreamerElement
	Int_t fOffset; // Offset within the object	Int_t fOffset; // Offset within the object

	skipping to change at line 67	skipping to change at line 68
	typedef Int_t (TStreamerInfoLoopAction_t)(TBuffer &buf, void iter, con st void end, const TLoopConfiguration loopconf, const TConfiguration *con f);	typedef Int_t (TStreamerInfoLoopAction_t)(TBuffer &buf, void iter, con st void end, const TLoopConfiguration loopconf, const TConfiguration *con f);

	class TConfiguredAction : public TObject {	class TConfiguredAction : public TObject {
	public:	public:
	union {	union {
	TStreamerInfoAction_t fAction;	TStreamerInfoAction_t fAction;
	TStreamerInfoVecPtrLoopAction_t fVecPtrLoopAction;	TStreamerInfoVecPtrLoopAction_t fVecPtrLoopAction;
	TStreamerInfoLoopAction_t fLoopAction;	TStreamerInfoLoopAction_t fLoopAction;
	};	};
	TConfiguration *fConfiguration;	TConfiguration *fConfiguration;

		private:
		// assignment operator must be the default because the 'copy' constru
		ctor is actually a move constructor and must be used.
	public:	public:
	TConfiguredAction() : fAction(0), fConfiguration(0) {}	TConfiguredAction() : fAction(0), fConfiguration(0) {}
	TConfiguredAction(const TConfiguredAction &rval) : TObject(rval), fAc tion(rval.fAction), fConfiguration(rval.fConfiguration)	TConfiguredAction(const TConfiguredAction &rval) : TObject(rval), fAc tion(rval.fAction), fConfiguration(rval.fConfiguration)
	{	{

	// Technically this is a move constructor ...	// WARNING: Technically this is a move constructor ...
	const_cast<TConfiguredAction&>(rval).fConfiguration = 0;	const_cast<TConfiguredAction&>(rval).fConfiguration = 0;
	}	}

		TConfiguredAction &operator=(const TConfiguredAction &rval)
		{
		// WARNING: Technically this is a move assignment!.

		TConfiguredAction tmp(rval); // this does a move.
		TObject::operator=(tmp); // we are missing TObject::Swap
		std::swap(fAction,tmp.fAction);
		std::swap(fConfiguration,tmp.fConfiguration);
		return *this;
		};

	TConfiguredAction(TStreamerInfoAction_t action, TConfiguration *conf) : fAction(action), fConfiguration(conf)	TConfiguredAction(TStreamerInfoAction_t action, TConfiguration *conf) : fAction(action), fConfiguration(conf)
	{	{
	// Usual constructor.	// Usual constructor.
	}	}
	TConfiguredAction(TStreamerInfoVecPtrLoopAction_t action, TConfigurat ion *conf) : fVecPtrLoopAction(action), fConfiguration(conf)	TConfiguredAction(TStreamerInfoVecPtrLoopAction_t action, TConfigurat ion *conf) : fVecPtrLoopAction(action), fConfiguration(conf)
	{	{
	// Usual constructor.	// Usual constructor.
	}	}
	TConfiguredAction(TStreamerInfoLoopAction_t action, TConfiguration *c onf) : fLoopAction(action), fConfiguration(conf)	TConfiguredAction(TStreamerInfoLoopAction_t action, TConfiguration *c onf) : fLoopAction(action), fConfiguration(conf)
	{	{

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

	TTable3Points.h	TTable3Points.h

	// @(#)root/table:$Id: TTable3Points.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/table:$Id: TTable3Points.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Valery Fine 10/05/99 (E-mail: fine@bnl.gov)	// Author: Valery Fine 10/05/99 (E-mail: fine@bnl.gov)

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TTable3Points	#ifndef ROOT_TTable3Points
	#define ROOT_TTable3Points	#define ROOT_TTable3Points

	#include "TTablePoints.h"	#include "TTablePoints.h"

	class TTable3Points : public TTablePoints	class TTable3Points : public TTablePoints
	{	{
	protected:	protected:
	ULong_t *fColumnOffset; //!	ULong_t *fColumnOffset; //!


		private:
		TTable3Points(const TTable3Points&); // Not implemented.
		TTable3Points &operator=(const TTable3Points&); // Not implemented.

	public:	public:
	enum EPointDirection {kXPoints,kYPoints,kZPoints,kTotalSize};	enum EPointDirection {kXPoints,kYPoints,kZPoints,kTotalSize};
	TTable3Points();	TTable3Points();
	TTable3Points(TTableSorter sorter,const void key, const Char_t *xName= "x",	TTable3Points(TTableSorter sorter,const void key, const Char_t *xName= "x",
	const Char_t yName="y", const Char_t zName="z",Option_t *opt="");	const Char_t yName="y", const Char_t zName="z",Option_t *opt="");
	TTable3Points(TTableSorter sorter,Int_t keyIndex, const Char_t xName=" x",	TTable3Points(TTableSorter sorter,Int_t keyIndex, const Char_t xName=" x",
	const Char_t yName="y", const Char_t zName="z",Option_t *opt="");	const Char_t yName="y", const Char_t zName="z",Option_t *opt="");
	~TTable3Points();	~TTable3Points();
	virtual void SetAnyColumn(const Char_t *anyName, EPointDirection indx );	virtual void SetAnyColumn(const Char_t *anyName, EPointDirection indx );
	virtual void SetXColumn(const Char_t *xName){ SetAnyColumn(xName,kXPo ints);}	virtual void SetXColumn(const Char_t *xName){ SetAnyColumn(xName,kXPo ints);}

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

	TTableSorter.h	TTableSorter.h

	// @(#)root/table:$Id: TTableSorter.h 27157 2009-01-15 14:05:12Z brun $	// @(#)root/table:$Id: TTableSorter.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Valery Fine 26/01/99 (E-mail: fine@bnl.gov)	// Author: Valery Fine 26/01/99 (E-mail: fine@bnl.gov)

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TTableSorter	#ifndef ROOT_TTableSorter

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

	class TTableSorter : public TNamed {	class TTableSorter : public TNamed {
	private:	private:
	union { Char_t fChar;	union { Char_t fChar;
	Int_t fInt;	Int_t fInt;
	Long_t fLong;	Long_t fLong;
	Float_t fFloat;	Float_t fFloat;
	Double_t fDouble;	Double_t fDouble;
	} fValue;	} fValue;


		TTableSorter(const TTableSorter&); // Not implemented.
		TTableSorter &operator=(const TTableSorter&); // Not implemented.

	protected:	protected:
	// enum EColumnType {kNAN, kFloat, kInt, kLong, kShort, kDouble, kUInt	// enum EColumnType {kNAN, kFloat, kInt, kLong, kShort, kDouble, kUInt
	// ,kULong, kUShort, kUChar, kChar };	// ,kULong, kUShort, kUChar, kChar };
	void **fSortIndex; // Array of pointers to columns of the sorted t able	void **fSortIndex; // Array of pointers to columns of the sorted t able
	Int_t fLastFound; // The index of the last found index within fSo rtIndex	Int_t fLastFound; // The index of the last found index within fSo rtIndex
	Int_t fFirstRow; // first row of the table to be sorted	Int_t fFirstRow; // first row of the table to be sorted
	Int_t fNumberOfRows; // number of rows of the table to be sorted	Int_t fNumberOfRows; // number of rows of the table to be sorted
	TString fColName; //	TString fColName; //
	Int_t fColOffset; //	Int_t fColOffset; //
	Int_t fColSize; // The size of the selected column in bytes	Int_t fColSize; // The size of the selected column in bytes

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

	TTreeCloner.h	TTreeCloner.h

	// @(#)root/tree:$Id: TTreeCloner.h 39059 2011-04-30 20:28:06Z pcanal $	// @(#)root/tree:$Id: TTreeCloner.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Philippe Canal 07/11/2005	// Author: Philippe Canal 07/11/2005

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 75	skipping to change at line 75
	kDefault = 0,	kDefault = 0,
	kSortBasketsByBranch = 1,	kSortBasketsByBranch = 1,
	kSortBasketsByOffset = 2,	kSortBasketsByOffset = 2,
	kSortBasketsByEntry = 3	kSortBasketsByEntry = 3
	};	};

	class CompareSeek {	class CompareSeek {
	TTreeCloner *fObject;	TTreeCloner *fObject;
	public:	public:
	CompareSeek(TTreeCloner *obj) : fObject(obj) {}	CompareSeek(TTreeCloner *obj) : fObject(obj) {}

	bool operator()(UInt_t i1, UInt_t i2);	Bool_t operator()(UInt_t i1, UInt_t i2);
	};	};

	class CompareEntry {	class CompareEntry {
	TTreeCloner *fObject;	TTreeCloner *fObject;
	public:	public:
	CompareEntry(TTreeCloner *obj) : fObject(obj) {}	CompareEntry(TTreeCloner *obj) : fObject(obj) {}

	bool operator()(UInt_t i1, UInt_t i2);	Bool_t operator()(UInt_t i1, UInt_t i2);
	};	};

	friend class CompareSeek;	friend class CompareSeek;
	friend class CompareEntry;	friend class CompareEntry;

	void ImportClusterRanges();	void ImportClusterRanges();


		private:
		TTreeCloner(const TTreeCloner&); // Not implemented.
		TTreeCloner &operator=(const TTreeCloner&); // Not implemented.

	public:	public:
	enum EClonerOptions {	enum EClonerOptions {
	kNone = 0,	kNone = 0,
	kNoWarnings = BIT(1),	kNoWarnings = BIT(1),
	kIgnoreMissingTopLevel = BIT(2)	kIgnoreMissingTopLevel = BIT(2)
	};	};

	TTreeCloner(TTree from, TTree to, Option_t *method, UInt_t options = k None);	TTreeCloner(TTree from, TTree to, Option_t *method, UInt_t options = k None);
	virtual ~TTreeCloner();	virtual ~TTreeCloner();


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

	TTreeRow.h	TTreeRow.h

	// @(#)root/tree:$Id: TTreeRow.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/tree:$Id: TTreeRow.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Fons Rademakers 30/11/99	// Author: Fons Rademakers 30/11/99

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


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

	private:	private:
	Int_t fColumnCount; // number of columns in row	Int_t fColumnCount; // number of columns in row
	Int_t *fFields; //[fColumnCount] index in fRow of the end of each field	Int_t *fFields; //[fColumnCount] index in fRow of the end of each field
	char *fRow; // string with all the fColumnCount fields	char *fRow; // string with all the fColumnCount fields
	TTreeRow *fOriginal; //! pointer to original row	TTreeRow *fOriginal; //! pointer to original row

	TTreeRow(TSQLRow *original);	TTreeRow(TSQLRow *original);
	Bool_t IsValid(Int_t field);	Bool_t IsValid(Int_t field);


		TTreeRow(const TTreeRow&); // Not implemented.
		TTreeRow &operator=(const TTreeRow&); // Not implemented.

	public:	public:
	TTreeRow();	TTreeRow();
	TTreeRow(Int_t nfields);	TTreeRow(Int_t nfields);
	TTreeRow(Int_t nfields, const Int_t fields, const char row);	TTreeRow(Int_t nfields, const Int_t fields, const char row);
	virtual ~TTreeRow();	virtual ~TTreeRow();

	void Close(Option_t *option="");	void Close(Option_t *option="");
	ULong_t GetFieldLength(Int_t field);	ULong_t GetFieldLength(Int_t field);
	const char *GetField(Int_t field);	const char *GetField(Int_t field);
	void SetRow(const Int_t fields, const char row);	void SetRow(const Int_t fields, const char row);

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

	TVirtualMC.h	TVirtualMC.h

	// @(#)root/vmc:$Name: $:$Id: TVirtualMC.h 42288 2011-11-28 19:31:52Z ivan a $	// @(#)root/vmc:$Name: $:$Id: TVirtualMC.h 43453 2012-03-22 16:11:34Z ivan a $
	// Authors: Ivana Hrivnacova, Rene Brun, Federico Carminati 13/04/2002	// Authors: Ivana Hrivnacova, Rene Brun, Federico Carminati 13/04/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002, ALICE Experiment at CERN. *	* Copyright (C) 2002, ALICE Experiment at CERN. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	skipping to change at line 35	skipping to change at line 35
	#include "TMCParticleType.h"	#include "TMCParticleType.h"
	#include "TMCOptical.h"	#include "TMCOptical.h"
	#include "TVirtualMCApplication.h"	#include "TVirtualMCApplication.h"
	#include "TVirtualMCStack.h"	#include "TVirtualMCStack.h"
	#include "TVirtualMCDecayer.h"	#include "TVirtualMCDecayer.h"
	#include "TVirtualMagField.h"	#include "TVirtualMagField.h"
	#include "TRandom.h"	#include "TRandom.h"
	#include "TString.h"	#include "TString.h"
	#include "TError.h"	#include "TError.h"


		#if defined(__linux__) && !defined(__CINT__)
		#include <pthread.h>
		#endif

	class TLorentzVector;	class TLorentzVector;
	class TGeoHMatrix;	class TGeoHMatrix;
	class TArrayI;	class TArrayI;
	class TArrayD;	class TArrayD;

	class TVirtualMC : public TNamed {	class TVirtualMC : public TNamed {

	public:	public:
	// Standard constructor	// Standard constructor
	// isRootGeometrySupported = True if implementation of TVirtualMC	// isRootGeometrySupported = True if implementation of TVirtualMC

	skipping to change at line 799	skipping to change at line 803

	//	//
	// ------------------------------------------------	// ------------------------------------------------
	// Control methods	// Control methods
	// ------------------------------------------------	// ------------------------------------------------
	//	//

	// Initialize MC	// Initialize MC
	virtual void Init() = 0;	virtual void Init() = 0;


	// Initialize MC physics	// Initialize MC in a multi-threaded application
		virtual void InitMT(Int_t threadRank);

		// Initialize MC physics
	virtual void BuildPhysics() = 0;	virtual void BuildPhysics() = 0;

	// Process one event	// Process one event
	// Deprecated	// Deprecated
	virtual void ProcessEvent() = 0;	virtual void ProcessEvent() = 0;

	// Process one run and return true if run has finished successfully,	// Process one run and return true if run has finished successfully,
	// return false in other cases (run aborted by user)	// return false in other cases (run aborted by user)
	virtual Bool_t ProcessRun(Int_t nevent) = 0;	virtual Bool_t ProcessRun(Int_t nevent) = 0;


	skipping to change at line 862	skipping to change at line 869
	// Return the magnetic field	// Return the magnetic field
	virtual TVirtualMagField* GetMagField() const { return fMagField; }	virtual TVirtualMagField* GetMagField() const { return fMagField; }

	protected:	protected:
	TVirtualMCApplication* fApplication; //! User MC application	TVirtualMCApplication* fApplication; //! User MC application

	private:	private:
	TVirtualMC(const TVirtualMC &mc);	TVirtualMC(const TVirtualMC &mc);
	TVirtualMC & operator=(const TVirtualMC &);	TVirtualMC & operator=(const TVirtualMC &);


	static TVirtualMC* fgMC; // Monte Carlo singleton instance	#if defined(__linux__) && !defined(__CINT__)
		static __thread TVirtualMC* fgMC; // Monte Carlo singleton instance
		#else
		static TVirtualMC* fgMC; // Monte Carlo singleton instance
		#endif

	TVirtualMCStack* fStack; //! Particles stack	TVirtualMCStack* fStack; //! Particles stack
	TVirtualMCDecayer* fDecayer; //! External decayer	TVirtualMCDecayer* fDecayer; //! External decayer
	TRandom* fRandom; //! Random number generator	TRandom* fRandom; //! Random number generator
	TVirtualMagField* fMagField;//! Magnetic field	TVirtualMagField* fMagField;//! Magnetic field

	ClassDef(TVirtualMC,1) //Interface to Monte Carlo	ClassDef(TVirtualMC,1) //Interface to Monte Carlo
	};	};

	// new functions	// new functions

	skipping to change at line 891	skipping to change at line 902

	inline Bool_t TVirtualMC::GetMaterial(Int_t /imat/, TString& /name/,	inline Bool_t TVirtualMC::GetMaterial(Int_t /imat/, TString& /name/,
	Double_t& /a/, Double_t& /z/, Double_t& /density /,	Double_t& /a/, Double_t& /z/, Double_t& /density /,
	Double_t& /radl/, Double_t& /inter/, TArrayD& /p ar/) {	Double_t& /radl/, Double_t& /inter/, TArrayD& /p ar/) {
	// Return the material parameters for the material specified by	// Return the material parameters for the material specified by
	// the material Id	// the material Id
	Warning("GetMaterial(Int_t imat, ...)", "New function - not yet implemen ted.");	Warning("GetMaterial(Int_t imat, ...)", "New function - not yet implemen ted.");
	return kFALSE;	return kFALSE;
	}	}


	R__EXTERN TVirtualMC *gMC;	inline void TVirtualMC::InitMT(Int_t /threadRank/) {
		// Initialize MC in a multi-threaded application
		Warning("InitMT(Int_t threadRank)", "New function - not yet implemented.
		");
		}

		#if defined(__linux__) && !defined(__CINT__)
		R__EXTERN __thread TVirtualMC *gMC;
		#else
		R__EXTERN TVirtualMC *gMC;
		#endif

	#endif //ROOT_TVirtualMC	#endif //ROOT_TVirtualMC

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

	TVirtualMCApplication.h	TVirtualMCApplication.h

	// @(#)root/vmc:$Id: TVirtualMCApplication.h 30651 2009-10-09 13:17:17Z bru n $	// @(#)root/vmc:$Id: TVirtualMCApplication.h 43453 2012-03-22 16:11:34Z iva na $
	// Author: Ivana Hrivnacova, 23/03/2002	// Author: Ivana Hrivnacova, 23/03/2002

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *	* Copyright (C) 2006, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2002, ALICE Experiment at CERN. *	* Copyright (C) 2002, ALICE Experiment at CERN. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	skipping to change at line 28	skipping to change at line 28
	// Interface to a user Monte Carlo application.	// Interface to a user Monte Carlo application.
	//	//

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif
	#ifndef ROOT_TMath	#ifndef ROOT_TMath
	#include "TMath.h"	#include "TMath.h"
	#endif	#endif


		#if defined(__linux__) && !defined(__CINT__)
		#include <pthread.h>
		#endif

	class TVirtualMCApplication : public TNamed {	class TVirtualMCApplication : public TNamed {

	public:	public:
	// Standard constructor	// Standard constructor
	TVirtualMCApplication(const char name, const char title);	TVirtualMCApplication(const char name, const char title);

	// Default constructor	// Default constructor
	TVirtualMCApplication();	TVirtualMCApplication();

	// Destructor	// Destructor

	skipping to change at line 104	skipping to change at line 108
	virtual Double_t TrackingZmax() const { return DBL_MAX; }	virtual Double_t TrackingZmax() const { return DBL_MAX; }

	// Calculate user field \a b at point \a x	// Calculate user field \a b at point \a x
	virtual void Field(const Double_t* x, Double_t* b) const;	virtual void Field(const Double_t* x, Double_t* b) const;

	// Define action at each step for Geane	// Define action at each step for Geane
	virtual void GeaneStepping() {;}	virtual void GeaneStepping() {;}

	private:	private:
	// static data members	// static data members

	static TVirtualMCApplication* fgInstance; // singleton instance	#if defined(__linux__) && !defined(__CINT__)
		static __thread TVirtualMCApplication* fgInstance; // singleton instance
		#else
		static TVirtualMCApplication* fgInstance; // singleton instance
		#endif

	ClassDef(TVirtualMCApplication,1) //Interface to MonteCarlo application	ClassDef(TVirtualMCApplication,1) //Interface to MonteCarlo application
	};	};

	inline void TVirtualMCApplication::Field(const Double_t* /x/, Double_t* b ) const {	inline void TVirtualMCApplication::Field(const Double_t* /x/, Double_t* b ) const {
	// No magnetic field	// No magnetic field
	b[0] = 0; b[1] = 0; b[2] = 0;	b[0] = 0; b[1] = 0; b[2] = 0;
	}	}

	#endif //ROOT_TVirtualMCApplication	#endif //ROOT_TVirtualMCApplication

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

	TXNetFile.h	TXNetFile.h

	// @(#)root/netx:$Id: TXNetFile.h 41550 2011-10-24 15:30:04Z rdm $	// @(#)root/netx:$Id: TXNetFile.h 43295 2012-03-08 15:01:08Z ganis $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TXNetFile	#ifndef ROOT_TXNetFile
	#define ROOT_TXNetFile	#define ROOT_TXNetFile

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

	#ifndef ROOT_TNetFile	#ifndef ROOT_TNetFile
	#include "TNetFile.h"	#include "TNetFile.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif
	#ifndef ROOT_TUrl	#ifndef ROOT_TUrl
	#include "TUrl.h"	#include "TUrl.h"
	#endif	#endif

	#ifndef ROOT_XrdSysToOuc
	#include "XrdSysToOuc.h"
	#endif

	class TFileStager;	class TFileStager;
	class TSocket;	class TSocket;
	class XrdClient;	class XrdClient;

	class XrdSysRecMutex;

	class TXNetFile : public TNetFile {	class TXNetFile : public TNetFile {

	friend class TXNetSystem;	friend class TXNetSystem;

	private:	private:
	// Members	// Members
	XrdClient *fClient; // Handle to the client object	XrdClient *fClient; // Handle to the client object
	Bool_t fIsRootd; // Nature of remote file server	Bool_t fIsRootd; // Nature of remote file server

	// Static members	// Static members
	static Bool_t fgInitDone; // Avoid initializing more than once	static Bool_t fgInitDone; // Avoid initializing more than once
	static Bool_t fgRootdBC; // Control rootd backward compatibility	static Bool_t fgRootdBC; // Control rootd backward compatibility
	static TFileStager *fgFileStager; // Stager for IsStaged checks	static TFileStager *fgFileStager; // Stager for IsStaged checks


	XrdSysRecMutex *fInitMtx; // Protects fInitDone, serializes the	void *fInitMtx; // Protects fInitDone, serializes the
	// attempts to Init() for this object on	// attempts to Init() for this object o
	ly	nly

	// Methods	// Methods
	TXNetFile(const TXNetFile&); // Not implemented	TXNetFile(const TXNetFile&); // Not implemented
	TXNetFile& operator=(const TXNetFile&); // Not implemented	TXNetFile& operator=(const TXNetFile&); // Not implemented
	void CreateXClient(const char url, Option_t option, Int_t netopt,	void CreateXClient(const char url, Option_t option, Int_t netopt,
	Bool_t parallelopen);	Bool_t parallelopen);

	Int_t ParseOptions(const char *opts, Int_t &cachesz, Int_t &readaheads z,	Int_t ParseOptions(const char *opts, Int_t &cachesz, Int_t &readaheads z,
	Int_t &rmpolicy, Int_t &mxredir, Int_t &rastrategy, Int_t &readtrimblksz);	Int_t &rmpolicy, Int_t &mxredir, Int_t &rastrategy, Int_t &readtrimblksz);


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

	TXNetSystem.h	TXNetSystem.h

	// @(#)root/netx:$Id: TXNetSystem.h 41574 2011-10-25 13:42:03Z ganis $	// @(#)root/netx:$Id: TXNetSystem.h 43295 2012-03-08 15:01:08Z ganis $
	// Author: Frank Winklmeier, Fabrizio Furano	// Author: Frank Winklmeier, Fabrizio Furano

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2005, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 40	skipping to change at line 40
	#endif	#endif

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

	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif


	#include "XrdProofdXrdVers.h"

	#if ROOTXRDVERS >= ROOT_OldXrdLocate
	#ifndef ROOT_THashList	#ifndef ROOT_THashList
	#include "THashList.h"	#include "THashList.h"
	#endif	#endif

	#endif

	#include "XrdOuc/XrdOucString.hh"	#include "XrdOuc/XrdOucString.hh"
	#include "XrdClient/XrdClientVector.hh"	#include "XrdClient/XrdClientVector.hh"

	class XrdClientAdmin;	class XrdClientAdmin;
	class TCollection;	class TCollection;
	class TXNetSystemConnectGuard;	class TXNetSystemConnectGuard;

	typedef XrdClientVector<XrdOucString> vecString;	typedef XrdClientVector<XrdOucString> vecString;
	typedef XrdClientVector<bool> vecBool;	typedef XrdClientVector<bool> vecBool;


	#if ROOTXRDVERS >= ROOT_OldXrdLocate
	class TXrdClientAdminWrapper : public TNamed {	class TXrdClientAdminWrapper : public TNamed {
	public:	public:
	TXrdClientAdminWrapper(const char key, XrdClientAdmin ca) : TNamed(key ,""), fXCA(ca) { }	TXrdClientAdminWrapper(const char key, XrdClientAdmin ca) : TNamed(key ,""), fXCA(ca) { }
	virtual ~TXrdClientAdminWrapper();	virtual ~TXrdClientAdminWrapper();
	XrdClientAdmin *fXCA;	XrdClientAdmin *fXCA;
	};	};

	#endif

	class TXNetSystem : public TNetSystem {	class TXNetSystem : public TNetSystem {

	friend class TXNetSystemConnectGuard;	friend class TXNetSystemConnectGuard;

	private:	private:
	Bool_t fIsRootd; // Nature of remote file server	Bool_t fIsRootd; // Nature of remote file server
	Bool_t fIsXRootd; // Nature of remote file server	Bool_t fIsXRootd; // Nature of remote file server
	TString fDir; // Current directory	TString fDir; // Current directory
	void *fDirp; // Directory pointer	void *fDirp; // Directory pointer

	skipping to change at line 88	skipping to change at line 82
	TString fDirEntry; // Last dir entry	TString fDirEntry; // Last dir entry
	TString fUrl; // Initial url	TString fUrl; // Initial url

	static Bool_t fgInitDone; // Avoid initializing more than once	static Bool_t fgInitDone; // Avoid initializing more than once
	static Bool_t fgRootdBC; // Control rootd backward compatibility	static Bool_t fgRootdBC; // Control rootd backward compatibility

	XrdClientAdmin Connect(const char url); // Connect to server	XrdClientAdmin Connect(const char url); // Connect to server
	void *GetDirPtr() const { return fDirp; }	void *GetDirPtr() const { return fDirp; }
	void InitXrdClient();	void InitXrdClient();


	#if ROOTXRDVERS >= ROOT_OldXrdLocate
	static THashList fgAddrFQDN; // Cross-table address<->FQDN	static THashList fgAddrFQDN; // Cross-table address<->FQDN
	static THashList fgAdminHash; // List of existing XrdClientAdmin	static THashList fgAdminHash; // List of existing XrdClientAdmin
	static XrdClientAdmin GetClientAdmin(const char url);	static XrdClientAdmin GetClientAdmin(const char url);
	static TString GetKey(const char *url);	static TString GetKey(const char *url);

	#endif

	public:	public:
	TXNetSystem(Bool_t owner = kTRUE);	TXNetSystem(Bool_t owner = kTRUE);
	TXNetSystem(const char *url, Bool_t owner = kTRUE);	TXNetSystem(const char *url, Bool_t owner = kTRUE);
	virtual ~TXNetSystem() { }	virtual ~TXNetSystem() { }

	Bool_t AccessPathName(const char *path, EAccessMode mode);	Bool_t AccessPathName(const char *path, EAccessMode mode);
	virtual Bool_t ConsistentWith(const char path, void dirptr);	virtual Bool_t ConsistentWith(const char path, void dirptr);
	virtual void FreeDirectory(void *dirp);	virtual void FreeDirectory(void *dirp);
	virtual const char GetDirEntry(void dirp);	virtual const char GetDirEntry(void dirp);

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

	TestStatistic.h	TestStatistic.h

	// @(#)root/roostats:$Id: TestStatistic.h 43199 2012-03-01 20:17:42Z moneta $	// @(#)root/roostats:$Id: TestStatistic.h 44157 2012-05-07 16:41:44Z moneta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_TestStatistic	#ifndef ROOSTATS_TestStatistic

	skipping to change at line 29	skipping to change at line 29
	distributions to the NeymanConstruction class. All the actual samplers inhe rit from this class.	distributions to the NeymanConstruction class. All the actual samplers inhe rit from this class.
	</p>	</p>
	END_HTML	END_HTML
	*/	*/
	//	//

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


		class RooArgSet;
		class RooAbsData;

	namespace RooStats {	namespace RooStats {

	class TestStatistic {	class TestStatistic {

	public:	public:
	//TestStatistic();	//TestStatistic();
	virtual ~TestStatistic() {	virtual ~TestStatistic() {
	}	}

	// Main interface to evaluate the test statistic on a dataset given t he	// Main interface to evaluate the test statistic on a dataset given t he
	// values for the Null Parameters Of Interest.	// values for the Null Parameters Of Interest.
	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullPOI) = 0;	virtual Double_t Evaluate(RooAbsData& data, RooArgSet& nullPOI) = 0;

	virtual const TString GetVarName() const = 0;	virtual const TString GetVarName() const = 0;

	// Defines the sign convention of the test statistic. Overwrite funct ion if necessary.	// Defines the sign convention of the test statistic. Overwrite funct ion if necessary.
	virtual bool PValueIsRightTail(void) const { return true; }	virtual bool PValueIsRightTail(void) const { return true; }


	// return detailed output: for fits this can be pulls, processing tim e, ...	// return detailed output: for fits this can be pulls, processing tim e, ... The returned pointer will not loose validity until another call to E valuate.
	virtual const RooArgSet* GetDetailedOutput() const { return NULL; }	virtual const RooArgSet* GetDetailedOutput() const { return NULL; }

	protected:	protected:
	ClassDef(TestStatistic,1) // Interface for a TestStatistic	ClassDef(TestStatistic,1) // Interface for a TestStatistic
	};	};

	} // end namespace RooStats	} // end namespace RooStats

	#endif	#endif

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

	ThreadLocalStorage.h	ThreadLocalStorage.h

	// @(#)root/thread:$Id: ThreadLocalStorage.h 43167 2012-02-29 09:02:00Z bru n $	// @(#)root/thread:$Id: ThreadLocalStorage.h 43319 2012-03-09 22:58:01Z rdm $
	/*	/*
	* Copyright (c) 2006-2011 High Performance Computing Center Stuttgart,	* Copyright (c) 2006-2011 High Performance Computing Center Stuttgart,
	* University of Stuttgart. All rights reserved.	* University of Stuttgart. All rights reserved.
	* Author: Rainer Keller, HLRS	* Author: Rainer Keller, HLRS
	* Modified: Fons Rademakers, CERN	* Modified: Fons Rademakers, CERN
	*	*
	* Thread-local storage (TLS) is not supported on all environments.	* Thread-local storage (TLS) is not supported on all environments.
	* This header file and test-program shows how to abstract away, using eith er	* This header file and test-program shows how to abstract away, using eith er
	* __thread,	* __thread,
	* __declspec(thread),	* __declspec(thread),

	skipping to change at line 47	skipping to change at line 47
	*/	*/

	#ifndef ROOT_ThreadLocalStorage	#ifndef ROOT_ThreadLocalStorage
	#define ROOT_ThreadLocalStorage	#define ROOT_ThreadLocalStorage

	#ifndef ROOT_RConfigure	#ifndef ROOT_RConfigure
	#include "RConfigure.h"	#include "RConfigure.h"
	#endif	#endif

	#if defined(R__MACOSX)	#if defined(R__MACOSX)

	# if defined(__clang__)	# if defined(__clang__) && defined(MAC_OS_X_VERSION_10_7) && defined(__x86 _64__)
	# define R__HAS___THREAD	# define R__HAS___THREAD
	# else	# else
	# define R__HAS_PTHREAD	# define R__HAS_PTHREAD
	# endif	# endif
	#endif	#endif
	#if defined(R__LINUX) \|\| defined(R__AIX)	#if defined(R__LINUX) \|\| defined(R__AIX)
	# define R__HAS___THREAD	# define R__HAS___THREAD
	#endif	#endif
	#if defined(R__SOLARIS)	#if defined(R__SOLARIS)
	# define R__HAS_PTHREAD	# define R__HAS_PTHREAD

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

	ToyMCStudy.h	ToyMCStudy.h

	// @(#)root/roostats:$Id: ToyMCStudy.h 43199 2012-03-01 20:17:42Z moneta $	// @(#)root/roostats:$Id: ToyMCStudy.h 44157 2012-05-07 16:41:44Z moneta $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_ToyMCStudy	#ifndef ROOSTATS_ToyMCStudy
	#define ROOSTATS_ToyMCStudy	#define ROOSTATS_ToyMCStudy

	skipping to change at line 88	skipping to change at line 88
	ClassDef(ToyMCStudy,1); // toy MC study for parallel processing	ClassDef(ToyMCStudy,1); // toy MC study for parallel processing

	};	};

	class ToyMCPayload : public TNamed {	class ToyMCPayload : public TNamed {

	public:	public:

	ToyMCPayload() {	ToyMCPayload() {
	// proof constructor, do not use	// proof constructor, do not use

		fDataSet = NULL;
	}	}

	ToyMCPayload(RooDataSet* sd)	ToyMCPayload(RooDataSet* sd)
	{	{
	fDataSet = sd;	fDataSet = sd;
	}	}

	virtual ~ToyMCPayload() {	virtual ~ToyMCPayload() {
	}	}


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

	TypeBase.h	TypeBase.h

	// @(#)root/reflex:$Id: TypeBase.h 32228 2010-02-05 16:13:09Z axel $	// @(#)root/reflex:$Id: TypeBase.h 44084 2012-05-03 09:55:25Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 37	skipping to change at line 37
	class TypeName;	class TypeName;
	class DictionaryGenerator;	class DictionaryGenerator;

	/**	/**
	* @class TypeBase TypeBase.h Reflex/TypeBase.h	* @class TypeBase TypeBase.h Reflex/TypeBase.h
	* @author Stefan Roiser	* @author Stefan Roiser
	* @date 24/11/2003	* @date 24/11/2003
	* @ingroup Ref	* @ingroup Ref
	*/	*/
	class RFLX_API TypeBase {	class RFLX_API TypeBase {

		private:
		TypeBase(const TypeBase&); // not implemented
		TypeBase& operator=(const TypeBase&); // not implemented
	public:	public:
	/** default constructor */	/** default constructor */
	TypeBase(const char* nam,	TypeBase(const char* nam,
	size_t size,	size_t size,
	TYPE typeTyp,	TYPE typeTyp,
	const std::type_info & ti,	const std::type_info & ti,
	const Type& finalType = Dummy::Type(),	const Type& finalType = Dummy::Type(),
	REPRESTYPE represType = REPRES_NOTYPE);	REPRESTYPE represType = REPRES_NOTYPE);

	/** destructor */	/** destructor */

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

	TypeTemplate.h	TypeTemplate.h

	// @(#)root/reflex:$Id: TypeTemplate.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: TypeTemplate.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Stefan Roiser 2004	// Author: Stefan Roiser 2004

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


	skipping to change at line 40	skipping to change at line 40
	public:	public:
	/** default constructor */	/** default constructor */
	TypeTemplate(const TypeTemplateName * typeTemplateName = 0);	TypeTemplate(const TypeTemplateName * typeTemplateName = 0);

	/** copy constructor */	/** copy constructor */
	TypeTemplate(const TypeTemplate &rh);	TypeTemplate(const TypeTemplate &rh);

	/** destructor */	/** destructor */
	~TypeTemplate();	~TypeTemplate();


		/** assignment op */
		TypeTemplate& operator=(const TypeTemplate &rh);

	/**	/**
	* operator bool will return true if the type template is resolved	* operator bool will return true if the type template is resolved
	* @return true if type template is resolved	* @return true if type template is resolved
	*/	*/
	operator bool() const;	operator bool() const;

	/**	/**
	* operator == will return true if two type templates are the same	* operator == will return true if two type templates are the same
	* @return true if type templates match	* @return true if type templates match
	*/	*/

	skipping to change at line 267	skipping to change at line 270
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::TypeTemplate::~TypeTemplate() {	inline Reflex::TypeTemplate::~TypeTemplate() {
	}	}

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

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline	inline

		Reflex::TypeTemplate&
		Reflex::TypeTemplate::operator=(const TypeTemplate& rh) {
		//-------------------------------------------------------------------------
		------
		if (&rh != this) {
		fTypeTemplateName = rh.fTypeTemplateName;
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
		inline
	Reflex::TypeTemplate::operator bool() const {	Reflex::TypeTemplate::operator bool() const {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	if (this->fTypeTemplateName && this->fTypeTemplateName->fTypeTemplateImp l) {	if (this->fTypeTemplateName && this->fTypeTemplateName->fTypeTemplateImp l) {
	return true;	return true;
	}	}
	return false;	return false;
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline bool	inline bool

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

	ValueObject.h	ValueObject.h

	// @(#)root/reflex:$Id: ValueObject.h 29288 2009-07-01 13:03:35Z axel $	// @(#)root/reflex:$Id: ValueObject.h 44094 2012-05-03 14:50:12Z axel $
	// Author: Pere Mato 2006	// Author: Pere Mato 2006

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


	skipping to change at line 42	skipping to change at line 42
	/** constructor */	/** constructor */
	template <typename T>	template <typename T>
	static ValueObject Create(const T& v);	static ValueObject Create(const T& v);

	/** constructor */	/** constructor */
	ValueObject(const ValueObject &o);	ValueObject(const ValueObject &o);

	/** destructor */	/** destructor */
	~ValueObject();	~ValueObject();


		/** assignment op */
		ValueObject& operator=(const ValueObject &o);

	/** get the actual value */	/** get the actual value */
	template <typename T> const T& Value();	template <typename T> const T& Value();

	template <typename T> ValueObject& Assign(const T&);	template <typename T> ValueObject& Assign(const T&);

	private:	private:
	/** the value of the generic object by value */	/** the value of the generic object by value */
	Any fValue;	Any fValue;

	}; // class ValueObject	}; // class ValueObject

	skipping to change at line 99	skipping to change at line 102
	} else { fAddress = fValue.Address(); }	} else { fAddress = fValue.Address(); }
	return *this;	return *this;
	}	}

	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	inline Reflex::ValueObject::~ValueObject() {	inline Reflex::ValueObject::~ValueObject() {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	}	}

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

		inline
		Reflex::ValueObject&
		Reflex::ValueObject::operator=(const ValueObject& o) {
		//-------------------------------------------------------------------------
		------
		if (&o != this) {
		Object::operator=(Object(o.TypeOf(), 0));
		fValue = o.fValue;
		if (TypeOf().IsPointer()) {
		fAddress = (void*) fValue.Address();
		} else { fAddress = fValue.Address(); }
		}
		return *this;
		}

		//-------------------------------------------------------------------------
		------
	template <typename T>	template <typename T>
	inline const T&	inline const T&
	Reflex::ValueObject::Value() {	Reflex::ValueObject::Value() {
	//------------------------------------------------------------------------- ------	//------------------------------------------------------------------------- ------
	return (T) fAddress;	return (T) fAddress;
	}	}

	#endif // Reflex_ValueObject	#endif // Reflex_ValueObject

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

	Version.h	Version.h

	// @(#)root/tmva $Id: Version.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: Version.h 44118 2012-05-04 12:29:18Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Jan Therhaag, Eckhard von Toerne, Helge Voss	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Jan Therhaag, Eckhard von Toerne, Helge Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Version *	* Class : Version *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Current TMVA Version - filled automatically during cvs tagging *	* Current TMVA Version - filled automatically during cvs tagging *

	skipping to change at line 44	skipping to change at line 44
	#define ROOT_TMVA_Version	#define ROOT_TMVA_Version

	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////
	// //	// //
	// Version //	// Version //
	// //	// //
	// Automatically filled by cvs tagger: development/tmvaTag.py //	// Automatically filled by cvs tagger: development/tmvaTag.py //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////


	#define TMVA_RELEASE "4.1.2"	#define TMVA_RELEASE "4.1.3"
	#define TMVA_RELEASE_DATE "Jun 21, 2011"	#define TMVA_RELEASE_DATE "May 04, 2012"
	#define TMVA_RELEASE_TIME "11:02:58"	#define TMVA_RELEASE_TIME "15:00:00"
	#define TMVA_VERSION_CODE 262402	#define TMVA_VERSION_CODE 262403
	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

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

	compiledata.h	compiledata.h
	/* This is file is automatically generated */	/* This is file is automatically generated */
	#define BUILD_ARCH "linux"	#define BUILD_ARCH "linux"
	#define BUILD_NODE "Linux lxbuild147.cern.ch 2.6.18-194.26.1.el5 #1 SMP Wed Nov 10 09:51:11 CET 2010 i686 i686 i386 GNU/Linux"	#define BUILD_NODE "Linux lxbuild147.cern.ch 2.6.18-194.26.1.el5 #1 SMP Wed Nov 10 09:51:11 CET 2010 i686 i686 i386 GNU/Linux"
	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.5/i686-slc5-gcc43-opt /bin/g++"	#define COMPILER "/afs/cern.ch/sw/lcg/contrib/gcc/4.3.5/i686-slc5-gcc43-opt /bin/g++"
	#define COMPILERVERS "gcc435"	#define COMPILERVERS "gcc435"

	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov	#define MAKESHAREDLIB "cd $BuildDir ; g++ -c $Opt -pipe -m32 -Wall -W -Wov
	erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile	erloaded-virtual -fPIC -pthread $IncludePath $SourceFiles ; g++ $ObjectFile
	s -shared -Wl,-soname,$LibName.so -m32 -O2 -Wl,--no-undefined $LinkedLibs	s -shared -Wl,-soname,$LibName.so -m32 -O2 -Wl,--no-undefined -Wl,--as-nee
	-o $SharedLib"	ded $LinkedLibs -o $SharedLib"
	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi	#define MAKEEXE "cd $BuildDir ; g++ -c -pipe -m32 -Wall -W -Woverloaded-vi
	rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2	rtual -fPIC -pthread $IncludePath $SourceFiles; g++ $ObjectFiles -m32 -O2
	-Wl,--no-undefined -o $ExeName $LinkedLibs -lm -ldl -pthread -rdynamic"	-Wl,--no-undefined -Wl,--as-needed -o $ExeName $LinkedLibs -lm -ldl -pthre
		ad -rdynamic"
	#define CXXOPT "-O2"	#define CXXOPT "-O2"
	#define CXXDEBUG "-g"	#define CXXDEBUG "-g"
	#define ROOTBUILD ""	#define ROOTBUILD ""
	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lRint "	#define LINKEDLIBS "-L$ROOTSYS/lib -lCore -lCint -lRint "
	#define INCLUDEPATH "-I$ROOTSYS/include"	#define INCLUDEPATH "-I$ROOTSYS/include"
	#define OBJEXT "o"	#define OBJEXT "o"
	#define SOEXT "so"	#define SOEXT "so"

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

	mmconfig.h	mmconfig.h

	/* @(#)root/clib:$Id: mmconfig.h 20882 2007-11-19 11:31:26Z rdm $ */	/* @(#)root/clib:$Id: mmconfig.h 43709 2012-04-12 11:04:01Z rdm $ */

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef MMCONFIG_H	#ifndef MMCONFIG_H

	skipping to change at line 31	skipping to change at line 31
	# endif	# endif
	#endif	#endif

	#if defined(R__UNIX)	#if defined(R__UNIX)
	# define R__HAVE_UNISTD_H	# define R__HAVE_UNISTD_H
	# define R__HAVE_STDLIB_H	# define R__HAVE_STDLIB_H
	# define R__HAVE_STDDEF_H	# define R__HAVE_STDDEF_H
	# define R__HAVE_LIMITS_H	# define R__HAVE_LIMITS_H
	# define R__HAVE_MMAP	# define R__HAVE_MMAP
	# define NO_SBRK_MALLOC	# define NO_SBRK_MALLOC

	#elif defined (R__VMS)
	# define R__HAVE_UNISTD_H
	# define R__HAVE_STDLIB_H
	# define R__HAVE_STDDEF_H
	# define NO_SBRK_MALLOC
	#else	#else
	# define R__HAVE_STDDEF_H	# define R__HAVE_STDDEF_H
	# define R__HAVE_LIMITS_H	# define R__HAVE_LIMITS_H
	# define R__HAVE_MMAP	# define R__HAVE_MMAP
	# define NO_SBRK_MALLOC	# define NO_SBRK_MALLOC
	#endif	#endif

	#endif	#endif

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

	rpdconn.h	rpdconn.h

	// @(#)root/rpdutils:$Id: rpdconn.h 39179 2011-05-13 11:09:21Z ganis $	// @(#)root/rpdutils:$Id: rpdconn.h 44103 2012-05-03 23:11:44Z ganis $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_rpdconn	#ifndef ROOT_rpdconn
	#define ROOT_rpdconn	#define ROOT_rpdconn

	skipping to change at line 148	skipping to change at line 148
	//	//
	// Class describing a TCP connection	// Class describing a TCP connection
	//	//
	class rpdtcp : public rpdconn {	class rpdtcp : public rpdconn {
	protected:	protected:
	std::string host; // Host name	std::string host; // Host name
	int port; // Port	int port; // Port
	int fd; // Socket descriptor	int fd; // Socket descriptor
	struct sockaddr addr; // Structure describing the peer address	struct sockaddr addr; // Structure describing the peer address
	public:	public:

	rpdtcp(int d = -1) : rpdconn(), port(0), fd(d) { setdescriptors(d,d); }	rpdtcp(int d = -1) : rpdconn(), port(0), fd(d) { memset(&addr, 0, sizeof
	// Used by rpdtcpsrv	(addr));
		setdescriptors(d,d); }
		// Used by rpdtcpsrv
	rpdtcp(const char *h, int p);	rpdtcp(const char *h, int p);
	virtual ~rpdtcp() { close(); }	virtual ~rpdtcp() { close(); }

	void close() { if (fd > 0) ::close(fd); fd = -1; setdescriptors(); }	void close() { if (fd > 0) ::close(fd); fd = -1; setdescriptors(); }
	int exportfd() { int d = fd; fd = -1; setdescriptors(); return d; }	int exportfd() { int d = fd; fd = -1; setdescriptors(); return d; }
	const struct sockaddr address() const { return (const struct sockaddr )&addr; }	const struct sockaddr address() const { return (const struct sockaddr )&addr; }
	};	};

	//	//
	// Class describing a server TCP connection	// Class describing a server TCP connection

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

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	BinarySearchTree.h	BinarySearchTree.h

	// @(#)root/tmva $Id: BinarySearchTree.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: BinarySearchTree.h 44112 2012-05-04 10:00:41Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : BinarySearchTree *	* Class : BinarySearchTree *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* BinarySearchTree incl. volume Search method *	* BinarySearchTree incl. volume Search method *

	skipping to change at line 122	skipping to change at line 122
	// Create the search tree from the event collection	// Create the search tree from the event collection
	// using ONLY the variables specified in "theVars"	// using ONLY the variables specified in "theVars"
	Double_t Fill( const std::vector<TMVA::Event*>& events, const std::ve ctor<Int_t>& theVars, Int_t theType = -1 );	Double_t Fill( const std::vector<TMVA::Event*>& events, const std::ve ctor<Int_t>& theVars, Int_t theType = -1 );

	// create the search tree from the events in a TTree	// create the search tree from the events in a TTree
	// using ALL the variables specified included in the Event	// using ALL the variables specified included in the Event
	Double_t Fill( const std::vector<TMVA::Event*>& events, Int_t theType = -1 );	Double_t Fill( const std::vector<TMVA::Event*>& events, Int_t theType = -1 );

	void NormalizeTree ();	void NormalizeTree ();


	void CalcStatistics( TMVA::Node* n = 0, Int_t signalClass=0 );	void CalcStatistics( TMVA::Node* n = 0 );
	void Clear ( TMVA::Node* n = 0 );	void Clear ( TMVA::Node* n = 0 );

	// access to mean for signal and background for each variable	// access to mean for signal and background for each variable
	Float_t Mean(Types::ESBType sb, UInt_t var ) { return fMeans[sb==Type s::kSignal?0:1][var]; }	Float_t Mean(Types::ESBType sb, UInt_t var ) { return fMeans[sb==Type s::kSignal?0:1][var]; }

	// access to RMS for signal and background for each variable	// access to RMS for signal and background for each variable
	Float_t RMS(Types::ESBType sb, UInt_t var ) { return fRMS[sb==Types:: kSignal?0:1][var]; }	Float_t RMS(Types::ESBType sb, UInt_t var ) { return fRMS[sb==Types:: kSignal?0:1][var]; }

	// access to Minimum for signal and background for each variable	// access to Minimum for signal and background for each variable
	Float_t Min(Types::ESBType sb, UInt_t var ) { return fMin[sb==Types:: kSignal?0:1][var]; }	Float_t Min(Types::ESBType sb, UInt_t var ) { return fMin[sb==Types:: kSignal?0:1][var]; }

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

	ConfidenceBelt.h	ConfidenceBelt.h

	// @(#)root/roostats:$Id: ConfidenceBelt.h 39391 2011-05-26 09:51:59Z monet a $	// @(#)root/roostats:$Id: ConfidenceBelt.h 44077 2012-05-02 17:10:21Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef RooStats_ConfidenceBelt	#ifndef RooStats_ConfidenceBelt

	skipping to change at line 31	skipping to change at line 31
	#include "RooStats/ConfInterval.h"	#include "RooStats/ConfInterval.h"
	#endif	#endif

	#include "RooStats/SamplingDistribution.h"	#include "RooStats/SamplingDistribution.h"

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

	#include <vector>	#include <vector>
	#include <map>	#include <map>


	using namespace std;

	namespace RooStats {	namespace RooStats {

	///////////////////////////	///////////////////////////
	class SamplingSummaryLookup : public TObject {	class SamplingSummaryLookup : public TObject {


	typedef pair<Double_t, Double_t> AcceptanceCriteria; // defined by Conf	typedef std::pair<Double_t, Double_t> AcceptanceCriteria; // defined b
	idence level, leftside tail probability	y Confidence level, leftside tail probability
	typedef map<Int_t, AcceptanceCriteria> LookupTable; // map ( Index, ( C	typedef std::map<Int_t, AcceptanceCriteria> LookupTable; // map ( Inde
	L, leftside tail prob) )	x, ( CL, leftside tail prob) )

	public:	public:
	SamplingSummaryLookup() {}	SamplingSummaryLookup() {}
	virtual ~SamplingSummaryLookup() {}	virtual ~SamplingSummaryLookup() {}

	void Add(Double_t cl, Double_t leftside){	void Add(Double_t cl, Double_t leftside){
	// add cl,leftside pair to lookup table	// add cl,leftside pair to lookup table
	AcceptanceCriteria tmp(cl, leftside);	AcceptanceCriteria tmp(cl, leftside);

	// should check to see if this is already in the map	// should check to see if this is already in the map
	if(GetLookupIndex(cl,leftside) >=0 ){	if(GetLookupIndex(cl,leftside) >=0 ){

	cout<< "SamplingSummaryLookup::Add, already in lookup table" << endl ;	std::cout<< "SamplingSummaryLookup::Add, already in lookup table" << std::endl;
	} else	} else
	fLookupTable[fLookupTable.size()]= tmp;	fLookupTable[fLookupTable.size()]= tmp;
	}	}

	Int_t GetLookupIndex(Double_t cl, Double_t leftside){	Int_t GetLookupIndex(Double_t cl, Double_t leftside){
	// get index for cl,leftside pair	// get index for cl,leftside pair
	AcceptanceCriteria tmp(cl, leftside);	AcceptanceCriteria tmp(cl, leftside);

	Double_t tolerance = 1E-6; // some small number to protect floating p oint comparison. What is better way?	Double_t tolerance = 1E-6; // some small number to protect floating p oint comparison. What is better way?
	LookupTable::iterator it = fLookupTable.begin();	LookupTable::iterator it = fLookupTable.begin();

	skipping to change at line 79	skipping to change at line 77

	// check that it was found	// check that it was found
	if(index == (Int_t)fLookupTable.size())	if(index == (Int_t)fLookupTable.size())
	index = -1;	index = -1;

	return index;	return index;
	}	}

	Double_t GetConfidenceLevel(Int_t index){	Double_t GetConfidenceLevel(Int_t index){
	if(index<0 \|\| index>(Int_t)fLookupTable.size()) {	if(index<0 \|\| index>(Int_t)fLookupTable.size()) {

	cout << "SamplingSummaryLookup::GetConfidenceLevel, index not in look	std::cout << "SamplingSummaryLookup::GetConfidenceLevel, index not i
	up table" << endl;	n lookup table" << std::endl;
	return -1;	return -1;
	}	}
	return fLookupTable[index].first;	return fLookupTable[index].first;
	}	}

	Double_t GetLeftSideTailFraction(Int_t index){	Double_t GetLeftSideTailFraction(Int_t index){
	if(index<0 \|\| index>(Int_t)fLookupTable.size()) {	if(index<0 \|\| index>(Int_t)fLookupTable.size()) {

	cout << "SamplingSummaryLookup::GetLeftSideTailFraction, index not in	std::cout << "SamplingSummaryLookup::GetLeftSideTailFraction, index
	lookup table" << endl;	not in lookup table" << std::endl;
	return -1;	return -1;
	}	}
	return fLookupTable[index].second;	return fLookupTable[index].second;
	}	}

	private:	private:
	LookupTable fLookupTable; // map ( Index, ( CL, leftside tail prob) )	LookupTable fLookupTable; // map ( Index, ( CL, leftside tail prob) )

	protected:	protected:
	ClassDef(SamplingSummaryLookup,1) // A simple class used by Confidence Belt	ClassDef(SamplingSummaryLookup,1) // A simple class used by Confidence Belt
	};	};

	skipping to change at line 149	skipping to change at line 147
	void AddAcceptanceRegion(AcceptanceRegion& ar){	void AddAcceptanceRegion(AcceptanceRegion& ar){
	Int_t index = ar.GetLookupIndex();	Int_t index = ar.GetLookupIndex();
	if( fAcceptanceRegions.count(index) !=0) {	if( fAcceptanceRegions.count(index) !=0) {
	std::cout << "SamplingSummary::AddAcceptanceRegion, need to implemen t merging protocol" << std::endl;	std::cout << "SamplingSummary::AddAcceptanceRegion, need to implemen t merging protocol" << std::endl;
	} else {	} else {
	fAcceptanceRegions[index]=ar;	fAcceptanceRegions[index]=ar;
	}	}
	}	}

	private:	private:

	Int_t fParameterPointIndex; // want a small footprint reference to the	Int_t fParameterPointIndex; // want a small footprint reference to the
	RooArgSet for particular parameter point	RooArgSet for particular parameter point
	TRef fSamplingDistribution; // persistent pointer to a SamplingDistribu	TRef fSamplingDistribution; // persistent pointer to a SamplingDistrib
	tion	ution
	map<Int_t, AcceptanceRegion> fAcceptanceRegions;	std::map<Int_t, AcceptanceRegion> fAcceptanceRegions;

	protected:	protected:
	ClassDef(SamplingSummary,1) // A summary of acceptance regions for con fidence belt	ClassDef(SamplingSummary,1) // A summary of acceptance regions for con fidence belt

	};	};

	/////////////////////////////////////////	/////////////////////////////////////////
	class ConfidenceBelt : public TNamed {	class ConfidenceBelt : public TNamed {

	private:	private:
	SamplingSummaryLookup fSamplingSummaryLookup;	SamplingSummaryLookup fSamplingSummaryLookup;

	vector<SamplingSummary> fSamplingSummaries; // composite of several Acc eptanceRegions	std::vector<SamplingSummary> fSamplingSummaries; // composite of severa l AcceptanceRegions
	RooAbsData* fParameterPoints; // either a histogram (RooDataHist) or a tree (RooDataSet)	RooAbsData* fParameterPoints; // either a histogram (RooDataHist) or a tree (RooDataSet)

	public:	public:
	// constructors,destructors	// constructors,destructors
	ConfidenceBelt();	ConfidenceBelt();
	ConfidenceBelt(const char* name);	ConfidenceBelt(const char* name);
	ConfidenceBelt(const char* name, const char* title);	ConfidenceBelt(const char* name, const char* title);
	ConfidenceBelt(const char* name, RooAbsData&);	ConfidenceBelt(const char* name, RooAbsData&);
	ConfidenceBelt(const char* name, const char* title, RooAbsData&);	ConfidenceBelt(const char* name, const char* title, RooAbsData&);
	virtual ~ConfidenceBelt();	virtual ~ConfidenceBelt();

	// add after creating a region	// add after creating a region
	void AddAcceptanceRegion(RooArgSet&, AcceptanceRegion region, Double_t cl=-1., Double_t leftside=-1.);	void AddAcceptanceRegion(RooArgSet&, AcceptanceRegion region, Double_t cl=-1., Double_t leftside=-1.);

	// add without creating a region, more useful for clients	// add without creating a region, more useful for clients
	void AddAcceptanceRegion(RooArgSet& point, Int_t dataSetIndex, Double_t lower, Double_t upper, Double_t cl=-1., Double_t leftside=-1.);	void AddAcceptanceRegion(RooArgSet& point, Int_t dataSetIndex, Double_t lower, Double_t upper, Double_t cl=-1., Double_t leftside=-1.);

	AcceptanceRegion* GetAcceptanceRegion(RooArgSet&, Double_t cl=-1., Doub le_t leftside=-1.);	AcceptanceRegion* GetAcceptanceRegion(RooArgSet&, Double_t cl=-1., Doub le_t leftside=-1.);
	Double_t GetAcceptanceRegionMin(RooArgSet&, Double_t cl=-1., Double_t l eftside=-1.);	Double_t GetAcceptanceRegionMin(RooArgSet&, Double_t cl=-1., Double_t l eftside=-1.);
	Double_t GetAcceptanceRegionMax(RooArgSet&, Double_t cl=-1., Double_t l eftside=-1.);	Double_t GetAcceptanceRegionMax(RooArgSet&, Double_t cl=-1., Double_t l eftside=-1.);

	vector<Double_t> ConfidenceLevels() const ;	std::vector<Double_t> ConfidenceLevels() const ;

	// Method to return lower limit on a given parameter	// Method to return lower limit on a given parameter
	// Double_t LowerLimit(RooRealVar& param) ; // could provide, but misl eading?	// Double_t LowerLimit(RooRealVar& param) ; // could provide, but misl eading?
	// Double_t UpperLimit(RooRealVar& param) ; // could provide, but misleading?	// Double_t UpperLimit(RooRealVar& param) ; // could provide, but misleading?

	// do we want it to return list of parameters	// do we want it to return list of parameters
	virtual RooArgSet* GetParameters() const;	virtual RooArgSet* GetParameters() const;

	// check if parameters are correct. (dummy implementation to start)	// check if parameters are correct. (dummy implementation to start)
	Bool_t CheckParameters(RooArgSet&) const ;	Bool_t CheckParameters(RooArgSet&) const ;

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

	DebuggingSampler.h	DebuggingSampler.h

	// @(#)root/roostats:$Id: DebuggingSampler.h 39391 2011-05-26 09:51:59Z mon eta $	// @(#)root/roostats:$Id: DebuggingSampler.h 44376 2012-05-30 21:47:29Z mon eta $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_DebuggingSampler	#ifndef ROOSTATS_DebuggingSampler

	skipping to change at line 73	skipping to change at line 73
	// Main interface to evaluate the test statistic on a dataset	// Main interface to evaluate the test statistic on a dataset
	virtual Double_t EvaluateTestStatistic(RooAbsData& /data/, RooArgSet & /paramsOfInterest/) {	virtual Double_t EvaluateTestStatistic(RooAbsData& /data/, RooArgSet & /paramsOfInterest/) {
	// data = data; // avoid warning	// data = data; // avoid warning
	// paramsOfInterest = paramsOfInterest; // avoid warning	// paramsOfInterest = paramsOfInterest; // avoid warning
	return fRand->Uniform();	return fRand->Uniform();
	}	}

	// Get the TestStatistic	// Get the TestStatistic
	virtual TestStatistic* GetTestStatistic() const {	virtual TestStatistic* GetTestStatistic() const {
	// TODO change to Roo... notifications	// TODO change to Roo... notifications

	cout << "GetTestStatistic() IS NOT IMPLEMENTED FOR THIS SAMPLER. R eturning NULL." << endl;	std::cout << "GetTestStatistic() IS NOT IMPLEMENTED FOR THIS SAMPL ER. Returning NULL." << std::endl;
	return NULL; /fTestStatistic;/	return NULL; /fTestStatistic;/
	}	}

	// Get the Confidence level for the test	// Get the Confidence level for the test
	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}

	// Common Initialization	// Common Initialization
	virtual void Initialize(RooAbsArg& /* testStatistic /, RooArgSet& / paramsOfInterest /, RooArgSet& / nuisanceParameters */ ) {	virtual void Initialize(RooAbsArg& /* testStatistic /, RooArgSet& / paramsOfInterest /, RooArgSet& / nuisanceParameters */ ) {
	}	}


	skipping to change at line 104	skipping to change at line 104
	virtual void SetGlobalObservables(const RooArgSet& ) {}	virtual void SetGlobalObservables(const RooArgSet& ) {}

	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)
	virtual void SetTestSize(Double_t size) {fSize = size;}	virtual void SetTestSize(Double_t size) {fSize = size;}
	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)
	virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl;}	virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl;}

	// Set the TestStatistic (want the argument to be a function of the d ata & parameter points	// Set the TestStatistic (want the argument to be a function of the d ata & parameter points
	virtual void SetTestStatistic(TestStatistic* /testStatistic/) {	virtual void SetTestStatistic(TestStatistic* /testStatistic/) {
	// TODO change to Roo... notifications	// TODO change to Roo... notifications

	cout << "SetTestStatistic(...) IS NOT IMPLEMENTED FOR THIS SAMPLER " << endl;	std::cout << "SetTestStatistic(...) IS NOT IMPLEMENTED FOR THIS SA MPLER" << std::endl;
	}	}

	private:	private:
	Double_t fSize;	Double_t fSize;
	RooRealVar* fTestStatistic;	RooRealVar* fTestStatistic;
	TRandom* fRand;	TRandom* fRand;

	protected:	protected:
	ClassDef(DebuggingSampler,1) // A simple implementation of the Dist ributionCreator interface	ClassDef(DebuggingSampler,1) // A simple implementation of the Dist ributionCreator interface
	};	};

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

	DistSamplerOptions.h	DistSamplerOptions.h

	// @(#)root/mathcore:$Id: DistSamplerOptions.h 37419 2010-12-08 21:19:45Z m oneta $	// @(#)root/mathcore:$Id: DistSamplerOptions.h 44131 2012-05-05 10:22:05Z m oneta $
	// Author: L. Moneta Fri Aug 15 2008	// Author: L. Moneta Fri Aug 15 2008

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

	#ifndef ROOT_Math_DistSamplerOptions	#ifndef ROOT_Math_DistSamplerOptions

	skipping to change at line 53	skipping to change at line 53
	static const std::string & DefaultAlgorithmND();	static const std::string & DefaultAlgorithmND();
	static int DefaultPrintLevel();	static int DefaultPrintLevel();

	/// retrieve extra options - if not existing create a IOptions	/// retrieve extra options - if not existing create a IOptions
	static ROOT::Math::IOptions & Default(const char * name);	static ROOT::Math::IOptions & Default(const char * name);

	// find extra options - return 0 if not existing	// find extra options - return 0 if not existing
	static ROOT::Math::IOptions * FindDefault(const char * name);	static ROOT::Math::IOptions * FindDefault(const char * name);

	/// print all the default options for the name given	/// print all the default options for the name given

	static void PrintDefault(const char * name = 0, std::ostream & os = std: :cout);	static void PrintDefault(const char * name, std::ostream & os = std::cou t);

	public:	public:

	// constructor using the default options	// constructor using the default options
	// pass optionally a pointer to the additional options	// pass optionally a pointer to the additional options
	// otherwise look if they exist for this default minimizer	// otherwise look if they exist for this default minimizer
	// and in that case they are copied in the constructed instance	// and in that case they are copied in the constructed instance
	// constructor takes dimension since a different default algorithm	// constructor takes dimension since a different default algorithm
	// is used if the dimension is 1 or greater than 1	// is used if the dimension is 1 or greater than 1
	DistSamplerOptions(int dim = 0);	DistSamplerOptions(int dim = 0);

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

	FeldmanCousins.h	FeldmanCousins.h

	// @(#)root/roostats:$Id: FeldmanCousins.h 39391 2011-05-26 09:51:59Z monet a $	// @(#)root/roostats:$Id: FeldmanCousins.h 44368 2012-05-30 15:38:44Z axel $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_FeldmanCousins	#ifndef ROOSTATS_FeldmanCousins

	skipping to change at line 57	skipping to change at line 57

	// Main interface to get a ConfInterval (will be a PointSetInterval)	// Main interface to get a ConfInterval (will be a PointSetInterval)
	virtual PointSetInterval* GetInterval() const;	virtual PointSetInterval* GetInterval() const;

	// Get the size of the test (eg. rate of Type I error)	// Get the size of the test (eg. rate of Type I error)
	virtual Double_t Size() const {return fSize;}	virtual Double_t Size() const {return fSize;}
	// Get the Confidence level for the test	// Get the Confidence level for the test
	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}
	// Set the DataSet	// Set the DataSet
	virtual void SetData(RooAbsData& /data/) {	virtual void SetData(RooAbsData& /data/) {

	cout << "DEPRECATED, set data in constructor" << endl;	std::cout << "DEPRECATED, set data in constructor" << std::endl;
	}	}
	// Set the Pdf	// Set the Pdf
	virtual void SetPdf(RooAbsPdf& /pdf/) {	virtual void SetPdf(RooAbsPdf& /pdf/) {

	cout << "DEPRECATED, use ModelConfig" << endl;	std::cout << "DEPRECATED, use ModelConfig" << std::endl;
	}	}

	// specify the parameters of interest in the interval	// specify the parameters of interest in the interval
	virtual void SetParameters(const RooArgSet& /set/) {	virtual void SetParameters(const RooArgSet& /set/) {

	cout << "DEPRECATED, use ModelConfig" << endl;	std::cout << "DEPRECATED, use ModelConfig" << std::endl;
	}	}

	// specify the nuisance parameters (eg. the rest of the parameters)	// specify the nuisance parameters (eg. the rest of the parameters)
	virtual void SetNuisanceParameters(const RooArgSet& /set/) {	virtual void SetNuisanceParameters(const RooArgSet& /set/) {

	cout << "DEPRECATED, use ModelConfig" << endl;	std::cout << "DEPRECATED, use ModelConfig" << std::endl;
	}	}

	// User-defined set of points to test	// User-defined set of points to test
	void SetParameterPointsToTest(RooAbsData& pointsToTest) {	void SetParameterPointsToTest(RooAbsData& pointsToTest) {
	fPointsToTest = &pointsToTest;	fPointsToTest = &pointsToTest;
	}	}

	// User-defined set of points to test	// User-defined set of points to test
	void SetPOIPointsToTest(RooAbsData& poiToTest) {	void SetPOIPointsToTest(RooAbsData& poiToTest) {
	fPOIToTest = &poiToTest;	fPOIToTest = &poiToTest;

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

	Functor.h	Functor.h

	// @(#)root/mathcore:$Id: Functor.h 33180 2010-04-25 10:14:07Z moneta $	// @(#)root/mathcore:$Id: Functor.h 43272 2012-03-07 08:06:40Z moneta $
	// Author: L. Moneta Mon Nov 13 15:58:13 2006	// Author: L. Moneta Mon Nov 13 15:58:13 2006

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

	// Heaer file for Functor classes.	// Heaer file for Functor classes.

	skipping to change at line 318	skipping to change at line 318
	};	};
	#endif	#endif

	//_________________________________________________________________________ ______________________	//_________________________________________________________________________ ______________________
	/**	/**
	Documentation for class Functor class.	Documentation for class Functor class.
	It is used to wrap in a very simple and convenient way multi-dimensional function objects.	It is used to wrap in a very simple and convenient way multi-dimensional function objects.
	It can wrap all the following types:	It can wrap all the following types:
	<ul>	<ul>
	<li> any C++ callable object implemention double operator()( const doubl e * )	<li> any C++ callable object implemention double operator()( const doubl e * )

	<li> a free C function of type double ()(double * )	<li> a free C function of type double ()(const double * )
	<li> a member function with the correct signature like Foo::Eval(const d ouble * ).	<li> a member function with the correct signature like Foo::Eval(const d ouble * ).
	In this case one pass the object pointer and a pointer to the member function (&Foo::Eval)	In this case one pass the object pointer and a pointer to the member function (&Foo::Eval)
	</ul>	</ul>
	The function dimension is required when constructing the functor.	The function dimension is required when constructing the functor.

	@ingroup GenFunc	@ingroup GenFunc

	*/	*/
	class Functor : public IBaseFunctionMultiDim {	class Functor : public IBaseFunctionMultiDim {


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

	HybridCalculatorOriginal.h	HybridCalculatorOriginal.h

	// @(#)root/roostats:$Id: HybridCalculatorOriginal.h 39391 2011-05-26 09:51 :59Z moneta $	// @(#)root/roostats:$Id: HybridCalculatorOriginal.h 44368 2012-05-30 15:38 :44Z axel $

	/*************************************************************************	/*************************************************************************
	* Project: RooStats *	* Project: RooStats *
	* Package: RooFit/RooStats *	* Package: RooFit/RooStats *
	* Authors: *	* Authors: *
	* Danilo Piparo, Gregory Schott *	* Danilo Piparo, Gregory Schott *
	*************************************************************************	*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *

	skipping to change at line 132	skipping to change at line 132
	/// index=2 : number of generated events	/// index=2 : number of generated events
	/// index=3 : profiled likelihood ratio	/// index=3 : profiled likelihood ratio
	/// if the index is different to any of those values, the default is used	/// if the index is different to any of those values, the default is used
	void SetTestStatistic(int index);	void SetTestStatistic(int index);

	HybridResult* Calculate(TH1& data, unsigned int nToys, bool usePriors ) const;	HybridResult* Calculate(TH1& data, unsigned int nToys, bool usePriors ) const;
	HybridResult* Calculate(RooAbsData& data, unsigned int nToys, bool us ePriors) const;	HybridResult* Calculate(RooAbsData& data, unsigned int nToys, bool us ePriors) const;
	HybridResult* Calculate(unsigned int nToys, bool usePriors) const;	HybridResult* Calculate(unsigned int nToys, bool usePriors) const;
	void PrintMore(const char* options) const;	void PrintMore(const char* options) const;


	void PatchSetExtended(bool on = true) { fTmpDoExtended = on; std::cou t << "extended patch set to " << on << endl; } // patch to test with RooPoi sson (or other non-extended models)	void PatchSetExtended(bool on = true) { fTmpDoExtended = on; std::cou t << "extended patch set to " << on << std::endl; } // patch to test with R ooPoisson (or other non-extended models)

	private:	private:

	void RunToys(std::vector<double>& bVals, std::vector<double>& sbVals, unsigned int nToys, bool usePriors) const;	void RunToys(std::vector<double>& bVals, std::vector<double>& sbVals, unsigned int nToys, bool usePriors) const;

	// check input parameters before performing the calculation	// check input parameters before performing the calculation
	bool DoCheckInputs() const;	bool DoCheckInputs() const;

	unsigned int fTestStatisticsIdx; // Index of the test statistics to u se	unsigned int fTestStatisticsIdx; // Index of the test statistics to u se
	unsigned int fNToys; // number of Toys MC	unsigned int fNToys; // number of Toys MC

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

	HypoTestResult.h	HypoTestResult.h

	// @(#)root/roostats:$Id: HypoTestResult.h 43199 2012-03-01 20:17:42Z monet a $	// @(#)root/roostats:$Id: HypoTestResult.h 44473 2012-06-01 16:12:31Z monet a $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke, S ven Kreiss
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	//_________________________________________________	//_________________________________________________

	skipping to change at line 69	skipping to change at line 69

	namespace RooStats {	namespace RooStats {

	class HypoTestResult : public TNamed {	class HypoTestResult : public TNamed {

	public:	public:

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


	// copy constructor	// copy constructo
	HypoTestResult(const HypoTestResult& other);	HypoTestResult(const HypoTestResult& other);

	// constructor from name, null and alternate p values	// constructor from name, null and alternate p values
	HypoTestResult(const char* name, Double_t nullp, Double_t altp);	HypoTestResult(const char* name, Double_t nullp, Double_t altp);

	// destructor	// destructor
	virtual ~HypoTestResult();	virtual ~HypoTestResult();


		// assignment operator
		HypoTestResult & operator=(const HypoTestResult& other);

	// add values from another HypoTestResult	// add values from another HypoTestResult
	virtual void Append(const HypoTestResult *other);	virtual void Append(const HypoTestResult *other);

	// Return p-value for null hypothesis	// Return p-value for null hypothesis
	virtual Double_t NullPValue() const { return fNullPValue; }	virtual Double_t NullPValue() const { return fNullPValue; }

	// Return p-value for alternate hypothesis	// Return p-value for alternate hypothesis
	virtual Double_t AlternatePValue() const { return fAlternatePValue; }	virtual Double_t AlternatePValue() const { return fAlternatePValue; }

	// Convert NullPValue into a "confidence level"	// Convert NullPValue into a "confidence level"

	skipping to change at line 111	skipping to change at line 114
	return thisCLsb / thisCLb;	return thisCLsb / thisCLb;
	}	}

	// familiar name for the Null p-value in terms of 1-sided Gaussian si gnificance	// familiar name for the Null p-value in terms of 1-sided Gaussian si gnificance
	virtual Double_t Significance() const {return RooStats::PValueToSigni ficance( NullPValue() ); }	virtual Double_t Significance() const {return RooStats::PValueToSigni ficance( NullPValue() ); }

	SamplingDistribution* GetNullDistribution(void) const { return fNullD istr; }	SamplingDistribution* GetNullDistribution(void) const { return fNullD istr; }
	SamplingDistribution* GetAltDistribution(void) const { return fAltDis tr; }	SamplingDistribution* GetAltDistribution(void) const { return fAltDis tr; }
	RooDataSet* GetNullDetailedOutput(void) const { return fNullDetailedO utput; }	RooDataSet* GetNullDetailedOutput(void) const { return fNullDetailedO utput; }
	RooDataSet* GetAltDetailedOutput(void) const { return fAltDetailedOut put; }	RooDataSet* GetAltDetailedOutput(void) const { return fAltDetailedOut put; }

		RooDataSet* GetFitInfo(void) const { return fFitInfo; }
	Double_t GetTestStatisticData(void) const { return fTestStatisticData ; }	Double_t GetTestStatisticData(void) const { return fTestStatisticData ; }
	const RooArgList* GetAllTestStatisticsData(void) const { return fAllT estStatisticsData; }	const RooArgList* GetAllTestStatisticsData(void) const { return fAllT estStatisticsData; }
	Bool_t HasTestStatisticData(void) const;	Bool_t HasTestStatisticData(void) const;

	void SetAltDistribution(SamplingDistribution *alt);	void SetAltDistribution(SamplingDistribution *alt);
	void SetNullDistribution(SamplingDistribution *null);	void SetNullDistribution(SamplingDistribution *null);
	void SetAltDetailedOutput(RooDataSet* d) { fAltDetailedOutput = d; }	void SetAltDetailedOutput(RooDataSet* d) { fAltDetailedOutput = d; }
	void SetNullDetailedOutput(RooDataSet* d) { fNullDetailedOutput = d; }	void SetNullDetailedOutput(RooDataSet* d) { fNullDetailedOutput = d; }

		void SetFitInfo(RooDataSet* d) { fFitInfo = d; }
	void SetTestStatisticData(const Double_t tsd);	void SetTestStatisticData(const Double_t tsd);
	void SetAllTestStatisticsData(const RooArgList* tsd);	void SetAllTestStatisticsData(const RooArgList* tsd);

	void SetPValueIsRightTail(Bool_t pr);	void SetPValueIsRightTail(Bool_t pr);
	Bool_t GetPValueIsRightTail(void) const { return fPValueIsRightTail; }	Bool_t GetPValueIsRightTail(void) const { return fPValueIsRightTail; }

	void SetBackgroundAsAlt(Bool_t l = kTRUE) { fBackgroundIsAlt = l; }	void SetBackgroundAsAlt(Bool_t l = kTRUE) { fBackgroundIsAlt = l; }
	Bool_t GetBackGroundIsAlt(void) const { return fBackgroundIsAlt; }	Bool_t GetBackGroundIsAlt(void) const { return fBackgroundIsAlt; }

	/// The error on the "confidence level" of the null hypothesis	/// The error on the "confidence level" of the null hypothesis
	Double_t CLbError() const;	Double_t CLbError() const;

	/// The error on the "confidence level" of the alternative hypothesis	/// The error on the "confidence level" of the alternative hypothesis
	Double_t CLsplusbError() const;	Double_t CLsplusbError() const;

	/// The error on the ratio CLs+b/CLb	/// The error on the ratio CLs+b/CLb
	Double_t CLsError() const;	Double_t CLsError() const;


		/// The error on the Null p-value
	Double_t NullPValueError() const;	Double_t NullPValueError() const;


		/// The error on the significance, computed from NullPValueError via
		error propagation
		Double_t SignificanceError() const;

	void Print(const Option_t* = "") const;	void Print(const Option_t* = "") const;

	private:	private:
	void UpdatePValue(const SamplingDistribution* distr, Double_t &pvalue , Double_t &perror, Bool_t pIsRightTail);	void UpdatePValue(const SamplingDistribution* distr, Double_t &pvalue , Double_t &perror, Bool_t pIsRightTail);

	protected:	protected:

	mutable Double_t fNullPValue; // p-value for the null hypothesis (sma ll number means disfavored)	mutable Double_t fNullPValue; // p-value for the null hypothesis (sma ll number means disfavored)
	mutable Double_t fAlternatePValue; // p-value for the alternate hypot hesis (small number means disfavored)	mutable Double_t fAlternatePValue; // p-value for the alternate hypot hesis (small number means disfavored)
	mutable Double_t fNullPValueError; // error of p-value for the null h ypothesis (small number means disfavored)	mutable Double_t fNullPValueError; // error of p-value for the null h ypothesis (small number means disfavored)
	mutable Double_t fAlternatePValueError; // error of p-value for the a lternate hypothesis (small number means disfavored)	mutable Double_t fAlternatePValueError; // error of p-value for the a lternate hypothesis (small number means disfavored)
	Double_t fTestStatisticData; // result of the test statistic evaluate d on data	Double_t fTestStatisticData; // result of the test statistic evaluate d on data
	const RooArgList* fAllTestStatisticsData; // for the case of multiple test statistics, holds all the results	const RooArgList* fAllTestStatisticsData; // for the case of multiple test statistics, holds all the results
	SamplingDistribution *fNullDistr;	SamplingDistribution *fNullDistr;
	SamplingDistribution *fAltDistr;	SamplingDistribution *fAltDistr;
	RooDataSet* fNullDetailedOutput;	RooDataSet* fNullDetailedOutput;
	RooDataSet* fAltDetailedOutput;	RooDataSet* fAltDetailedOutput;

		RooDataSet* fFitInfo;
	Bool_t fPValueIsRightTail;	Bool_t fPValueIsRightTail;
	Bool_t fBackgroundIsAlt;	Bool_t fBackgroundIsAlt;

	ClassDef(HypoTestResult,3) // Base class to represent results of a h ypothesis test	ClassDef(HypoTestResult,3) // Base class to represent results of a h ypothesis test

	};	};
	}	}

	#endif	#endif

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

	MCMCCalculator.h	MCMCCalculator.h

	// @(#)root/roostats:$Id: MCMCCalculator.h 40959 2011-09-20 16:33:21Z monet a $	// @(#)root/roostats:$Id: MCMCCalculator.h 44368 2012-05-30 15:38:44Z axel $
	// Authors: Kevin Belasco 17/06/2009	// Authors: Kevin Belasco 17/06/2009
	// Authors: Kyle Cranmer 17/06/2009	// Authors: Kyle Cranmer 17/06/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 146	skipping to change at line 146
	// desired confidence level (C_d), the algorithm will consider accept able	// desired confidence level (C_d), the algorithm will consider accept able
	// any found confidence level c such that Abs(c - C_d) < epsilon.	// any found confidence level c such that Abs(c - C_d) < epsilon.
	//	//
	// Any value of this "epsilon" > 0 is considered acceptable, though i t is	// Any value of this "epsilon" > 0 is considered acceptable, though i t is
	// advisable to not use a value too small, because the integration of the	// advisable to not use a value too small, because the integration of the
	// Keys PDF sometimes does not have extremely high accuracy.	// Keys PDF sometimes does not have extremely high accuracy.
	virtual void SetKeysConfidenceAccuracy(Double_t epsilon)	virtual void SetKeysConfidenceAccuracy(Double_t epsilon)
	{	{
	if (epsilon < 0)	if (epsilon < 0)
	coutE(InputArguments) << "MCMCInterval::SetEpsilon will not all ow "	coutE(InputArguments) << "MCMCInterval::SetEpsilon will not all ow "

	<< "negative epsilon value" << endl;	<< "negative epsilon value" << std::endl;
	else	else
	fEpsilon = epsilon;	fEpsilon = epsilon;
	}	}

	// When the shortest interval using Keys PDF could not be found to ha ve	// When the shortest interval using Keys PDF could not be found to ha ve
	// the desired confidence level +/- the accuracy (see	// the desired confidence level +/- the accuracy (see
	// SetKeysConfidenceAccuracy()), the interval determination algorithm	// SetKeysConfidenceAccuracy()), the interval determination algorithm
	// will have to terminate with an unsatisfactory confidence level whe n	// will have to terminate with an unsatisfactory confidence level whe n
	// the bottom and top of the cutoff search range are very close to be ing	// the bottom and top of the cutoff search range are very close to be ing
	// equal. This scenario comes into play when there seems to be an er ror	// equal. This scenario comes into play when there seems to be an er ror

	skipping to change at line 169	skipping to change at line 169
	// give an acceptable confidence level. To choose how small to allow the	// give an acceptable confidence level. To choose how small to allow the
	// search range to be before terminating, set the fraction delta such	// search range to be before terminating, set the fraction delta such
	// that the search will terminate when topCutoff (a) and bottomCutoff (b)	// that the search will terminate when topCutoff (a) and bottomCutoff (b)
	// satisfy this condition:	// satisfy this condition:
	//	//
	// TMath::Abs(a - b) < TMath::Abs(delta * (a + b)/2)	// TMath::Abs(a - b) < TMath::Abs(delta * (a + b)/2)
	virtual void SetKeysTerminationThreshold(Double_t delta)	virtual void SetKeysTerminationThreshold(Double_t delta)
	{	{
	if (delta < 0.)	if (delta < 0.)
	coutE(InputArguments) << "MCMCInterval::SetDelta will not allow "	coutE(InputArguments) << "MCMCInterval::SetDelta will not allow "

	<< "negative delta value" << endl;	<< "negative delta value" << std::endl;
	else	else
	fDelta = delta;	fDelta = delta;
	}	}

	protected:	protected:

	Double_t fSize; // size of the test (eg. specified rate of Type I e rror)	Double_t fSize; // size of the test (eg. specified rate of Type I e rror)
	RooArgSet fPOI; // parameters of interest for interval	RooArgSet fPOI; // parameters of interest for interval
	RooArgSet fNuisParams; // nuisance parameters for interval (not rea lly used)	RooArgSet fNuisParams; // nuisance parameters for interval (not rea lly used)
	RooArgSet fChainParams; // parameters to store in the chain (if not specified they are all of them )	RooArgSet fChainParams; // parameters to store in the chain (if not specified they are all of them )

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

	MCMCInterval.h	MCMCInterval.h

	// @(#)root/roostats:$Id: MCMCInterval.h 39391 2011-05-26 09:51:59Z moneta $	// @(#)root/roostats:$Id: MCMCInterval.h 44368 2012-05-30 15:38:44Z axel $
	// Authors: Kevin Belasco 17/06/2009	// Authors: Kevin Belasco 17/06/2009
	// Authors: Kyle Cranmer 17/06/2009	// Authors: Kyle Cranmer 17/06/2009
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 238	skipping to change at line 238

	// Get a clone of the weight variable from the markov chain	// Get a clone of the weight variable from the markov chain
	virtual RooRealVar* GetWeightVar() const	virtual RooRealVar* GetWeightVar() const
	{ return fChain->GetWeightVar(); }	{ return fChain->GetWeightVar(); }

	// set the acceptable level or error for Keys interval determination	// set the acceptable level or error for Keys interval determination
	virtual void SetEpsilon(Double_t epsilon)	virtual void SetEpsilon(Double_t epsilon)
	{	{
	if (epsilon < 0)	if (epsilon < 0)
	coutE(InputArguments) << "MCMCInterval::SetEpsilon will not all ow "	coutE(InputArguments) << "MCMCInterval::SetEpsilon will not all ow "

	<< "negative epsilon value" << endl;	<< "negative epsilon value" << std::endl;
	else	else
	fEpsilon = epsilon;	fEpsilon = epsilon;
	}	}

	// Set the type of interval to find. This will only have an effect f or	// Set the type of interval to find. This will only have an effect f or
	// 1-D intervals. If is more than 1 parameter of interest, then a	// 1-D intervals. If is more than 1 parameter of interest, then a
	// "shortest" interval will always be used, since it generalizes dire ctly	// "shortest" interval will always be used, since it generalizes dire ctly
	// to N dimensions	// to N dimensions
	virtual void SetIntervalType(enum IntervalType intervalType)	virtual void SetIntervalType(enum IntervalType intervalType)
	{ fIntervalType = intervalType; }	{ fIntervalType = intervalType; }

	skipping to change at line 268	skipping to change at line 268
	// the user any control over this process, if he desires it	// the user any control over this process, if he desires it
	//	//
	// Set the fraction delta such that	// Set the fraction delta such that
	// topCutoff (a) is considered == bottomCutoff (b) iff	// topCutoff (a) is considered == bottomCutoff (b) iff
	// (TMath::Abs(a - b) < TMath::Abs(fDelta * (a + b)/2))	// (TMath::Abs(a - b) < TMath::Abs(fDelta * (a + b)/2))
	// when determining the confidence interval by Keys	// when determining the confidence interval by Keys
	virtual void SetDelta(Double_t delta)	virtual void SetDelta(Double_t delta)
	{	{
	if (delta < 0.)	if (delta < 0.)
	coutE(InputArguments) << "MCMCInterval::SetDelta will not allow "	coutE(InputArguments) << "MCMCInterval::SetDelta will not allow "

	<< "negative delta value" << endl;	<< "negative delta value" << std::endl;
	else	else
	fDelta = delta;	fDelta = delta;
	}	}

	private:	private:
	inline Bool_t AcceptableConfLevel(Double_t confLevel);	inline Bool_t AcceptableConfLevel(Double_t confLevel);
	inline Bool_t WithinDeltaFraction(Double_t a, Double_t b);	inline Bool_t WithinDeltaFraction(Double_t a, Double_t b);

	protected:	protected:
	// data members	// data members

	skipping to change at line 299	skipping to change at line 299
	RooProduct* fProduct; // the (keysPdf * heaviside) product	RooProduct* fProduct; // the (keysPdf * heaviside) product
	Heaviside* fHeaviside; // the Heaviside function	Heaviside* fHeaviside; // the Heaviside function
	RooDataHist* fKeysDataHist; // data hist representing product	RooDataHist* fKeysDataHist; // data hist representing product
	RooRealVar* fCutoffVar; // cutoff variable to use for integrating key s pdf	RooRealVar* fCutoffVar; // cutoff variable to use for integrating key s pdf
	Double_t fKeysConfLevel; // the actual conf level determined by keys	Double_t fKeysConfLevel; // the actual conf level determined by keys
	Double_t fKeysCutoff; // cutoff keys pdf value to be in interval	Double_t fKeysCutoff; // cutoff keys pdf value to be in interval
	Double_t fFull; // Value of intergral of fProduct	Double_t fFull; // Value of intergral of fProduct

	Double_t fLeftSideTF; // left side tail-fraction for interval	Double_t fLeftSideTF; // left side tail-fraction for interval
	Double_t fTFConfLevel; // the actual conf level of tail-fraction inte rval	Double_t fTFConfLevel; // the actual conf level of tail-fraction inte rval

	vector<Int_t> fVector; // vector containing the Markov chain data	std::vector<Int_t> fVector; // vector containing the Markov chain dat a
	Double_t fVecWeight; // sum of weights of all entries in fVector	Double_t fVecWeight; // sum of weights of all entries in fVector
	Double_t fTFLower; // lower limit of the tail-fraction interval	Double_t fTFLower; // lower limit of the tail-fraction interval
	Double_t fTFUpper; // upper limit of the tail-fraction interval	Double_t fTFUpper; // upper limit of the tail-fraction interval

	TH1* fHist; // the binned Markov Chain data	TH1* fHist; // the binned Markov Chain data

	Bool_t fUseKeys; // whether to use kernel estimation	Bool_t fUseKeys; // whether to use kernel estimation
	Bool_t fUseSparseHist; // whether to use sparse hist (vs. RooDataHist )	Bool_t fUseSparseHist; // whether to use sparse hist (vs. RooDataHist )
	Bool_t fIsHistStrict; // whether the specified confidence level is a	Bool_t fIsHistStrict; // whether the specified confidence level is a
	// floor for the actual confidence level (stric t),	// floor for the actual confidence level (stric t),

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

	MethodBase.h	MethodBase.h

	// @(#)root/tmva $Id: MethodBase.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: MethodBase.h 44112 2012-05-04 10:00:41Z evt $
	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss, Eckhard von Toerne, Jan Therhaag	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka i Voss, Eckhard von Toerne, Jan Therhaag

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

	skipping to change at line 185	skipping to change at line 185

	// signal/background classification response	// signal/background classification response
	Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0, Double_t* errUpper = 0 );	Double_t GetMvaValue( const TMVA::Event* const ev, Double_t* err = 0, Double_t* errUpper = 0 );

	protected:	protected:
	// helper function to set errors to -1	// helper function to set errors to -1
	void NoErrorCalc(Double_t* const err, Double_t* const errUpper);	void NoErrorCalc(Double_t* const err, Double_t* const errUpper);

	public:	public:
	// regression response	// regression response

		const std::vector<Float_t>& GetRegressionValues(const TMVA::Event* co
		nst ev){
		fTmpEvent = ev;
		const std::vector<Float_t>* ptr = &GetRegressionValues();
		fTmpEvent = 0;
		return (*ptr);
		}

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

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

	skipping to change at line 278	skipping to change at line 285

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

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

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

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

	skipping to change at line 563	skipping to change at line 569
	TString fWeightFile; // weight file name	TString fWeightFile; // weight file name

	private:	private:

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

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


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

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

	private:	private:


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

	MinimizerOptions.h	MinimizerOptions.h

	// @(#)root/mathcore:$Id: MinimizerOptions.h 36905 2010-11-24 15:44:34Z mon eta $	// @(#)root/mathcore:$Id: MinimizerOptions.h 44131 2012-05-05 10:22:05Z mon eta $
	// Author: L. Moneta Fri Aug 15 2008	// Author: L. Moneta Fri Aug 15 2008

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

	#ifndef ROOT_Math_MinimizerOptions	#ifndef ROOT_Math_MinimizerOptions

	skipping to change at line 62	skipping to change at line 62
	static int DefaultStrategy();	static int DefaultStrategy();
	static int DefaultPrintLevel();	static int DefaultPrintLevel();

	/// retrieve extra options - if not existing create a IOptions	/// retrieve extra options - if not existing create a IOptions
	static ROOT::Math::IOptions & Default(const char * name);	static ROOT::Math::IOptions & Default(const char * name);

	// find extra options - return 0 if not existing	// find extra options - return 0 if not existing
	static ROOT::Math::IOptions * FindDefault(const char * name);	static ROOT::Math::IOptions * FindDefault(const char * name);

	/// print all the default options for the name given	/// print all the default options for the name given

	static void PrintDefault(const char * name = 0, std::ostream & os = std: :cout);	static void PrintDefault(const char * name, std::ostream & os = std::cou t);

	public:	public:

	// constructor using the default options	// constructor using the default options
	// pass optionally a pointer to the additional options	// pass optionally a pointer to the additional options
	// otehrwise look if they exist for this default minimizer	// otehrwise look if they exist for this default minimizer
	// and in that case they are copied in the constructed instance	// and in that case they are copied in the constructed instance
	MinimizerOptions(IOptions * extraOpts = 0);	MinimizerOptions(IOptions * extraOpts = 0);

	// destructor	// destructor

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

	Minuit2Minimizer.h	Minuit2Minimizer.h

	skipping to change at line 198	skipping to change at line 198
	Fill the passed array with the Hessian matrix elements	Fill the passed array with the Hessian matrix elements
	The Hessian matrix is the matrix of the second derivatives	The Hessian matrix is the matrix of the second derivatives
	and is the inverse of the covariance matrix	and is the inverse of the covariance matrix
	If the variable is fixed or const the values for that variables are zero.	If the variable is fixed or const the values for that variables are zero.
	The array will be filled as h[i *ndim + j]	The array will be filled as h[i *ndim + j]
	*/	*/
	virtual bool GetHessianMatrix(double * h) const;	virtual bool GetHessianMatrix(double * h) const;

	/**	/**
	return the status of the covariance matrix	return the status of the covariance matrix

		status = -1 : not available (inversion failed or Hesse failed)
		status = 0 : available but not positive defined
		status = 1 : covariance only approximate
		status = 2 : full matrix but forced pos def
		status = 3 : full accurate matrix

	*/	*/
	virtual int CovMatrixStatus() const;	virtual int CovMatrixStatus() const;
	/**	/**
	return correlation coefficient between variable i and j.	return correlation coefficient between variable i and j.
	If the variable is fixed or const the return value is zero	If the variable is fixed or const the return value is zero
	*/	*/
	virtual double Correlation(unsigned int i, unsigned int j ) const;	virtual double Correlation(unsigned int i, unsigned int j ) const;

	/**	/**
	get global correlation coefficient for the variable i. This is a numb er between zero and one which gives	get global correlation coefficient for the variable i. This is a numb er between zero and one which gives

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

	NeymanConstruction.h	NeymanConstruction.h

	// @(#)root/roostats:$Id: NeymanConstruction.h 39391 2011-05-26 09:51:59Z m oneta $	// @(#)root/roostats:$Id: NeymanConstruction.h 44368 2012-05-30 15:38:44Z a xel $
	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke	// Author: Kyle Cranmer, Lorenzo Moneta, Gregory Schott, Wouter Verkerke
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOSTATS_NeymanConstruction	#ifndef ROOSTATS_NeymanConstruction

	skipping to change at line 84	skipping to change at line 84
	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}	virtual Double_t ConfidenceLevel() const {return 1.-fSize;}

	// Set ModelConfig	// Set ModelConfig
	virtual void SetModel(const ModelConfig &model) {fModel = model;}	virtual void SetModel(const ModelConfig &model) {fModel = model;}

	// Set the DataSet	// Set the DataSet
	virtual void SetData(RooAbsData& data) { fData = data; }	virtual void SetData(RooAbsData& data) { fData = data; }

	// Set the Pdf, add to the the workspace if not already there	// Set the Pdf, add to the the workspace if not already there
	virtual void SetPdf(RooAbsPdf& /pdf/) {	virtual void SetPdf(RooAbsPdf& /pdf/) {

	cout << "DEPRECATED, use ModelConfig"<<endl;	std::cout << "DEPRECATED, use ModelConfig"<<std::endl;
	}	}

	// specify the parameters of interest in the interval	// specify the parameters of interest in the interval
	virtual void SetParameters(const RooArgSet& /set/) {	virtual void SetParameters(const RooArgSet& /set/) {

	cout << "DEPRECATED, use ModelConfig"<<endl;	std::cout << "DEPRECATED, use ModelConfig"<<std::endl;
	}	}

	// specify the nuisance parameters (eg. the rest of the parameters)	// specify the nuisance parameters (eg. the rest of the parameters)
	virtual void SetNuisanceParameters(const RooArgSet& /set/) {	virtual void SetNuisanceParameters(const RooArgSet& /set/) {

	cout << "DEPRECATED, use ModelConfig"<<endl;	std::cout << "DEPRECATED, use ModelConfig"<<std::endl;
	}	}

	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)	// set the size of the test (rate of Type I error) ( Eg. 0.05 for a 9 5% Confidence Interval)
	virtual void SetTestSize(Double_t size) {fSize = size;}	virtual void SetTestSize(Double_t size) {fSize = size;}
	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)	// set the confidence level for the interval (eg. 0.95 for a 95% Conf idence Interval)
	virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl;}	virtual void SetConfidenceLevel(Double_t cl) {fSize = 1.-cl;}

	// get confidence belt	// get confidence belt
	ConfidenceBelt* GetConfidenceBelt() {return fConfBelt;}	ConfidenceBelt* GetConfidenceBelt() {return fConfBelt;}


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

	PDEFoam.h	PDEFoam.h

	// @(#)root/tmva $Id: PDEFoam.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: PDEFoam.h 44112 2012-05-04 10:00:41Z evt $
	// Author: S. Jadach, Tancredi Carli, Dominik Dannheim, Alexander Voigt	// Author: S. Jadach, Tancredi Carli, Dominik Dannheim, Alexander Voigt

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

	skipping to change at line 270	skipping to change at line 270
	void PrintCell(Long_t iCell=0); // Print content of cell	void PrintCell(Long_t iCell=0); // Print content of cell
	void PrintCells(); // Prints content of all cells	void PrintCells(); // Prints content of all cells

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

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

	// project foam to two-dimensional histogram	// project foam to two-dimensional histogram
	virtual TH2D* Project2(Int_t idim1, Int_t idim2, ECellValue cell_valu e=kValue,	virtual TH2D* Project2(Int_t idim1, Int_t idim2, ECellValue cell_valu e=kValue,

	PDEFoamKernelBase *kernel=NULL, UInt_t maxbins= 50);	PDEFoamKernelBase *kernel=NULL, UInt_t nbin=50) ;

	// Project one-dimensional foam to a 1-dim histogram	// Project one-dimensional foam to a 1-dim histogram
	TH1D* Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase * kernel=NULL);	TH1D* Draw1Dim(ECellValue cell_value, Int_t nbin, PDEFoamKernelBase * kernel=NULL);

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

	Bool_t CreateCanvas = kTRUE, Bool_t colors = kTRUE );	Bool_t createCanvas = kTRUE, Bool_t colors = kTRUE );

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

	// get cell value for a given event	// get cell value for a given event
	virtual Float_t GetCellValue( const std::vector<Float_t>& xvec, ECell Value cv, PDEFoamKernelBase* );	virtual Float_t GetCellValue( const std::vector<Float_t>& xvec, ECell Value cv, PDEFoamKernelBase* );

	// get cell values for a given (incomplete) event vector	// get cell values for a given (incomplete) event vector
	virtual std::vector<Float_t> GetCellValue( const std::map<Int_t,Float _t>& xvec, ECellValue cv );	virtual std::vector<Float_t> GetCellValue( const std::map<Int_t,Float _t>& xvec, ECellValue cv );

	// get cell value stored in a foam cell	// get cell value stored in a foam cell

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

	RConfigOptions.h	RConfigOptions.h
	#ifndef ROOT_RConfigOptions	#ifndef ROOT_RConfigOptions
	#define ROOT_RConfigOptions	#define ROOT_RConfigOptions


	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.6.3p	#define R__CONFIGUREOPTIONS "QTDIR=/afs/cern.ch/sw/lcg/external/qt/4.7.4/
	2/i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5p1	i686-slc5-gcc43-opt PYTHONDIR=/afs/cern.ch/sw/lcg/external/Python/2.6.5p2/i
	/i686-slc5-gcc43-opt linux --fail-on-missing --enable-builtin-pcre --enable	686-slc5-gcc43-opt linux --fail-on-missing --enable-builtin-pcre --enable-c
	-cintex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb	intex --enable-explicitlink --enable-gdml --enable-genvector --enable-krb5
	5 --enable-mathmore --enable-minuit2 --enable-mysql --enable-oracle --enabl	--enable-mathmore --enable-minuit2 --enable-mysql --enable-oracle --enable-
	e-python --enable-qt --enable-qtgsi --enable-reflex --enable-roofit --enabl	python --enable-qt --enable-qtgsi --enable-reflex --enable-roofit --enable-
	e-table --enable-unuran --with-castor-incdir=/afs/cern.ch/sw/lcg/external/c	table --enable-unuran --with-castor-incdir=/afs/cern.ch/sw/lcg/external/cas
	astor/2.1.9-9/i686-slc5-gcc43-opt/usr/include/shift --with-castor-libdir=/a	tor/2.1.9-9/i686-slc5-gcc43-opt/usr/include/shift --with-castor-libdir=/afs
	fs/cern.ch/sw/lcg/external/castor/2.1.9-9/i686-slc5-gcc43-opt/usr/lib --wit	/cern.ch/sw/lcg/external/castor/2.1.9-9/i686-slc5-gcc43-opt/usr/lib --with-
	h-cern-libdir=/afs/cern.ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-op	cern-libdir=/afs/cern.ch/sw/lcg/external/cernlib/2006a/i686-slc5-gcc43-opt/
	t/lib --with-dcap-libdir=/afs/cern.ch/sw/lcg/external/dcache_client/1.9.3p1	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/extern	i686-slc5-gcc43-opt/dcap/lib --with-dcap-incdir=/afs/cern.ch/sw/lcg/externa
	al/dcache_client/1.9.3p1/i686-slc5-gcc43-opt/dcap/include --with-fftw3-incd	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	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	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_20110825/i68	pt/lib --with-gccxml=/afs/cern.ch/sw/lcg/external/gccxml/0.9.0_20110825/i68
	6-slc5-gcc43-opt/bin --with-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid/g	6-slc5-gcc43-opt/bin --with-gfal-libdir=/afs/cern.ch/sw/lcg/external/Grid/g
	fal/1.11.8-2/i686-slc5-gcc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg	fal/1.11.8-2/i686-slc5-gcc43-opt/lib --with-gfal-incdir=/afs/cern.ch/sw/lcg
	/external/Grid/gfal/1.11.8-2/i686-slc5-gcc43-opt/include --with-gsl-incdir=	/external/Grid/gfal/1.11.8-2/i686-slc5-gcc43-opt/include --with-gsl-incdir=
	/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/include --with-gs	/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/include --with-gs
	l-libdir=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib --wi	l-libdir=/afs/cern.ch/sw/lcg/external/GSL/1.10/i686-slc5-gcc43-opt/lib --wi
	th-mysql-incdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i686-slc5-gcc43-o	th-mysql-incdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i686-slc5-gcc43-o
	pt/include --with-mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i6	pt/include --with-mysql-libdir=/afs/cern.ch/sw/lcg/external/mysql/5.5.14/i6
	86-slc5-gcc43-opt/lib --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/ora	86-slc5-gcc43-opt/lib --with-oracle-incdir=/afs/cern.ch/sw/lcg/external/ora
	cle/11.2.0.1.0p3/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern	cle/11.2.0.1.0p3/i686-slc5-gcc43-opt/include --with-oracle-libdir=/afs/cern
	.ch/sw/lcg/external/oracle/11.2.0.1.0p3/i686-slc5-gcc43-opt/lib --with-rfio	.ch/sw/lcg/external/oracle/11.2.0.1.0p3/i686-slc5-gcc43-opt/lib --with-rfio
	-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.9-9/i686-slc5-gcc43-opt/usr	-incdir=/afs/cern.ch/sw/lcg/external/castor/2.1.9-9/i686-slc5-gcc43-opt/usr
	/include/shift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.9	/include/shift --with-rfio-libdir=/afs/cern.ch/sw/lcg/external/castor/2.1.9
	-9/i686-slc5-gcc43-opt/usr/lib --with-pythia6-libdir=/afs/cern.ch/sw/lcg/ex	-9/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	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-	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	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	/pythia8/160/i686-slc5-gcc43-opt/lib --with-gviz-incdir=/afs/cern.ch/sw/lcg
	/external/graphviz/2.24.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz-	/external/graphviz/2.24.0/i686-slc5-gcc43-opt/include/graphviz --with-gviz-
	libdir=/afs/cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5-gcc43-opt/lib	libdir=/afs/cern.ch/sw/lcg/external/graphviz/2.24.0/i686-slc5-gcc43-opt/lib
	--with-xrootd=/afs/cern.ch/sw/lcg/external/xrootd/3.1.0p2/i686-slc5-gcc43-	--with-xrootd=/afs/cern.ch/sw/lcg/external/xrootd/3.1.0p2/i686-slc5-gcc43-
	opt"	opt"
	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft	#define R__CONFIGUREFEATURES "asimage astiff builtin_afterimage builtin_ft
	gl builtin_glew builtin_pcre builtin_lzma castor cintex dcache exceptions e	gl builtin_glew builtin_pcre builtin_lzma castor cintex dcache explicitlink
	xplicitlink fftw3 gdml genvector gfal krb5 ldap mathmore memstat minuit2 my	fftw3 gdml genvector gfal krb5 ldap mathmore memstat minuit2 mysql opengl
	sql opengl oracle pythia8 python qt qtgsi reflex roofit rfio shadowpw share	oracle pythia8 python qt qtgsi reflex roofit rfio shadowpw shared ssl table
	d ssl table tmva unuran x11 xft xml xrootd thread"	tmva unuran x11 xft xml xrootd thread"

	#endif	#endif

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

	RichardsonDerivator.h	RichardsonDerivator.h

	// @(#)root/mathcore:$Id: RichardsonDerivator.h 24482 2008-06-23 15:33:08Z moneta $	// @(#)root/mathcore:$Id: RichardsonDerivator.h 44142 2012-05-06 20:44:03Z moneta $
	// Authors: David Gonzalez Maline 01/2008	// Authors: David Gonzalez Maline 01/2008

	/**********************************************************************	/**********************************************************************
	* *	* *
	* Copyright (c) 2006 , LCG ROOT MathLib Team *	* Copyright (c) 2006 , LCG ROOT MathLib Team *
	* *	* *
	* *	* *
	**********************************************************************/	**********************************************************************/

	// Header file for RichardsonDerivator	// Header file for RichardsonDerivator

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

	/**	/**
	Third Derivative calculation passing function and step-size	Third Derivative calculation passing function and step-size
	*/	*/
	double Derivative3(const IGenFunction & f, double x, double h) {	double Derivative3(const IGenFunction & f, double x, double h) {
	fFunction = &f;	fFunction = &f;
	fStepSize = h;	fStepSize = h;
	return Derivative3(x);	return Derivative3(x);
	}	}


	/** Set function for derivative calculation (function is not copied in)	/** Set function for derivative calculation (copy the function if option has been enabled in the constructor)

	\@param f Function to be differentiated	\@param f Function to be differentiated
	*/	*/

	void SetFunction (const IGenFunction & f) { fFunction = &f; }	void SetFunction (const IGenFunction & f);

	/** Set step size for derivative calculation	/** Set step size for derivative calculation

	\@param h step size for calculation	\@param h step size for calculation
	*/	*/
	void SetStepSize (double h) { fStepSize = h; }	void SetStepSize (double h) { fStepSize = h; }

	protected:	protected:

	bool fFunctionCopied; // flag to control if function is copied in th e class	bool fFunctionCopied; // flag to control if function is copied in th e class

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

	RooAbsData.h	RooAbsData.h

	skipping to change at line 212	skipping to change at line 212

	void addOwnedComponent(const char* idxlabel, RooAbsData& data) ;	void addOwnedComponent(const char* idxlabel, RooAbsData& data) ;
	static void claimVars(RooAbsData*) ;	static void claimVars(RooAbsData*) ;
	static Bool_t releaseVars(RooAbsData*) ;	static Bool_t releaseVars(RooAbsData*) ;

	enum StorageType { Tree, Vector} ;	enum StorageType { Tree, Vector} ;
	static StorageType defaultStorageType ;	static StorageType defaultStorageType ;

	static void setDefaultStorageType(StorageType s) ;	static void setDefaultStorageType(StorageType s) ;


		static StorageType getDefaultStorageType();

	protected:	protected:

	Double_t corrcov(RooRealVar &x,RooRealVar &y, const char* cutSpec, const char* cutRange, Bool_t corr) const ;	Double_t corrcov(RooRealVar &x,RooRealVar &y, const char* cutSpec, const char* cutRange, Bool_t corr) const ;
	TMatrixDSym* corrcovMatrix(const RooArgList& vars, const char* cutSpec, c onst char* cutRange, Bool_t corr) const ;	TMatrixDSym* corrcovMatrix(const RooArgList& vars, const char* cutSpec, c onst char* cutRange, Bool_t corr) const ;

	virtual void optimizeReadingWithCaching(RooAbsArg& arg, const RooArgSet& cacheList, const RooArgSet& keepObsList) ;	virtual void optimizeReadingWithCaching(RooAbsArg& arg, const RooArgSet& cacheList, const RooArgSet& keepObsList) ;
	Bool_t allClientsCached(RooAbsArg*, const RooArgSet&) ;	Bool_t allClientsCached(RooAbsArg*, const RooArgSet&) ;

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

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

	RooGlobalFunc.h	RooGlobalFunc.h

	skipping to change at line 186	skipping to change at line 186
	RooCmdArg Warnings(Bool_t flag=kTRUE) ;	RooCmdArg Warnings(Bool_t flag=kTRUE) ;
	RooCmdArg Strategy(Int_t code) ;	RooCmdArg Strategy(Int_t code) ;
	RooCmdArg InitialHesse(Bool_t flag=kTRUE) ;	RooCmdArg InitialHesse(Bool_t flag=kTRUE) ;
	RooCmdArg Hesse(Bool_t flag=kTRUE) ;	RooCmdArg Hesse(Bool_t flag=kTRUE) ;
	RooCmdArg Minos(Bool_t flag=kTRUE) ;	RooCmdArg Minos(Bool_t flag=kTRUE) ;
	RooCmdArg Minos(const RooArgSet& minosArgs) ;	RooCmdArg Minos(const RooArgSet& minosArgs) ;
	RooCmdArg SplitRange(Bool_t flag=kTRUE) ;	RooCmdArg SplitRange(Bool_t flag=kTRUE) ;
	RooCmdArg SumCoefRange(const char* rangeName) ;	RooCmdArg SumCoefRange(const char* rangeName) ;
	RooCmdArg Constrain(const RooArgSet& params) ;	RooCmdArg Constrain(const RooArgSet& params) ;
	RooCmdArg GlobalObservables(const RooArgSet& globs) ;	RooCmdArg GlobalObservables(const RooArgSet& globs) ;

		RooCmdArg GlobalObservablesTag(const char* tagName) ;
	RooCmdArg Constrained() ;	RooCmdArg Constrained() ;
	RooCmdArg ExternalConstraints(const RooArgSet& constraintPdfs) ;	RooCmdArg ExternalConstraints(const RooArgSet& constraintPdfs) ;
	RooCmdArg PrintEvalErrors(Int_t numErrors) ;	RooCmdArg PrintEvalErrors(Int_t numErrors) ;
	RooCmdArg EvalErrorWall(Bool_t flag) ;	RooCmdArg EvalErrorWall(Bool_t flag) ;
	RooCmdArg SumW2Error(Bool_t flag) ;	RooCmdArg SumW2Error(Bool_t flag) ;
	RooCmdArg CloneData(Bool_t flag) ;	RooCmdArg CloneData(Bool_t flag) ;
	RooCmdArg Integrate(Bool_t flag) ;	RooCmdArg Integrate(Bool_t flag) ;
	RooCmdArg Minimizer(const char* type, const char* alg=0) ;	RooCmdArg Minimizer(const char* type, const char* alg=0) ;

	// RooAbsPdf::paramOn arguments	// RooAbsPdf::paramOn arguments

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

	SamplingDistribution.h	SamplingDistribution.h

	// @(#)root/roostats:$Id: SamplingDistribution.h 40920 2011-09-19 06:41:59Z moneta $	// @(#)root/roostats:$Id: SamplingDistribution.h 44157 2012-05-07 16:41:44Z moneta $

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

	skipping to change at line 41	skipping to change at line 41

	public:	public:

	// Constructor for SamplingDistribution	// Constructor for SamplingDistribution
	SamplingDistribution(const char name,const char title, std::vector<Do uble_t>& samplingDist, const char * varName = 0);	SamplingDistribution(const char name,const char title, std::vector<Do uble_t>& samplingDist, const char * varName = 0);
	SamplingDistribution(const char name,const char title,	SamplingDistribution(const char name,const char title,
	std::vector<Double_t>& samplingDist, std::vector<Do uble_t>& sampleWeights, const char * varName = 0);	std::vector<Double_t>& samplingDist, std::vector<Do uble_t>& sampleWeights, const char * varName = 0);

	SamplingDistribution(const char name,const char title, const char * v arName = 0);	SamplingDistribution(const char name,const char title, const char * v arName = 0);


	SamplingDistribution(const char name,const char title, RooDataSet& da taSet, const char * varName = 0);	SamplingDistribution(const char name,const char title, RooDataSet& da taSet, const char * columnName = 0, const char * varName = 0);

	// Default constructor for SamplingDistribution	// Default constructor for SamplingDistribution
	SamplingDistribution();	SamplingDistribution();

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

	// get the inverse of the Cumulative distribution function	// get the inverse of the Cumulative distribution function
	Double_t InverseCDF(Double_t pvalue);	Double_t InverseCDF(Double_t pvalue);


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

	TBtree.h	TBtree.h

	// @(#)root/cont:$Id: TBtree.h 23644 2008-05-02 21:22:03Z rdm $	// @(#)root/cont:$Id: TBtree.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Fons Rademakers 10/10/95	// Author: Fons Rademakers 10/10/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 353	skipping to change at line 353
	public:	public:
	TBtreeIter(const TBtree *t, Bool_t dir = kIterForward);	TBtreeIter(const TBtree *t, Bool_t dir = kIterForward);
	TBtreeIter(const TBtreeIter &iter);	TBtreeIter(const TBtreeIter &iter);
	~TBtreeIter() { }	~TBtreeIter() { }
	TIterator &operator=(const TIterator &rhs);	TIterator &operator=(const TIterator &rhs);
	TBtreeIter &operator=(const TBtreeIter &rhs);	TBtreeIter &operator=(const TBtreeIter &rhs);

	const TCollection *GetCollection() const { return fTree; }	const TCollection *GetCollection() const { return fTree; }
	TObject *Next();	TObject *Next();
	void Reset();	void Reset();

	bool operator!=(const TIterator &aIter) const;	Bool_t operator!=(const TIterator &aIter) const;
	bool operator!=(const TBtreeIter &aIter) const;	Bool_t operator!=(const TBtreeIter &aIter) const;
	TObject operator() const;	TObject operator() const;

	ClassDef(TBtreeIter,0) //B-tree iterator	ClassDef(TBtreeIter,0) //B-tree iterator
	};	};

	//----- TBtree inlines ---------------------------------------------------- -----	//----- TBtree inlines ---------------------------------------------------- -----

	inline TObject *TBtree::operator[](Int_t i) const	inline TObject *TBtree::operator[](Int_t i) const
	{	{
	return (*fRoot)[i];	return (*fRoot)[i];

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

	TCint.h	TCint.h

	// @(#)root/meta:$Id: TCint.h 42064 2011-11-16 18:02:55Z pcanal $	// @(#)root/meta:$Id: TCint.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Fons Rademakers 01/03/96	// Author: Fons Rademakers 01/03/96

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 188	skipping to change at line 188
	// 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 Long_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 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;
	virtual void CallFunc_SetArg(CallFunc_t *func, ULong64_t param) const;	virtual void CallFunc_SetArg(CallFunc_t *func, ULong64_t param) const;
	virtual void CallFunc_SetArgArray(CallFunc_t func, Long_t paramArr, Int_t nparam) const;	virtual void CallFunc_SetArgArray(CallFunc_t func, Long_t paramArr, Int_t nparam) const;
	virtual void CallFunc_SetArgs(CallFunc_t func, const char param) con st;	virtual void CallFunc_SetArgs(CallFunc_t func, const char param) con st;
	virtual void CallFunc_SetFunc(CallFunc_t func, ClassInfo_t info, con st char method, const char params, Long_t *Offset) const;	virtual void CallFunc_SetFunc(CallFunc_t func, ClassInfo_t info, con st char method, const char params, Long_t *Offset) const;
	virtual void CallFunc_SetFunc(CallFunc_t func, MethodInfo_t info) co nst;	virtual void CallFunc_SetFunc(CallFunc_t func, MethodInfo_t info) co nst;
	virtual void CallFunc_SetFuncProto(CallFunc_t func, ClassInfo_t info , const char method, const char proto, Long_t *Offset) const;	virtual void CallFunc_SetFuncProto(CallFunc_t func, ClassInfo_t info , const char method, const char proto, Long_t *Offset) const;

	skipping to change at line 211	skipping to change at line 211
	virtual Long_t ClassInfo_ClassProperty(ClassInfo_t *info) const;	virtual Long_t ClassInfo_ClassProperty(ClassInfo_t *info) const;
	virtual void ClassInfo_Delete(ClassInfo_t *info) const;	virtual void ClassInfo_Delete(ClassInfo_t *info) const;
	virtual void ClassInfo_Delete(ClassInfo_t info, void arena) const;	virtual void ClassInfo_Delete(ClassInfo_t info, void arena) const;
	virtual void ClassInfo_DeleteArray(ClassInfo_t info, void arena, boo l dtorOnly) const;	virtual void ClassInfo_DeleteArray(ClassInfo_t info, void arena, boo l dtorOnly) const;
	virtual void ClassInfo_Destruct(ClassInfo_t info, void arena) const;	virtual void ClassInfo_Destruct(ClassInfo_t info, void arena) const;
	virtual ClassInfo_t *ClassInfo_Factory() const;	virtual ClassInfo_t *ClassInfo_Factory() const;
	virtual ClassInfo_t ClassInfo_Factory(G__value /* value */) const;	virtual ClassInfo_t ClassInfo_Factory(G__value /* value */) const;
	virtual ClassInfo_t ClassInfo_Factory(ClassInfo_t cl) const;	virtual ClassInfo_t ClassInfo_Factory(ClassInfo_t cl) const;
	virtual ClassInfo_t ClassInfo_Factory(const char name) const;	virtual ClassInfo_t ClassInfo_Factory(const char name) const;
	virtual int ClassInfo_GetMethodNArg(ClassInfo_t info, const char me thod,const char *proto) const;	virtual int ClassInfo_GetMethodNArg(ClassInfo_t info, const char me thod,const char *proto) const;

	virtual bool ClassInfo_HasDefaultConstructor(ClassInfo_t *info) const;	virtual Bool_t ClassInfo_HasDefaultConstructor(ClassInfo_t *info) const;
	virtual bool ClassInfo_HasMethod(ClassInfo_t info, const char name)	virtual Bool_t ClassInfo_HasMethod(ClassInfo_t info, const char name)
	const;	const;
	virtual void ClassInfo_Init(ClassInfo_t info, const char funcname) c onst;	virtual void ClassInfo_Init(ClassInfo_t info, const char funcname) c onst;
	virtual void ClassInfo_Init(ClassInfo_t *info, int tagnum) const;	virtual void ClassInfo_Init(ClassInfo_t *info, int tagnum) const;

	virtual bool ClassInfo_IsBase(ClassInfo_t info, const char name) con	virtual Bool_t ClassInfo_IsBase(ClassInfo_t info, const char name) con
	st;	st;
	virtual bool ClassInfo_IsEnum(const char *name) const;	virtual Bool_t ClassInfo_IsEnum(const char *name) const;
	virtual bool ClassInfo_IsLoaded(ClassInfo_t *info) const;	virtual Bool_t ClassInfo_IsLoaded(ClassInfo_t *info) const;
	virtual bool ClassInfo_IsValid(ClassInfo_t *info) const;	virtual Bool_t ClassInfo_IsValid(ClassInfo_t *info) const;
	virtual bool ClassInfo_IsValidMethod(ClassInfo_t info, const char me	virtual Bool_t ClassInfo_IsValidMethod(ClassInfo_t info, const char me
	thod,const char proto, Long_t offset) const;	thod,const char proto, Long_t offset) const;
	virtual int ClassInfo_Next(ClassInfo_t *info) const;	virtual int ClassInfo_Next(ClassInfo_t *info) const;
	virtual void ClassInfo_New(ClassInfo_t info) const;	virtual void ClassInfo_New(ClassInfo_t info) const;
	virtual void ClassInfo_New(ClassInfo_t info, int n) const;	virtual void ClassInfo_New(ClassInfo_t info, int n) const;
	virtual void ClassInfo_New(ClassInfo_t info, int n, void *arena) cons t;	virtual void ClassInfo_New(ClassInfo_t info, int n, void *arena) cons t;
	virtual void ClassInfo_New(ClassInfo_t info, void *arena) const;	virtual void ClassInfo_New(ClassInfo_t info, void *arena) const;
	virtual Long_t ClassInfo_Property(ClassInfo_t *info) const;	virtual Long_t ClassInfo_Property(ClassInfo_t *info) const;
	virtual int ClassInfo_RootFlag(ClassInfo_t *info) const;	virtual int ClassInfo_RootFlag(ClassInfo_t *info) const;
	virtual int ClassInfo_Size(ClassInfo_t *info) const;	virtual int ClassInfo_Size(ClassInfo_t *info) const;
	virtual Long_t ClassInfo_Tagnum(ClassInfo_t *info) const;	virtual Long_t ClassInfo_Tagnum(ClassInfo_t *info) const;
	virtual const char ClassInfo_FileName(ClassInfo_t info) const;	virtual const char ClassInfo_FileName(ClassInfo_t info) const;

	skipping to change at line 252	skipping to change at line 252
	virtual Long_t BaseClassInfo_Tagnum(BaseClassInfo_t *bcinfo) const;	virtual Long_t BaseClassInfo_Tagnum(BaseClassInfo_t *bcinfo) const;
	virtual const char BaseClassInfo_FullName(BaseClassInfo_t bcinfo) cons t;	virtual const char BaseClassInfo_FullName(BaseClassInfo_t bcinfo) cons t;
	virtual const char BaseClassInfo_Name(BaseClassInfo_t bcinfo) const;	virtual const char BaseClassInfo_Name(BaseClassInfo_t bcinfo) const;
	virtual const char BaseClassInfo_TmpltName(BaseClassInfo_t bcinfo) con st;	virtual const char BaseClassInfo_TmpltName(BaseClassInfo_t bcinfo) con st;

	// G__DataMemberInfo interface	// G__DataMemberInfo interface
	virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t *dminfo) const;	virtual int DataMemberInfo_ArrayDim(DataMemberInfo_t *dminfo) const;
	virtual void DataMemberInfo_Delete(DataMemberInfo_t *dminfo) const;	virtual void DataMemberInfo_Delete(DataMemberInfo_t *dminfo) const;
	virtual DataMemberInfo_t DataMemberInfo_Factory(ClassInfo_t clinfo = 0) const;	virtual DataMemberInfo_t DataMemberInfo_Factory(ClassInfo_t clinfo = 0) const;
	virtual DataMemberInfo_t DataMemberInfo_FactoryCopy(DataMemberInfo_t dminfo) const;	virtual DataMemberInfo_t DataMemberInfo_FactoryCopy(DataMemberInfo_t dminfo) const;

	virtual bool DataMemberInfo_IsValid(DataMemberInfo_t *dminfo) const;	virtual Bool_t DataMemberInfo_IsValid(DataMemberInfo_t *dminfo) const;
	virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t *dminfo, Int_t d im) const;	virtual int DataMemberInfo_MaxIndex(DataMemberInfo_t *dminfo, Int_t d im) const;
	virtual int DataMemberInfo_Next(DataMemberInfo_t *dminfo) const;	virtual int DataMemberInfo_Next(DataMemberInfo_t *dminfo) const;
	virtual Long_t DataMemberInfo_Offset(DataMemberInfo_t *dminfo) const;	virtual Long_t DataMemberInfo_Offset(DataMemberInfo_t *dminfo) const;
	virtual Long_t DataMemberInfo_Property(DataMemberInfo_t *dminfo) const;	virtual Long_t DataMemberInfo_Property(DataMemberInfo_t *dminfo) const;
	virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *dminfo) con st;	virtual Long_t DataMemberInfo_TypeProperty(DataMemberInfo_t *dminfo) con st;
	virtual int DataMemberInfo_TypeSize(DataMemberInfo_t *dminfo) const;	virtual int DataMemberInfo_TypeSize(DataMemberInfo_t *dminfo) const;
	virtual const char DataMemberInfo_TypeName(DataMemberInfo_t dminfo) co nst;	virtual const char DataMemberInfo_TypeName(DataMemberInfo_t dminfo) co nst;
	virtual const char DataMemberInfo_TypeTrueName(DataMemberInfo_t dminfo ) const;	virtual const char DataMemberInfo_TypeTrueName(DataMemberInfo_t dminfo ) const;
	virtual const char DataMemberInfo_Name(DataMemberInfo_t dminfo) const;	virtual const char DataMemberInfo_Name(DataMemberInfo_t dminfo) const;
	virtual const char DataMemberInfo_Title(DataMemberInfo_t dminfo) const ;	virtual const char DataMemberInfo_Title(DataMemberInfo_t dminfo) const ;
	virtual const char DataMemberInfo_ValidArrayIndex(DataMemberInfo_t dmi nfo) const;	virtual const char DataMemberInfo_ValidArrayIndex(DataMemberInfo_t dmi nfo) const;

	// G__MethodInfo interface	// G__MethodInfo interface
	virtual void MethodInfo_CreateSignature(MethodInfo_t *minfo, TString & signature) const;	virtual void MethodInfo_CreateSignature(MethodInfo_t *minfo, TString & signature) const;
	virtual void MethodInfo_Delete(MethodInfo_t *minfo) const;	virtual void MethodInfo_Delete(MethodInfo_t *minfo) const;
	virtual MethodInfo_t *MethodInfo_Factory() const;	virtual MethodInfo_t *MethodInfo_Factory() const;
	virtual MethodInfo_t MethodInfo_FactoryCopy(MethodInfo_t minfo) const ;	virtual MethodInfo_t MethodInfo_FactoryCopy(MethodInfo_t minfo) const ;
	virtual MethodInfo_t MethodInfo_InterfaceMethod(MethodInfo_t minfo) c onst;	virtual MethodInfo_t MethodInfo_InterfaceMethod(MethodInfo_t minfo) c onst;

	virtual bool MethodInfo_IsValid(MethodInfo_t *minfo) const;	virtual Bool_t MethodInfo_IsValid(MethodInfo_t *minfo) const;
	virtual int MethodInfo_NArg(MethodInfo_t *minfo) const;	virtual int MethodInfo_NArg(MethodInfo_t *minfo) const;
	virtual int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const;	virtual int MethodInfo_NDefaultArg(MethodInfo_t *minfo) const;
	virtual int MethodInfo_Next(MethodInfo_t *minfo) const;	virtual int MethodInfo_Next(MethodInfo_t *minfo) const;
	virtual Long_t MethodInfo_Property(MethodInfo_t *minfo) const;	virtual Long_t MethodInfo_Property(MethodInfo_t *minfo) const;
	virtual TypeInfo_t MethodInfo_Type(MethodInfo_t minfo) const;	virtual TypeInfo_t MethodInfo_Type(MethodInfo_t minfo) const;
	virtual const char MethodInfo_GetMangledName(MethodInfo_t minfo) const ;	virtual const char MethodInfo_GetMangledName(MethodInfo_t minfo) const ;
	virtual const char MethodInfo_GetPrototype(MethodInfo_t minfo) const;	virtual const char MethodInfo_GetPrototype(MethodInfo_t minfo) const;
	virtual const char MethodInfo_Name(MethodInfo_t minfo) const;	virtual const char MethodInfo_Name(MethodInfo_t minfo) const;
	virtual const char MethodInfo_TypeName(MethodInfo_t minfo) const;	virtual const char MethodInfo_TypeName(MethodInfo_t minfo) const;
	virtual const char MethodInfo_Title(MethodInfo_t minfo) const;	virtual const char MethodInfo_Title(MethodInfo_t minfo) const;

	// G__MethodArgInfo interface	// G__MethodArgInfo interface
	virtual void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const;	virtual void MethodArgInfo_Delete(MethodArgInfo_t *marginfo) const;
	virtual MethodArgInfo_t *MethodArgInfo_Factory() const;	virtual MethodArgInfo_t *MethodArgInfo_Factory() const;
	virtual MethodArgInfo_t MethodArgInfo_FactoryCopy(MethodArgInfo_t mar ginfo) const;	virtual MethodArgInfo_t MethodArgInfo_FactoryCopy(MethodArgInfo_t mar ginfo) const;

	virtual bool MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const;	virtual Bool_t MethodArgInfo_IsValid(MethodArgInfo_t *marginfo) const;
	virtual int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const;	virtual int MethodArgInfo_Next(MethodArgInfo_t *marginfo) const;
	virtual Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const;	virtual Long_t MethodArgInfo_Property(MethodArgInfo_t *marginfo) const;
	virtual const char MethodArgInfo_DefaultValue(MethodArgInfo_t marginfo ) const;	virtual const char MethodArgInfo_DefaultValue(MethodArgInfo_t marginfo ) const;
	virtual const char MethodArgInfo_Name(MethodArgInfo_t marginfo) const;	virtual const char MethodArgInfo_Name(MethodArgInfo_t marginfo) const;
	virtual const char MethodArgInfo_TypeName(MethodArgInfo_t marginfo) co nst;	virtual const char MethodArgInfo_TypeName(MethodArgInfo_t marginfo) co nst;

	// G__TypeInfo interface	// G__TypeInfo interface
	virtual void TypeInfo_Delete(TypeInfo_t *tinfo) const;	virtual void TypeInfo_Delete(TypeInfo_t *tinfo) const;
	virtual TypeInfo_t *TypeInfo_Factory() const;	virtual TypeInfo_t *TypeInfo_Factory() const;
	virtual TypeInfo_t TypeInfo_Factory(G__value /* value */) const;	virtual TypeInfo_t TypeInfo_Factory(G__value /* value */) const;
	virtual TypeInfo_t TypeInfo_FactoryCopy(TypeInfo_t /* tinfo */) const ;	virtual TypeInfo_t TypeInfo_FactoryCopy(TypeInfo_t /* tinfo */) const ;
	virtual void TypeInfo_Init(TypeInfo_t tinfo, const char funcname) co nst;	virtual void TypeInfo_Init(TypeInfo_t tinfo, const char funcname) co nst;

	virtual bool TypeInfo_IsValid(TypeInfo_t *tinfo) const;	virtual Bool_t TypeInfo_IsValid(TypeInfo_t *tinfo) const;
	virtual const char TypeInfo_Name(TypeInfo_t /* info */) const;	virtual const char TypeInfo_Name(TypeInfo_t /* info */) const;
	virtual Long_t TypeInfo_Property(TypeInfo_t *tinfo) const;	virtual Long_t TypeInfo_Property(TypeInfo_t *tinfo) const;
	virtual int TypeInfo_RefType(TypeInfo_t * /* tinfo */) const;	virtual int TypeInfo_RefType(TypeInfo_t * /* tinfo */) const;
	virtual int TypeInfo_Size(TypeInfo_t *tinfo) const;	virtual int TypeInfo_Size(TypeInfo_t *tinfo) const;
	virtual const char TypeInfo_TrueName(TypeInfo_t tinfo) const;	virtual const char TypeInfo_TrueName(TypeInfo_t tinfo) const;

	// G__TypedefInfo interface	// G__TypedefInfo interface
	virtual void TypedefInfo_Delete(TypedefInfo_t *tinfo) const;	virtual void TypedefInfo_Delete(TypedefInfo_t *tinfo) const;
	virtual TypedefInfo_t *TypedefInfo_Factory() const;	virtual TypedefInfo_t *TypedefInfo_Factory() const;
	virtual TypedefInfo_t TypedefInfo_FactoryCopy(TypedefInfo_t tinfo) co nst;	virtual TypedefInfo_t TypedefInfo_FactoryCopy(TypedefInfo_t tinfo) co nst;
	virtual void TypedefInfo_Init(TypedefInfo_t tinfo, const char funcna me) const;	virtual void TypedefInfo_Init(TypedefInfo_t tinfo, const char funcna me) const;

	virtual bool TypedefInfo_IsValid(TypedefInfo_t *tinfo) const;	virtual Bool_t TypedefInfo_IsValid(TypedefInfo_t *tinfo) const;
	virtual Long_t TypedefInfo_Property(TypedefInfo_t *tinfo) const;	virtual Long_t TypedefInfo_Property(TypedefInfo_t *tinfo) const;
	virtual int TypedefInfo_Size(TypedefInfo_t *tinfo) const;	virtual int TypedefInfo_Size(TypedefInfo_t *tinfo) const;
	virtual const char TypedefInfo_TrueName(TypedefInfo_t tinfo) const;	virtual const char TypedefInfo_TrueName(TypedefInfo_t tinfo) const;
	virtual const char TypedefInfo_Name(TypedefInfo_t tinfo) const;	virtual const char TypedefInfo_Name(TypedefInfo_t tinfo) const;
	virtual const char TypedefInfo_Title(TypedefInfo_t tinfo) const;	virtual const char TypedefInfo_Title(TypedefInfo_t tinfo) const;

	ClassDef(TCint,0) //Interface to CINT C/C++ interpreter	ClassDef(TCint,0) //Interface to CINT C/C++ interpreter
	};	};

	#endif	#endif

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

	TClass.h	TClass.h

	// @(#)root/meta:$Id: TClass.h 42967 2012-02-10 22:35:22Z pcanal $	// @(#)root/meta:$Id: TClass.h 43993 2012-04-27 16:23:16Z pcanal $
	// Author: Rene Brun 07/01/95	// Author: Rene Brun 07/01/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 174	skipping to change at line 174
	void StreamerStreamerInfo(void object, TBuffer &b, const TClass onfile _class) const;	void StreamerStreamerInfo(void object, TBuffer &b, const TClass onfile _class) const;
	void StreamerDefault(void object, TBuffer &b, const TClass onfile_clas s) const;	void StreamerDefault(void object, TBuffer &b, const TClass onfile_clas s) const;

	static IdMap_t *GetIdMap(); //Map from typeid to TClass pointer	static IdMap_t *GetIdMap(); //Map from typeid to TClass pointer
	static ENewType fgCallingNew; //Intent of why/how TClass::New() i s called	static ENewType fgCallingNew; //Intent of why/how TClass::New() i s called
	static Int_t fgClassCount; //provides unique id for a each cla ss	static Int_t fgClassCount; //provides unique id for a each cla ss
	//stored in TObject::fUniqueID	//stored in TObject::fUniqueID
	// Internal status bits	// Internal status bits
	enum { kLoading = BIT(14) };	enum { kLoading = BIT(14) };
	// Internal streamer type.	// Internal streamer type.

	enum {kDefault=0, kEmulated=1, kTObject=2, kInstrumented=4, kForeign=8, kExternal=16};	enum EStreamerType {kDefault=0, kEmulated=1, kTObject=2, kInstrumented=4 , kForeign=8, kExternal=16};

	// When a new class is created, we need to be able to find	// When a new class is created, we need to be able to find
	// if there are any existing classes that have the same name	// if there are any existing classes that have the same name
	// after any typedefs are expanded. (This only really affects	// after any typedefs are expanded. (This only really affects
	// template arguments.) To avoid having to search through all classes	// template arguments.) To avoid having to search through all classes
	// in that case, we keep a hash table mapping from the fully	// in that case, we keep a hash table mapping from the fully
	// typedef-expanded names to the original class names.	// typedef-expanded names to the original class names.
	// An entry is made in the table only if they are actually different.	// An entry is made in the table only if they are actually different.
	//	//
	// In these objects, the TObjString base holds the typedef-expanded	// In these objects, the TObjString base holds the typedef-expanded

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

	TClassEdit.h	TClassEdit.h

	// @(#)root/base:$Id: TClassEdit.h 38309 2011-03-04 17:14:19Z pcanal $	// @(#)root/base:$Id: TClassEdit.h 43294 2012-03-08 14:59:41Z pcanal $
	// Author: Victor Perev 10/04/2003	// Author: Victor Perev 10/04/2003
	// Philippe Canal 05/2004	// Philippe Canal 05/2004

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2003, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	skipping to change at line 85	skipping to change at line 85
	};	};

	std::string CleanType (const char typeDesc,int mode = 0,const char *ta il=0);	std::string CleanType (const char typeDesc,int mode = 0,const char *ta il=0);
	bool IsDefAlloc(const char alloc, const char classname);	bool IsDefAlloc(const char alloc, const char classname);
	bool IsDefAlloc(const char alloc, const char keyclassname, cons t char *valueclassname);	bool IsDefAlloc(const char alloc, const char keyclassname, cons t char *valueclassname);
	bool IsDefComp (const char comp , const char classname);	bool IsDefComp (const char comp , const char classname);
	bool IsSTLBitset(const char *type);	bool IsSTLBitset(const char *type);
	int IsSTLCont (const char *type,int testAlloc=0);	int IsSTLCont (const char *type,int testAlloc=0);
	bool IsStdClass(const char *type);	bool IsStdClass(const char *type);
	bool IsVectorBool(const char *name);	bool IsVectorBool(const char *name);

		std::string GetLong64_Name(const char *original);
	std::string GetLong64_Name(const std::string& original);	std::string GetLong64_Name(const std::string& original);
	int GetSplit (const char *type, std::vector<std::string> &outpu t, int &nestedLoc, EModType mode = TClassEdit::kNone);	int GetSplit (const char *type, std::vector<std::string> &outpu t, int &nestedLoc, EModType mode = TClassEdit::kNone);
	int STLKind (const char *type); //Kind of stl container	int STLKind (const char *type); //Kind of stl container
	int STLArgs (int kind); //Min number of arguments w ithout allocator	int STLArgs (int kind); //Min number of arguments w ithout allocator
	std::string ResolveTypedef(const char *tname, bool resolveAll = false);	std::string ResolveTypedef(const char *tname, bool resolveAll = false);
	std::string ShortType (const char *typeDesc, int mode);	std::string ShortType (const char *typeDesc, int mode);
	std::string InsertStd(const char *tname);	std::string InsertStd(const char *tname);
	}	}

	#endif	#endif

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

	TCollection.h	TCollection.h

	// @(#)root/cont:$Id: TCollection.h 37411 2010-12-08 17:42:11Z pcanal $	// @(#)root/cont:$Id: TCollection.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Fons Rademakers 13/08/95	// Author: Fons Rademakers 13/08/95

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 156	skipping to change at line 156
	TIter(TIterator *it) : fIterator(it) { }	TIter(TIterator *it) : fIterator(it) { }
	TIter(const TIter &iter);	TIter(const TIter &iter);
	TIter &operator=(const TIter &rhs);	TIter &operator=(const TIter &rhs);
	virtual ~TIter() { SafeDelete(fIterator); }	virtual ~TIter() { SafeDelete(fIterator); }
	TObject *operator()() { return Next(); }	TObject *operator()() { return Next(); }
	TObject *Next() { return fIterator ? fIterator->Next() : nullp tr; }	TObject *Next() { return fIterator ? fIterator->Next() : nullp tr; }
	const TCollection *GetCollection() const { return fIterator ? fIterator- >GetCollection() : nullptr; }	const TCollection *GetCollection() const { return fIterator ? fIterator- >GetCollection() : nullptr; }
	Option_t *GetOption() const { return fIterator ? fIterator->Get Option() : ""; }	Option_t *GetOption() const { return fIterator ? fIterator->Get Option() : ""; }
	void Reset() { if (fIterator) fIterator->Reset(); }	void Reset() { if (fIterator) fIterator->Reset(); }
	TIter &operator++() { Next(); return *this; }	TIter &operator++() { Next(); return *this; }

	bool operator!=(const TIter &aIter) const { return ((fIte rator) != (aIter.fIterator)); }	Bool_t operator!=(const TIter &aIter) const { return ((fIte rator) != (aIter.fIterator)); }
	TObject operator() const { return (fIterator); }	TObject operator() const { return (fIterator); }
	TIter &Begin();	TIter &Begin();
	static TIter End();	static TIter End();

	ClassDef(TIter,0) //Iterator wrapper	ClassDef(TIter,0) //Iterator wrapper
	};	};

	template <class T>	template <class T>
	class TIterCategory: public TIter, public std::iterator_traits<typename T:: Iterator_t> {	class TIterCategory: public TIter, public std::iterator_traits<typename T:: Iterator_t> {


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

	TColor.h	TColor.h

	// @(#)root/base:$Id: TColor.h 30239 2009-09-18 07:37:26Z couet $	// @(#)root/base:$Id: TColor.h 43719 2012-04-12 23:00:08Z rdm $
	// 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 47	skipping to change at line 47
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif
	#ifndef ROOT_TArrayI	#ifndef ROOT_TArrayI
	#include "TArrayI.h"	#include "TArrayI.h"
	#endif	#endif

	class TColor : public TNamed {	class TColor : public TNamed {

		protected:
	private:
	Int_t fNumber; //Color number identifier	Int_t fNumber; //Color number identifier

		private:
	Float_t fRed; //Fraction of Red	Float_t fRed; //Fraction of Red
	Float_t fGreen; //Fraction of Green	Float_t fGreen; //Fraction of Green
	Float_t fBlue; //Fraction of Blue	Float_t fBlue; //Fraction of Blue
	Float_t fHue; //Hue	Float_t fHue; //Hue
	Float_t fLight; //Light	Float_t fLight; //Light
	Float_t fSaturation; //Saturation	Float_t fSaturation; //Saturation
	Float_t fAlpha; //Alpha (transparency)	Float_t fAlpha; //Alpha (transparency)
	static Bool_t fgGrayscaleMode;//if set, GetColor will return grayscale	static Bool_t fgGrayscaleMode;//if set, GetColor will return grayscale
	static Bool_t fgInitDone; //kTRUE once ROOT colors have been initia lized	static Bool_t fgInitDone; //kTRUE once ROOT colors have been initia lized
	static TArrayI fgPalette; //Color palette	static TArrayI fgPalette; //Color palette

	skipping to change at line 95	skipping to change at line 95
	Float_t GetRed() const { return IsGrayscale() ? GetGrayscale() : f Red; }	Float_t GetRed() const { return IsGrayscale() ? GetGrayscale() : f Red; }
	Float_t GetGreen() const { return IsGrayscale() ? GetGrayscale() : fGreen; }	Float_t GetGreen() const { return IsGrayscale() ? GetGrayscale() : fGreen; }
	Float_t GetBlue() const { return IsGrayscale() ? GetGrayscale() : fBlue; }	Float_t GetBlue() const { return IsGrayscale() ? GetGrayscale() : fBlue; }
	Float_t GetHue() const { return fHue; }	Float_t GetHue() const { return fHue; }
	Float_t GetLight() const { return fLight; }	Float_t GetLight() const { return fLight; }
	Float_t GetSaturation() const { return IsGrayscale() ? 0 : fSatura tion; }	Float_t GetSaturation() const { return IsGrayscale() ? 0 : fSatura tion; }
	Float_t GetAlpha() const { return fAlpha; }	Float_t GetAlpha() const { return fAlpha; }
	virtual Float_t GetGrayscale() const { /ITU/ return 0.299ffRed + 0.58 7ffGreen + 0.114f*fBlue; }	virtual Float_t GetGrayscale() const { /ITU/ return 0.299ffRed + 0.58 7ffGreen + 0.114f*fBlue; }
	virtual void ls(Option_t *option="") const;	virtual void ls(Option_t *option="") const;
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;

		virtual void SetAlpha(Float_t a) { fAlpha = a; }
	virtual void SetRGB(Float_t r, Float_t g, Float_t b);	virtual void SetRGB(Float_t r, Float_t g, Float_t b);

	static void InitializeColors();	static void InitializeColors();
	static void HLS2RGB(Float_t h, Float_t l, Float_t s, Float_t &r, Floa t_t &g, Float_t &b);	static void HLS2RGB(Float_t h, Float_t l, Float_t s, Float_t &r, Floa t_t &g, Float_t &b);
	static void HLS2RGB(Int_t h, Int_t l, Int_t s, Int_t &r, Int_t &g, In t_t &b);	static void HLS2RGB(Int_t h, Int_t l, Int_t s, Int_t &r, Int_t &g, In t_t &b);
	static void HLStoRGB(Float_t h, Float_t l, Float_t s, Float_t &r, Flo at_t &g, Float_t &b)	static void HLStoRGB(Float_t h, Float_t l, Float_t s, Float_t &r, Flo at_t &g, Float_t &b)
	{ TColor::HLS2RGB(h, l, s, r, g, b); } // backward com patible	{ TColor::HLS2RGB(h, l, s, r, g, b); } // backward com patible
	static void HSV2RGB(Float_t h, Float_t s, Float_t v, Float_t &r, Floa t_t &g, Float_t &b);	static void HSV2RGB(Float_t h, Float_t s, Float_t v, Float_t &r, Floa t_t &g, Float_t &b);
	static void RGB2HLS(Float_t r, Float_t g, Float_t b, Float_t &h, Floa t_t &l, Float_t &s);	static void RGB2HLS(Float_t r, Float_t g, Float_t b, Float_t &h, Floa t_t &l, Float_t &s);
	static void RGB2HLS(Int_t r, Int_t g, Int_t b, Int_t &h, Int_t &l, In t_t &s);	static void RGB2HLS(Int_t r, Int_t g, Int_t b, Int_t &h, Int_t &l, In t_t &s);

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

	TCutG.h	TCutG.h

	// @(#)root/graf:$Id: TCutG.h 37309 2010-12-06 00:10:29Z pcanal $	// @(#)root/graf:$Id: TCutG.h 43271 2012-03-07 05:53:52Z pcanal $
	// Author: Rene Brun 16/05/97	// Author: Rene Brun 16/05/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 44	skipping to change at line 44
	TObject *fObjectX; //!pointer to an object corresponding to X	TObject *fObjectX; //!pointer to an object corresponding to X
	TObject *fObjectY; //!pointer to an object corresponding to Y	TObject *fObjectY; //!pointer to an object corresponding to Y

	public:	public:
	TCutG();	TCutG();
	TCutG(const TCutG &cutg);	TCutG(const TCutG &cutg);
	TCutG(const char *name, Int_t n);	TCutG(const char *name, Int_t n);
	TCutG(const char name, Int_t n, const Float_t x, const Float_t *y);	TCutG(const char name, Int_t n, const Float_t x, const Float_t *y);
	TCutG(const char name, Int_t n, const Double_t x, const Double_t *y);	TCutG(const char name, Int_t n, const Double_t x, const Double_t *y);
	virtual ~TCutG();	virtual ~TCutG();


		TCutG &operator=(const TCutG &);
	virtual Double_t Area() const;	virtual Double_t Area() const;
	virtual void Center(Double_t &cx, Double_t &cy) const;	virtual void Center(Double_t &cx, Double_t &cy) const;
	TObject *GetObjectX() const {return fObjectX;}	TObject *GetObjectX() const {return fObjectX;}
	TObject *GetObjectY() const {return fObjectY;}	TObject *GetObjectY() const {return fObjectY;}
	const char *GetVarX() const {return fVarX.Data();}	const char *GetVarX() const {return fVarX.Data();}
	const char *GetVarY() const {return fVarY.Data();}	const char *GetVarY() const {return fVarY.Data();}
	virtual Double_t IntegralHist(TH2 h, Option_t option="") const;	virtual Double_t IntegralHist(TH2 h, Option_t option="") const;
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");
	virtual void SetObjectX(TObject *obj);	virtual void SetObjectX(TObject *obj);
	virtual void SetObjectY(TObject *obj);	virtual void SetObjectY(TObject *obj);

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

	TDataSetIter.h	TDataSetIter.h

	// @(#)root/table:$Id: TDataSetIter.h 21571 2008-01-03 09:21:42Z brun $	// @(#)root/table:$Id: TDataSetIter.h 43276 2012-03-07 17:13:42Z pcanal $
	// Author: Valery Fine(fine@mail.cern.ch) 03/07/98	// Author: Valery Fine(fine@mail.cern.ch) 03/07/98

	/*************************************************************************	/*************************************************************************
	* 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 49	skipping to change at line 49
	Int_t fMaxDepth; // the max depth of the passing (=1 b y default)	Int_t fMaxDepth; // the max depth of the passing (=1 b y default)

	TDataSet *fDataSet; // Pointer to the last selected TDat aSet	TDataSet *fDataSet; // Pointer to the last selected TDat aSet
	TDataSet *fRootDataSet; // Pointer to the root TDataSet	TDataSet *fRootDataSet; // Pointer to the root TDataSet
	TDataSet *fWorkingDataSet; // Pointer to the working TDataSet	TDataSet *fWorkingDataSet; // Pointer to the working TDataSet
	TDataSet *NextDataSet(TIter &next);	TDataSet *NextDataSet(TIter &next);
	TDataSet *NextDataSet(Int_t nDataSet);	TDataSet *NextDataSet(Int_t nDataSet);
	TDataSet GetNullSet(); // return a fake pointer == -1 caste d to (TDataSet )	TDataSet GetNullSet(); // return a fake pointer == -1 caste d to (TDataSet )

	static TDataSet *fgNullDataSet;	static TDataSet *fgNullDataSet;


		private:

		TDataSetIter(const TDataSetIter&); // Not implemented.
		TDataSetIter &operator=(const TDataSetIter&); // Not implemented.

	public:	public:
	TDataSetIter(TDataSet *l=0, Int_t depth=1, Bool_t dir=kIterForward);	TDataSetIter(TDataSet *l=0, Int_t depth=1, Bool_t dir=kIterForward);
	TDataSetIter(TDataSet *l, Bool_t dir);	TDataSetIter(TDataSet *l, Bool_t dir);
	virtual ~TDataSetIter();	virtual ~TDataSetIter();

	virtual TDataSet Add(TDataSet set){return Add(set,(TDataSet *)0);}	virtual TDataSet Add(TDataSet set){return Add(set,(TDataSet *)0);}
	virtual TDataSet Add(TDataSet set, const Char_t *path);	virtual TDataSet Add(TDataSet set, const Char_t *path);
	virtual TDataSet Add(TDataSet set, TDataSet *dataset);	virtual TDataSet Add(TDataSet set, TDataSet *dataset);

	virtual TDataSet Cd(const Char_t dirname);	virtual TDataSet Cd(const Char_t dirname);

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

	TFileIter.h	TFileIter.h

	// @(#)root/table:$Id: TFileIter.h 41088 2011-10-01 19:38:48Z pcanal $	// @(#)root/table:$Id: TFileIter.h 43515 2012-03-27 21:15:53Z pcanal $
	// Author: Valery Fine(fine@bnl.gov) 01/03/2001	// Author: Valery Fine(fine@bnl.gov) 01/03/2001

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2004, Rene Brun and Fons Rademakers. *
	* Copyright (C) 2001 [BNL] Brookhaven National Laboratory. *	* Copyright (C) 2001 [BNL] Brookhaven National Laboratory. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	skipping to change at line 67	skipping to change at line 67
	#include "TFile.h"	#include "TFile.h"
	#endif	#endif

	class TFileIter : public TListIter {	class TFileIter : public TListIter {

	private:	private:

	TFileIter *fNestedIterator; //! The inner TFidrectory interator;	TFileIter *fNestedIterator; //! The inner TFidrectory interator;

	virtual TIterator &operator=(const TIterator &) { return *this; }	virtual TIterator &operator=(const TIterator &) { return *this; }

	virtual bool operator!=(const TIterator &it) const { return TListIter::o perator!=(it);}	virtual Bool_t operator!=(const TIterator &it) const { return TListIter: :operator!=(it);}

	protected:	protected:
	TDirectory *fRootFile; // TDirectory/TFile to be iterated over	TDirectory *fRootFile; // TDirectory/TFile to be iterated over
	TString fEventName; // current key name	TString fEventName; // current key name
	UInt_t fRunNumber; // current "run number"	UInt_t fRunNumber; // current "run number"
	UInt_t fEventNumber; // current "event number"	UInt_t fEventNumber; // current "event number"
	Int_t fCursorPosition; // the position of the current key in the sorted TKey list	Int_t fCursorPosition; // the position of the current key in the sorted TKey list
	Bool_t fOwnTFile; // Bit whether this classs creates TFile on its own to delete	Bool_t fOwnTFile; // Bit whether this classs creates TFile on its own to delete

	void Initialize();	void Initialize();

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

	TGClient.h	TGClient.h

	// @(#)root/gui:$Id: TGClient.h 38843 2011-04-14 12:13:31Z bellenot $	// @(#)root/gui:$Id: TGClient.h 43719 2012-04-12 23:00:08Z rdm $
	// Author: Fons Rademakers 27/12/97	// Author: Fons Rademakers 27/12/97

	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 53	skipping to change at line 53
	class TGGCPool;	class TGGCPool;
	class TGGC;	class TGGC;
	class TGFontPool;	class TGFontPool;
	class TGFont;	class TGFont;
	class TGMimeTypes;	class TGMimeTypes;
	class TGUnknownWindowHandler;	class TGUnknownWindowHandler;
	class TGIdleHandler;	class TGIdleHandler;

	class TGClient : public TObject, public TQObject {	class TGClient : public TObject, public TQObject {


		friend class TGCocoa;

	protected:	protected:
	Pixel_t fBackColor; // default background color	Pixel_t fBackColor; // default background color
	Pixel_t fForeColor; // default foreground color	Pixel_t fForeColor; // default foreground color
	Pixel_t fHilite; // default hilite color	Pixel_t fHilite; // default hilite color
	Pixel_t fShadow; // default shadow color	Pixel_t fShadow; // default shadow color
	Pixel_t fSelBackColor; // default selection background color	Pixel_t fSelBackColor; // default selection background color
	Pixel_t fSelForeColor; // default selection foreground color	Pixel_t fSelForeColor; // default selection foreground color
	Pixel_t fWhite; // white color index	Pixel_t fWhite; // white color index
	Pixel_t fBlack; // black color index	Pixel_t fBlack; // black color index
	TGWindow *fDefaultRoot; // default root window (base window o f display)	TGWindow *fDefaultRoot; // default root window (base window o f display)

	skipping to change at line 112	skipping to change at line 114
	Bool_t IsEditDisabled() const;	Bool_t IsEditDisabled() const;
	void SetEditDisabled(Bool_t on = kTRUE);	void SetEditDisabled(Bool_t on = kTRUE);

	FontStruct_t GetFontByName(const char *name, Bool_t fixedDefault = kTRUE ) const;	FontStruct_t GetFontByName(const char *name, Bool_t fixedDefault = kTRUE ) const;
	Bool_t GetColorByName(const char *name, Pixel_t &pixel) const;	Bool_t GetColorByName(const char *name, Pixel_t &pixel) const;
	Pixel_t GetHilite(Pixel_t base_color) const;	Pixel_t GetHilite(Pixel_t base_color) const;
	Pixel_t GetShadow(Pixel_t base_color) const;	Pixel_t GetShadow(Pixel_t base_color) const;
	void FreeColor(Pixel_t color) const;	void FreeColor(Pixel_t color) const;
	void ForceRedraw() { fForceRedraw = kTRUE; }	void ForceRedraw() { fForceRedraw = kTRUE; }
	void NeedRedraw(TGWindow *w, Bool_t force = kFALSE);	void NeedRedraw(TGWindow *w, Bool_t force = kFALSE);

		void CancelRedraw(TGWindow *w);
	void RegisterWindow(TGWindow *w);	void RegisterWindow(TGWindow *w);
	void UnregisterWindow(TGWindow *w);	void UnregisterWindow(TGWindow *w);
	void RegisterPopup(TGWindow *w);	void RegisterPopup(TGWindow *w);
	void UnregisterPopup(TGWindow *w);	void UnregisterPopup(TGWindow *w);
	void AddUnknownWindowHandler(TGUnknownWindowHandler *h);	void AddUnknownWindowHandler(TGUnknownWindowHandler *h);
	void RemoveUnknownWindowHandler(TGUnknownWindowHandler *h);	void RemoveUnknownWindowHandler(TGUnknownWindowHandler *h);
	void AddIdleHandler(TGIdleHandler *h);	void AddIdleHandler(TGIdleHandler *h);
	void RemoveIdleHandler(TGIdleHandler *h);	void RemoveIdleHandler(TGIdleHandler *h);
	Bool_t HandleInput();	Bool_t HandleInput();
	void ProcessLine(TString cmd, Long_t msg, Long_t parm1, Long_t p arm2);	void ProcessLine(TString cmd, Long_t msg, Long_t parm1, Long_t p arm2);
	void WaitFor(TGWindow *w);	void WaitFor(TGWindow *w);
	void WaitForUnmap(TGWindow *w);	void WaitForUnmap(TGWindow *w);
	void ResetWaitFor(TGWindow *w);	void ResetWaitFor(TGWindow *w);
	EGEventType GetWaitForEvent() const { return fWaitForEvent;}	EGEventType GetWaitForEvent() const { return fWaitForEvent;}
	Window_t GetWaitForWindow() const { return fWaitForWindow; }	Window_t GetWaitForWindow() const { return fWaitForWindow; }

		void SetWaitForWindow(Window_t wid) {fWaitForWindow = wid;}
	Bool_t ProcessEventsFor(TGWindow *w);	Bool_t ProcessEventsFor(TGWindow *w);

	Bool_t HandleEvent(Event_t *event);	Bool_t HandleEvent(Event_t *event);
	Bool_t HandleMaskEvent(Event_t *event, Window_t wid);	Bool_t HandleMaskEvent(Event_t *event, Window_t wid);
	void RegisteredWindow(Window_t w); //SIGNAL	void RegisteredWindow(Window_t w); //SIGNAL
	void ProcessedEvent(Event_t event, Window_t wid); //SIGNAL*	void ProcessedEvent(Event_t event, Window_t wid); //SIGNAL*

	const TGResourcePool *GetResourcePool() const { return fResourcePool; }	const TGResourcePool *GetResourcePool() const { return fResourcePool; }

	TGPicturePool *GetPicturePool() const { return fPicturePool; }	TGPicturePool *GetPicturePool() const { return fPicturePool; }

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