ROOT: headers diff between 5.34.03 and 5.34.04 versions

	Byteswap.h	Byteswap.h

	/* @(#)root/base:$Id: Byteswap.h 29820 2009-08-19 14:12:40Z rdm $ */	/* @(#)root/base:$Id: Byteswap.h 47381 2012-11-16 20:50:59Z rdm $ */

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

	#ifndef ROOT_Byteswap	#ifndef ROOT_Byteswap

	skipping to change at line 32	skipping to change at line 32
	The GNU C Library is distributed in the hope that it will be useful,	The GNU C Library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Library General Public License for more details.	Library General Public License for more details.

	You should have received a copy of the GNU Library General Public	You should have received a copy of the GNU Library General Public
	License along with the GNU C Library; see the file COPYING.LIB. If not,	License along with the GNU C Library; see the file COPYING.LIB. If not,
	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330 ,
	Boston, MA 02111-1307, USA. */	Boston, MA 02111-1307, USA. */


		#if (defined(__linux) \|\| defined(__APPLE__)) && \
		(defined(__i386__) \|\| defined(__x86_64__)) && \
		(defined(__GNUC__) && __GNUC__ >= 2)
		#ifndef R__USEASMSWAP
		#define R__USEASMSWAP
		#endif
		#endif

	/* Get the machine specific, optimized definitions. */	/* Get the machine specific, optimized definitions. */
	/* The following is copied from <bits/byteswap.h> (only from RH6.0 and abov e) */	/* The following is copied from <bits/byteswap.h> (only from RH6.0 and abov e) */

	/* Swap bytes in 16 bit value. */	/* Swap bytes in 16 bit value. */
	#define R__bswap_constant_16(x) \	#define R__bswap_constant_16(x) \
	((((x) >> 8) & 0xff) \| (((x) & 0xff) << 8))	((((x) >> 8) & 0xff) \| (((x) & 0xff) << 8))


	#if defined __GNUC__ && __GNUC__ >= 2	#if defined R__USEASMSWAP
	# define R__bswap_16(x) \	# define R__bswap_16(x) \
	(__extension__ \	(__extension__ \
	({ register unsigned short int __v; \	({ register unsigned short int __v; \
	if (__builtin_constant_p (x)) \	if (__builtin_constant_p (x)) \
	__v = R__bswap_constant_16 (x); \	__v = R__bswap_constant_16 (x); \
	else \	else \
	__asm__ __volatile__ ("rorw $8, %w0" \	__asm__ __volatile__ ("rorw $8, %w0" \
	: "=r" (__v) \	: "=r" (__v) \
	: "0" ((unsigned short int) (x)) \	: "0" ((unsigned short int) (x)) \
	: "cc"); \	: "cc"); \

	skipping to change at line 61	skipping to change at line 69
	#else	#else
	/* This is better than nothing. */	/* This is better than nothing. */
	# define R__bswap_16(x) R__bswap_constant_16 (x)	# define R__bswap_16(x) R__bswap_constant_16 (x)
	#endif	#endif

	/* Swap bytes in 32 bit value. */	/* Swap bytes in 32 bit value. */
	#define R__bswap_constant_32(x) \	#define R__bswap_constant_32(x) \
	((((x) & 0xff000000) >> 24) \| (((x) & 0x00ff0000) >> 8) \| \	((((x) & 0xff000000) >> 24) \| (((x) & 0x00ff0000) >> 8) \| \
	(((x) & 0x0000ff00) << 8) \| (((x) & 0x000000ff) << 24))	(((x) & 0x0000ff00) << 8) \| (((x) & 0x000000ff) << 24))


	#if defined __GNUC__ && __GNUC__ >= 2	#if defined R__USEASMSWAP
	/* To swap the bytes in a word the i486 processors and up provide the	/* To swap the bytes in a word the i486 processors and up provide the
	`bswap' opcode. On i386 we have to use three instructions. */	`bswap' opcode. On i386 we have to use three instructions. */
	# if !defined __i486__ && !defined __pentium__ && !defined __pentiumpro__ & & \	# if !defined __i486__ && !defined __pentium__ && !defined __pentiumpro__ & & \
	!defined __pentium4__ && !defined __x86_64__	!defined __pentium4__ && !defined __x86_64__
	# define R__bswap_32(x) \	# define R__bswap_32(x) \
	(__extension__ \	(__extension__ \
	({ register unsigned int __v; \	({ register unsigned int __v; \
	if (__builtin_constant_p (x)) \	if (__builtin_constant_p (x)) \
	__v = R__bswap_constant_32 (x); \	__v = R__bswap_constant_32 (x); \
	else \	else \

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

	Channel.h	Channel.h

		// @(#)root/roostats:$Id: Channel.h 47093 2012-11-07 10:30:12Z moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

	#ifndef HISTFACTORY_CHANNEL_H	#ifndef HISTFACTORY_CHANNEL_H
	#define HISTFACTORY_CHANNEL_H	#define HISTFACTORY_CHANNEL_H

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

	#include "RooStats/HistFactory/Data.h"	#include "RooStats/HistFactory/Data.h"
	#include "RooStats/HistFactory/Sample.h"	#include "RooStats/HistFactory/Sample.h"

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

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

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


		void AddAdditionalData( const RooStats::HistFactory::Data& data ) { fAddi
		tionalData.push_back(data); }
		std::vector<RooStats::HistFactory::Data>& GetAdditionalData() { return fA
		dditionalData; }

	void SetStatErrorConfig( double RelErrorThreshold, Constraint::Type Const raintType );	void SetStatErrorConfig( double RelErrorThreshold, Constraint::Type Const raintType );
	void SetStatErrorConfig( double RelErrorThreshold, std::string Constraint Type );	void SetStatErrorConfig( double RelErrorThreshold, std::string Constraint Type );
	void SetStatErrorConfig( RooStats::HistFactory::StatErrorConfig Config ) { fStatErrorConfig = Config; }	void SetStatErrorConfig( RooStats::HistFactory::StatErrorConfig Config ) { fStatErrorConfig = Config; }
	HistFactory::StatErrorConfig& GetStatErrorConfig() { return fStatErrorCon fig; }	HistFactory::StatErrorConfig& GetStatErrorConfig() { return fStatErrorCon fig; }

	void AddSample( RooStats::HistFactory::Sample sample );	void AddSample( RooStats::HistFactory::Sample sample );
	std::vector< RooStats::HistFactory::Sample >& GetSamples() { return fSamp les; }	std::vector< RooStats::HistFactory::Sample >& GetSamples() { return fSamp les; }

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

	skipping to change at line 61	skipping to change at line 73
	bool CheckHistograms();	bool CheckHistograms();

	protected:	protected:

	std::string fName;	std::string fName;
	std::string fInputFile;	std::string fInputFile;
	std::string fHistoPath;	std::string fHistoPath;

	HistFactory::Data fData;	HistFactory::Data fData;


		// One can add additional datasets
		// These are simply added to the xml under a different name
		std::vector<RooStats::HistFactory::Data> fAdditionalData;

	HistFactory::StatErrorConfig fStatErrorConfig;	HistFactory::StatErrorConfig fStatErrorConfig;

	std::vector< RooStats::HistFactory::Sample > fSamples;	std::vector< RooStats::HistFactory::Sample > fSamples;

	// Open a file and copy a histogram	// Open a file and copy a histogram
	TH1* GetHistogram( std::string InputFile, std::string HistoPath, std::str ing HistoName );	TH1* GetHistogram( std::string InputFile, std::string HistoPath, std::str ing HistoName );

	};	};

	extern Channel BadChannel;	extern Channel BadChannel;

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

	ConfigParser.h	ConfigParser.h

	// @(#)root/roostats:$Id: ConfigParser.h 44376 2012-05-30 21:47:29Z moneta $	// @(#)root/roostats:$Id: ConfigParser.h 47093 2012-11-07 10:30:12Z moneta $
	// Author: Kyle Cranmer, Akira Shibata	// Author: Kyle Cranmer, Akira Shibata
	/*************************************************************************	/*************************************************************************
	* 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_CONFIGPARSER_h	#ifndef ROOSTATS_CONFIGPARSER_h
	#define ROOSTATS_CONFIGPARSER_h	#define ROOSTATS_CONFIGPARSER_h

	#include <cstdlib>	#include <cstdlib>
	#include <string>	#include <string>
	#include <TXMLNode.h>	#include <TXMLNode.h>

	#include "TList.h"	#include "TList.h"
	#include "TFile.h"	#include "TFile.h"
	#include "TXMLAttr.h"	#include "TXMLAttr.h"


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

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


	//using namespace std;

	// KC: Should make this a class and have it do some of what is done in Make
	ModelAndMeasurements

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

	class ConfigParser {	class ConfigParser {

	public:	public:

	// The "main" method	// The "main" method
	std::vector< RooStats::HistFactory::Measurement > GetMeasurementsFro mXML(std::string input);	std::vector< RooStats::HistFactory::Measurement > GetMeasurementsFro mXML(std::string input);


	// Another alternet method
	// void FillMeasurementsAndChannelsFromXML(std::string input,
	// std::vector< RooStats::HistFa
	ctory::Measurement >&,
	// std::vector< RooStats::HistFa
	ctory::Channel >&);

	RooStats::HistFactory::Measurement CreateMeasurementFromDriverNode( TXMLNode* node );	RooStats::HistFactory::Measurement CreateMeasurementFromDriverNode( TXMLNode* node );
	RooStats::HistFactory::Channel ParseChannelXMLFile( std::string file n );	RooStats::HistFactory::Channel ParseChannelXMLFile( std::string file n );

	// Helpers used to process a channel	// Helpers used to process a channel
	HistFactory::Data CreateDataElement( TXMLNode* node );	HistFactory::Data CreateDataElement( TXMLNode* node );
	HistFactory::Sample CreateSampleElement( TXMLNode* node );	HistFactory::Sample CreateSampleElement( TXMLNode* node );
	HistFactory::StatErrorConfig CreateStatErrorConfigElement( TXMLNode* node );	HistFactory::StatErrorConfig CreateStatErrorConfigElement( TXMLNode* node );

	// Helpers used when processing a Sample	// Helpers used when processing a Sample
	HistFactory::NormFactor MakeNormFactor( TXMLNode* node );	HistFactory::NormFactor MakeNormFactor( TXMLNode* node );
	HistFactory::HistoSys MakeHistoSys( TXMLNode* node );	HistFactory::HistoSys MakeHistoSys( TXMLNode* node );
	HistFactory::HistoFactor MakeHistoFactor( TXMLNode* node );	HistFactory::HistoFactor MakeHistoFactor( TXMLNode* node );
	HistFactory::OverallSys MakeOverallSys( TXMLNode* node );	HistFactory::OverallSys MakeOverallSys( TXMLNode* node );
	HistFactory::ShapeFactor MakeShapeFactor( TXMLNode* node );	HistFactory::ShapeFactor MakeShapeFactor( TXMLNode* node );
	HistFactory::ShapeSys MakeShapeSys( TXMLNode* node );	HistFactory::ShapeSys MakeShapeSys( TXMLNode* node );
	HistFactory::StatError ActivateStatError( TXMLNode* node );	HistFactory::StatError ActivateStatError( TXMLNode* node );
	HistFactory::PreprocessFunction ParseFunctionConfig( TXMLNode* funct ionNode );	HistFactory::PreprocessFunction ParseFunctionConfig( TXMLNode* funct ionNode );


	// To be deprecated
	/*
	typedef std::pair<double,double> UncertPair;
	void AddSystematic( RooStats::HistFactory::EstimateSummary &, TXMLNo
	de*, std::string, std::string,std::string);
	void ReadXmlConfig( std::string, std::vector<RooStats::HistFactory::
	Channel>& , Double_t );
	*/

	protected:	protected:

	bool CheckTrueFalse( std::string val, std::string Name );	bool CheckTrueFalse( std::string val, std::string Name );
	bool IsAcceptableNode( TXMLNode* functionNode );	bool IsAcceptableNode( TXMLNode* functionNode );

	// To facilitate writing xml, when not	// To facilitate writing xml, when not
	// specified, files and paths default	// specified, files and paths default
	// to these cached values	// to these cached values
	std::string m_currentInputFile;	std::string m_currentInputFile;
	std::string m_currentChannel;	std::string m_currentChannel;

	// std::string m_currentHistoName;
	std::string m_currentHistoPath;	std::string m_currentHistoPath;

	};	};
	}	}
	}	}

	#endif	#endif

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

	Data.h	Data.h

		// @(#)root/roostats:$Id: Data.h 47093 2012-11-07 10:30:12Z moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

	#ifndef HISTFACTORY_DATA_H	#ifndef HISTFACTORY_DATA_H
	#define HISTFACTORY_DATA_H	#define HISTFACTORY_DATA_H

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

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

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

	class Data {	class Data {

	public:	public:
	//friend class Channel;	//friend class Channel;


	Data() {;}	Data();
	Data( std::string HistoName, std::string InputFile, std::string HistoPath ="" );	Data( std::string HistoName, std::string InputFile, std::string HistoPath ="" );


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

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

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

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

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

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

	protected:	protected:


		std::string fName;

	std::string fInputFile;	std::string fInputFile;
	std::string fHistoName;	std::string fHistoName;
	std::string fHistoPath;	std::string fHistoPath;

	// The Data Histogram	// The Data Histogram
	TRef fhData;	TRef fhData;

	};	};

	}	}

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

	DetailedOutputAggregator.h	DetailedOutputAggregator.h

	skipping to change at line 38	skipping to change at line 38

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

	class RooAbsCollection;	class RooAbsCollection;
	class RooFitResult;	class RooFitResult;
	class RooDataSet;	class RooDataSet;
	class RooArgList;	class RooArgList;

		class RooArgSet;

	namespace RooStats {	namespace RooStats {

	class DetailedOutputAggregator {	class DetailedOutputAggregator {

	public:	public:
	// Translate the given fit result to a RooArgSet in a generic way.	// Translate the given fit result to a RooArgSet in a generic way.
	// Prefix is prepended to all variable names.	// Prefix is prepended to all variable names.
	static RooArgSet GetAsArgSet(RooFitResult result, TString prefix="" , bool withErrorsAndPulls=false);	static RooArgSet GetAsArgSet(RooFitResult result, TString prefix="" , bool withErrorsAndPulls=false);


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

	Factory.h	Factory.h

	// @(#)root/mathcore:$Id: Factory.h 37448 2010-12-09 20:20:56Z moneta $	// @(#)root/tmva $Id: Factory.h 40005 2011-06-27 15:29:10Z stelzer $
	// Author: L. Moneta Fri Dec 22 14:43:33 2006	// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Ka
		i Voss, Eckhard von Toerne, Jan Therhaag


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

		#ifndef ROOT_TMVA_Factory
		#define ROOT_TMVA_Factory

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

	#include <string>	#include <string>

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

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

		class TFile;
		class TTree;
		class TDirectory;

		namespace TMVA {

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

		class Factory : public Configurable {
		public:

		typedef std::vector<IMethod*> MVector;

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

		// default destructor
		virtual ~Factory();

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

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

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

		// special case: signal/background

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

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

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

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

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

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

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

		// general

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

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

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

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

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

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

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

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

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

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

		// testing
		void TestAllMethods();

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

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

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

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

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

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

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

		private:

		// the beautiful greeting message
		void Greetings();

		void WriteDataInformation();

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

		private:

		// data members

		DataSetManager* fDataSetManager; // DSMTEST

		static TFile* fgTargetFile; //! ROOT
		output file

		DataInputHandler* fDataInputHandler;

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

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

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

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

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

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


	namespace ROOT {	protected:

	namespace Math {

	class Minimizer;
	class DistSampler;

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

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

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

	};


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


	} // end namespace ROOT	} // namespace TMVA


	#endif /* ROOT_Fit_MinimizerFactory */	#endif

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

	HistFactoryException.h	HistFactoryException.h

		// @(#)root/roostats:$Id: HistFactoryException.h 47093 2012-11-07 10:30:12Z
		moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

	#ifndef HISTFACTORY_EXCEPTION	#ifndef HISTFACTORY_EXCEPTION
	#define HISTFACTORY_EXCEPTION	#define HISTFACTORY_EXCEPTION

	#include <iostream>	#include <iostream>
	#include <exception>	#include <exception>

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


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

	HistFactoryNavigation.h	HistFactoryNavigation.h

	skipping to change at line 18	skipping to change at line 18

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

	#include "RooDataSet.h"	#include "RooDataSet.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooWorkspace.h"	#include "RooWorkspace.h"
	#include "RooSimultaneous.h"	#include "RooSimultaneous.h"
	#include "RooCategory.h"	#include "RooCategory.h"

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

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

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

	class HistFactoryNavigation {	class HistFactoryNavigation {

	public:	public:

	// Initialze based on an already-created HistFactory Model	// Initialze based on an already-created HistFactory Model
	HistFactoryNavigation(ModelConfig* mc);	HistFactoryNavigation(ModelConfig* mc);

		HistFactoryNavigation(const std::string& File,
		const std::string& WorkspaceName="combined",
		const std::string& ModelConfigName="ModelConfig"
		);
		HistFactoryNavigation(RooAbsPdf* model, RooArgSet* observables);

	virtual ~HistFactoryNavigation() {}	virtual ~HistFactoryNavigation() {}


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

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

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

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

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

	// Get the uncertainty based on the constraint term for a given syste
	matic
	double GetConstraintUncertainty(const std::string& parameter);

	// Should pretty print all channels and the current values	// Should pretty print all channels and the current values
	void PrintState();	void PrintState();
	// Should pretty print this and the current values	// Should pretty print this and the current values
	void PrintState(const std::string& channel);	void PrintState(const std::string& channel);

	// Print the current values and errors of pdf parameters	// Print the current values and errors of pdf parameters
	void PrintParameters(bool IncludeConstantParams=false);	void PrintParameters(bool IncludeConstantParams=false);


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

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

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

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

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

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

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


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

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

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

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

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

		// Get the uncertainty based on the constraint term for a given syste
		matic
		double GetConstraintUncertainty(const std::string& parameter);

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

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

		void SetNumBinsToPrint(int num) { _numBinsToPrint = num; }
		int GetNumBinsToPrint() const { return _numBinsToPrint; }

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

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

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

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

		/*
		// Add a constraint term to the pdf
		// This method requires that the pdf NOT be simultaneous
		void AddConstraintTerm(RooAbsArg* constraintTerm);

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

	protected:	protected:

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

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


	skipping to change at line 98	skipping to change at line 155
	std::map< std::string, RooAbsReal*> GetSampleFunctionMap(const std::s tring& channel);	std::map< std::string, RooAbsReal*> GetSampleFunctionMap(const std::s tring& channel);

	private:	private:

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

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


		int _numBinsToPrint;

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

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

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

	// Map of channel names to their set of ovservables	// Map of channel names to their set of ovservables
	std::map< std::string, RooArgSet*> fChannelObservMap;	std::map< std::string, RooArgSet*> fChannelObservMap;

	// Map of Map of Channel, Sample names to Function Nodes	// Map of Map of Channel, Sample names to Function Nodes
	// Used by doing: fChannelSampleFunctionMap["MyChannel"]["MySample"]	// Used by doing: fChannelSampleFunctionMap["MyChannel"]["MySample"]
	std::map< std::string, std::map< std::string, RooAbsReal*> > fChannel SampleFunctionMap;	std::map< std::string, std::map< std::string, RooAbsReal*> > fChannel SampleFunctionMap;

	// Internal method implementation of finding a daughter node	// Internal method implementation of finding a daughter node
	// from a parent node (looping over all generations)	// from a parent node (looping over all generations)

	RooAbsReal* findChild(const std::string& name, RooAbsReal* parent);	RooAbsArg* findChild(const std::string& name, RooAbsReal* parent) con
		st;

		// Recursively get all products of products
		RooArgSet _GetAllProducts(RooProduct* node);

	protected:	protected:
	ClassDef(RooStats::HistFactory::HistFactoryNavigation,2)	ClassDef(RooStats::HistFactory::HistFactoryNavigation,2)

	};	};

	}	}
	}	}

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

	HistoToWorkspaceFactoryFast.h	HistoToWorkspaceFactoryFast.h

	skipping to change at line 30	skipping to change at line 30
	#include <RooPlot.h>	#include <RooPlot.h>
	#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/Systematics.h"
	#include "RooStats/HistFactory/Measurement.h"

	class ParamHistFunc;	class ParamHistFunc;

	namespace RooStats{	namespace RooStats{

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


	public:	// Forward Declarations FTW
	typedef std::map<std::string, double> param_map;	class Measurement;
	HistoToWorkspaceFactoryFast( std::string, std::string , std::vector<st	class Channel;
	d::string> , double =200, double =20, int =0, int =6, TFile* =NULL, param_m	class Sample;
	ap = param_map() );
	HistoToWorkspaceFactoryFast( RooStats::HistFactory::Measurement& Meas
	);
	static void ConfigureWorkspaceForMeasurement( const std::string& ModelN
	ame, RooWorkspace* ws_single, Measurement& measurement );


	HistoToWorkspaceFactoryFast();	class HistoToWorkspaceFactoryFast: public TObject {
	virtual ~HistoToWorkspaceFactoryFast();


	RooWorkspace* MakeSingleChannelModel( Measurement& measurement, Channel	public:
	& channel );
	static RooWorkspace* MakeCombinedModel( Measurement& measurement );


	void SetFunctionsToPreprocess(std::vector<std::string> lines){ fPreproc	HistoToWorkspaceFactoryFast();
	essFunctions = lines; }	HistoToWorkspaceFactoryFast( RooStats::HistFactory::Measurement& Mea
		s );
		virtual ~HistoToWorkspaceFactoryFast();


	//ES//	static void ConfigureWorkspaceForMeasurement( const std::string& Mode
	/*	lName,
	void AddEfficiencyTerms(RooWorkspace* proto, std::string prefix, std::s	RooWorkspace* ws_single,
	tring interpName,	Measurement& measurement
	std::map<std::string,std::pair<double,double> >	);
	systMap,
	std::vector<std::string>& likelihoodTermNames, s
	td::vector<std::string>& totSystTermNames);
	*/
	void AddEfficiencyTerms(RooWorkspace* proto, std::string prefix, std::s
	tring interpName,
	std::vector<OverallSys>& systList,
	std::vector<std::string>& likelihoodTermNames, s
	td::vector<std::string>& totSystTermNames);


	//ES// std::string AddNormFactor(RooWorkspace *, std::string & , std::s	RooWorkspace* MakeSingleChannelModel( Measurement& measurement, Chann
	tring & , EstimateSummary & , bool );	el& channel );
	std::string AddNormFactor(RooWorkspace* proto, std::string& channel, st	RooWorkspace* MakeCombinedModel(std::vector<std::string>, std::vecto
	d::string& sigmaEpsilon, Sample& sample, bool doRatio);	r<RooWorkspace*>);


	void AddMultiVarGaussConstraint(RooWorkspace* proto, std::string prefix	static RooWorkspace* MakeCombinedModel( Measurement& measurement );
	,int lowBin, int highBin, std::vector<std::string>& likelihoodTermNames);	static void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* pa
		rams,
		std::string filename);


	void AddPoissonTerms(RooWorkspace* proto, std::string prefix, std::stri	void SetFunctionsToPreprocess(std::vector<std::string> lines) { fPrep
	ng obsPrefix, std::string expPrefix, int lowBin, int highBin,	rocessFunctions=lines; }
	std::vector<std::string>& likelihoodTermNames);


	//void Combine_old();	protected:


	RooWorkspace * MakeCombinedModel(std::vector<std::string>, std::vector	void AddEfficiencyTerms(RooWorkspace* proto, std::string prefix, std:
	<RooWorkspace*>);	:string interpName,
		std::vector<OverallSys>& systList,
		std::vector<std::string>& likelihoodTermNames,
		std::vector<std::string>& totSystTermNames);


	//void Combine_ratio(std::vector<std::string> , std::vector<RooWorkspac	std::string AddNormFactor(RooWorkspace* proto, std::string& channel,
	e*>);	std::string& sigmaEpsilon, Sample& sample, b
		ool doRatio);


	void Customize(RooWorkspace* proto, const char* pdfNameChar, std::map<s	void AddMultiVarGaussConstraint(RooWorkspace* proto, std::string pref
	td::string,std::string> renameMap);	ix,
		int lowBin, int highBin,
		std::vector<std::string>& likelihoodTe
		rmNames);


	static void EditSyst(RooWorkspace* proto, const char* pdfNameChar,	void AddPoissonTerms(RooWorkspace* proto, std::string prefix, std::st
	std::map<std::string,double> gammaSyst, std::map<st	ring obsPrefix,
	d::string,double> uniformSyst, std::map<std::string,double> logNormSyst, st	std::string expPrefix, int lowBin, int highBin,
	d::map<std::string,double> noSyst);	std::vector<std::string>& likelihoodTermNames);


	//void FormatFrameForLikelihood(RooPlot* frame, std::string XTitle=std:	static void EditSyst(RooWorkspace* proto, const char* pdfNameChar,
	:string("#sigma / #sigma_{SM}"), std::string YTitle=std::string("-log likel	std::map<std::string,double> gammaSyst,
	ihood"));	std::map<std::string,double> uniformSyst,
		std::map<std::string,double> logNormSyst,
		std::map<std::string,double> noSyst);


	//ES// void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal,	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, std::
	std::vector<TH1> lowHist, std::vector<TH1> highHist,	vector<HistoSys>,
	//ES// std::vector<std::string> sourceName	std::string prefix, std::string productPr
	, std::string prefix, std::string productPrefix, std::string systTerm,	efix,
	//ES// int lowBin, int highBin, std::vecto	std::string systTerm,
	r<std::string>& likelihoodTermNames);	std::vector<std::string>& likelihoodTermN
	void LinInterpWithConstraint(RooWorkspace* proto, TH1* nominal, std::ve	ames);
	ctor<HistoSys>, std::string prefix, std::string productPrefix, std::string
	systTerm,
	int lowBin, int highBin, std::vector<std::s
	tring>& likelihoodTermNames);


	TDirectory* Makedirs( TDirectory* file, std::vector<std::string> names );	RooWorkspace* MakeSingleChannelWorkspace(Measurement& measurement, Ch annel& channel);


	//ES// RooWorkspace* MakeSingleChannelModel(std::vector<RooStats::HistF	void MakeTotalExpected(RooWorkspace* proto, std::string totName,
	actory::EstimateSummary> summary, std::vector<std::string> systToFix, bool	std::vector<std::string>& syst_x_expectedPrefix
	doRatio=false);	Names,
	// GHL: Renaming to "MakeSingleChannelWorkspace"	std::vector<std::string>& normByNames);
	RooWorkspace* MakeSingleChannelWorkspace(Measurement& measurement, Chan
	nel& channel);


	void MakeTotalExpected(RooWorkspace* proto, std::string totName, std::	RooDataSet* MergeDataSets(RooWorkspace* combined,
	string //, std::string //,	std::vector<RooWorkspace*> wspace_vec,
	int lowBin, int highBin, std::vector<std::string	std::vector<std::string> channel_names,
	>& syst_x_expectedPrefixNames,	std::string dataSetName,
	std::vector<std::string>& normByNames);	RooArgList obsList,
		RooCategory* channelCat);


	TDirectory* Mkdir( TDirectory * file, std::string name );	void ProcessExpectedHisto(TH1* hist, RooWorkspace* proto, std::string
		prefix,
		std::string productPrefix, std::string systT
		erm );


	static void PrintCovarianceMatrix(RooFitResult* result, RooArgSet* para	void SetObsToExpected(RooWorkspace* proto, std::string obsPrefix, std
	ms, std::string filename);	::string expPrefix,
	void ProcessExpectedHisto(TH1* hist,RooWorkspace* proto, std::string pr	int lowBin, int highBin);
	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	TH1* MakeScaledUncertaintyHist(const std::string& Name,
	td::pair<TH1,TH1> > HistVec );	std::vector< std::pair<TH1, TH1> > Hi
	TH1* MakeAbsolUncertaintyHist( const std::string& Name, const TH1* Hist	stVec );
	);
	RooArgList createStatConstraintTerms( RooWorkspace* proto, std::vector<
	std::string>& constraintTerms, ParamHistFunc& paramHist, TH1* uncertHist,
	EstimateSummary::ConstraintType ty
	pe, Double_t minSigma );


	inline void SetObsNameVec(const std::vector<std::string>& obsNameVec) {	TH1* MakeAbsolUncertaintyHist( const std::string& Name, const TH1* Hi
	fObsNameVec = obsNameVec; }	st );
	inline void SetObsName(const std::string& obsName) { fObsNameVec.clear(
	); fObsNameVec.push_back(obsName); fObsName = obsName; }
	inline void AddObsName(const std::string& obsName) { fObsNameVec.push_b
	ack(obsName); }


	//string fFileNamePrefix;	RooArgList createStatConstraintTerms( RooWorkspace* proto,
	//string fRowTitle;	std::vector<std::string>& constr
	std::vector<std::string> fSystToFix;	aintTerms,
	std::map<std::string, double> fParamValues;	ParamHistFunc& paramHist, TH1* u
	double fNomLumi, fLumiError;	ncertHist,
	int fLowBin, fHighBin;	Constraint::Type type, Double_t
	//std::stringstream fResultsPrefixStr;	minSigma );
	//TFile * fOut_f;
	// FILE * pFile;


	private:	void ConfigureHistFactoryDataset(RooDataSet* obsData, TH1* nominal, R
		ooWorkspace* proto,
		std::vector<std::string> obsNameVec);


	void GuessObsNameVec(TH1* hist);	std::vector<std::string> fSystToFix;
		std::map<std::string, double> fParamValues;
		double fNomLumi;
		double fLumiError;
		int fLowBin;
		int fHighBin;


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


	ClassDef(RooStats::HistFactory::HistoToWorkspaceFactoryFast,3)	void GuessObsNameVec(TH1* hist);
	};


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

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

		}
	}	}

	#endif	#endif

End of changes. 30 change blocks.
	123 lines changed or deleted	106 lines changed or added

	HypoTestCalculatorGeneric.h	HypoTestCalculatorGeneric.h

	skipping to change at line 76	skipping to change at line 76
	// set the model for the alternate hypothesis (S+B)	// set the model for the alternate hypothesis (S+B)
	virtual void SetAlternateModel(const ModelConfig &altModel) { fAltMod el = &altModel; }	virtual void SetAlternateModel(const ModelConfig &altModel) { fAltMod el = &altModel; }
	const ModelConfig* GetAlternateModel(void) const { return fAltModel; }	const ModelConfig* GetAlternateModel(void) const { return fAltModel; }
	// Set the DataSet	// Set the DataSet
	virtual void SetData(RooAbsData &data) { fData = &data; }	virtual void SetData(RooAbsData &data) { fData = &data; }

	// Returns instance of TestStatSampler. Use to change properties of	// Returns instance of TestStatSampler. Use to change properties of
	// TestStatSampler, e.g. GetTestStatSampler.SetTestSize(Double_t size );	// TestStatSampler, e.g. GetTestStatSampler.SetTestSize(Double_t size );
	TestStatSampler* GetTestStatSampler(void) const { return fTestStatSam pler; }	TestStatSampler* GetTestStatSampler(void) const { return fTestStatSam pler; }


		// set this for re-using always the same toys for alternate hypothesi
		s in
		// case of calls at dofferent null parameter points
		// This is useful to get more stable bands when running the HypoTest
		inversion
		void UseSameAltToys();

	protected:	protected:
	// should return zero (to be used later for conditional flow)	// should return zero (to be used later for conditional flow)
	virtual int CheckHook(void) const { return 0; }	virtual int CheckHook(void) const { return 0; }
	virtual int PreNullHook(RooArgSet* /parameterPoint/, double /obsTe stStat/) const { return 0; }	virtual int PreNullHook(RooArgSet* /parameterPoint/, double /obsTe stStat/) const { return 0; }
	virtual int PreAltHook(RooArgSet* /parameterPoint/, double /obsTes tStat/) const { return 0; }	virtual int PreAltHook(RooArgSet* /parameterPoint/, double /obsTes tStat/) const { return 0; }
	virtual void PreHook() const { }	virtual void PreHook() const { }
	virtual void PostHook() const { }	virtual void PostHook() const { }

	protected:	protected:
	const ModelConfig *fAltModel;	const ModelConfig *fAltModel;
	const ModelConfig *fNullModel;	const ModelConfig *fNullModel;
	const RooAbsData *fData;	const RooAbsData *fData;
	TestStatSampler *fTestStatSampler;	TestStatSampler *fTestStatSampler;
	TestStatSampler *fDefaultSampler;	TestStatSampler *fDefaultSampler;
	TestStatistic *fDefaultTestStat;	TestStatistic *fDefaultTestStat;


		unsigned int fAltToysSeed; // to have same toys for alternate

	private:	private:
	void SetupSampler(const ModelConfig& model) const;	void SetupSampler(const ModelConfig& model) const;
	void SetAdaptiveLimits(Double_t obsTestStat, Bool_t forNull) const;	void SetAdaptiveLimits(Double_t obsTestStat, Bool_t forNull) const;
	SamplingDistribution* GenerateSamplingDistribution(	SamplingDistribution* GenerateSamplingDistribution(
	ModelConfig *thisModel,	ModelConfig *thisModel,
	double obsTestStat,	double obsTestStat,
	RooAbsPdf *impDens=NULL,	RooAbsPdf *impDens=NULL,
	const RooArgSet *impSnapshot=NULL	const RooArgSet *impSnapshot=NULL
	) const;	) const;

	protected:	protected:

	ClassDef(HypoTestCalculatorGeneric,1)	ClassDef(HypoTestCalculatorGeneric,2)
	};	};
	}	}

	#endif	#endif

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

	MakeModelAndMeasurementsFast.h	MakeModelAndMeasurementsFast.h

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

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

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


		void fastDriver(std::string input);

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

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

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

	void FormatFrameForLikelihood(RooPlot* frame, std::string xTitle=std::s tring("#sigma / #sigma_{SM}"), std::string yTitle=std::string("-log likelih ood"));	void FormatFrameForLikelihood(RooPlot* frame, std::string xTitle=std::s tring("#sigma / #sigma_{SM}"), std::string yTitle=std::string("-log likelih ood"));

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

	Measurement.h	Measurement.h

		// @(#)root/roostats:$Id: Measurement.h 47093 2012-11-07 10:30:12Z moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

	#ifndef HISTFACTORY_MEASUREMENT_H	#ifndef HISTFACTORY_MEASUREMENT_H
	#define HISTFACTORY_MEASUREMENT_H	#define HISTFACTORY_MEASUREMENT_H

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

	#include "TObject.h"	#include "TObject.h"
	#include "TFile.h"	#include "TFile.h"

	#include "PreprocessFunction.h"	#include "PreprocessFunction.h"
	#include "RooStats/HistFactory/Channel.h"	#include "RooStats/HistFactory/Channel.h"

		#include "RooStats/HistFactory/Asimov.h"

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

	class Measurement : public TNamed {	class Measurement : public TNamed {

	public:	public:

	Measurement();	Measurement();
	// Measurement( const Measurement& other ); // Copy	// Measurement( const Measurement& other ); // Copy

	skipping to change at line 55	skipping to change at line 65
	void SetParamValue( const std::string& param, double value);	void SetParamValue( const std::string& param, double value);
	std::map<std::string, double>& GetParamValues() { return fParamValues; }	std::map<std::string, double>& GetParamValues() { return fParamValues; }
	void ClearParamValues() { fParamValues.clear(); }	void ClearParamValues() { fParamValues.clear(); }

	void AddPreprocessFunction( std::string name, std::string expression, std ::string dependencies );	void AddPreprocessFunction( std::string name, std::string expression, std ::string dependencies );
	void AddFunctionObject( const RooStats::HistFactory::PreprocessFunction f unction) { fFunctionObjects.push_back( function ); }	void AddFunctionObject( const RooStats::HistFactory::PreprocessFunction f unction) { fFunctionObjects.push_back( function ); }
	void SetFunctionObjects( std::vector< RooStats::HistFactory::PreprocessFu nction > objects ) { fFunctionObjects = objects; }	void SetFunctionObjects( std::vector< RooStats::HistFactory::PreprocessFu nction > objects ) { fFunctionObjects = objects; }
	std::vector< RooStats::HistFactory::PreprocessFunction >& GetFunctionObje cts() { return fFunctionObjects; }	std::vector< RooStats::HistFactory::PreprocessFunction >& GetFunctionObje cts() { return fFunctionObjects; }
	std::vector< std::string > GetPreprocessFunctions();	std::vector< std::string > GetPreprocessFunctions();


	// Make these dynamically from the list of preprocess functions	// Get and set Asimov Datasets
	// instead of storing them	std::vector< RooStats::HistFactory::Asimov >& GetAsimovDatasets() { retur
	// void AddPreprocessFunction( const std::string& function ) { fPreproces	n fAsimovDatasets; }
	sFunctions.push_back( function ); }	void AddAsimovDataset( RooStats::HistFactory::Asimov dataset ) { fAsimovD
	// void SetPreprocessFunctions( std::vector< std::string > functions ) {	atasets.push_back(dataset); }
	fPreprocessFunctions = functions; }
	// std::vector< std::string >& GetPreprocessFunctions() { return fPrepro
	cessFunctions; }
	// void ClearPreprocessFunctions() { fPreprocessFunctions.clear(); }

	/*
	<ParamSetting Const=\"True\" Val=\"%g\">%s</ParamSetting>\n" % (setting
	[1],param)
	<ConstraintTerm Type=\"%s\" RelativeUncertainty=\"%g\">%s</ConstraintTe
	rm>\n" % (constraint[0],constraint[1],param)
	*/

	void SetLumi(double Lumi ) { fLumi = Lumi; }	void SetLumi(double Lumi ) { fLumi = Lumi; }
	void SetLumiRelErr( double RelErr ) { fLumiRelErr = RelErr; }	void SetLumiRelErr( double RelErr ) { fLumiRelErr = RelErr; }
	double GetLumi() { return fLumi; }	double GetLumi() { return fLumi; }
	double GetLumiRelErr() { return fLumiRelErr; }	double GetLumiRelErr() { return fLumiRelErr; }

	void SetBinLow( int BinLow ) { fBinLow = BinLow; }	void SetBinLow( int BinLow ) { fBinLow = BinLow; }
	void SetBinHigh ( int BinHigh ) { fBinHigh = BinHigh; }	void SetBinHigh ( int BinHigh ) { fBinHigh = BinHigh; }
	int GetBinLow() { return fBinLow; }	int GetBinLow() { return fBinLow; }
	int GetBinHigh() { return fBinHigh; }	int GetBinHigh() { return fBinHigh; }

	skipping to change at line 125	skipping to change at line 127
	std::vector< RooStats::HistFactory::Channel > fChannels;	std::vector< RooStats::HistFactory::Channel > fChannels;

	// List of Parameters to be set constant	// List of Parameters to be set constant
	std::vector< std::string > fConstantParams;	std::vector< std::string > fConstantParams;

	// Map of parameter names to inital values to be set	// Map of parameter names to inital values to be set
	std::map< std::string, double > fParamValues;	std::map< std::string, double > fParamValues;

	// List of Preprocess Function objects	// List of Preprocess Function objects
	std::vector< RooStats::HistFactory::PreprocessFunction > fFunctionObjects ;	std::vector< RooStats::HistFactory::PreprocessFunction > fFunctionObjects ;

	// std::vector< std::string > fPreprocessFunctions;
		// List of Asimov datasets to generate
		std::vector< RooStats::HistFactory::Asimov > fAsimovDatasets;

	// List of Alternate constraint terms	// List of Alternate constraint terms
	std::map< std::string, double > fGammaSyst;	std::map< std::string, double > fGammaSyst;
	std::map< std::string, double > fUniformSyst;	std::map< std::string, double > fUniformSyst;
	std::map< std::string, double > fLogNormSyst;	std::map< std::string, double > fLogNormSyst;
	std::map< std::string, double > fNoSyst;	std::map< std::string, double > fNoSyst;

	std::string GetDirPath( TDirectory* dir );	std::string GetDirPath( TDirectory* dir );

	ClassDef(RooStats::HistFactory::Measurement, 1);	ClassDef(RooStats::HistFactory::Measurement, 1);

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

	ParamHistFunc.h	ParamHistFunc.h

	/**************************************************************************	// @(#)root/roostats:$Id: cranmer $
	***	// Author: George Lewis, Kyle Cranmer
	* Project: RooFit	/*************************************************************************
	*	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	* Package: RooFitCore	* All rights reserved. *
	*	* *
	* File: $Id: ParamHistFunc.h,v 1.3 2007/05/11 09:11:30 verkerke Exp $	* For the licensing terms see $ROOTSYS/LICENSE. *
	* Authors:	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*	*************************************************************************/
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu
	*
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu
	*
	*
	*
	* Copyright (c) 2000-2005, Regents of the University of California
	*
	* and Stanford University. All rights reserved.
	*
	*
	*
	* Redistribution and use in source and binary forms,
	*
	* with or without modification, are permitted according to the terms
	*
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt)
	*
	**************************************************************************
	***/

	#ifndef ROO_PARAMHISTFUNC	#ifndef ROO_PARAMHISTFUNC
	#define ROO_PARAMHISTFUNC	#define ROO_PARAMHISTFUNC

	#include <map>	#include <map>
	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooListProxy.h"	#include "RooListProxy.h"
	#include "RooObjCacheManager.h"	#include "RooObjCacheManager.h"
	#include "RooDataHist.h"	#include "RooDataHist.h"

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

	// Turn into a RooListProxy	// Turn into a RooListProxy
	//RooRealProxy _dataVar; // The RooRealVar	//RooRealProxy _dataVar; // The RooRealVar
	RooListProxy _dataVars; // The RooRealVars	RooListProxy _dataVars; // The RooRealVars
	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;

		Bool_t _Normalized;

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


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

	RVersion.h	RVersion.h

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


	#define ROOT_RELEASE "5.34/03"	#define ROOT_RELEASE "5.34/04"
	#define ROOT_RELEASE_DATE "Oct 27 2012"	#define ROOT_RELEASE_DATE "Jan 10 2013"
	#define ROOT_RELEASE_TIME "23:08:14"	#define ROOT_RELEASE_TIME "16:43:26"
	#define ROOT_SVN_REVISION 46829	#define ROOT_SVN_REVISION 48256
	#define ROOT_SVN_BRANCH "branches/v5-34-00-patches"	#define ROOT_SVN_BRANCH "branches/v5-34-00-patches"

	#define ROOT_VERSION_CODE 336387	#define ROOT_VERSION_CODE 336388
	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define ROOT_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

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

	RooAbsReal.h	RooAbsReal.h

	skipping to change at line 295	skipping to change at line 295

	RooMoment* mean(RooRealVar& obs) { return moment(obs,1,kFALSE,kFALSE) ; }	RooMoment* mean(RooRealVar& obs) { return moment(obs,1,kFALSE,kFALSE) ; }
	RooMoment* mean(RooRealVar& obs, const RooArgSet& nset) { return moment(o bs,nset,1,kFALSE,kFALSE,kTRUE) ; }	RooMoment* mean(RooRealVar& obs, const RooArgSet& nset) { return moment(o bs,nset,1,kFALSE,kFALSE,kTRUE) ; }
	RooMoment* sigma(RooRealVar& obs) { return moment(obs,2,kTRUE,kTRUE) ; }	RooMoment* sigma(RooRealVar& obs) { return moment(obs,2,kTRUE,kTRUE) ; }
	RooMoment* sigma(RooRealVar& obs, const RooArgSet& nset) { return moment( obs,nset,2,kTRUE,kTRUE,kTRUE) ; }	RooMoment* sigma(RooRealVar& obs, const RooArgSet& nset) { return moment( obs,nset,2,kTRUE,kTRUE,kTRUE) ; }

	Double_t findRoot(RooRealVar& x, Double_t xmin, Double_t xmax, Double_t y val) ;	Double_t findRoot(RooRealVar& x, Double_t xmin, Double_t xmax, Double_t y val) ;

	virtual Bool_t setData(RooAbsData& /data/, Bool_t /cloneData/=kTRUE) { return kTRUE ; }	virtual Bool_t setData(RooAbsData& /data/, Bool_t /cloneData/=kTRUE) { return kTRUE ; }


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

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

	protected:	protected:

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

	// Hook for objects with normalization-dependent parameters interperetati on	// Hook for objects with normalization-dependent parameters interperetati on
	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;	virtual void selectNormalization(const RooArgSet* depSet=0, Bool_t force= kFALSE) ;
	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;	virtual void selectNormalizationRange(const char* rangeName=0, Bool_t for ce=kFALSE) ;

	// Helper functions for plotting	// Helper functions for plotting

	skipping to change at line 453	skipping to change at line 460
	friend class RooAddModel ;	friend class RooAddModel ;
	void selectComp(Bool_t flag) {	void selectComp(Bool_t flag) {
	// If flag is true, only selected component will be included in evaluat es of RooAddPdf components	// If flag is true, only selected component will be included in evaluat es of RooAddPdf components
	_selectComp = flag ;	_selectComp = flag ;
	}	}
	static void globalSelectComp(Bool_t flag) ;	static void globalSelectComp(Bool_t flag) ;
	Bool_t _selectComp ; //! Component selection flag for RooAb sPdf::plotCompOn	Bool_t _selectComp ; //! Component selection flag for RooAb sPdf::plotCompOn
	static Bool_t _globalSelectComp ; // Global activation switch for compon ent selection	static Bool_t _globalSelectComp ; // Global activation switch for compon ent selection

	mutable RooArgSet* _lastNSet ; //!	mutable RooArgSet* _lastNSet ; //!

		static Bool_t _hideOffset ; // Offset hiding flag

	ClassDef(RooAbsReal,2) // Abstract real-valued variable	ClassDef(RooAbsReal,2) // Abstract real-valued variable
	};	};

	#endif	#endif

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

	RooAbsTestStatistic.h	RooAbsTestStatistic.h

	skipping to change at line 60	skipping to change at line 60
	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;	virtual void constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlso TrackingOpt=kTRUE) ;

	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const = 0 ;	virtual Double_t combinedValue(RooAbsReal** gofArray, Int_t nVal) const = 0 ;
	virtual Double_t globalNormalization() const {	virtual Double_t globalNormalization() const {
	// Default value of global normalization factor is 1.0	// Default value of global normalization factor is 1.0
	return 1.0 ;	return 1.0 ;
	}	}

	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;


		void enableOffsetting(Bool_t flag) ;
		Bool_t isOffsetting() const { return _doOffset ; }
		virtual Double_t offset() const { return _offset ; }

	protected:	protected:

	virtual void printCompactTreeHook(std::ostream& os, const char* indent="" ) ;	virtual void printCompactTreeHook(std::ostream& os, const char* indent="" ) ;

	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;	virtual Bool_t redirectServersHook(const RooAbsCollection& newServerList, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursive) ;
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;

	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const = 0 ;	virtual Double_t evaluatePartition(Int_t firstEvent, Int_t lastEvent, Int _t stepSize) const = 0 ;

	void setMPSet(Int_t setNum, Int_t numSets) ;	void setMPSet(Int_t setNum, Int_t numSets) ;

	skipping to change at line 133	skipping to change at line 137

	// Simultaneous mode data	// Simultaneous mode data
	Int_t _nGof ; // Number of sub-contexts	Int_t _nGof ; // Number of sub-contexts
	pRooAbsTestStatistic* _gofArray ; //! Array of sub-contexts representing part of the combined test statistic	pRooAbsTestStatistic* _gofArray ; //! Array of sub-contexts representing part of the combined test statistic

	// Parallel mode data	// Parallel mode data
	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode	Int_t _nCPU ; // Number of processors to use in parallel c alculation mode
	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends	pRooRealMPFE* _mpfeArray ; //! Array of parallel execution frond ends

	Bool_t _mpinterl ; // Use interleaving strategy rather than N-wis e split for partioning of dataset for multiprocessor-split	Bool_t _mpinterl ; // Use interleaving strategy rather than N-wis e split for partioning of dataset for multiprocessor-split

		Bool_t _doOffset ; // Apply interval value offset to control nume
		ric precision?
		mutable Double_t _offset ; //! Offset


	ClassDef(RooAbsTestStatistic,1) // Abstract base class for real-valued te st statistics	ClassDef(RooAbsTestStatistic,2) // Abstract base class for real-valued te st statistics
	};	};

	#endif	#endif

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

	RooAddition.h	RooAddition.h

	skipping to change at line 57	skipping to change at line 57
	}	}
	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& numVars, const char* rangeName=0) const;	Int_t getAnalyticalIntegral(RooArgSet& allVars, RooArgSet& numVars, const char* rangeName=0) const;
	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;	Double_t analyticalIntegral(Int_t code, const char* rangeName=0) const ;

	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;	Bool_t setData(RooAbsData& data, Bool_t cloneData=kTRUE) ;

	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/, Double_t /xlo/, Double_t /xhi/) const ;	virtual std::list<Double_t>* plotSamplingHint(RooAbsRealLValue& /obs/, Double_t /xlo/, Double_t /xhi/) const ;
	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;	Bool_t isBinnedDistribution(const RooArgSet& obs) const ;


		virtual void enableOffsetting(Bool_t) ;

	protected:	protected:

	RooArgList _ownedList ; // List of owned components	RooArgList _ownedList ; // List of owned components
	RooListProxy _set ; // set of terms to be summed	RooListProxy _set ; // set of terms to be summed
	mutable TIterator* _setIter ; //! Iterator over set	mutable TIterator* _setIter ; //! Iterator over set

	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	virtual ~CacheElem();	virtual ~CacheElem();
	// Payload	// Payload

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

	RooBarlowBeestonLL.h	RooBarlowBeestonLL.h

	/**************************************************************************	// @(#)root/roostats:$Id: RooBarlowBeestonLL.h 47093 2012-11-07 10:30:12Z m
	***	oneta $
	* Project: RooFit	// Author: George Lewis, Kyle Cranmer
	*	/*************************************************************************
	*	* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
	*	* All rights reserved. *
	* Copyright (c) 2000-2005, Regents of the University of California	* *
	*	* For the licensing terms see $ROOTSYS/LICENSE. *
	* and Stanford University. All rights reserved.	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*	*************************************************************************/
	*
	*
	* Redistribution and use in source and binary forms,
	*
	* with or without modification, are permitted according to the terms
	*
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt)
	*
	**************************************************************************
	***/

	#ifndef ROOBARLOWBEESTONLL	#ifndef ROOBARLOWBEESTONLL
	#define ROOBARLOWBEESTONLL	#define ROOBARLOWBEESTONLL

	#include "RooAbsReal.h"	#include "RooAbsReal.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooSetProxy.h"	#include "RooSetProxy.h"
	#include <map>	#include <map>
	#include <set>	#include <set>
	#include <string>	#include <string>

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

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

	* File: $Id: RooConstraintSum.h 31654 2009-12-08 13:38:37Z wouter $	* File: $Id: RooConstraintSum.h 47307 2012-11-15 12:12:32Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* *	* *
	* Copyright (c) 2000-2005, Regents of the University of California *	* Copyright (c) 2000-2005, Regents of the University of California *
	* and Stanford University. All rights reserved. *	* and Stanford University. All rights reserved. *
	* *	* *
	* Redistribution and use in source and binary forms, *	* Redistribution and use in source and binary forms, *
	* with or without modification, are permitted according to the terms *	* with or without modification, are permitted according to the terms *
	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *	* listed in LICENSE (http://roofit.sourceforge.net/license.txt) *

	skipping to change at line 36	skipping to change at line 36
	class RooConstraintSum : public RooAbsReal {	class RooConstraintSum : public RooAbsReal {
	public:	public:

	RooConstraintSum() ;	RooConstraintSum() ;
	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet, const RooArgSet& paramSet) ;	RooConstraintSum(const char name, const char title, const RooArgSet& co nstraintSet, const RooArgSet& paramSet) ;
	virtual ~RooConstraintSum() ;	virtual ~RooConstraintSum() ;

	RooConstraintSum(const RooConstraintSum& other, const char* name = 0);	RooConstraintSum(const RooConstraintSum& other, const char* name = 0);
	virtual TObject* clone(const char* newname) const { return new RooConstra intSum(*this, newname); }	virtual TObject* clone(const char* newname) const { return new RooConstra intSum(*this, newname); }


		const RooArgList& list() { return _set1 ; }

	protected:	protected:

	RooListProxy _set1 ; // Set of constraint terms	RooListProxy _set1 ; // Set of constraint terms
	RooSetProxy _paramSet ; // Set of parameters to which constraints apply	RooSetProxy _paramSet ; // Set of parameters to which constraints apply
	TIterator* _setIter1 ; //! do not persist	TIterator* _setIter1 ; //! do not persist

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

	ClassDef(RooConstraintSum,2) // sum of -log of set of RooAbsPdf represent ing parameter constraints	ClassDef(RooConstraintSum,2) // sum of -log of set of RooAbsPdf represent ing parameter constraints
	};	};

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

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

	* File: $Id: RooMinimizer.h 44982 2012-07-10 08:36:13Z moneta $	* File: $Id: RooMinimizer.h 47307 2012-11-15 12:12:32Z wouter $
	* Authors: *	* Authors: *
	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *	* WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu *
	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *	* DK, David Kirkby, UC Irvine, dkirkby@uci.edu *
	* 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) *
	************************************************************************ */	************************************************************************ */

	skipping to change at line 50	skipping to change at line 50
	RooMinimizer(RooAbsReal& function) ;	RooMinimizer(RooAbsReal& function) ;
	virtual ~RooMinimizer() ;	virtual ~RooMinimizer() ;

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

		void setOffsetting(Bool_t flag) ;

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

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

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

	RooMinuit.h	RooMinuit.h

	skipping to change at line 52	skipping to change at line 52
	RooMinuit(RooAbsReal& function) ;	RooMinuit(RooAbsReal& function) ;
	virtual ~RooMinuit() ;	virtual ~RooMinuit() ;

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

		void setOffsetting(Bool_t flag) ;

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

	Int_t migrad() ;	Int_t migrad() ;
	Int_t hesse() ;	Int_t hesse() ;
	Int_t minos() ;	Int_t minos() ;
	Int_t minos(const RooArgSet& minosParamList) ; // added FMV, 08/18/03	Int_t minos(const RooArgSet& minosParamList) ; // added FMV, 08/18/03
	Int_t seek() ;	Int_t seek() ;
	Int_t simplex() ;	Int_t simplex() ;
	Int_t improve() ;	Int_t improve() ;

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

	RooNormSetCache.h	RooNormSetCache.h

	skipping to change at line 34	skipping to change at line 34
	#include "RooHashTable.h"	#include "RooHashTable.h"

	class RooArgSet ;	class RooArgSet ;
	class RooSetPair ;	class RooSetPair ;

	typedef RooArgSet* pRooArgSet ;	typedef RooArgSet* pRooArgSet ;

	class RooNormSetCache {	class RooNormSetCache {

	public:	public:

	RooNormSetCache(Int_t regSize=64) ;	RooNormSetCache(Int_t regSize=32) ;
	RooNormSetCache(const RooNormSetCache& other) ;	RooNormSetCache(const RooNormSetCache& other) ;
	virtual ~RooNormSetCache() ;	virtual ~RooNormSetCache() ;

	void add(const RooArgSet* set1, const RooArgSet* set2=0) ;	void add(const RooArgSet* set1, const RooArgSet* set2=0) ;

	inline Int_t index(const RooArgSet* set1, const RooArgSet* set2=0, const TNamed* set2RangeName=0) {	inline Int_t index(const RooArgSet* set1, const RooArgSet* set2=0, const TNamed* set2RangeName=0) {

	// Match range name first	// Match range name first
	if (set2RangeName != _set2RangeName) return -1 ;	if (set2RangeName != _set2RangeName) return -1 ;


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

	RooRealMPFE.h	RooRealMPFE.h

	skipping to change at line 43	skipping to change at line 43
	virtual ~RooRealMPFE();	virtual ~RooRealMPFE();

	void calculate() const ;	void calculate() const ;
	virtual Double_t getValV(const RooArgSet* nset=0) const ;	virtual Double_t getValV(const RooArgSet* nset=0) const ;
	void standby() ;	void standby() ;

	void setVerbose(Bool_t clientFlag=kTRUE, Bool_t serverFlag=kTRUE) ;	void setVerbose(Bool_t clientFlag=kTRUE, Bool_t serverFlag=kTRUE) ;

	void applyNLLWeightSquared(Bool_t flag) ;	void applyNLLWeightSquared(Bool_t flag) ;


		void enableOffsetting(Bool_t flag) ;

	protected:	protected:

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

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

	enum Message { SendReal=0, SendCat=1, Calculate=2, Retrieve=3, ReturnValu e=4, Terminate=5,	enum Message { SendReal=0, SendCat=1, Calculate=2, Retrieve=3, ReturnValu e=4, Terminate=5,

	ConstOpt=6, Verbose=7, RetrieveErrors=8, SendError=9, LogEv alError=10, ApplyNLLW2=11 } ;	ConstOpt=6, Verbose=7, RetrieveErrors=8, SendError=9, LogEv alError=10, ApplyNLLW2=11, EnableOffset=12, CalculateNoOffset=13 } ;

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

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

	RooRealProxy _arg ; // Function to calculate in parallel process	RooRealProxy _arg ; // Function to calculate in parallel process

	RooListProxy _vars ; // Variables	RooListProxy _vars ; // Variables

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

	RooResolutionModel.h	RooResolutionModel.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_RESOLUTION_MODEL	#ifndef ROO_RESOLUTION_MODEL
	#define ROO_RESOLUTION_MODEL	#define ROO_RESOLUTION_MODEL

	#include "RooAbsPdf.h"	#include "RooAbsPdf.h"
	#include "RooRealProxy.h"	#include "RooRealProxy.h"
	#include "RooRealVar.h"	#include "RooRealVar.h"
	#include "RooFormulaVar.h"	#include "RooFormulaVar.h"


		class RooAbsAnaConvPdf;

	class RooResolutionModel : public RooAbsPdf {	class RooResolutionModel : public RooAbsPdf {
	public:	public:

	// Constructors, assignment etc	// Constructors, assignment etc
	inline RooResolutionModel() : _basis(0) { }	inline RooResolutionModel() : _basis(0) { }
	RooResolutionModel(const char name, const char title, RooRealVar& x) ;	RooResolutionModel(const char name, const char title, RooRealVar& x) ;
	RooResolutionModel(const RooResolutionModel& other, const char* name=0);	RooResolutionModel(const RooResolutionModel& other, const char* name=0);
	virtual TObject* clone(const char* newname) const = 0 ;	virtual TObject* clone(const char* newname) const = 0 ;
	virtual ~RooResolutionModel();	virtual ~RooResolutionModel();


		virtual RooAbsGenContext* modelGenContext(const RooAbsAnaConvPdf&, const
		RooArgSet&,
		const RooDataSet*, const RooArg
		Set*,
		Bool_t) const { return 0; }

	Double_t getValV(const RooArgSet* nset=0) const ;	Double_t getValV(const RooArgSet* nset=0) const ;
	virtual RooResolutionModel* convolution(RooFormulaVar* basis, RooAbsArg* owner) const ;	virtual RooResolutionModel* convolution(RooFormulaVar* basis, RooAbsArg* owner) const ;
	RooRealVar& convVar() const ;	RooRealVar& convVar() const ;
	const RooRealVar& basisConvVar() const ;	const RooRealVar& basisConvVar() const ;

	inline Bool_t isBasisSupported(const char* name) const { return basisCode (name)?kTRUE:kFALSE ; }	inline Bool_t isBasisSupported(const char* name) const { return basisCode (name)?kTRUE:kFALSE ; }
	virtual Int_t basisCode(const char* name) const = 0 ;	virtual Int_t basisCode(const char* name) const = 0 ;

	virtual void normLeafServerList(RooArgSet& list) const ;	virtual void normLeafServerList(RooArgSet& list) const ;
	Double_t getNorm(const RooArgSet* nset=0) const ;	Double_t getNorm(const RooArgSet* nset=0) const ;

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

	RooStatsUtils.h	RooStatsUtils.h

	// @(#)root/roostats:$Id: RooStatsUtils.h 46661 2012-10-18 19:48:16Z moneta $	// @(#)root/roostats:$Id: RooStatsUtils.h 47012 2012-11-02 16:06:59Z 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. *
	*************************************************************************/	*************************************************************************/


	skipping to change at line 111	skipping to change at line 111
	if (!var->isConstant() )	if (!var->isConstant() )
	var->randomize();	var->randomize();
	}	}

	}	}

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


		// extract constraint terms from pdf
	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);

		// remove constraints from pdf and return the unconstrained pdf
		RooAbsPdf * MakeUnconstrainedPdf(RooAbsPdf &pdf, const RooArgSet &observ
		ables, const char *name = NULL);
		RooAbsPdf * MakeUnconstrainedPdf(const RooStats::ModelConfig &model, con
		st char *name = NULL);

	// 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.	// 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);	TTree* GetAsTTree(TString name, TString desc, const RooDataSet& data);

	}	}

	#endif	#endif

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

	RooTruthModel.h	RooTruthModel.h

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

	// Constructors, assignment etc	// Constructors, assignment etc
	inline RooTruthModel() { }	inline RooTruthModel() { }
	RooTruthModel(const char name, const char title, RooRealVar& x) ;	RooTruthModel(const char name, const char title, RooRealVar& x) ;
	RooTruthModel(const RooTruthModel& other, const char* name=0);	RooTruthModel(const RooTruthModel& other, const char* name=0);
	virtual TObject* clone(const char* newname) const { return new RooTruthMo del(*this,newname) ; }	virtual TObject* clone(const char* newname) const { return new RooTruthMo del(*this,newname) ; }
	virtual ~RooTruthModel();	virtual ~RooTruthModel();

	virtual Int_t basisCode(const char* name) const ;	virtual Int_t basisCode(const char* name) const ;


		virtual RooAbsGenContext* modelGenContext(const RooAbsAnaConvPdf& convPdf
		, const RooArgSet &vars,
		const RooDataSet *prototype=0,
		const RooArgSet* auxProto=0,
		Bool_t verbose= kFALSE) const;

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

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

	protected:	protected:
	virtual Double_t evaluate() const ;	virtual Double_t evaluate() const ;
	virtual void changeBasis(RooFormulaVar* basis) ;	virtual void changeBasis(RooFormulaVar* basis) ;


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

	RootFinder.h	RootFinder.h

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


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

		#ifndef ROOT_TMVA_RootFinder
		#define ROOT_TMVA_RootFinder

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


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


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


	/**	class MsgLogger;
	@defgroup RootFinders One-dimensional Root-Finding algorithms
	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


	};	class RootFinder : public TObject {


	} // namespace Math	public:
	} // namespace ROOT


	#ifndef ROOT_Math_WrappedFunction	RootFinder( Double_t (*rootVal)( Double_t ),
	#include "Math/WrappedFunction.h"	Double_t rootMin, Double_t rootMax,
	#endif	Int_t maxIterations = 100,
		Double_t absTolerance = 0.0 );
		virtual ~RootFinder( void );


	#ifndef ROOT_Math_Functor	// returns the root of the function
	#include "Math/Functor.h"	Double_t Root( Double_t refValue );
	#endif
		private:

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


	template<class Function, class Derivative>	// function pointer
	bool ROOT::Math::RootFinder::Solve(Function &f, Derivative &d, double start	Double_t (*fGetRootVal)( Double_t );
	,
	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 /* ROOT_Math_RootFinder */	mutable MsgLogger* fLogger; //! message logger
		MsgLogger& Log() const { return *fLogger; }

		ClassDef(RootFinder,0) // Root finding using Brents algorithm
		};

		} // namespace TMVA

		#endif

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

	Sample.h	Sample.h

		// @(#)root/roostats:$Id: Sample.h 47093 2012-11-07 10:30:12Z moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

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

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

	#include "TRef.h"	#include "TRef.h"
	#include "RooStats/HistFactory/Systematics.h"	#include "RooStats/HistFactory/Systematics.h"

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

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

	class Sample {	class Sample {

	public:	public:

	//friend class Channel;
	//
	// Nominal definitions
	//

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

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

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

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

	SparseData.h	SparseData.h

	// @(#)root/mathcore:$Id: SparseData.h 35349 2010-09-17 09:25:00Z moneta $	// @(#)root/mathcore:$Id: SparseData.h 47627 2012-11-26 13:47:00Z moneta $
	// Author: David Gonzalez Maline Wed Aug 28 15:23:43 2009	// Author: David Gonzalez Maline Wed Aug 28 15:23:43 2009

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

	// Header file for class SparseData	// Header file for class SparseData

	#ifndef ROOT_Fit_SparseData	#ifndef ROOT_Fit_SparseData
	#define ROOT_Fit_SparseData	#define ROOT_Fit_SparseData

	#include <vector>	#include <vector>

	#ifndef ROOT_Fit_DataVector	#ifndef ROOT_Fit_DataVector
	#include "Fit/DataVector.h"	#include "Fit/DataVector.h"

		#endif
		#ifndef ROOT_Fit_BinData
	#include "Fit/BinData.h"	#include "Fit/BinData.h"
	#endif	#endif

	namespace ROOT {	namespace ROOT {

	namespace Fit {	namespace Fit {

	// This is a proxy to a list<Box>	// This is a proxy to a list<Box>
	class ProxyListBox;	class ProxyListBox;


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

	Systematics.h	Systematics.h

		// @(#)root/roostats:$Id: Systematics.h 47093 2012-11-07 10:30:12Z moneta $
		// Author: George Lewis, Kyle Cranmer
		/*************************************************************************
		* Copyright (C) 1995-2008, Rene Brun and Fons Rademakers. *
		* All rights reserved. *
		* *
		* For the licensing terms see $ROOTSYS/LICENSE. *
		* For the list of contributors see $ROOTSYS/README/CREDITS. *
		*************************************************************************/

	#ifndef HISTFACTORY_SYSTEMATICS_H	#ifndef HISTFACTORY_SYSTEMATICS_H
	#define HISTFACTORY_SYSTEMATICS_H	#define HISTFACTORY_SYSTEMATICS_H

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

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

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

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


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

	class OverallSys {	class OverallSys {

	public:	public:
	//friend class Channel;	//friend class Channel;


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

	TChain.h	TChain.h

	// @(#)root/tree:$Id: TChain.h 46369 2012-10-06 01:11:07Z pcanal $	// @(#)root/tree:$Id: TChain.h 48256 2013-01-10 14:24:07Z axel $
	// Author: Rene Brun 03/02/97	// Author: Rene Brun 03/02/97

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


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

	TFileStager.h	TFileStager.h

	// @(#)root/net:$Id: TFileStager.h 23091 2008-04-09 15:04:27Z rdm $	// @(#)root/net:$Id: TFileStager.h 48077 2012-12-17 16:44:37Z rdm $
	// Author: A. Peters, G. Ganis 7/2/2007	// Author: A. Peters, G. Ganis 7/2/2007

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


	skipping to change at line 38	skipping to change at line 38
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif
	#ifndef ROOT_TString	#ifndef ROOT_TString
	#include "TString.h"	#include "TString.h"
	#endif	#endif

	class TCollection;	class TCollection;

		class TFileCollection;

	class TFileStager : public TNamed {	class TFileStager : public TNamed {

	public:	public:
	TFileStager(const char *stager) : TNamed(stager, stager) { }	TFileStager(const char *stager) : TNamed(stager, stager) { }
	virtual ~TFileStager() { }	virtual ~TFileStager() { }

	virtual TList GetStaged(TCollection pathlist);	virtual TList GetStaged(TCollection pathlist);
	virtual Bool_t IsStaged(const char *);	virtual Bool_t IsStaged(const char *);
	virtual Int_t Locate(const char *u, TString &f);	virtual Int_t Locate(const char *u, TString &f);

		virtual Int_t LocateCollection(TFileCollection *fc, Bool_t add DummyUrl = kFALSE);
	virtual Bool_t Matches(const char *s) { return ((s && (fName == s)) ? kTRUE : kFALSE); }	virtual Bool_t Matches(const char *s) { return ((s && (fName == s)) ? kTRUE : kFALSE); }
	virtual Bool_t Stage(const char , Option_t = 0) { return kTR UE; }	virtual Bool_t Stage(const char , Option_t = 0) { return kTR UE; }
	virtual Bool_t Stage(TCollection pathlist, Option_t opt = 0);	virtual Bool_t Stage(TCollection pathlist, Option_t opt = 0);

	virtual Bool_t IsValid() const { return kTRUE; }	virtual Bool_t IsValid() const { return kTRUE; }

	// Extract the path name from supported object types	// Extract the path name from supported object types
	static TString GetPathName(TObject *o);	static TString GetPathName(TObject *o);

	//--- Load desired plugin	//--- Load desired plugin

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

	TGLContextPrivate.h	TGLContextPrivate.h

	// @(#)root/gl:$Id: TGLContextPrivate.h 46562 2012-10-16 11:20:32Z tpochep $	// @(#)root/gl:$Id: TGLContextPrivate.h 47130 2012-11-09 03:05:52Z matevz $
	#ifndef ROOT_TGLContextPrivate	#ifndef ROOT_TGLContextPrivate
	#define ROOT_TGLContextPrivate	#define ROOT_TGLContextPrivate

	#include <map>	#include <map>

	#include "TGLIncludes.h"	#include "TGLIncludes.h"
	#include "TGLWSIncludes.h"	#include "TGLWSIncludes.h"
	#include "TGLContext.h"	#include "TGLContext.h"

	//#include "RConfigure.h"	#include "RConfigure.h"
	#include "GuiTypes.h"	#include "GuiTypes.h"

	#ifdef WIN32	#ifdef WIN32

	class TGLContextPrivate {	class TGLContextPrivate {
	public:	public:
	HWND fHWND;	HWND fHWND;
	HDC fHDC;	HDC fHDC;
	HGLRC fGLContext;	HGLRC fGLContext;


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

	TGLUtil.h	TGLUtil.h

	// @(#)root/gl:$Id: TGLUtil.h 46586 2012-10-16 20:43:26Z matevz $	// @(#)root/gl:$Id: TGLUtil.h 47130 2012-11-09 03:05:52Z matevz $
	// Author: Richard Maunder 25/05/2005	// Author: Richard Maunder 25/05/2005

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


	skipping to change at line 924	skipping to change at line 924
	static UInt_t fgDefaultDrawQuality;	static UInt_t fgDefaultDrawQuality;
	static UInt_t fgDrawQuality;	static UInt_t fgDrawQuality;

	static UInt_t fgColorLockCount;	static UInt_t fgColorLockCount;

	static Float_t fgPointSize;	static Float_t fgPointSize;
	static Float_t fgLineWidth;	static Float_t fgLineWidth;
	static Float_t fgPointSizeScale;	static Float_t fgPointSizeScale;
	static Float_t fgLineWidthScale;	static Float_t fgLineWidthScale;


		static Float_t fgScreenScalingFactor;
		static Float_t fgPointLineScalingFactor;
		static Int_t fgPickingRadius;

	TGLUtil(const TGLUtil&); // Not implemented.	TGLUtil(const TGLUtil&); // Not implemented.
	TGLUtil& operator=(const TGLUtil&); // Not implemented.	TGLUtil& operator=(const TGLUtil&); // Not implemented.

	public:	public:
	virtual ~TGLUtil() {}	virtual ~TGLUtil() {}

		static void InitializeIfNeeded();

	// Error checking	// Error checking
	static Int_t CheckError(const char * loc);	static Int_t CheckError(const char * loc);

	// Polygon tesselator for direct drawing	// Polygon tesselator for direct drawing
	static GLUtesselator* GetDrawTesselator3fv();	static GLUtesselator* GetDrawTesselator3fv();
	static GLUtesselator* GetDrawTesselator4fv();	static GLUtesselator* GetDrawTesselator4fv();
	static GLUtesselator* GetDrawTesselator3dv();	static GLUtesselator* GetDrawTesselator3dv();
	static GLUtesselator* GetDrawTesselator4dv();	static GLUtesselator* GetDrawTesselator4dv();


	skipping to change at line 967	skipping to change at line 972
	static void ColorTransparency(Color_t color_index, Char_t transparency=0 );	static void ColorTransparency(Color_t color_index, Char_t transparency=0 );
	static void Color3ub(UChar_t r, UChar_t g, UChar_t b);	static void Color3ub(UChar_t r, UChar_t g, UChar_t b);
	static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a);	static void Color4ub(UChar_t r, UChar_t g, UChar_t b, UChar_t a);
	static void Color3ubv(const UChar_t* rgb);	static void Color3ubv(const UChar_t* rgb);
	static void Color4ubv(const UChar_t* rgba);	static void Color4ubv(const UChar_t* rgba);
	static void Color3f(Float_t r, Float_t g, Float_t b);	static void Color3f(Float_t r, Float_t g, Float_t b);
	static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a);	static void Color4f(Float_t r, Float_t g, Float_t b, Float_t a);
	static void Color3fv(const Float_t* rgb);	static void Color3fv(const Float_t* rgb);
	static void Color4fv(const Float_t* rgba);	static void Color4fv(const Float_t* rgba);


		// Coordinate conversion and extra scaling (needed for osx retina)
		static void PointToViewport(Int_t& x, Int_t& y);
		static void PointToViewport(Int_t& x, Int_t& y, Int_t& w, Int_t& h);
		static Float_t GetScreenScalingFactor();
		static Float_t GetPointLineScalingFactor();
		static Int_t GetPickingRadius();

	static Float_t GetPointSizeScale();	static Float_t GetPointSizeScale();
	static void SetPointSizeScale(Float_t scale);	static void SetPointSizeScale(Float_t scale);
	static Float_t GetLineWidthScale();	static Float_t GetLineWidthScale();
	static void SetLineWidthScale(Float_t scale);	static void SetLineWidthScale(Float_t scale);

	static void PointSize(Float_t point_size);	static void PointSize(Float_t point_size);
	static void LineWidth(Float_t line_width);	static void LineWidth(Float_t line_width);

	static Float_t PointSize();	static Float_t PointSize();
	static Float_t LineWidth();	static Float_t LineWidth();

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

	TGeoPcon.h	TGeoPcon.h

	// @(#)root/geom:$Id: TGeoPcon.h 24879 2008-07-18 08:04:40Z brun $	// @(#)root/geom:$Id: TGeoPcon.h 47063 2012-11-06 15:45:17Z agheata $
	// Author: Andrei Gheata 24/10/01	// Author: Andrei Gheata 24/10/01

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


	skipping to change at line 34	skipping to change at line 34
	// - the number of z planes (at least two) where the inner/outer //	// - the number of z planes (at least two) where the inner/outer //
	// radii are changing; //	// radii are changing; //
	// - z coordinate, inner and outer radius for each z plane //	// - z coordinate, inner and outer radius for each z plane //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///

	class TGeoPcon : public TGeoBBox	class TGeoPcon : public TGeoBBox
	{	{
	protected:	protected:
	// data members	// data members

	Int_t fNz; // number of z planes (at least two)	Int_t fNz; // number of z planes (at least two)
	Double_t fPhi1; // lower phi limit	Double_t fPhi1; // lower phi limit (converted to [0,2*pi
	Double_t fDphi; // phi range	)
	Double_t *fRmin; //[fNz] pointer to array of inner radii	Double_t fDphi; // phi range
	Double_t *fRmax; //[fNz] pointer to array of outer radii	Double_t *fRmin; //[fNz] pointer to array of inner radii
	Double_t *fZ; //[fNz] pointer to array of Z planes posit	Double_t *fRmax; //[fNz] pointer to array of outer radii
	ions	Double_t *fZ; //[fNz] pointer to array of Z planes pos
		itions
		Bool_t fFullPhi; //! Full phi range flag
		Double_t fC1; //! Cosine of phi1
		Double_t fS1; //! Sine of phi1
		Double_t fC2; //! Cosine of phi1+dphi
		Double_t fS2; //! Sine of phi1+dphi
		Double_t fCm; //! Cosine of (phi1+phi2)/2
		Double_t fSm; //! Sine of (phi1+phi2)/2
		Double_t fCdphi; //! Cosine of dphi

	// methods	// methods
	TGeoPcon(const TGeoPcon&);	TGeoPcon(const TGeoPcon&);
	TGeoPcon& operator=(const TGeoPcon&);	TGeoPcon& operator=(const TGeoPcon&);

	public:	public:
	// constructors	// constructors
	TGeoPcon();	TGeoPcon();
	TGeoPcon(Double_t phi, Double_t dphi, Int_t nz);	TGeoPcon(Double_t phi, Double_t dphi, Int_t nz);
	TGeoPcon(const char *name, Double_t phi, Double_t dphi, Int_t nz);	TGeoPcon(const char *name, Double_t phi, Double_t dphi, Int_t nz);

	skipping to change at line 63	skipping to change at line 71
	// methods	// methods
	virtual Double_t Capacity() const;	virtual Double_t Capacity() const;
	virtual void ComputeBBox();	virtual void ComputeBBox();
	virtual void ComputeNormal(Double_t point, Double_t dir, Doub le_t *norm);	virtual void ComputeNormal(Double_t point, Double_t dir, Doub le_t *norm);
	virtual Bool_t Contains(Double_t *point) const;	virtual Bool_t Contains(Double_t *point) const;
	virtual void DefineSection(Int_t snum, Double_t z, Double_t rmi n, Double_t rmax);	virtual void DefineSection(Int_t snum, Double_t z, Double_t rmi n, Double_t rmax);
	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,	virtual Double_t DistFromInside(Double_t point, Double_t dir, Int _t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;
	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,	virtual Double_t DistFromOutside(Double_t point, Double_t dir, In t_t iact=1,
	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;	Double_t step=TGeoShape::Big(), Double_t *safe=0) const;

	Double_t DistToSegZ(Double_t point, Double_t dir, Int_t &	Double_t DistToSegZ(Double_t point, Double_t dir, Int_t &
	iz, Double_t c1, Double_t s1,	iz) const;
	Double_t c2, Double_t s2, Double_t cfio
	, Double_t sfio, Double_t cdfi) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,	virtual TGeoVolume Divide(TGeoVolume voldiv, const char *divname, In t_t iaxis, Int_t ndiv,
	Double_t start, Double_t step);	Double_t start, Double_t step);
	virtual const char *GetAxisName(Int_t iaxis) const;	virtual const char *GetAxisName(Int_t iaxis) const;
	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;	virtual Double_t GetAxisRange(Int_t iaxis, Double_t &xlo, Double_t &xhi) const;
	virtual void GetBoundingCylinder(Double_t *param) const;	virtual void GetBoundingCylinder(Double_t *param) const;
	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;	virtual const TBuffer3D &GetBuffer3D(Int_t reqSections, Bool_t localFram e) const;
	virtual Int_t GetByteCount() const {return 60+12*fNz;}	virtual Int_t GetByteCount() const {return 60+12*fNz;}
	Double_t GetPhi1() const {return fPhi1;}	Double_t GetPhi1() const {return fPhi1;}
	Double_t GetDphi() const {return fDphi;}	Double_t GetDphi() const {return fDphi;}

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

	TMath.h	TMath.h

	// @(#)root/mathcore:$Id: TMath.h 41837 2011-11-09 16:04:19Z rdm $	// @(#)root/mathcore:$Id: TMath.h 47076 2012-11-06 17:16:13Z moneta $
	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/95	// Authors: Rene Brun, Anna Kreshuk, Eddy Offermann, Fons Rademakers 29/0 7/95

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


	skipping to change at line 502	skipping to change at line 502
	{ return isfinite(x); }	{ return isfinite(x); }
	#else	#else
	// from cmath	// from cmath
	{ return std::isfinite(x); }	{ return std::isfinite(x); }
	#endif	#endif
	#else	#else
	{ return finite(x); }	{ return finite(x); }
	#endif	#endif

	inline Int_t TMath::IsNaN(Double_t x)	inline Int_t TMath::IsNaN(Double_t x)

	#if (defined(R__ANSISTREAM) \|\| (defined(R__MACOSX) && defined(__arm__))) && !defined(_AIX)	#if (defined(R__ANSISTREAM) \|\| (defined(R__MACOSX) && defined(__arm__))) && !defined(_AIX) && !defined(__CUDACC__)
	#if defined(isnan) \|\| defined(R__SOLARIS_CC50) \|\| defined(__INTEL_COMPILER)	#if defined(isnan) \|\| defined(R__SOLARIS_CC50) \|\| defined(__INTEL_COMPILER)
	// from math.h	// from math.h
	{ return ::isnan(x); }	{ return ::isnan(x); }
	#else	#else
	// from cmath	// from cmath
	{ return std::isnan(x); }	{ return std::isnan(x); }
	#endif	#endif
	#else	#else
	{ return isnan(x); }	{ return isnan(x); }
	#endif	#endif

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

	TPDF.h	TPDF.h

	skipping to change at line 98	skipping to change at line 98
	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);
	void Text(Double_t x, Double_t y, const char *string);	void Text(Double_t x, Double_t y, const char *string);

		void Text(Double_t, Double_t, const wchar_t *){}
	void TextNDC(Double_t u, Double_t v, const char *string);	void TextNDC(Double_t u, Double_t v, const char *string);

		void TextNDC(Double_t, Double_t, const wchar_t *){}
	void WriteCompressedBuffer();	void WriteCompressedBuffer();
	virtual void WriteReal(Float_t r);	virtual void WriteReal(Float_t r);
	Double_t UtoPDF(Double_t u);	Double_t UtoPDF(Double_t u);
	Double_t VtoPDF(Double_t v);	Double_t VtoPDF(Double_t v);
	Double_t XtoPDF(Double_t x);	Double_t XtoPDF(Double_t x);
	Double_t YtoPDF(Double_t y);	Double_t YtoPDF(Double_t y);

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


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

	TParameter.h	TParameter.h

	// @(#)root/base:$Id: TParameter.h 40272 2011-07-18 11:12:14Z rdm $	// @(#)root/base:$Id: TParameter.h 48256 2013-01-10 14:24:07Z axel $
	// Author: Maarten Ballintijn 21/06/2004	// Author: Maarten Ballintijn 21/06/2004

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


	skipping to change at line 58	skipping to change at line 58
	class TParameter : public TObject {	class TParameter : public TObject {

	public:	public:
	enum EStatusBits { kMultiply = BIT(16) }; // Use multiplication while me rging	enum EStatusBits { kMultiply = BIT(16) }; // Use multiplication while me rging

	private:	private:
	TString fName;	TString fName;
	AParamType fVal;	AParamType fVal;

	public:	public:

	TParameter() { /* leave fVal uninitialized */ }	TParameter(): fVal() {}
	TParameter(const char *name, const AParamType &val)	TParameter(const char *name, const AParamType &val)
	: fName(name), fVal(val) { ResetBit(kMultiply); }	: fName(name), fVal(val) { ResetBit(kMultiply); }
	TParameter(const char *name, const AParamType &val, char mergemode)	TParameter(const char *name, const AParamType &val, char mergemode)
	: fName(name), fVal(val) { SetMergeMode(mergemode); }	: fName(name), fVal(val) { SetMergeMode(mergemode); }
	~TParameter() { }	~TParameter() { }

	const char *GetName() const { return fName; }	const char *GetName() const { return fName; }
	const AParamType &GetVal() const { return fVal; }	const AParamType &GetVal() const { return fVal; }
	void SetVal(const AParamType &val) { fVal = val; }	void SetVal(const AParamType &val) { fVal = val; }
	void SetMergeMode(char mergemode = '+') { ResetBit(kMultipl y);	void SetMergeMode(char mergemode = '+') { ResetBit(kMultipl y);

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

	TPostScript.h	TPostScript.h

	// @(#)root/postscript:$Id: TPostScript.h 23936 2008-05-20 16:00:26Z couet $	// @(#)root/postscript:$Id: TPostScript.h 47117 2012-11-08 16:14:55Z couet $
	// Author: O.Couet 16/07/99	// Author: O.Couet 16/07/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 87	skipping to change at line 87
	Bool_t fZone; //Zone indicator	Bool_t fZone; //Zone indicator
	char fPatterns[32]; //Indicate if pattern n is defined	char fPatterns[32]; //Indicate if pattern n is defined
	Int_t fNbinCT; //Number of entries in the current Cell Array	Int_t fNbinCT; //Number of entries in the current Cell Array
	Int_t fNbCellW; //Number of boxes per line	Int_t fNbCellW; //Number of boxes per line
	Int_t fNbCellLine; //Number of boxes in the current line	Int_t fNbCellLine; //Number of boxes in the current line
	Int_t fMaxLines; //Maximum number of lines in a PS array	Int_t fMaxLines; //Maximum number of lines in a PS array
	Int_t fLastCellRed; //Last red value	Int_t fLastCellRed; //Last red value
	Int_t fLastCellGreen; //Last green value	Int_t fLastCellGreen; //Last green value
	Int_t fLastCellBlue; //Last blue value	Int_t fLastCellBlue; //Last blue value
	Int_t fNBSameColorCell; //Number of boxes with the same color	Int_t fNBSameColorCell; //Number of boxes with the same color

		TString fFileName; //PS file name
		Bool_t fFontEmbed; //True is FontEmbed has been called

	static Int_t fgLineJoin; //Appearance of joining lines	static Int_t fgLineJoin; //Appearance of joining lines

	public:	public:
	TPostScript();	TPostScript();
	TPostScript(const char *filename, Int_t type=-111);	TPostScript(const char *filename, Int_t type=-111);
	virtual ~TPostScript();	virtual ~TPostScript();

	void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2,	void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2,
	Double_t y1, Double_t y2);	Double_t y1, Double_t y2);

	skipping to change at line 115	skipping to change at line 117
	void DrawHatch(Float_t dy, Float_t angle, Int_t n, Float_t *x,	void DrawHatch(Float_t dy, Float_t angle, Int_t n, Float_t *x,
	Float_t *y);	Float_t *y);
	void DrawHatch(Float_t dy, Float_t angle, Int_t n, Double_t *x,	void DrawHatch(Float_t dy, Float_t angle, Int_t n, Double_t *x,
	Double_t *y);	Double_t *y);
	void DrawPolyLine(Int_t n, TPoints *xy);	void DrawPolyLine(Int_t n, TPoints *xy);
	void DrawPolyLineNDC(Int_t n, TPoints *uv);	void DrawPolyLineNDC(Int_t n, TPoints *uv);
	void DrawPolyMarker(Int_t n, Float_t x, Float_t y);	void DrawPolyMarker(Int_t n, Float_t x, Float_t y);
	void DrawPolyMarker(Int_t n, Double_t x, Double_t y);	void DrawPolyMarker(Int_t n, Double_t x, Double_t y);
	void DrawPS(Int_t n, Float_t xw, Float_t yw);	void DrawPS(Int_t n, Float_t xw, Float_t yw);
	void DrawPS(Int_t n, Double_t xw, Double_t yw);	void DrawPS(Int_t n, Double_t xw, Double_t yw);

		bool FontEmbedType1(const char *filename);
		bool FontEmbedType2(const char *filename);
		bool FontEmbedType42(const char *filename);
		void FontEmbed();
	void FontEncode();	void FontEncode();
	void Initialize();	void Initialize();
	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 SaveRestore(Int_t flag);	void SaveRestore(Int_t flag);
	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);

	skipping to change at line 136	skipping to change at line 142
	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 SetLineScale(Float_t scale=3) {fLineScale = scale;}	void SetLineScale(Float_t scale=3) {fLineScale = scale;}
	void SetMarkerColor( Color_t cindex=1);	void SetMarkerColor( Color_t cindex=1);
	void SetTextColor( Color_t cindex=1);	void SetTextColor( Color_t cindex=1);
	void MovePS(Int_t x, Int_t y);	void MovePS(Int_t x, Int_t y);
	void Range(Float_t xrange, Float_t yrange);	void Range(Float_t xrange, Float_t yrange);
	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 Text(Double_t x, Double_t y, const char *string);	void Text(Double_t x, Double_t y, const char *string);

		void Text(Double_t x, Double_t y, const wchar_t *string);
	void TextNDC(Double_t u, Double_t v, const char *string);	void TextNDC(Double_t u, Double_t v, const char *string);

		void TextNDC(Double_t u, Double_t v, const wchar_t *string);
	Int_t UtoPS(Double_t u);	Int_t UtoPS(Double_t u);
	Int_t VtoPS(Double_t v);	Int_t VtoPS(Double_t v);
	Int_t XtoPS(Double_t x);	Int_t XtoPS(Double_t x);
	Int_t YtoPS(Double_t y);	Int_t YtoPS(Double_t y);
	void Zone();	void Zone();

	ClassDef(TPostScript,0) //PostScript driver	ClassDef(TPostScript,0) //PostScript driver
	};	};

	#endif	#endif

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

	TProof.h	TProof.h

	// @(#)root/proof:$Id: TProof.h 45751 2012-08-30 10:28:19Z ganis $	// @(#)root/proof:$Id: TProof.h 48061 2012-12-15 19:46:14Z ganis $
	// Author: Fons Rademakers 13/02/97	// Author: Fons Rademakers 13/02/97

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


	skipping to change at line 99	skipping to change at line 99
	class TQueryResult;	class TQueryResult;
	class TSignalHandler;	class TSignalHandler;
	class TSlave;	class TSlave;
	class TSemaphore;	class TSemaphore;
	class TSocket;	class TSocket;
	class TTree;	class TTree;
	class TVirtualMutex;	class TVirtualMutex;
	class TFileCollection;	class TFileCollection;
	class TMap;	class TMap;
	class TDataSetManager;	class TDataSetManager;

		class TDataSetManagerFile;
	class TMacro;	class TMacro;
	class TSelector;	class TSelector;

	// protocol changes:	// protocol changes:
	// 1 -> 2: new arguments for Process() command, option added	// 1 -> 2: new arguments for Process() command, option added
	// 2 -> 3: package manager enabling protocol changed	// 2 -> 3: package manager enabling protocol changed
	// 3 -> 4: introduction of multi-level-master support	// 3 -> 4: introduction of multi-level-master support
	// 4 -> 5: added friends support	// 4 -> 5: added friends support
	// 5 -> 6: drop TFTP, support for asynchronous queries	// 5 -> 6: drop TFTP, support for asynchronous queries
	// 6 -> 7: support for multisessions, archieve, retrieve, ...	// 6 -> 7: support for multisessions, archieve, retrieve, ...

	skipping to change at line 138	skipping to change at line 139
	// 25 -> 26: Use new TProofProgressInfo class	// 25 -> 26: Use new TProofProgressInfo class
	// 26 -> 27: Use new file for updating the session status	// 26 -> 27: Use new file for updating the session status
	// 27 -> 28: Support for multi-datasets, fix global pack dirs, fix AskStati stics,	// 27 -> 28: Support for multi-datasets, fix global pack dirs, fix AskStati stics,
	// package download, dataset caching	// package download, dataset caching
	// 28 -> 29: Support for config parameters in EnablePackage, idle-timeout	// 28 -> 29: Support for config parameters in EnablePackage, idle-timeout
	// 29 -> 30: Add information about data dir in TSlaveInfo	// 29 -> 30: Add information about data dir in TSlaveInfo
	// 30 -> 31: Development cycle 5.29	// 30 -> 31: Development cycle 5.29
	// 31 -> 32: New log path trasmission	// 31 -> 32: New log path trasmission
	// 32 -> 33: Development cycle 5.29/04 (fixed worker activation, new startu p technology, ...)	// 32 -> 33: Development cycle 5.29/04 (fixed worker activation, new startu p technology, ...)
	// 33 -> 34: Development cycle 5.33/02 (fix load issue, ...)	// 33 -> 34: Development cycle 5.33/02 (fix load issue, ...)

		// 34 -> 35: Development cycle 5.99/01 (PLite on workers, staging requests in separate dsmgr...)

	// PROOF magic constants	// PROOF magic constants
	const Int_t kPROOF_Protocol = 34; // protocol versi on number	const Int_t kPROOF_Protocol = 34; // protocol versi on number
	const Int_t kPROOF_Port = 1093; // IANA registere d PROOF port	const Int_t kPROOF_Port = 1093; // IANA registere d PROOF port
	const char* const kPROOF_ConfFile = "proof.conf"; // default config file	const char* const kPROOF_ConfFile = "proof.conf"; // default config file
	const char* const kPROOF_ConfDir = "/usr/local/root"; // default c onfig dir	const char* const kPROOF_ConfDir = "/usr/local/root"; // default c onfig dir
	const char* const kPROOF_WorkDir = ".proof"; // default workin g directory	const char* const kPROOF_WorkDir = ".proof"; // default workin g directory
	const char* const kPROOF_CacheDir = "cache"; // file cache dir , under WorkDir	const char* const kPROOF_CacheDir = "cache"; // file cache dir , under WorkDir
	const char* const kPROOF_PackDir = "packages"; // package dir, u nder WorkDir	const char* const kPROOF_PackDir = "packages"; // package dir, u nder WorkDir
	const char* const kPROOF_PackDownloadDir = "downloaded"; // subdir with do wnloaded PARs, under PackDir	const char* const kPROOF_PackDownloadDir = "downloaded"; // subdir with do wnloaded PARs, under PackDir

	skipping to change at line 318	skipping to change at line 320

	ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker se rving as merger	ClassDef(TMergerInfo,0) // Basic info on merger, i.e. worker se rving as merger
	};	};

	// Small auxilliary class for merging progress notification	// Small auxilliary class for merging progress notification
	class TProofMergePrg {	class TProofMergePrg {
	private:	private:
	TString fExp;	TString fExp;
	Int_t fIdx;	Int_t fIdx;
	Int_t fNWrks;	Int_t fNWrks;

		Int_t fLastNWrks;
	static char fgCr[4];	static char fgCr[4];
	public:	public:

	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1) { }	TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1), fLastNWrks(-1) { }


	const char *Export() { fExp.Form("%c (%d workers still sending) ", fg	const char *Export(Bool_t &changed) {
	Cr[fIdx], fNWrks);	fExp.Form("%c (%d workers still sending) ", fgCr[fIdx],
	return fExp.Data(); }	fNWrks);
		changed = (fLastNWrks != fNWrks \|\| fLastNWrks == -1) ? kT
		RUE : kFALSE;
		fLastNWrks = fNWrks;
		return fExp.Data(); }
	void DecreaseNWrks() { fNWrks--; }	void DecreaseNWrks() { fNWrks--; }
	void IncreaseNWrks() { fNWrks++; }	void IncreaseNWrks() { fNWrks++; }
	void IncreaseIdx() { fIdx++; if (fIdx == 4) fIdx = 0; }	void IncreaseIdx() { fIdx++; if (fIdx == 4) fIdx = 0; }
	void Reset(Int_t n = -1) { fIdx = -1; SetNWrks(n); }	void Reset(Int_t n = -1) { fIdx = -1; SetNWrks(n); }
	void SetNWrks(Int_t n) { fNWrks = n; }	void SetNWrks(Int_t n) { fNWrks = n; }
	};	};

	class TProof : public TNamed, public TQObject {	class TProof : public TNamed, public TQObject {

	friend class TPacketizer;	friend class TPacketizer;

	skipping to change at line 456	skipping to change at line 462
	kGetDataSets = 3, //List datasets saved on the master node	kGetDataSets = 3, //List datasets saved on the master node
	kRegisterDataSet = 4, //Save a TList object as a dataset	kRegisterDataSet = 4, //Save a TList object as a dataset
	kGetDataSet = 5, //Get a TFileCollection of TFileInfo objec ts	kGetDataSet = 5, //Get a TFileCollection of TFileInfo objec ts
	kVerifyDataSet = 6, //Try open all files from a dataset and re port results	kVerifyDataSet = 6, //Try open all files from a dataset and re port results
	kRemoveDataSet = 7, //Remove a dataset but leave files belongi ng to it	kRemoveDataSet = 7, //Remove a dataset but leave files belongi ng to it
	kMergeDataSet = 8, //Add new files to an existing dataset	kMergeDataSet = 8, //Add new files to an existing dataset
	kShowDataSets = 9, //Shows datasets, returns formatted output	kShowDataSets = 9, //Shows datasets, returns formatted output
	kGetQuota = 10, //Get quota info per group	kGetQuota = 10, //Get quota info per group
	kShowQuota = 11, //Show quotas	kShowQuota = 11, //Show quotas
	kSetDefaultTreeName = 12, //Set the default tree name	kSetDefaultTreeName = 12, //Set the default tree name

	kCache = 13 //Show/clear cache	kCache = 13, //Show/clear cache
		kRequestStaging = 14, //Request staging of a dataset
		kStagingStatus = 15 //Obtain staging status for the given data
		set
	};	};
	enum ESendFileOpt {	enum ESendFileOpt {
	kAscii = 0x0,	kAscii = 0x0,
	kBinary = 0x1,	kBinary = 0x1,
	kForce = 0x2,	kForce = 0x2,
	kForward = 0x4,	kForward = 0x4,
	kCpBin = 0x8,	kCpBin = 0x8,
	kCp = 0x10	kCp = 0x10
	};	};
	enum EProofWrkListAction {	enum EProofWrkListAction {
	kActivateWorker = 1,	kActivateWorker = 1,
	kDeactivateWorker = 2	kDeactivateWorker = 2
	};	};
	enum EBuildPackageOpt {	enum EBuildPackageOpt {
	kDontBuildOnClient = -2,	kDontBuildOnClient = -2,
	kBuildOnSlavesNoWait = -1,	kBuildOnSlavesNoWait = -1,
	kBuildAll = 0,	kBuildAll = 0,
	kCollectBuildResults = 1	kCollectBuildResults = 1
	};	};

		enum EParCheckVersionOpt {
		kDontCheck = 0,
		kCheckROOT = 1,
		kCheckSVN = 2
		};
	enum EProofShowQuotaOpt {	enum EProofShowQuotaOpt {
	kPerGroup = 0x1,	kPerGroup = 0x1,
	kPerUser = 0x2	kPerUser = 0x2
	};	};

	Bool_t fValid; //is this a valid proof object	Bool_t fValid; //is this a valid proof object

		Bool_t fTty; //TRUE if connected to a terminal
	TString fMaster; //master server ("" if a master); used in the browser	TString fMaster; //master server ("" if a master); used in the browser
	TString fWorkDir; //current work directory on remote ser vers	TString fWorkDir; //current work directory on remote ser vers
	TString fGroup; //PROOF group of this user	TString fGroup; //PROOF group of this user
	Int_t fLogLevel; //server debug logging level	Int_t fLogLevel; //server debug logging level
	Int_t fStatus; //remote return status (part of kPROOF _LOGDONE)	Int_t fStatus; //remote return status (part of kPROOF _LOGDONE)
	Int_t fCheckFileStatus; //remote return status after kPROOF_CH ECKFILE	Int_t fCheckFileStatus; //remote return status after kPROOF_CH ECKFILE
	TList *fRecvMessages; //Messages received during collect not yet processed	TList *fRecvMessages; //Messages received during collect not yet processed
	TList *fSlaveInfo; //!list returned by kPROOF_GETSLAVEINF O	TList *fSlaveInfo; //!list returned by kPROOF_GETSLAVEINF O
	Bool_t fSendGroupView; //if true send new group view	Bool_t fSendGroupView; //if true send new group view
	TList *fActiveSlaves; //list of active slaves (subset of all slaves)	TList *fActiveSlaves; //list of active slaves (subset of all slaves)

	skipping to change at line 630	skipping to change at line 644
	Int_t SendInitialState();	Int_t SendInitialState();
	Int_t SendPrint(Option_t *option="");	Int_t SendPrint(Option_t *option="");
	Int_t Ping(ESlaves list);	Int_t Ping(ESlaves list);
	void Interrupt(EUrgent type, ESlaves list = kActive);	void Interrupt(EUrgent type, ESlaves list = kActive);
	void AskStatistics();	void AskStatistics();
	void AskParallel();	void AskParallel();
	Int_t GoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE);	Int_t GoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE);
	Int_t SetParallelSilent(Int_t nodes, Bool_t random = kFALSE);	Int_t SetParallelSilent(Int_t nodes, Bool_t random = kFALSE);
	void RecvLogFile(TSocket *s, Int_t size);	void RecvLogFile(TSocket *s, Int_t size);
	void NotifyLogMsg(const char msg, const char sfx = "\n");	void NotifyLogMsg(const char msg, const char sfx = "\n");

	Int_t BuildPackage(const char *package, EBuildPackageOpt opt = kBuild	Int_t BuildPackage(const char *package, EBuildPackageOpt opt = kBuild
	All);	All, Int_t chkveropt = 2);
	Int_t BuildPackageOnClient(const char *package, Int_t opt = 0, TStrin	Int_t BuildPackageOnClient(const char *package, Int_t opt = 0, TStrin
	g *path = 0);	g *path = 0, Int_t chkveropt = 2);
	Int_t LoadPackage(const char package, Bool_t notOnClient = kFALSE, T List loadopts = 0);	Int_t LoadPackage(const char package, Bool_t notOnClient = kFALSE, T List loadopts = 0);
	Int_t LoadPackageOnClient(const char package, TList loadopts = 0);	Int_t LoadPackageOnClient(const char package, TList loadopts = 0);
	Int_t UnloadPackage(const char *package);	Int_t UnloadPackage(const char *package);
	Int_t UnloadPackageOnClient(const char *package);	Int_t UnloadPackageOnClient(const char *package);
	Int_t UnloadPackages();	Int_t UnloadPackages();
	Int_t UploadPackageOnClient(const char package, EUploadPackageOpt op t, TMD5 md5);	Int_t UploadPackageOnClient(const char package, EUploadPackageOpt op t, TMD5 md5);
	Int_t DisablePackage(const char *package);	Int_t DisablePackage(const char *package);
	Int_t DisablePackageOnClient(const char *package);	Int_t DisablePackageOnClient(const char *package);
	Int_t DisablePackages();	Int_t DisablePackages();


	skipping to change at line 890	skipping to change at line 904
	Int_t UploadDataSetFromFile(const char , const char , const char * = 0, Int_t = 0, TList * = 0);	Int_t UploadDataSetFromFile(const char , const char , const char * = 0, Int_t = 0, TList * = 0);
	virtual Bool_t RegisterDataSet(const char *name,	virtual Bool_t RegisterDataSet(const char *name,
	TFileCollection dataset, const char optStr = "");	TFileCollection dataset, const char optStr = "");
	virtual TMap GetDataSets(const char uri = "", const char* optStr = "") ;	virtual TMap GetDataSets(const char uri = "", const char* optStr = "") ;
	virtual void ShowDataSets(const char uri = "", const char optStr = "" );	virtual void ShowDataSets(const char uri = "", const char optStr = "" );

	TMap GetDataSetQuota(const char optStr = "");	TMap GetDataSetQuota(const char optStr = "");
	void ShowDataSetQuota(Option_t* opt = 0);	void ShowDataSetQuota(Option_t* opt = 0);

	virtual Bool_t ExistsDataSet(const char *dataset);	virtual Bool_t ExistsDataSet(const char *dataset);

	void ShowDataSet(const char dataset = "", const char opt = " M");	void ShowDataSet(const char dataset = "", const char opt = " filter:SsCc");
	virtual Int_t RemoveDataSet(const char dataset, const char optStr = " ");	virtual Int_t RemoveDataSet(const char dataset, const char optStr = " ");
	virtual Int_t VerifyDataSet(const char dataset, const char optStr = " ");	virtual Int_t VerifyDataSet(const char dataset, const char optStr = " ");
	virtual TFileCollection GetDataSet(const char dataset, const char* opt Str = "");	virtual TFileCollection GetDataSet(const char dataset, const char* opt Str = "");
	TList FindDataSets(const char searchString, const char* optStr = "");	TList FindDataSets(const char searchString, const char* optStr = "");

		virtual Bool_t RequestStagingDataSet(const char *dataset);
		virtual TFileCollection GetStagingStatusDataSet(const char dataset);
		virtual void ShowStagingStatusDataSet(const char *dataset, const char
		*optStr = "filter:SsCc");

	virtual Int_t SetDataSetTreeName( const char dataset, const char treen ame);	virtual Int_t SetDataSetTreeName( const char dataset, const char treen ame);

	virtual void ShowDataSetCache(const char *dataset = 0);	virtual void ShowDataSetCache(const char *dataset = 0);
	virtual void ClearDataSetCache(const char *dataset = 0);	virtual void ClearDataSetCache(const char *dataset = 0);


	void ShowData();	virtual void ShowData();
	void ClearData(UInt_t what = kUnregistered, const char *dsname = 0);	void ClearData(UInt_t what = kUnregistered, const char *dsname = 0);

	const char *GetMaster() const { return fMaster; }	const char *GetMaster() const { return fMaster; }
	const char *GetConfDir() const { return fConfDir; }	const char *GetConfDir() const { return fConfDir; }
	const char *GetConfFile() const { return fConfFile; }	const char *GetConfFile() const { return fConfFile; }
	const char *GetUser() const { return fUrl.GetUser(); }	const char *GetUser() const { return fUrl.GetUser(); }
	const char *GetGroup() const { return fGroup; }	const char *GetGroup() const { return fGroup; }
	const char *GetWorkDir() const { return fWorkDir; }	const char *GetWorkDir() const { return fWorkDir; }
	const char *GetSessionTag() const { return GetName(); }	const char *GetSessionTag() const { return GetName(); }
	const char *GetImage() const { return fImage; }	const char *GetImage() const { return fImage; }

	skipping to change at line 934	skipping to change at line 951
	EQueryMode GetQueryMode(Option_t *mode = 0) const;	EQueryMode GetQueryMode(Option_t *mode = 0) const;
	void SetQueryMode(EQueryMode mode);	void SetQueryMode(EQueryMode mode);

	void SetRealTimeLog(Bool_t on = kTRUE);	void SetRealTimeLog(Bool_t on = kTRUE);

	void GetStatistics(Bool_t verbose = kFALSE);	void GetStatistics(Bool_t verbose = kFALSE);
	Long64_t GetBytesRead() const { return fBytesRead; }	Long64_t GetBytesRead() const { return fBytesRead; }
	Float_t GetRealTime() const { return fRealTime; }	Float_t GetRealTime() const { return fRealTime; }
	Float_t GetCpuTime() const { return fCpuTime; }	Float_t GetCpuTime() const { return fCpuTime; }


	Bool_t IsLite() const { return (fServType == TProofMgr::kProofLite)	Bool_t IsLite() const { return (fServType == TProofMgr::kProofLite)
	; }	? kTRUE : kFALSE; }
	Bool_t IsProofd() const { return (fServType == TProofMgr::kProofd);	Bool_t IsProofd() const { return (fServType == TProofMgr::kProofd)
	}	? kTRUE : kFALSE; }
	Bool_t IsFolder() const { return kTRUE; }	Bool_t IsFolder() const { return kTRUE; }
	Bool_t IsMaster() const { return fMasterServ; }	Bool_t IsMaster() const { return fMasterServ; }
	Bool_t IsValid() const { return fValid; }	Bool_t IsValid() const { return fValid; }

		Bool_t IsTty() const { return fTty; }
	Bool_t IsParallel() const { return GetParallel() > 0 ? kTRUE : kFAL SE; }	Bool_t IsParallel() const { return GetParallel() > 0 ? kTRUE : kFAL SE; }
	Bool_t IsIdle() const { return (fNotIdle <= 0) ? kTRUE : kFALSE; }	Bool_t IsIdle() const { return (fNotIdle <= 0) ? kTRUE : kFALSE; }
	Bool_t IsWaiting() const { return fIsWaiting; }	Bool_t IsWaiting() const { return fIsWaiting; }

	ERunStatus GetRunStatus() const { return fRunStatus; }	ERunStatus GetRunStatus() const { return fRunStatus; }
	TList *GetLoadedMacros() const { return fLoadedMacros; }	TList *GetLoadedMacros() const { return fLoadedMacros; }

	//-- input list parameter handling	//-- input list parameter handling
	void SetParameter(const char par, const char value);	void SetParameter(const char par, const char value);
	void SetParameter(const char *par, Int_t value);	void SetParameter(const char *par, Int_t value);

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

	TProofLite.h	TProofLite.h

	// @(#)root/proof:$Id: TProofLite.h 45751 2012-08-30 10:28:19Z ganis $	// @(#)root/proof:$Id: TProofLite.h 47252 2012-11-14 11:03:46Z ganis $
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *
	* For the licensing terms see $ROOTSYS/LICENSE. *	* For the licensing terms see $ROOTSYS/LICENSE. *
	* For the list of contributors see $ROOTSYS/README/CREDITS. *	* For the list of contributors see $ROOTSYS/README/CREDITS. *
	*************************************************************************/	*************************************************************************/

	#ifndef ROOT_TProofLite	#ifndef ROOT_TProofLite
	#define ROOT_TProofLite	#define ROOT_TProofLite

	skipping to change at line 75	skipping to change at line 75

	Int_t CleanupSandbox();	Int_t CleanupSandbox();
	Int_t CreateSandbox();	Int_t CreateSandbox();
	void FindUniqueSlaves();	void FindUniqueSlaves();
	void NotifyStartUp(const char *action, Int_t done, Int_t tot);	void NotifyStartUp(const char *action, Int_t done, Int_t tot);
	Int_t SetProofServEnv(const char *ord);	Int_t SetProofServEnv(const char *ord);
	Int_t InitDataSetManager();	Int_t InitDataSetManager();

	void ResolveKeywords(TString &s, const char *logfile);	void ResolveKeywords(TString &s, const char *logfile);


	void SendInputDataFile();	void SendInputDataFile();
		void ShowDataDir(const char *dirname);

	protected:	protected:
	TProofLite() : TProof() { } // For derived classes to use	TProofLite() : TProof() { } // For derived classes to use

	Int_t CreateSymLinks(TList *files);	Int_t CreateSymLinks(TList *files);
	Int_t Init(const char masterurl, const char conffile,	Int_t Init(const char masterurl, const char conffile,
	const char *confdir, Int_t loglevel,	const char *confdir, Int_t loglevel,
	const char *alias = 0);	const char *alias = 0);
	TProofQueryResult MakeQueryResult(Long64_t nent, const char opt,	TProofQueryResult MakeQueryResult(Long64_t nent, const char opt,
	Long64_t fst, TDSet *dset,	Long64_t fst, TDSet *dset,

	skipping to change at line 133	skipping to change at line 134
	{ return TProof::Process(dsname, sel, o, nent, fst, enl ); }	{ return TProof::Process(dsname, sel, o, nent, fst, enl ); }
	Long64_t Process(TSelector* sel, Long64_t nent, Option_t *o = "")	Long64_t Process(TSelector* sel, Long64_t nent, Option_t *o = "")
	{ return TProof::Process(sel, nent, o); }	{ return TProof::Process(sel, nent, o); }

	// Cache management	// Cache management
	void ShowCache(Bool_t all = kFALSE);	void ShowCache(Bool_t all = kFALSE);
	void ClearCache(const char *file = 0);	void ClearCache(const char *file = 0);
	Int_t Load(const char *macro, Bool_t notOnClient = kFALSE, Bool_t unique Only = kTRUE,	Int_t Load(const char *macro, Bool_t notOnClient = kFALSE, Bool_t unique Only = kTRUE,
	TList *wrks = 0);	TList *wrks = 0);


		// Data management
		void ShowData();

	// Query management	// Query management
	TList GetListOfQueries(Option_t opt = "");	TList GetListOfQueries(Option_t opt = "");
	Int_t Remove(const char *ref, Bool_t all);	Int_t Remove(const char *ref, Bool_t all);

	// Dataset handling	// Dataset handling
	Bool_t RegisterDataSet(const char dsName, TFileCollection ds, const char *opt = "");	Bool_t RegisterDataSet(const char dsName, TFileCollection ds, const char *opt = "");
	Bool_t ExistsDataSet(const char *uri);	Bool_t ExistsDataSet(const char *uri);
	TMap GetDataSets(const char uri = "", const char * = 0);	TMap GetDataSets(const char uri = "", const char * = 0);
	void ShowDataSets(const char uri = "", const char = 0);	void ShowDataSets(const char uri = "", const char = 0);
	TFileCollection GetDataSet(const char uri, const char * = 0);	TFileCollection GetDataSet(const char uri, const char * = 0);

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

	TProofServ.h	TProofServ.h

	// @(#)root/proof:$Id: TProofServ.h 45751 2012-08-30 10:28:19Z ganis $	// @(#)root/proof:$Id: TProofServ.h 48213 2013-01-07 14:29:32Z 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 46	skipping to change at line 46
	#include "TStopwatch.h"	#include "TStopwatch.h"
	#endif	#endif
	#ifndef ROOT_TTimer	#ifndef ROOT_TTimer
	#include "TTimer.h"	#include "TTimer.h"
	#endif	#endif
	#ifndef ROOT_TProofQueryResult	#ifndef ROOT_TProofQueryResult
	#include "TProofQueryResult.h"	#include "TProofQueryResult.h"
	#endif	#endif

	class TDataSetManager;	class TDataSetManager;

		class TDataSetManagerFile;
	class TDSet;	class TDSet;
	class TDSetElement;	class TDSetElement;
	class TFileCollection;	class TFileCollection;
	class TFileHandler;	class TFileHandler;
	class THashList;	class THashList;
	class TIdleTOTimer;	class TIdleTOTimer;
	class TList;	class TList;
	class TMap;	class TMap;
	class TMessage;	class TMessage;
	class TMonitor;	class TMonitor;

	skipping to change at line 156	skipping to change at line 157

	TShutdownTimer *fShutdownTimer; // Timer used to shutdown out-of-contro l sessions	TShutdownTimer *fShutdownTimer; // Timer used to shutdown out-of-contro l sessions
	TReaperTimer *fReaperTimer; // Timer used to control children state	TReaperTimer *fReaperTimer; // Timer used to control children state
	TIdleTOTimer *fIdleTOTimer; // Timer used to control children state	TIdleTOTimer *fIdleTOTimer; // Timer used to control children state

	Int_t fInflateFactor; // Factor in 1/1000 to inflate the CPU time	Int_t fInflateFactor; // Factor in 1/1000 to inflate the CPU time

	Int_t fCompressMsg; // Compression level for messages	Int_t fCompressMsg; // Compression level for messages

	TDataSetManager* fDataSetManager; // dataset manager	TDataSetManager* fDataSetManager; // dataset manager

		TDataSetManagerFile *fDataSetStgRepo; // repository for staging request s

	Bool_t fSendLogToMaster; // On workers, controls logs sending to master	Bool_t fSendLogToMaster; // On workers, controls logs sending to master

	TServerSocket *fMergingSocket; // Socket used for merging outputs if su bmerger	TServerSocket *fMergingSocket; // Socket used for merging outputs if su bmerger
	TMonitor *fMergingMonitor; // Monitor for merging sockets	TMonitor *fMergingMonitor; // Monitor for merging sockets
	Int_t fMergedWorkers; // Number of workers merged	Int_t fMergedWorkers; // Number of workers merged

	// Quotas (-1 to disable)	// Quotas (-1 to disable)
	Int_t fMaxQueries; //Max number of queries fully kept	Int_t fMaxQueries; //Max number of queries fully kept
	Long64_t fMaxBoxSize; //Max size of the sandbox	Long64_t fMaxBoxSize; //Max size of the sandbox

	skipping to change at line 432	skipping to change at line 434
	TProofServLogHandlerGuard(FILE f, TSocket s,	TProofServLogHandlerGuard(FILE f, TSocket s,
	const char *pfx = "", Bool_t on = kTRUE);	const char *pfx = "", Bool_t on = kTRUE);
	virtual ~TProofServLogHandlerGuard();	virtual ~TProofServLogHandlerGuard();
	};	};

	//--- Special timer to control delayed shutdowns	//--- Special timer to control delayed shutdowns
	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	class TShutdownTimer : public TTimer {	class TShutdownTimer : public TTimer {
	private:	private:
	TProofServ *fProofServ;	TProofServ *fProofServ;

		Int_t fTimeout;

	public:	public:

	TShutdownTimer(TProofServ *p, Int_t delay) : TTimer(delay, kFALSE), fPro ofServ(p) { }	TShutdownTimer(TProofServ *p, Int_t delay);

	Bool_t Notify();	Bool_t Notify();
	};	};

	//--- Synchronous timer used to reap children processes change of state	//--- Synchronous timer used to reap children processes change of state
	//_________________________________________________________________________ _____	//_________________________________________________________________________ _____
	class TReaperTimer : public TTimer {	class TReaperTimer : public TTimer {
	private:	private:
	TList *fChildren; // List of children (forked) processes	TList *fChildren; // List of children (forked) processes


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

	TPython.h	TPython.h

	// @(#)root/pyroot:$Id: TPython.h 23159 2008-04-11 20:13:29Z wlav $	// @(#)root/pyroot:$Id: TPython.h 48108 2012-12-18 19:11:13Z wlav $
	#ifndef ROOT_TPython	#ifndef ROOT_TPython
	#define ROOT_TPython	#define ROOT_TPython

	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///
	// //	// //
	// TPython //	// TPython //
	// //	// //
	// Access to the python interpreter and API onto PyROOT. //	// Access to the python interpreter and API onto PyROOT. //
	// //	// //
	/////////////////////////////////////////////////////////////////////////// ///	/////////////////////////////////////////////////////////////////////////// ///

	skipping to change at line 53	skipping to change at line 53
	static void Prompt();	static void Prompt();

	// type verifiers for ObjectProxy	// type verifiers for ObjectProxy
	static Bool_t ObjectProxy_Check( PyObject* pyobject );	static Bool_t ObjectProxy_Check( PyObject* pyobject );
	static Bool_t ObjectProxy_CheckExact( PyObject* pyobject );	static Bool_t ObjectProxy_CheckExact( PyObject* pyobject );

	// object proxy to void* conversion	// object proxy to void* conversion
	static void* ObjectProxy_AsVoidPtr( PyObject* pyobject );	static void* ObjectProxy_AsVoidPtr( PyObject* pyobject );

	// void* to object proxy conversion, returns a new reference	// void* to object proxy conversion, returns a new reference

	static PyObject* ObjectProxy_FromVoidPtr( void* addr, const char* classn	static PyObject* ObjectProxy_FromVoidPtr(
	ame );	void* addr, const char* classname, Bool_t python_owns = kFALSE );

	virtual ~TPython() { }	virtual ~TPython() { }
	ClassDef(TPython,0) //Access to the python interpreter	ClassDef(TPython,0) //Access to the python interpreter
	};	};

	#endif	#endif

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

	TSVG.h	TSVG.h

	// @(#)root/postscript:$Id: TSVG.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/postscript:$Id: TSVG.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Olivier Couet	// Author: Olivier Couet

	/*************************************************************************	/*************************************************************************
	* 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
	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 SetLineColor( Color_t cindex=1);	void SetLineColor( Color_t cindex=1);
	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 SetLineScale(Float_t =3) { }	void SetLineScale(Float_t =3) { }
	void SetMarkerColor( Color_t cindex=1);	void SetMarkerColor( Color_t cindex=1);
	void SetTextColor( Color_t cindex=1);	void SetTextColor( Color_t cindex=1);
	void Text(Double_t x, Double_t y, const char *string);	void Text(Double_t x, Double_t y, const char *string);

		void Text(Double_t, Double_t, const wchar_t *){}
	void TextNDC(Double_t u, Double_t v, const char *string);	void TextNDC(Double_t u, Double_t v, const char *string);

		void TextNDC(Double_t, Double_t, const wchar_t *){}
	Int_t UtoSVG(Double_t u);	Int_t UtoSVG(Double_t u);
	Int_t VtoSVG(Double_t v);	Int_t VtoSVG(Double_t v);
	Int_t XtoSVG(Double_t x);	Int_t XtoSVG(Double_t x);
	Int_t YtoSVG(Double_t y);	Int_t YtoSVG(Double_t y);

	ClassDef(TSVG,0) //SVG driver	ClassDef(TSVG,0) //SVG driver
	};	};

	#endif	#endif

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

	TStatus.h	TStatus.h

	// @(#)root/proofplayer:$Id: TStatus.h 44010 2012-04-29 23:07:48Z ganis $	// @(#)root/proofplayer:$Id: TStatus.h 47253 2012-11-14 11:08:51Z 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 42	skipping to change at line 42

	#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 TStatus : public TNamed {	class TStatus : public TNamed {

	public:	public:

	enum EProcStatus { kNotOk = 15}; // True if status of things are not OK	enum EProcStatus {
		kNotOk = BIT(15) // True if status of things are not OK
		};

	private:	private:
	TList fMsgs; // list of error messages	TList fMsgs; // list of error messages
	TIter fIter; //!iterator in messages	TIter fIter; //!iterator in messages
	THashList fInfoMsgs; // list of info messages	THashList fInfoMsgs; // list of info 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

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

	TTF.h	TTF.h

	// @(#)root/graf:$Id: TTF.h 46562 2012-10-16 11:20:32Z tpochep $	// @(#)root/graf:$Id: TTF.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Olivier Couet 01/10/02	// Author: Olivier Couet 01/10/02
	// Author: Fons Rademakers 21/11/98	// Author: Fons Rademakers 21/11/98

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

	skipping to change at line 54	skipping to change at line 54
	// Class (actually structure) containing glyphs description	// Class (actually structure) containing glyphs description
	class TTGlyph {	class TTGlyph {
	public:	public:
	UInt_t fIndex; // glyph index in face	UInt_t fIndex; // glyph index in face
	FT_Vector fPos; // position of glyph origin	FT_Vector fPos; // position of glyph origin
	FT_Glyph fImage; // glyph image	FT_Glyph fImage; // glyph image
	};	};

	class TGX11TTF;	class TGX11TTF;
	class TGWin32;	class TGWin32;

		class TMathTextRenderer;

	class TTF {	class TTF {

	friend class TGX11TTF;	friend class TGX11TTF;
	friend class TGWin32;	friend class TGWin32;

		friend class TMathTextRenderer;
	friend class TGQuartz;	friend class TGQuartz;


	private:	protected:
	enum { kTTMaxFonts = 32, kMaxGlyphs = 1024 };	enum { kTTMaxFonts = 32, kMaxGlyphs = 1024 };

	static Int_t fgAscent; // string ascent, used to co mpute Y alignment	static Int_t fgAscent; // string ascent, used to co mpute Y alignment
	static FT_BBox fgCBox; // string control box	static FT_BBox fgCBox; // string control box
	static FT_CharMap fgCharMap[kTTMaxFonts]; // font character map	static FT_CharMap fgCharMap[kTTMaxFonts]; // font character map
	static Int_t fgCurFontIdx; // current font index	static Int_t fgCurFontIdx; // current font index
	static Int_t fgSymbItaFontIdx; // Symbol italic font index	static Int_t fgSymbItaFontIdx; // Symbol italic font index
	static Int_t fgFontCount; // number of fonts loaded	static Int_t fgFontCount; // number of fonts loaded
	static char *fgFontName[kTTMaxFonts]; // font name	static char *fgFontName[kTTMaxFonts]; // font name
	static FT_Face fgFace[kTTMaxFonts]; // font face	static FT_Face fgFace[kTTMaxFonts]; // font face

	skipping to change at line 87	skipping to change at line 89
	static Int_t fgNumGlyphs; // number of glyphs in the s tring	static Int_t fgNumGlyphs; // number of glyphs in the s tring
	static FT_Matrix *fgRotMatrix; // rotation matrix	static FT_Matrix *fgRotMatrix; // rotation matrix
	static Bool_t fgSmoothing; // use anti-aliasing (true w hen >8 planes, false otherwise)	static Bool_t fgSmoothing; // use anti-aliasing (true w hen >8 planes, false otherwise)
	static Int_t fgTBlankW; // trailing blanks width	static Int_t fgTBlankW; // trailing blanks width
	static Int_t fgWidth; // string width, used to com pute X alignment	static Int_t fgWidth; // string width, used to com pute X alignment

	public:	public:
	static Short_t CharToUnicode(UInt_t code);	static Short_t CharToUnicode(UInt_t code);
	static void LayoutGlyphs();	static void LayoutGlyphs();
	static void PrepareString(const char *string);	static void PrepareString(const char *string);

		static void PrepareString(const wchar_t *string);
	static void SetRotationMatrix(Float_t angle);	static void SetRotationMatrix(Float_t angle);

	public:	public:
	TTF() { }	TTF() { }
	virtual ~TTF();	virtual ~TTF();

	static void Init();	static void Init();
	static void Cleanup();	static void Cleanup();
	static Int_t GetAscent();	static Int_t GetAscent();
	static const FT_BBox &GetBox();	static const FT_BBox &GetBox();

	skipping to change at line 108	skipping to change at line 111
	static Bool_t GetHinting();	static Bool_t GetHinting();
	static Bool_t GetKerning();	static Bool_t GetKerning();
	static Int_t GetNumGlyphs();	static Int_t GetNumGlyphs();
	static FT_Matrix *GetRotMatrix();	static FT_Matrix *GetRotMatrix();
	static Bool_t GetSmoothing();	static Bool_t GetSmoothing();
	static Int_t GetWidth();	static Int_t GetWidth();
	static void SetHinting(Bool_t state);	static void SetHinting(Bool_t state);
	static void SetKerning(Bool_t state);	static void SetKerning(Bool_t state);
	static void SetSmoothing(Bool_t state);	static void SetSmoothing(Bool_t state);
	static void GetTextExtent(UInt_t &w, UInt_t &h, char *text);	static void GetTextExtent(UInt_t &w, UInt_t &h, char *text);

		static void GetTextExtent(UInt_t &w, UInt_t &h, wchar_t *text) ;
	static void GetTextAdvance(UInt_t &a, char *text);	static void GetTextAdvance(UInt_t &a, char *text);
	static void SetTextFont(Font_t fontnumber);	static void SetTextFont(Font_t fontnumber);
	static Int_t SetTextFont(const char *fontname, Int_t italic=0);	static Int_t SetTextFont(const char *fontname, Int_t italic=0);
	static void SetTextSize(Float_t textsize);	static void SetTextSize(Float_t textsize);
	static Bool_t IsInitialized();	static Bool_t IsInitialized();
	static void Version(Int_t &major, Int_t &minor, Int_t &patch);	static void Version(Int_t &major, Int_t &minor, Int_t &patch);

	ClassDef(TTF,0) //Interface to TTF font handling	ClassDef(TTF,0) //Interface to TTF font handling
	};	};


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

	TText.h	TText.h

	// @(#)root/graf:$Id: TText.h 33120 2010-04-21 14:29:04Z couet $	// @(#)root/graf:$Id: TText.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Nicolas Brun 12/12/94	// Author: Nicolas 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 36	skipping to change at line 36

	#ifndef ROOT_TNamed	#ifndef ROOT_TNamed
	#include "TNamed.h"	#include "TNamed.h"
	#endif	#endif

	class TText : public TNamed, public TAttText {	class TText : public TNamed, public TAttText {

	protected:	protected:
	Double_t fX; // X position of text (left,center,etc..)	Double_t fX; // X position of text (left,center,etc..)
	Double_t fY; // Y position of text (left,center,etc..)	Double_t fY; // Y position of text (left,center,etc..)

		void *fWcsTitle; //!Used by TMathText

	public:	public:
	// TText status bits	// TText status bits
	enum { kTextNDC = BIT(14) };	enum { kTextNDC = BIT(14) };

	TText();	TText();
	TText(Double_t x, Double_t y, const char *text);	TText(Double_t x, Double_t y, const char *text);

		TText(Double_t x, Double_t y, const wchar_t *text);
	TText(const TText &text);	TText(const TText &text);
	virtual ~TText();	virtual ~TText();
	void Copy(TObject &text) const;	void Copy(TObject &text) const;
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual TText DrawText(Double_t x, Double_t y, const char text);	virtual TText DrawText(Double_t x, Double_t y, const char text);

		virtual TText DrawText(Double_t x, Double_t y, const wchar_t text);
	virtual TText DrawTextNDC(Double_t x, Double_t y, const char text);	virtual TText DrawTextNDC(Double_t x, Double_t y, const char text);

		virtual TText DrawTextNDC(Double_t x, Double_t y, const wchar_t text );
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);

	virtual void GetControlBox(Int_t x, Int_t y, Double_t theta,	virtual void GetControlBox(Int_t x, Int_t y, Double_t theta,
	Int_t cBoxX[4], Int_t cBoxY[4]);	Int_t cBoxX[4], Int_t cBoxY[4]);
	Double_t GetX() const { return fX; }	Double_t GetX() const { return fX; }
	virtual void GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle = kFA LSE);	virtual void GetBoundingBox(UInt_t &w, UInt_t &h, Bool_t angle = kFA LSE);
	virtual void GetTextAscentDescent(UInt_t &a, UInt_t &d, const char * text) const;	virtual void GetTextAscentDescent(UInt_t &a, UInt_t &d, const char * text) const;

		virtual void GetTextAscentDescent(UInt_t &a, UInt_t &d, const wchar_ t *text) const;
	virtual void GetTextExtent(UInt_t &w, UInt_t &h, const char *text) c onst;	virtual void GetTextExtent(UInt_t &w, UInt_t &h, const char *text) c onst;

		virtual void GetTextExtent(UInt_t &w, UInt_t &h, const wchar_t *text ) const;
	virtual void GetTextAdvance(UInt_t &a, const char *text, const Bool_ t kern=kTRUE) const;	virtual void GetTextAdvance(UInt_t &a, const char *text, const Bool_ t kern=kTRUE) const;

		const void * GetWcsTitle(void) const;
	Double_t GetY() const { return fY; }	Double_t GetY() const { return fY; }

	virtual void ls(Option_t *option="") const;	virtual void ls(Option_t *option="") const;
	virtual void Paint(Option_t *option="");	virtual void Paint(Option_t *option="");
	virtual void PaintControlBox(Int_t x, Int_t y, Double_t theta);	virtual void PaintControlBox(Int_t x, Int_t y, Double_t theta);
	virtual void PaintText(Double_t x, Double_t y, const char *text);	virtual void PaintText(Double_t x, Double_t y, const char *text);

		virtual void PaintText(Double_t x, Double_t y, const wchar_t *text);
	virtual void PaintTextNDC(Double_t u, Double_t v, const char *text);	virtual void PaintTextNDC(Double_t u, Double_t v, const char *text);

		virtual void PaintTextNDC(Double_t u, Double_t v, const wchar_t *tex t);
	virtual void Print(Option_t *option="") const;	virtual void Print(Option_t *option="") const;

	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "")
		;
		virtual void SetMbTitle(const wchar_t title=L""); // MENU*
	virtual void SetNDC(Bool_t isNDC=kTRUE);	virtual void SetNDC(Bool_t isNDC=kTRUE);
	virtual void SetText(Double_t x, Double_t y, const char text) {fX=x ; fY=y; SetTitle(text);} // MENU* *ARGS={x=>fX,y=>fY,text=>fTitle}	virtual void SetText(Double_t x, Double_t y, const char text) {fX=x ; fY=y; SetTitle(text);} // MENU* *ARGS={x=>fX,y=>fY,text=>fTitle}

		virtual void SetText(Double_t x, Double_t y, const wchar_t *text) {f X=x; fY=y; SetMbTitle(text);}
	virtual void SetX(Double_t x) { fX = x; } // MENU	virtual void SetX(Double_t x) { fX = x; } // MENU
	virtual void SetY(Double_t y) { fY = y; } // MENU	virtual void SetY(Double_t y) { fY = y; } // MENU

	ClassDef(TText,2) //Text	ClassDef(TText,2) //Text
	};	};

	#endif	#endif

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

	TXNetFileStager.h	TXNetFileStager.h

	// @(#)root/netx:$Id: TXNetFileStager.h 24747 2008-07-09 15:41:49Z rdm $	// @(#)root/netx:$Id: TXNetFileStager.h 48077 2012-12-17 16:44:37Z rdm $
	// Author: A. Peters, G. Ganis 7/2/2007	// Author: A. Peters, G. Ganis 7/2/2007

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


	skipping to change at line 29	skipping to change at line 29
	// Interface to the 'XRD' staging capabilities. //	// Interface to the 'XRD' staging capabilities. //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TFileStager	#ifndef ROOT_TFileStager
	#include "TFileStager.h"	#include "TFileStager.h"
	#endif	#endif

	class TCollection;	class TCollection;
	class TXNetSystem;	class TXNetSystem;

		class TFileCollection;

	class TXNetFileStager : public TFileStager {	class TXNetFileStager : public TFileStager {

	private:	private:
	TString fPrefix; // prefix to prepend to requests	TString fPrefix; // prefix to prepend to requests
	TXNetSystem *fSystem; // instance of the admin interface	TXNetSystem *fSystem; // instance of the admin interface

	static void GetPrefix(const char *url, TString &pfx);	static void GetPrefix(const char *url, TString &pfx);

	public:	public:
	TXNetFileStager(const char *stager = "");	TXNetFileStager(const char *stager = "");
	virtual ~TXNetFileStager();	virtual ~TXNetFileStager();

	Bool_t IsStaged(const char *path);	Bool_t IsStaged(const char *path);
	Int_t Locate(const char *path, TString &endpath);	Int_t Locate(const char *path, TString &endpath);

		Int_t LocateCollection(TFileCollection *fc, Bool_t addDummyUrl = kFALS E);
	Bool_t Matches(const char *s);	Bool_t Matches(const char *s);
	Bool_t Stage(const char path, Option_t opt = 0);	Bool_t Stage(const char path, Option_t opt = 0);
	Bool_t Stage(TCollection pathlist, Option_t opt = 0);	Bool_t Stage(TCollection pathlist, Option_t opt = 0);

	Bool_t IsValid() const { return (fSystem ? kTRUE : kFALSE); }	Bool_t IsValid() const { return (fSystem ? kTRUE : kFALSE); }

	void Print(Option_t *option = "") const;	void Print(Option_t *option = "") const;

	ClassDef(TXNetFileStager,0) // Interface to a 'XRD' staging	ClassDef(TXNetFileStager,0) // Interface to a 'XRD' staging
	};	};

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

	Tools.h	Tools.h

	// @(#)root/tmva $Id: Tools.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: Tools.h 47774 2012-12-02 15:07:49Z evt $
	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss	// Author: Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai Voss

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : Tools *	* Class : Tools *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* Global auxiliary applications and data treatment routines *	* Global auxiliary applications and data treatment routines *

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

	public:	public:

	// destructor	// destructor
	~Tools();	~Tools();

	// accessor to single instance	// accessor to single instance
	static Tools& Instance();	static Tools& Instance();
	static void DestroyInstance();	static void DestroyInstance();


		template <typename T> Double_t Mean(Long64_t n, const T *a, const Dou
		ble_t *w=0);
		template <typename Iterator, typename WeightIterator> Double_t Mean (
		Iterator first, Iterator last, WeightIterator w);

		template <typename T> Double_t RMS(Long64_t n, const T *a, const Doub
		le_t *w=0);
		template <typename Iterator, typename WeightIterator> Double_t RMS(It
		erator first, Iterator last, WeightIterator w);

	// simple statistics operations on tree entries	// simple statistics operations on tree entries
	void ComputeStat( const std::vector<TMVA::Event*>&,	void ComputeStat( const std::vector<TMVA::Event*>&,
	std::vector<Float_t>*,	std::vector<Float_t>*,
	Double_t&, Double_t&, Double_t&,	Double_t&, Double_t&, Double_t&,
	Double_t&, Double_t&, Double_t&, Int_t signalClass ,	Double_t&, Double_t&, Double_t&, Int_t signalClass ,
	Bool_t norm = kFALSE );	Bool_t norm = kFALSE );

	// compute variance from sums	// compute variance from sums
	inline Double_t ComputeVariance( Double_t sumx2, Double_t sumx, Int_t nx );	inline Double_t ComputeVariance( Double_t sumx2, Double_t sumx, Int_t nx );


	skipping to change at line 133	skipping to change at line 139

	// parse option string for ANN methods	// parse option string for ANN methods
	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,	std::vector<Int_t>* ParseANNOptionString( TString theOptions, Int_t n var,
	std::vector<Int_t>* nodes ) ;	std::vector<Int_t>* nodes ) ;

	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat	// returns the square-root of a symmetric matrix: symMat = sqrtMat*sq rtMat
	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );	TMatrixD* GetSQRootMatrix( TMatrixDSym* symMat );

	// returns the covariance matrix of of the different classes (and the sum)	// returns the covariance matrix of of the different classes (and the sum)
	// given the event sample	// given the event sample

	std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector<	std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector<
	Event>& events, Int_t maxCls, VariableTransformBase transformBase=0 );	TMVA::Event>& events, Int_t maxCls, VariableTransformBase transformBase=0
		);
		std::vector<TMatrixDSym> CalcCovarianceMatrices( const std::vector<
		const TMVA::Event>& events, Int_t maxCls, VariableTransformBase transform
		Base=0 );

	// turns covariance into correlation matrix	// turns covariance into correlation matrix
	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );	const TMatrixD* GetCorrelationMatrix( const TMatrixD* covMat );

	// check spline quality by comparison with initial histogram	// check spline quality by comparison with initial histogram
	Bool_t CheckSplines( const TH1, const TSpline );	Bool_t CheckSplines( const TH1, const TSpline );

	// normalization of variable output	// normalization of variable output
	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );	Double_t NormVariable( Double_t x, Double_t xmin, Double_t xmax );


	skipping to change at line 176	skipping to change at line 183
	TString ReplaceRegularExpressions( const TString& s, const TString& r eplace = "+" );	TString ReplaceRegularExpressions( const TString& s, const TString& r eplace = "+" );

	// routines for formatted output -----------------	// routines for formatted output -----------------
	void FormattedOutput( const std::vector<Double_t>&, const std::vector <TString>&,	void FormattedOutput( const std::vector<Double_t>&, const std::vector <TString>&,
	const TString titleVars, const TString titleVal ues, MsgLogger& logger,	const TString titleVars, const TString titleVal ues, MsgLogger& logger,
	TString format = "%+1.3f" );	TString format = "%+1.3f" );
	void FormattedOutput( const TMatrixD&, const std::vector<TString>&, M sgLogger& logger );	void FormattedOutput( const TMatrixD&, const std::vector<TString>&, M sgLogger& logger );
	void FormattedOutput( const TMatrixD&, const std::vector<TString>& ve rt, const std::vector<TString>& horiz,	void FormattedOutput( const TMatrixD&, const std::vector<TString>& ve rt, const std::vector<TString>& horiz,
	MsgLogger& logger );	MsgLogger& logger );


	void WriteFloatArbitraryPrecision( Float_t val, ostream& os );	void WriteFloatArbitraryPrecision( Float_t val, std::ostream& os );
	void ReadFloatArbitraryPrecision ( Float_t& val, istream& is );	void ReadFloatArbitraryPrecision ( Float_t& val, std::istream& is );

	// for histogramming	// for histogramming
	TString GetXTitleWithUnit( const TString& title, const TString& unit );	TString GetXTitleWithUnit( const TString& title, const TString& unit );
	TString GetYTitleWithUnit( const TH1& h, const TString& unit, Bool_t normalised );	TString GetYTitleWithUnit( const TH1& h, const TString& unit, Bool_t normalised );

	// Mutual Information method for non-linear correlations estimates in 2D histogram	// Mutual Information method for non-linear correlations estimates in 2D histogram
	// Author: Moritz Backes, Geneva (2009)	// Author: Moritz Backes, Geneva (2009)
	Double_t GetMutualInformation( const TH2F& );	Double_t GetMutualInformation( const TH2F& );

	// Correlation Ratio method for non-linear correlations estimates in 2D histogram	// Correlation Ratio method for non-linear correlations estimates in 2D histogram

	skipping to change at line 261	skipping to change at line 268
	Bool_t AddRawLine ( void* node, const char * raw );	Bool_t AddRawLine ( void* node, const char * raw );
	Bool_t AddComment ( void* node, const char* comment );	Bool_t AddComment ( void* node, const char* comment );

	void* GetParent( void* child);	void* GetParent( void* child);
	void* GetChild ( void* parent, const char* childname=0 );	void* GetChild ( void* parent, const char* childname=0 );
	void* GetNextChild( void* prevchild, const char* childname=0 );	void* GetNextChild( void* prevchild, const char* childname=0 );
	const char* GetContent ( void* node );	const char* GetContent ( void* node );
	const char* GetName ( void* node );	const char* GetName ( void* node );

	TXMLEngine& xmlengine() { return *fXMLEngine; }	TXMLEngine& xmlengine() { return *fXMLEngine; }

		int xmlenginebuffersize() { return 1000000; }
	TXMLEngine* fXMLEngine;	TXMLEngine* fXMLEngine;

	private:	private:

	// utilities for correlation ratio	// utilities for correlation ratio
	Double_t GetYMean_binX( const TH2& , Int_t bin_x );	Double_t GetYMean_binX( const TH2& , Int_t bin_x );

	}; // Common tools	}; // Common tools

	Tools& gTools(); // global accessor	Tools& gTools(); // global accessor

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

	Version.h	Version.h

	// @(#)root/tmva $Id: Version.h 44118 2012-05-04 12:29:18Z evt $	// @(#)root/tmva $Id: Version.h 47816 2012-12-04 13:19:34Z hvoss $
	// 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.3"	#define TMVA_RELEASE "4.1.4"
	#define TMVA_RELEASE_DATE "May 04, 2012"	#define TMVA_RELEASE_DATE "Dec 04, 2012"
	#define TMVA_RELEASE_TIME "15:00:00"	#define TMVA_RELEASE_TIME "14:19:17"
	#define TMVA_VERSION_CODE 262403	#define TMVA_VERSION_CODE 262404
	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))	#define TMVA_VERSION(a,b,c) (((a) << 16) + ((b) << 8) + (c))

	#endif	#endif

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

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	PDF.h	PDF.h

	// @(#)root/tmva $Id: PDF.h 40005 2011-06-27 15:29:10Z stelzer $	// @(#)root/tmva $Id: PDF.h 47734 2012-11-30 16:07:56Z hvoss $
	// Author: Asen Christov, Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai V oss , Jan Therhaag	// Author: Asen Christov, Andreas Hoecker, Joerg Stelzer, Helge Voss, Kai V oss , Jan Therhaag

	/************************************************************************ ******	/************************************************************************ ******
	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *	* Project: TMVA - a Root-integrated toolkit for multivariate data analysis *
	* Package: TMVA *	* Package: TMVA *
	* Class : PDF *	* Class : PDF *
	* Web : http://tmva.sourceforge.net *	* Web : http://tmva.sourceforge.net *
	* *	* *
	* Description: *	* Description: *
	* PDF wrapper for histograms; uses user-defined spline interpolation *	* PDF wrapper for histograms; uses user-defined spline interpolation *

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

	// returns probability density at given abscissa	// returns probability density at given abscissa
	Double_t GetVal ( Double_t x ) const;	Double_t GetVal ( Double_t x ) const;
	Double_t GetValInverse( Double_t y, Bool_t isMonotonouslyIncreasingFu nction=kFALSE ) const;	Double_t GetValInverse( Double_t y, Bool_t isMonotonouslyIncreasingFu nction=kFALSE ) const;

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

	// histogram underlying the PDF	// histogram underlying the PDF
	TH1* GetPDFHist() const { return fPDFHist; }	TH1* GetPDFHist() const { return fPDFHist; }

		TGraph* GetGraph() const { return fGraph; }
	TH1* GetOriginalHist() const { return fHistOriginal; }	TH1* GetOriginalHist() const { return fHistOriginal; }
	TH1* GetSmoothedHist() const { return fHist; }	TH1* GetSmoothedHist() const { return fHist; }
	TH1* GetNSmoothHist() const { return fNSmoothHist; }	TH1* GetNSmoothHist() const { return fNSmoothHist; }

	// integral of PDF within given range	// integral of PDF within given range
	Double_t GetIntegral( Double_t xmin, Double_t xmax );	Double_t GetIntegral( Double_t xmin, Double_t xmax );

	// accessors	// accessors
	TSpline* GetSpline() const { return fSpline; }	TSpline* GetSpline() const { return fSpline; }
	Int_t GetNBins () const { return fHist->GetNbinsX(); }	Int_t GetNBins () const { return fHist->GetNbinsX(); }

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

	RooAbsPdf.h	RooAbsPdf.h

	skipping to change at line 59	skipping to change at line 59
	virtual ~RooAbsPdf();	virtual ~RooAbsPdf();

	// Toy MC generation	// Toy MC generation
	RooDataSet *generate(const RooArgSet &whatVars, Int_t nEvents, const RooC mdArg& arg1,	RooDataSet *generate(const RooArgSet &whatVars, Int_t nEvents, const RooC mdArg& arg1,
	const RooCmdArg& arg2=RooCmdArg::none(), const RooCm dArg& arg3=RooCmdArg::none(),	const RooCmdArg& arg2=RooCmdArg::none(), const RooCm dArg& arg3=RooCmdArg::none(),
	const RooCmdArg& arg4=RooCmdArg::none(), const RooCm dArg& arg5=RooCmdArg::none()) ;	const RooCmdArg& arg4=RooCmdArg::none(), const RooCm dArg& arg5=RooCmdArg::none()) ;
	RooDataSet *generate(const RooArgSet &whatVars,	RooDataSet *generate(const RooArgSet &whatVars,
	const RooCmdArg& arg1=RooCmdArg::none(),const RooCmd Arg& arg2=RooCmdArg::none(),	const RooCmdArg& arg1=RooCmdArg::none(),const RooCmd Arg& arg2=RooCmdArg::none(),
	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmd Arg& arg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(),const RooCmd Arg& arg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmd Arg& arg6=RooCmdArg::none()) ;	const RooCmdArg& arg5=RooCmdArg::none(),const RooCmd Arg& arg6=RooCmdArg::none()) ;

	RooDataSet *generate(const RooArgSet &whatVars, Int_t nEvents = 0, Bool_t verbose=kFALSE, Bool_t autoBinned=kTRUE,	RooDataSet *generate(const RooArgSet &whatVars, Double_t nEvents = 0, Boo l_t verbose=kFALSE, Bool_t autoBinned=kTRUE,
	const char* binnedTag="", Bool_t expectedData=kFALSE, Bool_t extended = kFALSE) const;	const char* binnedTag="", Bool_t expectedData=kFALSE, Bool_t extended = kFALSE) const;
	RooDataSet *generate(const RooArgSet &whatVars, const RooDataSet &prototy pe, Int_t nEvents= 0,	RooDataSet *generate(const RooArgSet &whatVars, const RooDataSet &prototy pe, Int_t nEvents= 0,
	Bool_t verbose=kFALSE, Bool_t randProtoOrder=kFALSE, Bool_t resampleProto=kFALSE) const;	Bool_t verbose=kFALSE, Bool_t randProtoOrder=kFALSE, Bool_t resampleProto=kFALSE) const;

	class GenSpec {	class GenSpec {
	public:	public:
	virtual ~GenSpec() ;	virtual ~GenSpec() ;
	GenSpec() { _genContext = 0 ; _protoData = 0 ; _init = kFALSE ; _extend ed=kFALSE, _nGen=0 ; _randProto = kFALSE ; _resampleProto=kFALSE ; }	GenSpec() { _genContext = 0 ; _protoData = 0 ; _init = kFALSE ; _extend ed=kFALSE, _nGen=0 ; _randProto = kFALSE ; _resampleProto=kFALSE ; }
	private:	private:
	GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSe t* protoData, Int_t nGen, Bool_t extended,	GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSe t* protoData, Int_t nGen, Bool_t extended,

	skipping to change at line 182	skipping to change at line 182
	const RooCmdArg& arg3=RooCmdArg::none(), const RooCm dArg& arg4=RooCmdArg::none(),	const RooCmdArg& arg3=RooCmdArg::none(), const RooCm dArg& arg4=RooCmdArg::none(),
	const RooCmdArg& arg5=RooCmdArg::none(), const RooCm dArg& arg6=RooCmdArg::none(),	const RooCmdArg& arg5=RooCmdArg::none(), const RooCm dArg& arg6=RooCmdArg::none(),
	const RooCmdArg& arg7=RooCmdArg::none(), const RooCm dArg& arg8=RooCmdArg::none()) ;	const RooCmdArg& arg7=RooCmdArg::none(), const RooCm dArg& arg8=RooCmdArg::none()) ;
	RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, I nt_t numScanBins, Int_t intOrder) ;	RooAbsReal* createScanCdf(const RooArgSet& iset, const RooArgSet& nset, I nt_t numScanBins, Int_t intOrder) ;

	// Function evaluation support	// Function evaluation support
	virtual Bool_t traceEvalHook(Double_t value) const ;	virtual Bool_t traceEvalHook(Double_t value) const ;
	virtual Double_t getValV(const RooArgSet* set=0) const ;	virtual Double_t getValV(const RooArgSet* set=0) const ;
	virtual Double_t getLogVal(const RooArgSet* set=0) const ;	virtual Double_t getLogVal(const RooArgSet* set=0) const ;


	void setNormValueCaching(Int_t minNumIntDim, Int_t ipOrder=2) ;
	Int_t minDimNormValueCaching() const { return _minDimNormValueCache ; }
	Int_t intOrderNormValueCaching() const { return _valueCacheIntOrder ; }

	Double_t getNorm(const RooArgSet& nset) const {	Double_t getNorm(const RooArgSet& nset) const {
	// Get p.d.f normalization term needed for observables 'nset'	// Get p.d.f normalization term needed for observables 'nset'
	return getNorm(&nset) ;	return getNorm(&nset) ;
	}	}
	virtual Double_t getNorm(const RooArgSet* set=0) const ;	virtual Double_t getNorm(const RooArgSet* set=0) const ;

	virtual void resetErrorCounters(Int_t resetValue=10) ;	virtual void resetErrorCounters(Int_t resetValue=10) ;
	void setTraceCounter(Int_t value, Bool_t allNodes=kFALSE) ;	void setTraceCounter(Int_t value, Bool_t allNodes=kFALSE) ;
	Bool_t traceEvalPdf(Double_t value) const ;	Bool_t traceEvalPdf(Double_t value) const ;


	skipping to change at line 244	skipping to change at line 240

	static void clearEvalError() ;	static void clearEvalError() ;
	static Bool_t evalError() ;	static Bool_t evalError() ;

	void setNormRange(const char* rangeName) ;	void setNormRange(const char* rangeName) ;
	const char* normRange() const {	const char* normRange() const {
	return _normRange.Length()>0 ? _normRange.Data() : 0 ;	return _normRange.Length()>0 ? _normRange.Data() : 0 ;
	}	}
	void setNormRangeOverride(const char* rangeName) ;	void setNormRangeOverride(const char* rangeName) ;


		const RooAbsReal* getNormIntegral(const RooArgSet& nset) const { return g
		etNormObj(0,&nset,0) ; }

	protected:	protected:

	public:	public:
	virtual const RooAbsReal* getNormObj(const RooArgSet* set, const RooArgSe t* iset, const TNamed* rangeName=0) const ;	virtual const RooAbsReal* getNormObj(const RooArgSet* set, const RooArgSe t* iset, const TNamed* rangeName=0) const ;
	protected:	protected:

	RooDataSet generate(RooAbsGenContext& context, const RooArgSet& whatVars , const RooDataSet prototype,	RooDataSet generate(RooAbsGenContext& context, const RooArgSet& whatVars , const RooDataSet prototype,

	Int_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto, Bool_t skipInit=kFALSE,	Double_t nEvents, Bool_t verbose, Bool_t randProtoOrd er, Bool_t resampleProto, Bool_t skipInit=kFALSE,
	Bool_t extended=kFALSE) const ;	Bool_t extended=kFALSE) const ;

	// Implementation version	// Implementation version
	virtual RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants=kFALSE,	virtual RooPlot* paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants=kFALSE,
	const char label= "", Int_t sigDigits = 2, Opti on_t options = "NELU", Double_t xmin=0.65,	const char label= "", Int_t sigDigits = 2, Opti on_t options = "NELU", Double_t xmin=0.65,
	Double_t xmax= 0.99,Double_t ymax=0.95, const Roo CmdArg* formatCmd=0) ;	Double_t xmax= 0.99,Double_t ymax=0.95, const Roo CmdArg* formatCmd=0) ;

	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;	virtual RooPlot* plotOn(RooPlot* frame, RooLinkedList& cmdList) const ;
	void plotOnCompSelect(RooArgSet* selNodes) const ;	void plotOnCompSelect(RooArgSet* selNodes) const ;


	skipping to change at line 298	skipping to change at line 296

	friend class RooRealIntegral ;	friend class RooRealIntegral ;
	static Int_t _verboseEval ;	static Int_t _verboseEval ;

	virtual Bool_t syncNormalization(const RooArgSet* dset, Bool_t adjustProx ies=kTRUE) const ;	virtual Bool_t syncNormalization(const RooArgSet* dset, Bool_t adjustProx ies=kTRUE) const ;

	friend class RooAbsAnaConvPdf ;	friend class RooAbsAnaConvPdf ;
	mutable Double_t _rawValue ;	mutable Double_t _rawValue ;
	mutable RooAbsReal* _norm ; //! Normalization integral (owned by _ normMgr)	mutable RooAbsReal* _norm ; //! Normalization integral (owned by _ normMgr)
	mutable RooArgSet* _normSet ; //! Normalization set with for above i ntegral	mutable RooArgSet* _normSet ; //! Normalization set with for above i ntegral

	Int_t _minDimNormValueCache ; // Minimum number of numerically integ
	rated dimensions to activate normalization value caching
	Int_t _valueCacheIntOrder ; // Interpolation order for numeric int
	egral value cache

	class CacheElem : public RooAbsCacheElement {	class CacheElem : public RooAbsCacheElement {
	public:	public:
	CacheElem(RooAbsReal& norm) : _norm(&norm) {} ;	CacheElem(RooAbsReal& norm) : _norm(&norm) {} ;
	void operModeHook(RooAbsArg::OperMode) ;	void operModeHook(RooAbsArg::OperMode) ;
	virtual ~CacheElem() ;	virtual ~CacheElem() ;
	virtual RooArgList containedArgs(Action) { return RooArgList(*_norm) ; }	virtual RooArgList containedArgs(Action) { return RooArgList(*_norm) ; }
	RooAbsReal* _norm ;	RooAbsReal* _norm ;
	} ;	} ;
	mutable RooObjCacheManager _normMgr ; // The cache manager	mutable RooObjCacheManager _normMgr ; // The cache manager

	skipping to change at line 338	skipping to change at line 334

	static void raiseEvalError() ;	static void raiseEvalError() ;

	static Bool_t _evalError ;	static Bool_t _evalError ;

	RooNumGenConfig* _specGeneratorConfig ; //! MC generator configuration sp ecific for this object	RooNumGenConfig* _specGeneratorConfig ; //! MC generator configuration sp ecific for this object

	TString _normRange ; // Normalization range	TString _normRange ; // Normalization range
	static TString _normRangeOverride ;	static TString _normRangeOverride ;


	ClassDef(RooAbsPdf,3) // Abstract PDF with normalization support	ClassDef(RooAbsPdf,4) // Abstract PDF with normalization support
	};	};

	#endif	#endif

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

	RooGlobalFunc.h	RooGlobalFunc.h

	skipping to change at line 195	skipping to change at line 195
	RooCmdArg GlobalObservables(const RooArgSet& globs) ;	RooCmdArg GlobalObservables(const RooArgSet& globs) ;
	RooCmdArg GlobalObservablesTag(const char* tagName) ;	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) ;

		RooCmdArg Offset(Bool_t flag=kTRUE) ;

	// RooAbsPdf::paramOn arguments	// RooAbsPdf::paramOn arguments
	RooCmdArg Label(const char* str) ;	RooCmdArg Label(const char* str) ;
	RooCmdArg Layout(Double_t xmin, Double_t xmax=0.99, Double_t ymin=0.95) ;	RooCmdArg Layout(Double_t xmin, Double_t xmax=0.99, Double_t ymin=0.95) ;
	RooCmdArg Parameters(const RooArgSet& params) ;	RooCmdArg Parameters(const RooArgSet& params) ;
	RooCmdArg ShowConstants(Bool_t flag=kTRUE) ;	RooCmdArg ShowConstants(Bool_t flag=kTRUE) ;

	// RooTreeData::statOn arguments	// RooTreeData::statOn arguments
	RooCmdArg What(const char* str) ;	RooCmdArg What(const char* str) ;


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

	RooNameSet.h	RooNameSet.h

	skipping to change at line 20	skipping to change at line 20
	* 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_NAME_SET	#ifndef ROO_NAME_SET
	#define ROO_NAME_SET	#define ROO_NAME_SET

	#include "TString.h"	#include "TString.h"

	#include "RooAbsArg.h"	#include "TObject.h"
	#include "RooPrintable.h"	#include "RooPrintable.h"
	class RooArgSet ;	class RooArgSet ;

	class RooNameSet : public TObject, public RooPrintable {	class RooNameSet : public TObject, public RooPrintable {
	public:	public:

	// Constructors, assignment etc.	// Constructors, assignment etc.
	RooNameSet();	RooNameSet();
	RooNameSet(const RooArgSet& argSet);	RooNameSet(const RooArgSet& argSet);
	RooNameSet(const RooNameSet& other) ;	RooNameSet(const RooNameSet& other) ;
	virtual TObject* Clone(const char) const { return new RooNameSet(this) ; }	virtual TObject* Clone(const char) const { return new RooNameSet(this) ; }
	virtual ~RooNameSet() ;	virtual ~RooNameSet() ;

	void refill(const RooArgSet& argSet) ;	void refill(const RooArgSet& argSet) ;
	RooArgSet* select(const RooArgSet& list) const ;	RooArgSet* select(const RooArgSet& list) const ;
	Bool_t operator==(const RooNameSet& other) ;	Bool_t operator==(const RooNameSet& other) ;
	RooNameSet& operator=(const RooNameSet&) ;	RooNameSet& operator=(const RooNameSet&) ;

		Bool_t operator<(const RooNameSet& other) const ;

	virtual void printName(std::ostream& os) const ;	virtual void printName(std::ostream& os) const ;
	virtual void printTitle(std::ostream& os) const ;	virtual void printTitle(std::ostream& os) const ;
	virtual void printClassName(std::ostream& os) const ;	virtual void printClassName(std::ostream& os) const ;
	virtual void printValue(std::ostream& os) const ;	virtual void printValue(std::ostream& os) const ;

	inline virtual void Print(Option_t *options= 0) const {	inline virtual void Print(Option_t *options= 0) const {
	printStream(defaultPrintStream(),defaultPrintContents(options),defaultP rintStyle(options));	printStream(defaultPrintStream(),defaultPrintContents(options),defaultP rintStyle(options));
	}	}


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

	TDataSetManagerFile.h	TDataSetManagerFile.h

	// @(#)root/proof:$Id: TDataSetManagerFile.h 33357 2010-05-04 06:56:18Z gan is $	// @(#)root/proof:$Id: TDataSetManagerFile.h 48061 2012-12-15 19:46:14Z gan is $
	// Author: Jan Fiete Grosse-Oetringhaus, 08.08.07	// Author: Jan Fiete Grosse-Oetringhaus, 08.08.07

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

	#ifndef ROOT_TDataSetManagerFile	#ifndef ROOT_TDataSetManagerFile
	#define ROOT_TDataSetManagerFile	#define ROOT_TDataSetManagerFile

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

	// TDataSetManagerFile //	// TDataSetManagerFile //
	// //	// //

	// Implementation of TDataSetManager handling datasets from root //	// Implementation of TDataSetManager handling datasets from root //
	// files under a specific directory path //	// files under a specific directory path //
	// //	// //
	//////////////////////////////////////////////////////////////////////////	//////////////////////////////////////////////////////////////////////////

	#ifndef ROOT_TDataSetManager	#ifndef ROOT_TDataSetManager
	#include "TDataSetManager.h"	#include "TDataSetManager.h"
	#endif	#endif

	const char* const kDataSet_LocalCache = "dataset.cache"; // default cache subdirectory	const char* const kDataSet_LocalCache = "dataset.cache"; // default cache subdirectory
	const char* const kDataSet_DataSetList = "dataset.list"; // file with inf o about all datasets	const char* const kDataSet_DataSetList = "dataset.list"; // file with inf o about all datasets

	skipping to change at line 45	skipping to change at line 45
	TString fDataSetDir; // Location of datasets	TString fDataSetDir; // Location of datasets
	TString fMSSUrl; // URL for the Mass Storage System	TString fMSSUrl; // URL for the Mass Storage System
	TString fStageOpts; // Option string to be used in issuing stagi ng requests	TString fStageOpts; // Option string to be used in issuing stagi ng requests
	TString fDataSetLockFile; // Dataset lock file	TString fDataSetLockFile; // Dataset lock file
	Int_t fLockFileTimeLimit; // Limit in seconds after a lock automatical ly expires	Int_t fLockFileTimeLimit; // Limit in seconds after a lock automatical ly expires
	TString fListFile; // File to check repository updates	TString fListFile; // File to check repository updates
	Bool_t fIsRemote; // True if the repository is remote	Bool_t fIsRemote; // True if the repository is remote
	Bool_t fUseCache; // True if the cache is used for browsing re mote repositories	Bool_t fUseCache; // True if the cache is used for browsing re mote repositories
	TString fLocalCacheDir; // Local cache when the repository is remote	TString fLocalCacheDir; // Local cache when the repository is remote
	Int_t fCacheUpdatePeriod; // Period for checking for new updated infor mation	Int_t fCacheUpdatePeriod; // Period for checking for new updated infor mation

		Bool_t fOpenPerms; // True if file permissions must be open

	// Local cache handling	// Local cache handling
	void InitLocalCache();	void InitLocalCache();
	Int_t CheckLocalCache(const char group, const char user, const char *dsName = "ls", UInt_t option = 0);	Int_t CheckLocalCache(const char group, const char user, const char *dsName = "ls", UInt_t option = 0);

	protected:	protected:
	const char GetDataSetPath(const char group, const char user, const ch ar dsName);	const char GetDataSetPath(const char group, const char user, const ch ar dsName);
	const char GetDataSetPath(const char group, const char user, const ch ar dsName,	const char GetDataSetPath(const char group, const char user, const ch ar dsName,
	TString &md5path, Bool_t local = kFALSE);	TString &md5path, Bool_t local = kFALSE);
	void Init();	void Init();

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

	// These should / could be private but they are used directly by the ext ernal daemon	// These should / could be private but they are used directly by the ext ernal daemon
	TFileCollection GetDataSet(const char group, const char user, const c har dsName,	TFileCollection GetDataSet(const char group, const char user, const c har dsName,
	UInt_t option = 0, TMD5 **checksum = 0);	UInt_t option = 0, TMD5 **checksum = 0);
	TMap GetDataSets(const char group, const char user, const char dsName = 0,	TMap GetDataSets(const char group, const char user, const char dsName = 0,
	UInt_t option = 0);	UInt_t option = 0);
	const char *GetMSSUrl() const { return fMSSUrl; }	const char *GetMSSUrl() const { return fMSSUrl; }
	const char *GetStageOpts() const { return fStageOpts; }	const char *GetStageOpts() const { return fStageOpts; }
	Int_t WriteDataSet(const char group, const char user, const char *dsName,	Int_t WriteDataSet(const char group, const char user, const char *dsName,
	TFileCollection dataset, UInt_t option = 0, TMD5 checksum = 0);	TFileCollection dataset, UInt_t option = 0, TMD5 checksum = 0);

		Long_t GetModTime(const char *uri);

	ClassDef(TDataSetManagerFile, 0) // DataSet manager for files	ClassDef(TDataSetManagerFile, 0) // DataSet manager for files
	};	};

	#endif	#endif

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

	TFileCollection.h	TFileCollection.h

	// @(#)root/base:$Id: TFileCollection.h 42775 2012-01-23 16:43:54Z rdm $	// @(#)root/base:$Id: TFileCollection.h 48059 2012-12-15 15:37:12Z rdm $
	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07	// Author: Jan Fiete Grosse-Oetringhaus 01/06/07

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


	skipping to change at line 58	skipping to change at line 58
	TString fDefaultTree; // name of default tree	TString fDefaultTree; // name of default tree
	Long64_t fTotalSize; // total size of files in the list	Long64_t fTotalSize; // total size of files in the list
	Long64_t fNFiles; // number of files ( == fList->GetEntri es(), needed	Long64_t fNFiles; // number of files ( == fList->GetEntri es(), needed
	// because TFileCollection might be rea d without fList)	// because TFileCollection might be rea d without fList)
	Long64_t fNStagedFiles; // number of staged files	Long64_t fNStagedFiles; // number of staged files
	Long64_t fNCorruptFiles; // number of corrupt files	Long64_t fNCorruptFiles; // number of corrupt files

	TFileCollection(const TFileCollection&); // not implemented	TFileCollection(const TFileCollection&); // not implemented
	TFileCollection& operator=(const TFileCollection&); // not implemented	TFileCollection& operator=(const TFileCollection&); // not implemented


		void PrintDetailed(TString &showOnly) const;
		void FormatSize(Long64_t bytes, TString &um, Double_t &size) const;

	public:	public:
	enum EStatusBits {	enum EStatusBits {
	kRemoteCollection = BIT(15) // the collection is not staged	kRemoteCollection = BIT(15) // the collection is not staged
	};	};
	TFileCollection(const char name = 0, const char title = 0,	TFileCollection(const char name = 0, const char title = 0,
	const char *file = 0, Int_t nfiles = -1, Int_t firstfile = 1);	const char *file = 0, Int_t nfiles = -1, Int_t firstfile = 1);
	virtual ~TFileCollection();	virtual ~TFileCollection();

	Int_t Add(TFileInfo *info);	Int_t Add(TFileInfo *info);
	Int_t Add(TFileCollection *coll);	Int_t Add(TFileCollection *coll);

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

	TFileInfo.h	TFileInfo.h

	// @(#)root/base:$Id: TFileInfo.h 42788 2012-01-24 23:48:37Z rdm $	// @(#)root/base:$Id: TFileInfo.h 48059 2012-12-15 15:37:12Z rdm $
	// Author: Andreas-Joachim Peters 20/9/2005	// Author: Andreas-Joachim Peters 20/9/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 83	skipping to change at line 83
	TFileInfo(const char url = 0, Long64_t size = -1, const char uuid = 0,	TFileInfo(const char url = 0, Long64_t size = -1, const char uuid = 0,
	const char md5 = 0, TObject meta = 0);	const char md5 = 0, TObject meta = 0);
	TFileInfo(const TFileInfo &);	TFileInfo(const TFileInfo &);

	virtual ~TFileInfo();	virtual ~TFileInfo();

	void ResetUrl() { fCurrentUrl = (TUrl*)fUrlList->First(); }	void ResetUrl() { fCurrentUrl = (TUrl*)fUrlList->First(); }
	TUrl *NextUrl();	TUrl *NextUrl();
	TUrl *GetCurrentUrl() const;	TUrl *GetCurrentUrl() const;
	TUrl GetFirstUrl() const { return (TUrl)fUrlList->First(); }	TUrl GetFirstUrl() const { return (TUrl)fUrlList->First(); }

		TUrl GetUrlAt(Int_t i) const { return (TUrl)fUrlList->At(i);
		}
		Bool_t RemoveUrlAt(Int_t i);
	Int_t GetNUrls() const { return fUrlList->GetEntries(); }	Int_t GetNUrls() const { return fUrlList->GetEntries(); }

	Bool_t SetCurrentUrl(const char *url);	Bool_t SetCurrentUrl(const char *url);
	Bool_t SetCurrentUrl(TUrl *url);	Bool_t SetCurrentUrl(TUrl *url);

	Long64_t GetSize() const { return fSize; }	Long64_t GetSize() const { return fSize; }
	TUUID *GetUUID() const { return fUUID; }	TUUID *GetUUID() const { return fUUID; }
	TMD5 *GetMD5() const { return fMD5; }	TMD5 *GetMD5() const { return fMD5; }
	TList *GetMetaDataList() const { return fMetaDataList; }	TList *GetMetaDataList() const { return fMetaDataList; }
	TFileInfoMeta GetMetaData(const char meta = 0) const;	TFileInfoMeta GetMetaData(const char meta = 0) const;

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

	TGLPadPainter.h	TGLPadPainter.h

	// @(#)root/gl:$Id: TGLPadPainter.h 33600 2010-05-21 09:24:32Z rdm $	// @(#)root/gl:$Id: TGLPadPainter.h 47130 2012-11-09 03:05:52Z matevz $
	// Author: Timur Pocheptsov 06/05/2009	// Author: Timur Pocheptsov 06/05/2009

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


	skipping to change at line 117	skipping to change at line 117
	//TPad needs both double and float versions of DrawPolyLine.	//TPad needs both double and float versions of DrawPolyLine.
	void DrawPolyLine(Int_t n, const Double_t x, const Double_t y);	void DrawPolyLine(Int_t n, const Double_t x, const Double_t y);
	void DrawPolyLine(Int_t n, const Float_t x, const Float_t y);	void DrawPolyLine(Int_t n, const Float_t x, const Float_t y);
	void DrawPolyLineNDC(Int_t n, const Double_t u, const Double_t v);	void DrawPolyLineNDC(Int_t n, const Double_t u, const Double_t v);

	//TPad needs both versions.	//TPad needs both versions.
	void DrawPolyMarker(Int_t n, const Double_t x, const Double_t y);	void DrawPolyMarker(Int_t n, const Double_t x, const Double_t y);
	void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y);	void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y);

	void DrawText(Double_t x, Double_t y, const char *text, ETextMode mo de);	void DrawText(Double_t x, Double_t y, const char *text, ETextMode mo de);

		void DrawText(Double_t, Double_t, const wchar_t *, ETextMode){}
	void DrawTextNDC(Double_t x, Double_t y, const char *text, ETextMode mode);	void DrawTextNDC(Double_t x, Double_t y, const char *text, ETextMode mode);

		void DrawTextNDC(Double_t, Double_t, const wchar_t *, ETextMode){}

	//jpg, png, gif and bmp output.	//jpg, png, gif and bmp output.
	void SaveImage(TVirtualPad pad, const char fileName, Int_t type) c onst;	void SaveImage(TVirtualPad pad, const char fileName, Int_t type) c onst;

	private:	private:

	//Attention! GL_PROJECTION will become	//Attention! GL_PROJECTION will become
	//the current matrix after these calls.	//the current matrix after these calls.
	void SaveProjectionMatrix()const;	void SaveProjectionMatrix()const;
	void RestoreProjectionMatrix()const;	void RestoreProjectionMatrix()const;

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

	TGX11.h	TGX11.h

	// @(#)root/x11:$Id: TGX11.h 37734 2011-01-07 09:53:54Z rdm $	// @(#)root/x11:$Id: TGX11.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Rene Brun, Olivier Couet, Fons Rademakers 28/11/94	// Author: Rene Brun, Olivier Couet, Fons Rademakers 28/11/94

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


	skipping to change at line 192	skipping to change at line 192
	void ClosePixmap();	void ClosePixmap();
	void CloseWindow();	void CloseWindow();
	void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos);	void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos);
	void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMode mode) ;	void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMode mode) ;
	void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2, Int_t nx , Int_t ny, Int_t *ic);	void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2, Int_t nx , Int_t ny, Int_t *ic);
	void DrawFillArea(Int_t n, TPoint *xy);	void DrawFillArea(Int_t n, TPoint *xy);
	void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);	void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);
	void DrawPolyLine(Int_t n, TPoint *xy);	void DrawPolyLine(Int_t n, TPoint *xy);
	void DrawPolyMarker(Int_t n, TPoint *xy);	void DrawPolyMarker(Int_t n, TPoint *xy);
	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, cons t char *text, ETextMode mode);	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, cons t char *text, ETextMode mode);

		virtual void DrawText(Int_t, Int_t, Float_t, Float_t, const wchar_t *, E TextMode) {}
	void GetCharacterUp(Float_t &chupx, Float_t &chupy);	void GetCharacterUp(Float_t &chupx, Float_t &chupy);
	Int_t GetDoubleBuffer(Int_t wid);	Int_t GetDoubleBuffer(Int_t wid);
	void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t & h);	void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t & h);
	const char DisplayName(const char dpyName = 0);	const char DisplayName(const char dpyName = 0);
	Handle_t GetNativeEvent() const { return (Handle_t) fXEvent; }	Handle_t GetNativeEvent() const { return (Handle_t) fXEvent; }
	ULong_t GetPixel(Color_t cindex);	ULong_t GetPixel(Color_t cindex);
	void GetPlanes(Int_t &nplanes);	void GetPlanes(Int_t &nplanes);
	void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b);	void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b);
	virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess);	virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess);

		virtual void GetTextExtent(UInt_t &, UInt_t &, wchar_t *){}
	Float_t GetTextMagnitude() { return fTextMagnitude; }	Float_t GetTextMagnitude() { return fTextMagnitude; }
	Window_t GetWindowID(Int_t wid);	Window_t GetWindowID(Int_t wid);
	Bool_t HasTTFonts() const { return fHasTTFonts; }	Bool_t HasTTFonts() const { return fHasTTFonts; }
	Int_t InitWindow(ULong_t window);	Int_t InitWindow(ULong_t window);
	Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h);	Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h);
	Int_t AddPixmap(ULong_t pixid, UInt_t w, UInt_t h);	Int_t AddPixmap(ULong_t pixid, UInt_t w, UInt_t h);
	void RemoveWindow(ULong_t qwid);	void RemoveWindow(ULong_t qwid);
	void MoveWindow(Int_t wid, Int_t x, Int_t y);	void MoveWindow(Int_t wid, Int_t x, Int_t y);
	Int_t OpenDisplay(Display *display);	Int_t OpenDisplay(Display *display);
	Int_t OpenPixmap(UInt_t w, UInt_t h);	Int_t OpenPixmap(UInt_t w, UInt_t h);

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

	TGX11TTF.h	TGX11TTF.h

	// @(#)root/x11ttf:$Id: TGX11TTF.h 20882 2007-11-19 11:31:26Z rdm $	// @(#)root/x11ttf:$Id: TGX11TTF.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Olivier Couet 01/10/02	// Author: Olivier Couet 01/10/02
	// Author: Fons Rademakers 21/11/98	// Author: Fons Rademakers 21/11/98

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

	skipping to change at line 69	skipping to change at line 69
	XImage *GetBackground(Int_t x, Int_t y, UInt_t w, UInt_t h);	XImage *GetBackground(Int_t x, Int_t y, UInt_t w, UInt_t h);
	void RenderString(Int_t x, Int_t y, ETextMode mode);	void RenderString(Int_t x, Int_t y, ETextMode mode);

	public:	public:
	TGX11TTF(const TGX11 &org);	TGX11TTF(const TGX11 &org);
	virtual ~TGX11TTF() { }	virtual ~TGX11TTF() { }

	Bool_t Init(void *display);	Bool_t Init(void *display);
	void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,	void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,
	const char *text, ETextMode mode);	const char *text, ETextMode mode);

		void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,
		const wchar_t *text, ETextMode mode);
	void SetTextFont(Font_t fontnumber);	void SetTextFont(Font_t fontnumber);
	Int_t SetTextFont(char *fontname, ETextSetMode mode);	Int_t SetTextFont(char *fontname, ETextSetMode mode);
	void SetTextSize(Float_t textsize);	void SetTextSize(Float_t textsize);

	#ifdef R__HAS_XFT	#ifdef R__HAS_XFT
	//---- Methods used text/fonts handling via Xft -----	//---- Methods used text/fonts handling via Xft -----
	//void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectan gle_t *recs, Int_t n);	//void SetClipRectangles(GContext_t gc, Int_t x, Int_t y, Rectan gle_t *recs, Int_t n);
	FontStruct_t LoadQueryFont(const char *font_name);	FontStruct_t LoadQueryFont(const char *font_name);
	void DeleteFont(FontStruct_t fs);	void DeleteFont(FontStruct_t fs);
	void DrawString(Drawable_t id, GContext_t gc, Int_t x, Int_t y, const char *s, Int_t len);	void DrawString(Drawable_t id, GContext_t gc, Int_t x, Int_t y, const char *s, Int_t len);

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

	TGeoShape.h	TGeoShape.h

	// @(#)root/geom:$Id: TGeoShape.h 42999 2012-02-14 13:42:55Z agheata $	// @(#)root/geom:$Id: TGeoShape.h 47063 2012-11-06 15:45:17Z agheata $
	// Author: Andrei Gheata 31/01/02	// Author: Andrei Gheata 31/01/02

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


	skipping to change at line 152	skipping to change at line 152
	virtual Bool_t IsReflected() const {return kFALSE;}	virtual Bool_t IsReflected() const {return kFALSE;}
	Bool_t IsRunTimeShape() const {return TestShapeBit(kGeoRu nTimeShape);}	Bool_t IsRunTimeShape() const {return TestShapeBit(kGeoRu nTimeShape);}
	Bool_t IsValid() const {return !TestShapeBit(kGeoInvalidS hape);}	Bool_t IsValid() const {return !TestShapeBit(kGeoInvalidS hape);}
	virtual Bool_t IsValidBox() const = 0;	virtual Bool_t IsValidBox() const = 0;
	virtual void InspectShape() const = 0;	virtual void InspectShape() const = 0;
	virtual TBuffer3D *MakeBuffer3D() const {return 0;}	virtual TBuffer3D *MakeBuffer3D() const {return 0;}
	static void NormalPhi(Double_t point, Double_t dir, Double_t *norm, Double_t c1, Double_t s1, Double_t c2, Double_t s2);	static void NormalPhi(Double_t point, Double_t dir, Double_t *norm, Double_t c1, Double_t s1, Double_t c2, Double_t s2);
	virtual void Paint(Option_t *option="");	virtual void Paint(Option_t *option="");
	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const = 0 ;	virtual Double_t Safety(Double_t *point, Bool_t in=kTRUE) const = 0 ;
	static Double_t SafetyPhi(Double_t *point, Bool_t in, Double_t phi 1, Double_t phi2);	static Double_t SafetyPhi(Double_t *point, Bool_t in, Double_t phi 1, Double_t phi2);

		static Double_t SafetySeg(Double_t r, Double_t z, Double_t r1, Dou ble_t z1, Double_t r2, Double_t z2, Bool_t outer);
	virtual void SetDimensions(Double_t *param) = 0;	virtual void SetDimensions(Double_t *param) = 0;
	void SetId(Int_t id) {fShapeId = id;}	void SetId(Int_t id) {fShapeId = id;}
	virtual void SetPoints(Double_t *points) const = 0;	virtual void SetPoints(Double_t *points) const = 0;
	virtual void SetPoints(Float_t *points) const = 0;	virtual void SetPoints(Float_t *points) const = 0;
	virtual void SetSegsAndPols(TBuffer3D &buff) const = 0;	virtual void SetSegsAndPols(TBuffer3D &buff) const = 0;
	void SetRuntime(Bool_t flag=kTRUE) {SetShapeBit(kGeoRun TimeShape, flag);}	void SetRuntime(Bool_t flag=kTRUE) {SetShapeBit(kGeoRun TimeShape, flag);}
	Int_t ShapeDistancetoPrimitive(Int_t numpoints, Int_t px , Int_t py) const;	Int_t ShapeDistancetoPrimitive(Int_t numpoints, Int_t px , Int_t py) const;
	virtual void Sizeof3D() const = 0;	virtual void Sizeof3D() const = 0;

	//----- bit manipulation	//----- bit manipulation

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

	TImageDump.h	TImageDump.h

	// @(#)root/postscript:$Id: TImageDump.h 22872 2008-03-27 16:59:12Z couet $	// @(#)root/postscript:$Id: TImageDump.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Valeriy Onuchin 29/04/2005	// Author: Valeriy Onuchin 29/04/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 60	skipping to change at line 60
	void DrawBox(Double_t x1, Double_t y1,Double_t x2, Double_t y2);	void DrawBox(Double_t x1, Double_t y1,Double_t x2, Double_t y2);
	void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt,	void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt,
	Int_t mode, Int_t border, Int_t dark, Int_t light);	Int_t mode, Int_t border, Int_t dark, Int_t light);
	void DrawPolyMarker(Int_t n, Float_t x, Float_t y);	void DrawPolyMarker(Int_t n, Float_t x, Float_t y);
	void DrawPolyMarker(Int_t n, Double_t x, Double_t y);	void DrawPolyMarker(Int_t n, Double_t x, Double_t y);
	void DrawPS(Int_t n, Float_t xw, Float_t yw);	void DrawPS(Int_t n, Float_t xw, Float_t yw);
	void DrawPS(Int_t n, Double_t xw, Double_t yw);	void DrawPS(Int_t n, Double_t xw, Double_t yw);
	void NewPage();	void NewPage();
	void Open(const char *filename, Int_t type = -111);	void Open(const char *filename, Int_t type = -111);
	void Text(Double_t x, Double_t y, const char *string);	void Text(Double_t x, Double_t y, const char *string);

		void Text(Double_t x, Double_t y, const wchar_t *string);
	void SetColor(Float_t r, Float_t g, Float_t b);	void SetColor(Float_t r, Float_t g, Float_t b);
	void GetStream() const { return (void)fImage; }	void GetStream() const { return (void)fImage; }
	void SetType(Int_t type = -111) { fType = type; }	void SetType(Int_t type = -111) { fType = type; }
	Int_t GetType() const { return fType; }	Int_t GetType() const { return fType; }
	TImage *GetImage() const { return fImage; }	TImage *GetImage() const { return fImage; }

	ClassDef(TImageDump,0) // create image in batch mode	ClassDef(TImageDump,0) // create image in batch mode
	};	};

	#endif	#endif

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

	TObject.h	TObject.h

	// @(#)root/base:$Id: TObject.h 38832 2011-04-13 17:54:49Z rdm $	// @(#)root/base:$Id: TObject.h 48256 2013-01-10 14:24:07Z axel $
	// Author: Rene Brun 26/12/94	// Author: Rene Brun 26/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 210	skipping to change at line 210
	void AbstractMethod(const char *method) const;	void AbstractMethod(const char *method) const;
	void MayNotUse(const char *method) const;	void MayNotUse(const char *method) const;
	void Obsolete(const char method, const char asOfVers, const char * removedFromVers) const;	void Obsolete(const char method, const char asOfVers, const char * removedFromVers) const;

	//---- static functions	//---- static functions
	static Long_t GetDtorOnly();	static Long_t GetDtorOnly();
	static void SetDtorOnly(void *obj);	static void SetDtorOnly(void *obj);
	static Bool_t GetObjectStat();	static Bool_t GetObjectStat();
	static void SetObjectStat(Bool_t stat);	static void SetObjectStat(Bool_t stat);


		friend class TClonesArray; // needs to reset kNotDeleted in fBits

	ClassDef(TObject,1) //Basic ROOT object	ClassDef(TObject,1) //Basic ROOT object
	};	};

	// Global bits (can be set for any object and should not be reused).	// Global bits (can be set for any object and should not be reused).
	// Only here for backward compatibility reasons.	// Only here for backward compatibility reasons.
	// For detailed description see TObject::EStatusBits above.	// For detailed description see TObject::EStatusBits above.
	enum EObjBits {	enum EObjBits {
	kCanDelete = TObject::kCanDelete,	kCanDelete = TObject::kCanDelete,
	kMustCleanup = TObject::kMustCleanup,	kMustCleanup = TObject::kMustCleanup,
	kObjInCanvas = TObject::kObjInCanvas,	kObjInCanvas = TObject::kObjInCanvas,

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

	TPad.h	TPad.h

	// @(#)root/gpad:$Id: TPad.h 43408 2012-03-20 13:02:53Z couet $	// @(#)root/gpad:$Id: TPad.h 47117 2012-11-08 16:14:55Z couet $
	// 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 129	skipping to change at line 129
	// 3D Viewer support	// 3D Viewer support
	TVirtualViewer3D *fViewer3D; //! Current 3D viewer	TVirtualViewer3D *fViewer3D; //! Current 3D viewer

	void DestroyExternalViewer3D();	void DestroyExternalViewer3D();
	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	virtual void HideToolTip(Int_t event);	virtual void HideToolTip(Int_t event);
	void PaintBorder(Color_t color, Bool_t tops);	void PaintBorder(Color_t color, Bool_t tops);
	virtual void PaintBorderPS(Double_t xl,Double_t yl,Double_t xt,Double_t yt,Int_t bmode,Int_t bsize,Int_t dark,Int_t light);	virtual void PaintBorderPS(Double_t xl,Double_t yl,Double_t xt,Double_t yt,Int_t bmode,Int_t bsize,Int_t dark,Int_t light);
	void PaintDate();	void PaintDate();

	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(std::ostream &out, Option_t *option = "");
	virtual void SetBatch(Bool_t batch=kTRUE);	virtual void SetBatch(Bool_t batch=kTRUE);

	private:	private:
	TPad(const TPad &pad); // cannot copy pads, use TObject::Clone()	TPad(const TPad &pad); // cannot copy pads, use TObject::Clone()
	TPad &operator=(const TPad &rhs); // idem	TPad &operator=(const TPad &rhs); // idem

	void CopyBackgroundPixmap(Int_t x, Int_t y);	void CopyBackgroundPixmap(Int_t x, Int_t y);
	void CopyBackgroundPixmaps(TPad start, TPad stop, Int_t x, Int_t y);	void CopyBackgroundPixmaps(TPad start, TPad stop, Int_t x, Int_t y);

	public:	public:

	skipping to change at line 286	skipping to change at line 286
	void PaintLine3D(Float_t p1, Float_t p2);	void PaintLine3D(Float_t p1, Float_t p2);
	void PaintLine3D(Double_t p1, Double_t p2);	void PaintLine3D(Double_t p1, Double_t p2);
	void PaintPolyLine(Int_t n, Float_t x, Float_t y, Option_ t *option="");	void PaintPolyLine(Int_t n, Float_t x, Float_t y, Option_ t *option="");
	void PaintPolyLine(Int_t n, Double_t x, Double_t y, Optio n_t *option="");	void PaintPolyLine(Int_t n, Double_t x, Double_t y, Optio n_t *option="");
	void PaintPolyLine3D(Int_t n, Double_t *p);	void PaintPolyLine3D(Int_t n, Double_t *p);
	void PaintPolyLineNDC(Int_t n, Double_t x, Double_t y, Op tion_t *option="");	void PaintPolyLineNDC(Int_t n, Double_t x, Double_t y, Op tion_t *option="");
	void PaintPolyMarker(Int_t n, Float_t x, Float_t y, Optio n_t *option="");	void PaintPolyMarker(Int_t n, Float_t x, Float_t y, Optio n_t *option="");
	void PaintPolyMarker(Int_t n, Double_t x, Double_t y, Opt ion_t *option="");	void PaintPolyMarker(Int_t n, Double_t x, Double_t y, Opt ion_t *option="");
	virtual void PaintModified();	virtual void PaintModified();
	void PaintText(Double_t x, Double_t y, const char *text);	void PaintText(Double_t x, Double_t y, const char *text);

		void PaintText(Double_t x, Double_t y, const wchar_t *text) ;
	void PaintTextNDC(Double_t u, Double_t v, const char *text) ;	void PaintTextNDC(Double_t u, Double_t v, const char *text) ;

		void PaintTextNDC(Double_t u, Double_t v, const wchar_t *te xt);
	virtual TPad Pick(Int_t px, Int_t py, TObjLink &pickobj);	virtual TPad Pick(Int_t px, Int_t py, TObjLink &pickobj);
	Double_t PixeltoX(Int_t px);	Double_t PixeltoX(Int_t px);
	Double_t PixeltoY(Int_t py);	Double_t PixeltoY(Int_t py);
	virtual void PixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Dou ble_t &y);	virtual void PixeltoXY(Int_t xpixel, Int_t ypixel, Double_t &x, Dou ble_t &y);
	virtual void Pop(); // MENU	virtual void Pop(); // MENU
	virtual void Print(const char *filename="") const;	virtual void Print(const char *filename="") const;
	virtual void Print(const char filename, Option_t option);	virtual void Print(const char filename, Option_t option);
	virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2); // MENU *ARGS={x1=>fX1,y1=>fY1,x2=>fX2,y2=>fY2}	virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y2); // MENU *ARGS={x1=>fX1,y1=>fY1,x2=>fX2,y2=>fY2}
	virtual void RangeChanged() { Emit("RangeChanged()"); } // SIGNAL	virtual void RangeChanged() { Emit("RangeChanged()"); } // SIGNAL
	virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);	virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax);

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

	TPadPainter.h	TPadPainter.h

	skipping to change at line 77	skipping to change at line 77
	//TPad needs both double and float versions of DrawPolyLine.	//TPad needs both double and float versions of DrawPolyLine.
	void DrawPolyLine(Int_t n, const Double_t x, const Double_t y);	void DrawPolyLine(Int_t n, const Double_t x, const Double_t y);
	void DrawPolyLine(Int_t n, const Float_t x, const Float_t y);	void DrawPolyLine(Int_t n, const Float_t x, const Float_t y);
	void DrawPolyLineNDC(Int_t n, const Double_t u, const Double_t v);	void DrawPolyLineNDC(Int_t n, const Double_t u, const Double_t v);

	//TPad needs both versions.	//TPad needs both versions.
	void DrawPolyMarker(Int_t n, const Double_t x, const Double_t y);	void DrawPolyMarker(Int_t n, const Double_t x, const Double_t y);
	void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y);	void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y);

	void DrawText(Double_t x, Double_t y, const char *text, ETextMode mo de);	void DrawText(Double_t x, Double_t y, const char *text, ETextMode mo de);

		void DrawText(Double_t x, Double_t y, const wchar_t *text, ETextMode mode);
	void DrawTextNDC(Double_t u, Double_t v, const char *text, ETextMode mode);	void DrawTextNDC(Double_t u, Double_t v, const char *text, ETextMode mode);

		void DrawTextNDC(Double_t u, Double_t v, const wchar_t *text, ETextM ode mode);

	//jpg, png, bmp, gif output.	//jpg, png, bmp, gif output.
	void SaveImage(TVirtualPad pad, const char fileName, Int_t type) c onst;	void SaveImage(TVirtualPad pad, const char fileName, Int_t type) c onst;

	private:	private:
	TPadPainter(const TPadPainter &rhs);	TPadPainter(const TPadPainter &rhs);
	TPadPainter & operator = (const TPadPainter &rhs);	TPadPainter & operator = (const TPadPainter &rhs);

	ClassDef(TPadPainter, 0) //Abstract interface for painting in TPad	ClassDef(TPadPainter, 0) //Abstract interface for painting in TPad
	};	};

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

	TPaletteAxis.h	TPaletteAxis.h

	// @(#)root/histpainter:$Id: TPaletteAxis.h 27028 2008-12-19 12:45:24Z coue t $	// @(#)root/histpainter:$Id: TPaletteAxis.h 48067 2012-12-17 14:36:02Z coue t $
	// Author: Rene Brun 15/11/2002	// Author: Rene Brun 15/11/2002

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


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

	public:	public:
	// TPaletteAxis status bits	// TPaletteAxis status bits
	enum { kHasView = BIT(11)};	enum { kHasView = BIT(11)};

	TPaletteAxis();	TPaletteAxis();
	TPaletteAxis(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2, TH1 *h);	TPaletteAxis(Double_t x1, Double_t y1,Double_t x2 ,Double_t y2, TH1 *h);
	TPaletteAxis(const TPaletteAxis &palette);	TPaletteAxis(const TPaletteAxis &palette);
	virtual ~TPaletteAxis();	virtual ~TPaletteAxis();
	void Copy(TObject &palette) const;	void Copy(TObject &palette) const;

		TPaletteAxis& operator=(const TPaletteAxis&);

	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);	virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);	virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
	TGaxis *GetAxis() {return &fAxis;}	TGaxis *GetAxis() {return &fAxis;}
	Int_t GetBinColor(Int_t i, Int_t j);	Int_t GetBinColor(Int_t i, Int_t j);
	Option_t *GetName() const {return fName.Data();}	Option_t *GetName() const {return fName.Data();}
	virtual char *GetObjectInfo(Int_t px, Int_t py) const;	virtual char *GetObjectInfo(Int_t px, Int_t py) const;
	Int_t GetValueColor(Double_t zc);	Int_t GetValueColor(Double_t zc);
	virtual void Paint(Option_t *option="");	virtual void Paint(Option_t *option="");
	virtual void SavePrimitive(ostream &out, Option_t *option = "");	virtual void SavePrimitive(ostream &out, Option_t *option = "");

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

	TProofMgr.h	TProofMgr.h

	// @(#)root/proof:$Id: TProofMgr.h 42858 2012-02-03 11:34:05Z ganis $	// @(#)root/proof:$Id: TProofMgr.h 47252 2012-11-14 11:03:46Z 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_TProofMgr	#ifndef ROOT_TProofMgr
	#define ROOT_TProofMgr	#define ROOT_TProofMgr

	skipping to change at line 124	skipping to change at line 124
	virtual void ShowROOTVersions() { }	virtual void ShowROOTVersions() { }
	virtual void ShutdownSession(Int_t id) { DetachSession(id,"S"); }	virtual void ShutdownSession(Int_t id) { DetachSession(id,"S"); }
	virtual void ShutdownSession(TProof *p) { DetachSession(p,"S"); }	virtual void ShutdownSession(TProof *p) { DetachSession(p,"S"); }

	// Remote file system actions	// Remote file system actions
	virtual Int_t Cp(const char , const char = 0, const char * = 0) { return -1; }	virtual Int_t Cp(const char , const char = 0, const char * = 0) { return -1; }
	virtual void Find(const char * = "~/", const char * = 0, const ch ar * = 0) { }	virtual void Find(const char * = "~/", const char * = 0, const ch ar * = 0) { }
	virtual void Grep(const char , const char = 0, const char * = 0) { }	virtual void Grep(const char , const char = 0, const char * = 0) { }
	virtual void Ls(const char * = "~/", const char * = 0, const char * = 0) { }	virtual void Ls(const char * = "~/", const char * = 0, const char * = 0) { }
	virtual void More(const char , const char = 0, const char * = 0) { }	virtual void More(const char , const char = 0, const char * = 0) { }

	virtual Int_t Rm(const char , const char = 0, const char * = 0) { return -1; }	virtual Int_t Rm(const char , const char = 0, const char * = 0) ;
	virtual void Tail(const char , const char = 0, const char * = 0) { }	virtual void Tail(const char , const char = 0, const char * = 0) { }
	virtual Int_t Md5sum(const char , TString &, const char = 0) { return -1; }	virtual Int_t Md5sum(const char , TString &, const char = 0) { return -1; }
	virtual Int_t Stat(const char , FileStat_t &, const char = 0) { return -1; }	virtual Int_t Stat(const char , FileStat_t &, const char = 0) { return -1; }

	virtual Int_t GetFile(const char , const char , const char * = 0 ) { return -1; }	virtual Int_t GetFile(const char , const char , const char * = 0 ) { return -1; }
	virtual Int_t PutFile(const char , const char , const char * = 0 ) { return -1; }	virtual Int_t PutFile(const char , const char , const char * = 0 ) { return -1; }

	static TList *GetListOfManagers();	static TList *GetListOfManagers();

	static void SetTXProofMgrHook(TProofMgr_t pmh);	static void SetTXProofMgrHook(TProofMgr_t pmh);

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

	TVirtualPS.h	TVirtualPS.h

	// @(#)root/base:$Id: TVirtualPS.h 33327 2010-04-30 14:36:34Z couet $	// @(#)root/base:$Id: TVirtualPS.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Rene Brun 05/09/99	// Author: Rene Brun 05/09/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. *
	*************************************************************************/	*************************************************************************/
	#ifndef ROOT_TVirtualPS	#ifndef ROOT_TVirtualPS

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

	private:	private:
	TVirtualPS(const TVirtualPS&); // Not implemented	TVirtualPS(const TVirtualPS&); // Not implemented
	TVirtualPS& operator=(const TVirtualPS&); // Not implemented	TVirtualPS& operator=(const TVirtualPS&); // Not implemented

	protected:	protected:
	Int_t fNByte; //Number of bytes written in the file (PD F)	Int_t fNByte; //Number of bytes written in the file (PD F)
	Int_t fLenBuffer; //Buffer length	Int_t fLenBuffer; //Buffer length
	Int_t fSizBuffer; //Buffer size	Int_t fSizBuffer; //Buffer size
	Bool_t fPrinted; //True when a page must be printed	Bool_t fPrinted; //True when a page must be printed

	ofstream *fStream; //File stream identifier	std::ofstream *fStream; //File stream identifier
	char *fBuffer; //File buffer	char *fBuffer; //File buffer
	const char *fImplicitCREsc; //Escape symbol before enforced new line	const char *fImplicitCREsc; //Escape symbol before enforced new line

	public:	public:
	TVirtualPS();	TVirtualPS();
	TVirtualPS(const char *filename, Int_t type=-111);	TVirtualPS(const char *filename, Int_t type=-111);
	virtual ~TVirtualPS();	virtual ~TVirtualPS();
	virtual void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2, Double_t y1, Double_t y2) = 0;	virtual void CellArrayBegin(Int_t W, Int_t H, Double_t x1, Double_t x2, Double_t y1, Double_t y2) = 0;
	virtual void CellArrayFill(Int_t r, Int_t g, Int_t b) = 0;	virtual void CellArrayFill(Int_t r, Int_t g, Int_t b) = 0;
	virtual void CellArrayEnd() = 0;	virtual void CellArrayEnd() = 0;

	skipping to change at line 71	skipping to change at line 71
	virtual void DrawBox(Double_t x1, Double_t y1,Double_t x2, Double_t y2 ) = 0;	virtual void DrawBox(Double_t x1, Double_t y1,Double_t x2, Double_t y2 ) = 0;
	virtual void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt,	virtual void DrawFrame(Double_t xl, Double_t yl, Double_t xt, Double_t yt,
	Int_t mode, Int_t border, Int_t dark, Int_t ligh t) = 0;	Int_t mode, Int_t border, Int_t dark, Int_t ligh t) = 0;
	virtual void DrawPolyMarker(Int_t n, Float_t x, Float_t y) = 0;	virtual void DrawPolyMarker(Int_t n, Float_t x, Float_t y) = 0;
	virtual void DrawPolyMarker(Int_t n, Double_t x, Double_t y) = 0;	virtual void DrawPolyMarker(Int_t n, Double_t x, Double_t y) = 0;
	virtual void DrawPS(Int_t n, Float_t xw, Float_t yw) = 0;	virtual void DrawPS(Int_t n, Float_t xw, Float_t yw) = 0;
	virtual void DrawPS(Int_t n, Double_t xw, Double_t yw) = 0;	virtual void DrawPS(Int_t n, Double_t xw, Double_t yw) = 0;
	virtual void NewPage() = 0;	virtual void NewPage() = 0;
	virtual void Open(const char *filename, Int_t type=-111) = 0;	virtual void Open(const char *filename, Int_t type=-111) = 0;
	virtual void Text(Double_t x, Double_t y, const char *string) = 0;	virtual void Text(Double_t x, Double_t y, const char *string) = 0;

		virtual void Text(Double_t x, Double_t y, const wchar_t *string) = 0;
	virtual void SetColor(Float_t r, Float_t g, Float_t b) = 0;	virtual void SetColor(Float_t r, Float_t g, Float_t b) = 0;

	virtual void PrintFast(Int_t nch, const char *string="");	virtual void PrintFast(Int_t nch, const char *string="");
	virtual void PrintStr(const char *string="");	virtual void PrintStr(const char *string="");
	virtual void WriteInteger(Int_t i, Bool_t space=kTRUE);	virtual void WriteInteger(Int_t i, Bool_t space=kTRUE);
	virtual void WriteReal(Float_t r);	virtual void WriteReal(Float_t r);

		virtual void PrintRaw(Int_t len, const char *str);
	virtual void GetStream() const { return (void)fStream; }	virtual void GetStream() const { return (void)fStream; }

	virtual void SetStream(ofstream *os) { fStream = os; }	virtual void SetStream(std::ofstream *os) { fStream = os; }

	virtual void SetType(Int_t /type/ = -111) { }	virtual void SetType(Int_t /type/ = -111) { }
	virtual Int_t GetType() const { return 111; }	virtual Int_t GetType() const { return 111; }

	ClassDef(TVirtualPS,0) //Abstract interface to a PostScript driver	ClassDef(TVirtualPS,0) //Abstract interface to a PostScript driver
	};	};

	R__EXTERN TVirtualPS *gVirtualPS;	R__EXTERN TVirtualPS *gVirtualPS;

	#endif	#endif

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

	TVirtualPad.h	TVirtualPad.h

	// @(#)root/base:$Id: TVirtualPad.h 42441 2011-12-08 14:15:45Z couet $	// @(#)root/base:$Id: TVirtualPad.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Rene Brun 05/12/95	// Author: Rene Brun 05/12/95

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


	skipping to change at line 178	skipping to change at line 178
	virtual void PaintLine3D(Float_t p1, Float_t p2) = 0;	virtual void PaintLine3D(Float_t p1, Float_t p2) = 0;
	virtual void PaintLine3D(Double_t p1, Double_t p2) = 0;	virtual void PaintLine3D(Double_t p1, Double_t p2) = 0;
	virtual void PaintPolyLine(Int_t n, Float_t x, Float_t y, Option_t *option="") = 0;	virtual void PaintPolyLine(Int_t n, Float_t x, Float_t y, Option_t *option="") = 0;
	virtual void PaintPolyLine(Int_t n, Double_t x, Double_t y, Option _t *option="") = 0;	virtual void PaintPolyLine(Int_t n, Double_t x, Double_t y, Option _t *option="") = 0;
	virtual void PaintPolyLine3D(Int_t n, Double_t *p) = 0;	virtual void PaintPolyLine3D(Int_t n, Double_t *p) = 0;
	virtual void PaintPolyLineNDC(Int_t n, Double_t x, Double_t y, Opt ion_t *option="") = 0;	virtual void PaintPolyLineNDC(Int_t n, Double_t x, Double_t y, Opt ion_t *option="") = 0;
	virtual void PaintPolyMarker(Int_t n, Float_t x, Float_t y, Option _t *option="") = 0;	virtual void PaintPolyMarker(Int_t n, Float_t x, Float_t y, Option _t *option="") = 0;
	virtual void PaintPolyMarker(Int_t n, Double_t x, Double_t y, Opti on_t *option="") = 0;	virtual void PaintPolyMarker(Int_t n, Double_t x, Double_t y, Opti on_t *option="") = 0;
	virtual void PaintModified() = 0;	virtual void PaintModified() = 0;
	virtual void PaintText(Double_t x, Double_t y, const char *text) = 0 ;	virtual void PaintText(Double_t x, Double_t y, const char *text) = 0 ;

		virtual void PaintText(Double_t x, Double_t y, const wchar_t *text) = 0;
	virtual void PaintTextNDC(Double_t u, Double_t v, const char *text) = 0;	virtual void PaintTextNDC(Double_t u, Double_t v, const char *text) = 0;

		virtual void PaintTextNDC(Double_t u, Double_t v, const wchar_t *tex t) = 0;
	virtual Double_t PixeltoX(Int_t px) = 0;	virtual Double_t PixeltoX(Int_t px) = 0;
	virtual Double_t PixeltoY(Int_t py) = 0;	virtual Double_t PixeltoY(Int_t py) = 0;
	virtual void Pop() = 0;	virtual void Pop() = 0;
	virtual void Print(const char *filename="") const = 0;	virtual void Print(const char *filename="") const = 0;
	virtual void Print(const char filename, Option_t option) = 0;	virtual void Print(const char filename, Option_t option) = 0;
	virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y 2) = 0;	virtual void Range(Double_t x1, Double_t y1, Double_t x2, Double_t y 2) = 0;
	virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax) = 0;	virtual void RangeAxis(Double_t xmin, Double_t ymin, Double_t xmax, Double_t ymax) = 0;
	virtual void RecursiveRemove(TObject *obj) = 0;	virtual void RecursiveRemove(TObject *obj) = 0;
	virtual void RedrawAxis(Option_t *option="") = 0;	virtual void RedrawAxis(Option_t *option="") = 0;
	virtual void ResetView3D(TObject *view=0) = 0;	virtual void ResetView3D(TObject *view=0) = 0;

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

	TVirtualPadPainter.h	TVirtualPadPainter.h

	skipping to change at line 88	skipping to change at line 88
	virtual void DrawFillArea(Int_t n, const Float_t x, const Float_t y) = 0;	virtual void DrawFillArea(Int_t n, const Float_t x, const Float_t y) = 0;

	virtual void DrawPolyLine(Int_t n, const Double_t x, const Double_t y) = 0;	virtual void DrawPolyLine(Int_t n, const Double_t x, const Double_t y) = 0;
	virtual void DrawPolyLine(Int_t n, const Float_t x, const Float_t y) = 0;	virtual void DrawPolyLine(Int_t n, const Float_t x, const Float_t y) = 0;
	virtual void DrawPolyLineNDC(Int_t n, const Double_t u, const Doubl e_t v) = 0;	virtual void DrawPolyLineNDC(Int_t n, const Double_t u, const Doubl e_t v) = 0;

	virtual void DrawPolyMarker(Int_t n, const Double_t x, const Double _t y) = 0;	virtual void DrawPolyMarker(Int_t n, const Double_t x, const Double _t y) = 0;
	virtual void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y) = 0;	virtual void DrawPolyMarker(Int_t n, const Float_t x, const Float_t y) = 0;

	virtual void DrawText(Double_t x, Double_t y, const char *text, ETex tMode mode) = 0;	virtual void DrawText(Double_t x, Double_t y, const char *text, ETex tMode mode) = 0;

		virtual void DrawText(Double_t x, Double_t y, const wchar_t *text, E TextMode mode) = 0;
	virtual void DrawTextNDC(Double_t u, Double_t v, const char *text, E TextMode mode) = 0;	virtual void DrawTextNDC(Double_t u, Double_t v, const char *text, E TextMode mode) = 0;

		virtual void DrawTextNDC(Double_t u, Double_t v, const wchar_t *text , ETextMode mode) = 0;

	//gif, jpg, png, bmp output.	//gif, jpg, png, bmp output.
	virtual void SaveImage(TVirtualPad pad, const char fileName, Int_t type) const = 0;	virtual void SaveImage(TVirtualPad pad, const char fileName, Int_t type) const = 0;

	static TVirtualPadPainter PadPainter(Option_t opt = "");	static TVirtualPadPainter PadPainter(Option_t opt = "");

	ClassDef(TVirtualPadPainter, 0)//Painter interface for pad.	ClassDef(TVirtualPadPainter, 0)//Painter interface for pad.
	};	};

	#endif	#endif

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

	TVirtualX.h	TVirtualX.h

	// @(#)root/base:$Id: TVirtualX.h 46801 2012-10-25 12:47:21Z rdm $	// @(#)root/base:$Id: TVirtualX.h 47117 2012-11-08 16:14:55Z couet $
	// Author: Fons Rademakers 3/12/95	// Author: Fons Rademakers 3/12/95

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


	skipping to change at line 109	skipping to change at line 109

	virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMo de mode);	virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMo de mode);
	virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2,	virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2,
	Int_t nx, Int_t ny, Int_t *ic);	Int_t nx, Int_t ny, Int_t *ic);
	virtual void DrawFillArea(Int_t n, TPoint *xy);	virtual void DrawFillArea(Int_t n, TPoint *xy);
	virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);	virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);
	virtual void DrawPolyLine(Int_t n, TPoint *xy);	virtual void DrawPolyLine(Int_t n, TPoint *xy);
	virtual void DrawPolyMarker(Int_t n, TPoint *xy);	virtual void DrawPolyMarker(Int_t n, TPoint *xy);
	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text,	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text,
	ETextMode mode);	ETextMode mode);

		virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn,
		const wchar_t *text,
		ETextMode mode);
	virtual UInt_t ExecCommand(TGWin32Command *code);	virtual UInt_t ExecCommand(TGWin32Command *code);
	virtual void GetCharacterUp(Float_t &chupx, Float_t &chupy);	virtual void GetCharacterUp(Float_t &chupx, Float_t &chupy);
	EDrawMode GetDrawMode() { return fDrawMode; }	EDrawMode GetDrawMode() { return fDrawMode; }
	virtual Int_t GetDoubleBuffer(Int_t wid);	virtual Int_t GetDoubleBuffer(Int_t wid);
	virtual void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h);	virtual void GetGeometry(Int_t wid, Int_t &x, Int_t &y, UInt_t &w, UInt_t &h);
	virtual const char DisplayName(const char = 0);	virtual const char DisplayName(const char = 0);
	virtual Handle_t GetNativeEvent() const;	virtual Handle_t GetNativeEvent() const;
	virtual ULong_t GetPixel(Color_t cindex);	virtual ULong_t GetPixel(Color_t cindex);
	virtual void GetPlanes(Int_t &nplanes);	virtual void GetPlanes(Int_t &nplanes);
	virtual void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b );	virtual void GetRGB(Int_t index, Float_t &r, Float_t &g, Float_t &b );
	virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess);	virtual void GetTextExtent(UInt_t &w, UInt_t &h, char *mess);

		virtual void GetTextExtent(UInt_t &w, UInt_t &h, wchar_t *mess);
	virtual Int_t GetFontAscent() const;	virtual Int_t GetFontAscent() const;
	virtual Int_t GetFontDescent() const ;	virtual Int_t GetFontDescent() const ;
	virtual Float_t GetTextMagnitude();	virtual Float_t GetTextMagnitude();
	virtual Window_t GetWindowID(Int_t wid);	virtual Window_t GetWindowID(Int_t wid);
	virtual Bool_t HasTTFonts() const;	virtual Bool_t HasTTFonts() const;
	virtual Int_t InitWindow(ULong_t window);	virtual Int_t InitWindow(ULong_t window);
	virtual Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h);	virtual Int_t AddWindow(ULong_t qwid, UInt_t w, UInt_t h);
	virtual Int_t AddPixmap(ULong_t pixid, UInt_t w, UInt_t h);	virtual Int_t AddPixmap(ULong_t pixid, UInt_t w, UInt_t h);
	virtual void RemoveWindow(ULong_t qwid);	virtual void RemoveWindow(ULong_t qwid);
	virtual void MoveWindow(Int_t wid, Int_t x, Int_t y);	virtual void MoveWindow(Int_t wid, Int_t x, Int_t y);

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

	TVirtualX.interface.h	TVirtualX.interface.h

	// @(#)root/base:$Id: TVirtualX.interface.h 45302 2012-07-31 08:05:22Z tpoc hep $	// @(#)root/base:$Id: TVirtualX.interface.h 47132 2012-11-09 08:52:11Z coue t $
	// Author: Valeri Fine 28/07/2004	// Author: Valeri Fine 28/07/2004

	//	//
	// This is a copy of the all "abstract" TVirtualX methods to make sure	// This is a copy of the all "abstract" TVirtualX methods to make sure
	// we don't miss it with the implementation	// we don't miss it with the implementation
	//	//
	/*************************************************************************	/*************************************************************************
	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *	* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
	* All rights reserved. *	* All rights reserved. *
	* *	* *

	skipping to change at line 24	skipping to change at line 24
	*************************************************************************/	*************************************************************************/

	public:	public:

	virtual Bool_t Init(void *display=0);	virtual Bool_t Init(void *display=0);
	virtual void ClearWindow();	virtual void ClearWindow();
	virtual void ClosePixmap();	virtual void ClosePixmap();
	virtual void CloseWindow();	virtual void CloseWindow();
	virtual void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos);	virtual void CopyPixmap(Int_t wid, Int_t xpos, Int_t ypos);


	//-Woverloaded-virtual	//TVirtualX has two versions of CreateOpenGLContext
	using TVirtualX::CreateOpenGLContext;	using TVirtualX::CreateOpenGLContext;


		//TVirtualX has these two methods with wchar_t
		using TVirtualX::DrawText;
		using TVirtualX::GetTextExtent;;

	virtual void CreateOpenGLContext(Int_t wid=0);	virtual void CreateOpenGLContext(Int_t wid=0);
	virtual void DeleteOpenGLContext(Int_t wid=0);	virtual void DeleteOpenGLContext(Int_t wid=0);
	virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMo de mode);	virtual void DrawBox(Int_t x1, Int_t y1, Int_t x2, Int_t y2, EBoxMo de mode);
	virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2,	virtual void DrawCellArray(Int_t x1, Int_t y1, Int_t x2, Int_t y2,
	Int_t nx, Int_t ny, Int_t *ic);	Int_t nx, Int_t ny, Int_t *ic);
	virtual void DrawFillArea(Int_t n, TPoint *xy);	virtual void DrawFillArea(Int_t n, TPoint *xy);
	virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);	virtual void DrawLine(Int_t x1, Int_t y1, Int_t x2, Int_t y2);
	virtual void DrawPolyLine(Int_t n, TPoint *xy);	virtual void DrawPolyLine(Int_t n, TPoint *xy);
	virtual void DrawPolyMarker(Int_t n, TPoint *xy);	virtual void DrawPolyMarker(Int_t n, TPoint *xy);
	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text,	virtual void DrawText(Int_t x, Int_t y, Float_t angle, Float_t mgn, const char *text,

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