DrawingToolsBase Class Reference

#include <DrawingToolsBase.hxx>

Inheritance diagram for DrawingToolsBase:

Public Member Functions
	DrawingToolsBase (const std::string &file="", Int_t T2KstyleIndex=1)
TH1_h *	AddErrorsInQuadrature (TH1_h *h1, TH1_h *h2, const std::string &opt="")
std::string	GetSameRootOption (const std::string &root_opt)
	extract the same or sames option from the full root option
std::string	GetNoSameRootOption (const std::string &root_opt)
	remove same and sames options from the root option
void	Reset ()
	reset all saved histograms
double	GetEntries (TTree *tree, const std::string &cut)
	Get number (sum of weights) of events (i.e. bunches) passing "cut".
double	GetEntries (TTree *tree, const std::string &cut, const std::string &var, const std::string &opt="", int toy_ref=-1)
	Get number (sum of weights) for variable var pasing "cut" (useful for vector variables, which number can be different than number of events/bunches)
void	ScaleHisto (TH1 *h, double scale, bool scale_errors=true)
	Scale an histogram and its errors(when requested)
double *	GetVariableBins (int nx, double xmin, double xmax, double *)
	Get a vector with variable binning.
std::string	GetSameLevel (const std::string &root_opt)
	Get the superposition level.
std::string	GetUniqueName (const std::string &name)
void	CreateLegend (const std::string &uopt="")
	create the legend
void	PrintEventNumbers (TTree *tree, const std::string &cut, const std::string &file="", int toy_ref=-1)
	Print the event number of a specific selection.
std::string	FormatCut (const std::string &cut)
	Give the appropriate format to any cut.
std::string	AddRangeCut (const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &cut, const std::string &uopt)
	Add cut on range shown on plot.
TH1 *	Draw (TTree *tree, const std::string &var, int nbins, double *xbins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
	1D histos
TH1 *	Draw (TTree *tree, const std::string &var, int nbins, double xmin, double xmax, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
TH1 *	Draw (TTree *tree, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
	2D histos
TH1 *	Draw (TTree *tree, const std::string &var, int nx, double xmin, double xmax, int ny, double ymin, double ymax, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
void	Draw (TTree *tree, const std::string &var, int nx, double xmin, double xmax, int ny, double ymin, double ymax, const std::string &idVar, std::vector< int > idSel, std::vector< std::string > idName, std::vector< int > idColor, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1., bool scale_errors=true)
void	Draw (TTree *tree_mc, TTree *tree_data, const std::string &var, int nx, double xmin, double xmax, int ny, double ymin, double ymax, const std::string &idVar, std::vector< int > idSel, std::vector< std::string > idName, std::vector< int > idColor, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1., bool scale_errors=true)
void	Draw (TTree *tree, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &idvar, std::vector< int > idSel, std::vector< std::string > idName, std::vector< int > idColor, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
void	Draw (TTree *tree_mc, TTree *tree_data, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &idvar, std::vector< int > idSel, std::vector< std::string > idName, std::vector< int > idColor, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
double	GetEff (TTree *tree, const std::string &var, double xmin, double xmax, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="")
double	GetEff (TTree *tree, const std::string &var, double xmin, double xmax, double &errlow, double &errhigh, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="")
void	DrawRatio (TTree *tree, const std::string &var, int nbins, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawRatio (TTree *tree, const std::string &var, int nx, double xmin, double xmax, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawEff (TTree *tree, const std::string &var, int nbins, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawEff (TTree *tree, const std::string &var, int nx, double xmin, double xmax, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawDoubleEff (TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	ratio between two Efficiencies
void	DrawDoubleEff (TTree *tree1, TTree *tree2, const std::string &var, int nx, double xmin, double xmax, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawSignificance (TTree *tree, const std::string &var, int nbins, double *xbins, const std::string &cut1, const std::string &cut2, double norm=1, double rel_syst=0, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	1D significance
void	DrawSignificance (TTree *tree, const std::string &var, int nbins, double xmin, double xmax, const std::string &cut1, const std::string &cut2, double norm=1, double rel_syst=0, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawGraph (TGraphAsymmErrors *eff, int nbins, double *xbins, const std::string &uroot_opt, const std::string &uopt, const std::string &leg, double ymax=1.05)
	[DrawingToolsBase_eff_ratio]
void	DumpGraph (TGraphAsymmErrors *graph, int nbins, const std::string &uopt)
TH1_h *	GetEventsVSCut (TTree *tree, const std::string &var, const std::string &cut_norm, int isel, int branch, int &first_cut, int &last_cut, const std::string &root_opt="", const std::string &opt="")
	Get a TH1 containing the number of events passing the selection as a function of the cut.
void	DrawEventsVSCut (TTree *tree, const std::string &cut_norm="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawEventsVSCut (TTree *tree, int branch, const std::string &cut_norm="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the number of events passing the selection as a function of the cut, for a given branch.
void	DrawEventsVSCut (TTree *tree, int isel, int branch, const std::string &cut_norm="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the number of events passing the selection as a function of the cut, for a given selection and branch.
void	DrawRatioVSCut (TTree *tree1, TTree *tree2, const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1.)
	Draw the ratio between two trees as a function of the cut.
void	DrawRatioVSCut (TTree *tree1, TTree *tree2, int branch, const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1.)
	Draw the ratio between two trees as a function of the cut for a given branch.
void	DrawRatioVSCut (TTree *tree1, TTree *tree2, int isel, int branch, const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1.)
	Draw the ratio between two trees as a function of the cut for a given selection and branch.
void	DrawEffVSCut (TTree *tree, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection efficiency as a function of the cut. Must use the truth tree as input.
void	DrawEffVSCut (TTree *tree, int branch, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection efficiency as a function of the cut for a given branch. Must use the truth tree as input.
void	DrawEffVSCut (TTree *tree, int isel, int branch, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection efficiency as a function of the cut for a given selection and branch. Must use the truth tree as input.
void	DrawPurVSCut (TTree *tree, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection purity as a function of the cut. Must use the default tree as input.
void	DrawPurVSCut (TTree *tree, int branch, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection purity as a function of the cut for a given branch. Must use the default tree as input.
void	DrawPurVSCut (TTree *tree, int isel, int branch, const std::string &signal="", const std::string &precut="", int first_cut=-1, int last_cut=-1, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the selection purity as a function of the cut for a given selection and branch. Must use the default tree as input.
void	DrawRatioVSCut (TH1_h *h1, TH1_h *h2, int isel, int branch, int first_cut, const std::string &root_opt, const std::string &opt, const std::string &leg)
	[DrawingToolsBaseVsCutsMethods] More...
void	DrawToys (TTree *tree, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
void	DrawToysRatio (TTree *tree1, TTree *tree2, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
void	DrawToysRatioTwoCuts (TTree *tree1, TTree *tree2, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
void	DrawToysBase (TH1_h &result, TH1_h &entries, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	[DrawingToolsBaseDrawToyMethods] More...
void	DrawVariations (const std::string &name, Int_t ipar=-1, int nx=100, double xmin=-5, double xmax=5, const std::string &root_opt="", const std::string &opt="", const std::string &leg="")
	Draw the variations for systematic parameter ipar.
void	Draw (TTree *tree1, TTree *tree2, const std::string &var, int nx, double xmin, double xmax, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=false)
	1D comparison More...
void	Draw (TTree *tree1, TTree *tree2, const std::string &var, int nbins, double *xbins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=false)
void	Draw (TTree *tree1, TTree *tree2, const std::string &var, int nx, double xmin, double xmax, int ny, double ymin, double ymax, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=false)
	2D comparison
void	Draw (TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=false)
void	DrawRatio (TTree *tree1, TTree *tree2, const std::string &var, int nx, double xmin, double xmax, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
	Ratio between the two data samples with the same cut.
void	DrawRatio (TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
void	DrawRatioTwoCuts (TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &cut1="", const std::string &cut2="", const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1, bool scale_errors=false)
void	DrawRatioTwoCuts (TTree *tree1, TTree *tree2, const std::string &var, int nx, double xmin, double xmax, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
	Ratio between the two data samples with different cuts.
virtual void	DrawRatioTwoCuts (TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &root_opt="", const std::string &opt="", const std::string &leg="", double norm=1)
void	DrawRatio (TH1_h *ratio, const std::string &root_opt, const std::string &uopt, const std::string &leg)
	just Draw the ratio histogram
void	Project (HistoStack *hs1, HistoStack *hs2, TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm2=1, bool scale_errors=true)
void	ProjectNew (HistoStack *hs1, HistoStack *hs2, TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &categ="all", const std::string &cut1="", const std::string &cut2="", const std::string &root_opt="", const std::string &opt="", double norm2=1, bool scale_errors=true)
void	DumpHisto (TH1 *histo, const std::string &uopt)
	dump histo contents
void	DumpHistoInfo (TH1 *histo, const std::string &uopt)
	Dump integral, underflow and overflow.
void	DrawHisto (TH1 *h, int lc, int lw, int fc, int fs, const std::string &root_opt="", const std::string &opt="", const std::string &leg_opt="", int mode=0)
void	DrawHisto (TH1 *h, int lw, int fc, int fs, const std::string &root_opt="", const std::string &opt="", const std::string &leg_opt="", int mode=0)
void	DrawHisto (TH2 *h, int lc, int lw, int fc, int fs, const std::string &root_opt="", const std::string &opt="", const std::string &leg_opt="", int mode=0)
void	DrawHisto (TH3F *h, int lc, int lw, int fc, int fs, const std::string &opt="")
void	DrawHistoStack (HistoStack *hs, const std::string &categ, const std::string &root_opt, const std::string &opt, const std::string &leg_opt="", int mode=2)
void	DrawHistoStack (HistoStack *hs, const std::string &categ, const std::string &root_opt, const std::string &opt, int lc, int lw, int fc, int fs, const std::string &leg_opt="", int mode=2)
void	DrawHistoStacks (HistoStack *hs1, HistoStack *hs2, const std::string &categ, const std::string &root_opt, const std::string &opt, double norm)
void	DrawRatioHistoStacks (HistoStack *hs1, HistoStack *hs2, const std::string &root_opt, const std::string &opt, double norm, const std::string &leg="")
void	Project (HistoStack *hs, const std::string &sample_name, TTree *tree, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &categ="all", const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
void	Project (HistoStack *hs, TTree *tree, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &idVar, std::vector< int > idSel, std::vector< std::string > idName, std::vector< int > idColor, const std::string &cut="", const std::string &root_opt="", const std::string &opt="", double norm=1, bool scale_errors=true)
TH1_h *	GetHisto (TTree *tree, const std::string &name, const std::string &var, int nx, double *xbins, const std::string &cut, const std::string &root_opt, const std::string &opt, double scale, bool scale_errors=true, int toy_ref=-1)
virtual TH2_h *	GetHisto (TTree *tree, const std::string &name, const std::string &var, int nx, double *xbins, int ny, double *ybins, const std::string &cut, const std::string &root_opt, const std::string &opt, double scale, bool scale_errors=true, int toy_ref=-1)
virtual TH1_h *	GetHisto (HistoStack *hs, TTree *tree, const std::string &name, const std::string &var, int nx, double *xbins, const std::string &cut, const std::string &root_opt, const std::string &opt, TH1_h *&hsyst, double scale, bool scale_errors=true, int toy_ref=-1)
TH1_h *	GetHisto (HistoStack *hs, TTree *tree, const std::string &name, const std::string &var, int nx, double *xbins, const std::string &cut, const std::string &root_opt, const std::string &opt, double scale, bool scale_errors=true, int toy_ref=-1)
TH1_h *	GetRatioHisto (HistoStack *hs1, HistoStack *hs2, const std::string &opt)
virtual TH1_h *	GetRatioHisto (TTree *tree1, TTree *tree2, const std::string &name, const std::string &var, int nx, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &root_opt, const std::string &opt, double norm, double scale, bool scale_errors=true, int toy_ref=-1)
virtual void	FillHistoErrors (HistoStack *hs1, HistoStack *hs2, TTree *tree1, TTree *tree2, const std::string &name, const std::string &var, int nx, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &opt, double norm, TH1_h *hstat, TH1_h *&hsyst)
virtual void	FillHistoErrors (HistoStack *hs1, HistoStack *hs2, TH1_h *histo, const std::string uopt)
virtual void	UpdateSystInfo (HistoStack *hs1, HistoStack *hs2, TTree *tree1, TTree *tree2, const std::string &var, int nx, double *xbins, const std::string &cut1, const std::string &cut2, const std::string &opt, double norm)
	fill/update systematics information (fill appopriate histograms) for the stacks
virtual void	FillGraphErrors (HistoStack *hs1, HistoStack *hs2, TGraphAsymmErrors *graph, const std::string uopt)
void	DumpLegendPos ()
	Dump position and size of the legend/small legend.
void	DumpSmallLegendPos ()
void	SetLegendEntryHeight (double h)
	[DrawingToolsCommandLineOptions] More...
void	SetLegendParam (double a, double b, double c, double d)
	Set position and size of the legend.
void	SetLegendPos (double x=-999, double y=-999)
void	SetLegendPos (std::string pos)
void	SetLegendSize (double w=-999, double h=-999)
	Set legend/small legend size, width and height (if -999 keep same value)
void	SetSmallLegendSize (double w=-999, double h=-999)
double	GetLegendX ()
	Get position/size of the legend/small legend.
double	GetLegendY ()
double	GetLegendW ()
double	GetLegendH ()
double	GetSmallLegendX ()
double	GetSmallLegendY ()
double	GetSmallLegendW ()
double	GetSmallLegendH ()
void	SetOptStat (int opt)
	Set the stat option (by int or string)
void	SetOptStat (Option_t *stat)
double	GetStatW ()
	Set/Get the stat box size.
double	GetStatH ()
void	SetStatSize (double w=-999, double h=-999)
double	GetStatX ()
	Set/Get the stat box position (if -999 keep same value)
double	GetStatY ()
void	SetStatPos (double x=-999, double y=-999)
void	SetStackFillStyle (int FillStyle)
	Change the fill style.
void	SetDifferentStackFillStyles (bool diff=true)
	Make each histogram in the stack have a different fill style.
void	SetMarkerStyle (int style)
	change the marker style
void	SetMarkerSize (double size)
	change the marker size
void	SetFillStyle (int style)
	Set the fill style of the current histogram..
void	SetLineWidth (int width)
	Set the line width of the current histogram..
void	SetLineColor (int color)
	Set the line color of the current histogram..
void	SetLineColor (EColor kColor)
void	SetFillColor (int color)
	Set the line color of the current histogram..
void	SetFillColor (EColor kColor)
void	SetMCErrorColor (EColor kColor)
	Set the color for the MC error bars.
void	SetMCErrorColor (int color)
void	SetMCStatErrorColor (EColor kColor)
void	SetMCStatErrorColor (int color)
void	SetAutoColors (int colors[], int ncolors)
	Set the auto colors when superimposing histograms.
void	SetAutoMarkers (int markers[], int nmarkers)
	Set the auto Markers when superimposing histograms.
const std::string &	GetEffDivideParams ()
	Setter and Getter for params controlling the efficiency calculation.
void	SetEffDivideParams (const std::string &params)
void	SetDefaultEffDivideParams ()
	Setter of default params.
void	SetTitleX (const std::string &titleX)
	Set the title in X.
void	SetTitleY (const std::string &titleY)
	Set the title in Y.
void	SetTitle (const std::string &title)
	Set the title that appears at the top of the plot.
void	SetDataLabel (const std::string &label, Color_t color=kBlack)
void	SetAllMCLabel (const std::string &label, Color_t color=kBlack)
void	SetAllMCStatLabel (const std::string &label)
void	SetAllMCSystLabel (const std::string &label)
void	SetMinY (double minY=0)
void	SetMaxY (double maxY=0)
void	SetRangeY (double minY=0, double maxY=0)
void	SetLogY (bool logY=true)
	Set the current histogram to be drawn with a logarithmic Y axis.
void	SetLogZ (bool logZ=true)
	Set the current 2D histogram to be drawn with a logarithmic Z axis (works only for category "all").
void	SetRelativeMaxY (double maxY)
	Set the maximum value in Y relative to the bin with maximum content.
std::string	GetErrorStyle (const std::string &opt)
	Gets the root error style from the user option.
void	SetDraw2p2h (bool draw=true)
	switch on/off 2p2h type for reaction histos
void	DrawCutLineVertical (double xval, bool addarrow=false, std::string arrowdir="l", double arrowpos=0.5)
	[DrawingToolsCommandLineOptions] More...
void	DrawCutLineHorizontal (double yval, bool addarrow=false, std::string arrowdir="u", double arrowpos=0.5)
void	DrawCutLine (double xmin, double ymin, double xmax, double ymax)
void	DrawCutRegion (double xmin, double ymin, double xmax, double ymax, std::string opt="tblr")
void	DrawCutArrow (double xmin, double ymin, double xmax, double ymax)
void	SetCutLineColor (int col)
	Set the color of lines drawn with the DrawCut* functions.
void	SetCutLineColor (EColor kCol)
void	SetCutLineWidth (int width)
	Set the width of lines drawn with the DrawCut* functions.
CorrectionManager &	corr ()
	[DrawingToolsBaseDrawCutLineMethods] More...
SystematicManager &	syst ()
SelectionManager &	sel ()
ConfigurationManager &	conf ()
CategoryManager &	cat ()
DocStringManager &	doc ()
Header &	header ()
SystematicsTools &	syst_tools ()
	an access to tools instance
ConfigTreeTools &	config_tools ()
void	DumpVariationSystematics ()
	Print out the Standard Systematics for a given configuration.
void	DumpWeightSystematics ()
	Print out the Weight Systematics for a given configuration.
void	DumpSystematics ()
	Print out all Systematics for a given configuration.
void	DumpCorrections (const std::string &file="")
	Print out the Corrections.
void	ReadCorrections (const std::string &file)
	Read the list of Corrections.
void	ReadSystematics (const std::string &file)
void	DumpConfigurations (const std::string &file="")
	Print out the Configurations.
void	DumpConfiguration (const std::string &name)
	Print out the Configuration.
void	ReadConfigurations (const std::string &file)
	Read the list of Configurations.
void	DumpSoftwareVersions (const std::string &file="")
	—— Package versions -------—— More...
void	DumpOriginalSoftwareVersion (const std::string &file="", bool all=true)
	Dumps on the screen the software version of the original file (i.e. output of recon)
void	DumpFileInfo (const std::string &file="")
	---— Package versions ----------—
void	ReadCategories (const std::string &file)
void	DumpCategories ()
void	DumpCategories (const std::string &file)
void	DumpCategory (std::string category)
void	ChangeCategory (const std::string &categ_name, int ntypes, std::string *names, int *codes, int *colors)
	[DrawingToolsBase_categ] More...
bool	HasCategory (const std::string &categ_name)
	Check whether a category has been defined.
void	ReadSelections (const std::string &file)
	Read the list of Selections.
void	DumpSelections (const std::string &file="")
void	DumpBranches (Int_t sel_index=0)
	Dump the list of branches in the selection provided selection index.
void	DumpBranches (const std::string &sel_name)
	Dump the list of branches in the selection provided selection name.
void	DumpCuts (int branch=-1)
	[DrawingToolsBase_DumpSelections] More...
void	DumpSteps (int branch=-1)
void	DumpCuts (const std::string &sel_name, int branch=-1)
void	DumpSteps (const std::string &sel_name, int branch=-1)
void	DumpCuts (Int_t sel_index, int branch)
void	DumpSteps (Int_t sel_index, int branch)
std::vector< std::string >	GetCutNames (const std::string &sel_name, int branch=0)
	[DrawingToolsBase_DumpSteps] More...
std::vector< std::string >	GetStepNames (const std::string &sel_name, int branch=0)
	Get a vector of steps names for a given branch (in order) in a selection with a given name.
std::vector< std::string >	GetCutNames (Int_t sel_index, int branch)
	Get a vector of cut names for a given branch (in order) in a selection with a given index.
std::vector< std::string >	GetStepNames (Int_t sel_index, int branch)
	Get a vector of steps names for a given branch (in order) in a selection with a given index.
void	ExplainOption (std::string name)
void	ListOptions ()
	List all drawing options.
void	ExplainVar (std::string name, std::string tree_name="default")
	[DrawingToolsBase_ops] More...
void	ListVars (std::string tree_name="default")
	List all the variables stored in a tree. If no tree name is provided the "default" tree is used.
void	ReadDocStrings (const std::string &file)
	[DrawingToolsBase_vars] More...
void	DumpPOT (TTree *tree)
void	DumpPOT (const std::string &file)
	Dump the POT information for this sample, provided an input file name.
void	ReadConfig (const std::string &file)
	[DrawingToolsBase_POT] More...
void	ReadOther (const std::string &file)
	Read any other variables in the config tree.
void	ReadOther (TTree *chain)
void	PrintPurities (TTree *tree, const std::string &categ, const std::string &cut, double events_ratio=1)
std::vector< TGraph *>	GetGraphs ()
	Get all the graphs that have been drawn. Useful if you want to save them to file.
TGraph *	GetLastGraph ()
	Get the last graph that was drawn. Useful if you want to modify its appearance.
std::vector< TH1 *>	GetHistos ()
TLegend *	GetLastLegend ()
	Get the last legend that was drawn. Useful if you want to modify its appearance.
void	ChangeLegendEntry (Int_t index, const std::string &new_label="", const std::string &new_opt="")
	Change the label or drawing style of a entry in the legend provided the entry number.
void	DeleteLegendEntry (Int_t index)
	Delete a given Legent entry provided its index.
std::vector< TH1 *>	Get2DHistos ()
TH1 *	GetLastHisto ()
	Get all the last Histo that was drawn. Useful if you want to modify its appearance.
TH1 *	GetLastStackTotal (int nexttolast=0)
HistoStack *	GetLastStack (int nexttolast=0)
	Get the most recently-drawn stacked histogram. Useful to access its histograms.
void	StartDocument (const std::string &title, bool pdf=true, bool web=false, const std::string &pdffile="plots.pdf", const std::string &webpath="plots")
void	AddDocumentPage (const std::string &name)
void	FinishDocument ()
int	MakeDirectory (const std::string &path, mode_t mode)
	Make a directory on the filesystem.
std::string	ConvertCutForTruthTree (const std::string cut, bool replace_selmu=true)
double	GetChi2 (const TH1 *h1, const TH1 *h2)
int	GetNDOF (const TH1 *h1, const TH1 *h2)
double	GetPvalue (double chi2, int ndof)
double	GetPvalue (const TH1 *h1, const TH1 *h2)

Protected Member Functions
int	GetFillStyle (int i)

Protected Attributes
int	_unique
	Counter for ensuring all histograms get a unique name.
bool	_drawleg
std::vector< TLegend * >	_legends
double	_legendParam [4]
double	_legendSize [2]
double	_legendPos [2]
double	_legendSmallSize [2]
double	_statPos [2]
std::string	_legendPosS
int	_stat_option
int	_stack_fill_style
bool	_different_fill_styles
int	_marker_style
int	_fill_style
int	_fill_color
int	_line_width
int	_line_color
int	_mcerror_color
int	_mcstaterror_color
double	_marker_size
int	_cut_line_col
int	_cut_line_width
std::string	_titleX
std::string	_titleY
std::string	_title
Color_t	_data_color
Color_t	_allmc_color
std::string	_data_label
std::string	_allmc_label
std::string	_allmcstat_label
std::string	_allmcsyst_label
double	_minY
double	_maxY
double	_relativeMaxY
bool	_logY
bool	_logZ
std::string	_eff_params
	parameter to control options for TGraphAsymmErrors::Divide() method, the one used to get the efficiencies
bool	_draw_2p2h
TFile *	_file
int	_same_level
int	_same_level_tot
int	_auto_colors [NMAXAUTOCOLORS]
int	_auto_markers [NMAXAUTOCOLORS]
std::vector< TH1 *>	_saved_histos
std::vector< TH2 *>	_saved_histos2D
std::vector< HistoStack *>	_saved_histoStacks
std::vector< TGraph *>	_saved_graphs
std::vector< TLine *>	_cut_lines
TPad *	_MainPad
TPad *	_RatioPad
TCanvas *	_pdfcanvas
TPad *	_bodypad
TPad *	_headpad
std::string	_pdfpath
std::string	_webpath
std::string	_webheader
std::string	_webbody
std::string	_config_file
DocStringManager	_docStrings
CategoryManager	_categories
ConfigurationManager	_configurations
CorrectionManager	_corrections
SystematicManager	_systematics
SelectionManager	_selections
SystematicsTools	_syst_tools
ConfigTreeTools	_configTree_tools
Header	_header
Int_t	_minAccumLevelToSave

Detailed Description

This is the base class for the DrawingTools, and uses a single TTree to as input, rather than a DataSample object. It handles color code drawing and variable binning.

Users generally shouldn't instantiate this class directly, but use the DrawingTools class instead. See the DrawingTools class documentation for more details.

TODO: This class must be properly documented.

Definition at line 62 of file DrawingToolsBase.hxx.

Member Function Documentation

AddDocumentPage()

void DrawingToolsBase::AddDocumentPage

(

const std::string &

name

)

Add a page to the PDF document and/or webpage that was opened with StartDocument(). "name" will appear on web pages to give context to what each plot is. If StartDocument() createdg a canvas for you, "name" will also appear in the header section of the PDF page.

Definition at line 3590 of file DrawingToolsBase.cxx.

                                                            {
//*********************************************************
  if (_webpath != "") {
    TString safename = name;
    safename = safename.ReplaceAll(" ", "_");
    gPad->SaveAs((_webpath + "/" + safename.Data() + ".png").c_str());
    _webheader += std::string("<li><a href=\"#") + safename.Data() + "\">" + name + "</a></li>\n";
    _webbody += std::string("<p><a name=\"") + safename.Data() + "\"></a>" + name + "</p>\n";
    _webbody += std::string("<p><img src=\"") + safename.Data() + ".png\" alt=\"" + name + "\"/></p>\n";
  }

  if (_pdfpath != "") {
    TVirtualPad* currpad = gPad;

    if (currpad && currpad == _bodypad) {
      _headpad->Clear();
      _headpad->cd();
      TLatex l;
      l.SetTextSize(0.5);
      l.SetTextAlign(22);
      l.DrawLatex(0.5, 0.5, name.c_str());

      _pdfcanvas->cd();
      _pdfcanvas->Draw();
      _pdfcanvas->Print(_pdfpath.c_str());

      currpad->cd();
    } else {
      currpad->Print(_pdfpath.c_str());
    }
  }
}

ChangeCategory()

void DrawingToolsBase::ChangeCategory	(	const std::string &	categ_name,
		int	ntypes,
		std::string *	names,
		int *	codes,
		int *	colors
	)

[DrawingToolsBase_categ]

Update or add a category.

• categ_name is the name this category will have. This must be a variable that is stored in the output file, such as "particle" (you can of course save your own variables).
• ntypes is the number of options your category will have.
• names is an array of length ntypes of the name of each option.
• codes is an array of length ntypes of the value stored in the output file for this option.
• colors is an array of length ntypes of the colour to plot each option with.

Definition at line 3304 of file DrawingToolsBase.cxx.

                                                                                                                       {
//********************************************************************

  // Read the categories from the config tree
  ReadCategories(_config_file);

  bool multi = false;
  bool noWarning = false; 

  // don't add automatic categories 
  bool addNOTRUTH=false; 
  bool addSAND=false;


  cat().AddCategory(categ_name, ntypes, names, codes, colors, multi, noWarning, addNOTRUTH, addSAND);
}

corr()

CorrectionManager& DrawingToolsBase::corr ( )

inline

[DrawingToolsBaseDrawCutLineMethods]

Provide easy access to the managers.

Definition at line 613 of file DrawingToolsBase.hxx.

{return _corrections;}

Draw()

void DrawingToolsBase::Draw	(	TTree *	tree1,
		TTree *	tree2,
		const std::string &	var,
		int	nx,
		double	xmin,
		double	xmax,
		const std::string &	categ = "all",
		const std::string &	cut = "",
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		double	norm = 1,
		bool	scale_errors = false
	)

1D comparison

---

----—— comparisons between two data samples (two trees) -----------——

Definition at line 1241 of file DrawingToolsBase.cxx.

                                                                                                                                                          {
//**************************************************

  // 1D comparison between two data samples with different normalisation. Uniform binning
  double xbins[NMAXBINS];
  Draw(tree1,tree2,var,nx,GetVariableBins(nx,xmin,xmax,xbins),categ,cut,root_opt,opt,norm,scale_errors);
}

DrawCutArrow()

void DrawingToolsBase::DrawCutArrow	(	double	xmin,
		double	ymin,
		double	xmax,
		double	ymax
	)

Draw an arrow between two points. If a legend had already been created by the DrawingTools, and drawn on the current pad, it is re-drawn. This means that the line does not cover it up.

Definition at line 3457 of file DrawingToolsBase.cxx.

                                                                                      {
//*********************************************************
  TArrow* arr = new TArrow(xmin, ymin, xmax, ymax, 0.02, "|>");
  arr->SetLineColor(_cut_line_col);
  arr->SetFillColor(_cut_line_col);
  arr->SetLineWidth(_cut_line_width);
  _cut_lines.push_back(arr);
  arr->Draw();

  if (_drawleg && _legends.size() > 0 && gPad->FindObject(_legends.back())) {
    _legends.back()->Draw();
  }
}

DrawCutLine()

void DrawingToolsBase::DrawCutLine	(	double	xmin,
		double	ymin,
		double	xmax,
		double	ymax
	)

Draw an abritary line between two points. If a legend had already been created by the DrawingTools, and drawn on the current pad, it is re-drawn. This means that the line does not cover it up.

Definition at line 3442 of file DrawingToolsBase.cxx.

                                                                                     {
//*********************************************************
  TLine* l = new TLine(xmin, ymin, xmax, ymax);

  l->SetLineColor(_cut_line_col);
  l->SetLineWidth(_cut_line_width);
  _cut_lines.push_back(l);
  l->Draw();

  if (_drawleg && _legends.size() > 0 && gPad->FindObject(_legends.back())) {
    _legends.back()->Draw();
  }
}

DrawCutLineHorizontal()

void DrawingToolsBase::DrawCutLineHorizontal	(	double	yval,
		bool	addarrow = false,
		std::string	arrowdir = "u",
		double	arrowpos = 0.5
	)

Draw a horizontal line at the specified Y value, spanning the currently-drawn histogram. See note in DrawCutLine() about legends being re-drawn when calling this function. If addarrow is set to true, then an arrow indicating the direction of the cut is drawn. arrowdir respects the following options: u : Draw the arrow pointing upwards (default) d : Draw the arrow pointing downwards arrowpos specifies the fractional length along the cut line to draw the arrow at, measuring from the left end of the line. Defaults to half way along.

Definition at line 3420 of file DrawingToolsBase.cxx.

                                                                                                            {
//*********************************************************
  double xmin = gPad->PadtoX(gPad->GetUxmin());
  double xmax = gPad->PadtoX(gPad->GetUxmax());
  DrawCutLine(xmin, yval, xmax, yval);

  if (addarrow) {
    std::string uarrowdir = drawUtils::ToUpper(arrowdir);
    double deltay = yval-gPad->PadtoY( gPad->YtoPad(yval)-(gPad->GetUymax()-gPad->GetUymin())/20.);

    if (uarrowdir.find("D") != std::string::npos) {
      deltay *= -1;
    }

    // It needs this to work in LogX scale
    double xarr = gPad->PadtoX((gPad->GetUxmax()-gPad->GetUxmin())*arrowpos+gPad->GetUxmin());
    double yarrmax = yval + deltay;
    DrawCutArrow(xarr, yval, xarr, yarrmax);
  }
}

DrawCutLineVertical()

void DrawingToolsBase::DrawCutLineVertical	(	double	xval,
		bool	addarrow = false,
		std::string	arrowdir = "l",
		double	arrowpos = 0.5
	)

[DrawingToolsCommandLineOptions]

[DrawingToolsBaseDrawCutLineMethods] Draw a vertical line at the specified X value, spanning the currently-drawn histogram. See note in DrawCutLine() about legends being re-drawn when calling this function. If addarrow is set to true, then an arrow indicating the direction of the cut is drawn. arrowdir respects the following options: l : Draw the arrow pointing to the left r : Draw the arrow pointing to the right (default) arrowpos specifies the fractional length along the cut line to draw the arrow at, measuring from the bottom of the line. Defaults to half way along.

Definition at line 3397 of file DrawingToolsBase.cxx.

                                                                                                          {
//*********************************************************

  double ymin = gPad->PadtoY(gPad->GetUymin());
  double ymax = gPad->PadtoY(gPad->GetUymax());
  DrawCutLine(xval, ymin, xval, ymax);

  if (addarrow) {
    std::string uarrowdir = drawUtils::ToUpper(arrowopt);
    double deltax = xval-gPad->PadtoX( gPad->XtoPad(xval)-(gPad->GetUxmax()-gPad->GetUxmin())/20.);

    if (uarrowdir.find("L") != std::string::npos) {
      deltax *= -1;
    }

    // It needs this to work in LogY scale
    double yarr = gPad->PadtoY((gPad->GetUymax()-gPad->GetUymin())*arrowpos+gPad->GetUymin());
    double xarrmax = xval + deltax;
    DrawCutArrow(xval, yarr, xarrmax, yarr);
  }
}

DrawCutRegion()

void DrawingToolsBase::DrawCutRegion	(	double	xmin,
		double	ymin,
		double	xmax,
		double	ymax,
		std::string	opt = "tblr"
	)

Draw a box defined by the minimum and maximum points. The opt parameter specifies, among other things, which sides of the box to draw: t : draw the (t)op of the box b : draw the (b)ottom of the box l : draw the (l)eft of the box r : draw the (r)ight of the box nochop : Don't constrain the sides of the box to stay within the current axes.

See note in DrawCutLine() about legends being re-drawn when calling this function.

Definition at line 3472 of file DrawingToolsBase.cxx.

                                                                                                      {
//*********************************************************
  std::string uopt = drawUtils::ToUpper(opt);

  if (!drawUtils::CheckOption(uopt,"NOCHOP")) {
    xmin = std::max(xmin, gPad->PadtoX(gPad->GetUxmin()));
    xmax = std::min(xmax, gPad->PadtoY(gPad->GetUxmax()));
    ymin = std::max(ymin, gPad->PadtoX(gPad->GetUymin()));
    ymax = std::min(ymax, gPad->PadtoY(gPad->GetUymax()));
  }

  if (uopt.find("T")!=std::string::npos) {
    DrawCutLine(xmin, ymax, xmax, ymax);
  }
  if (uopt.find("B")!=std::string::npos) {
    DrawCutLine(xmin, ymin, xmax, ymin);
  }
  if (uopt.find("L")!=std::string::npos) {
    DrawCutLine(xmin, ymin, xmin, ymax);
  }
  if (uopt.find("R")!=std::string::npos) {
    DrawCutLine(xmax, ymin, xmax, ymax);
  }
}

DrawEventsVSCut()

void DrawingToolsBase::DrawEventsVSCut	(	TTree *	tree,
		const std::string &	cut_norm = "",
		int	first_cut = -1,
		int	last_cut = -1,
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = ""
	)

[DrawingToolsBaseVsCutsMethods] Draw the number of events passing the selection as a function of the cut

Definition at line 1427 of file DrawingToolsBase.cxx.

                                                                                                             {
//**************************************************

  DrawEventsVSCut(tree,0,cut_norm,first_cut,last_cut,root_opt,opt,leg);
}

DrawRatio()

void DrawingToolsBase::DrawRatio	(	TTree *	tree,
		const std::string &	var,
		int	nbins,
		double *	xbins,
		const std::string &	cut1,
		const std::string &	cut2,
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = ""
	)

[DrawingToolsBase_eff_ratio] 1D Ratio between two independent cuts (the denominator cut is cut2, the numerator cut is cut1)

Definition at line 1232 of file DrawingToolsBase.cxx.

                                                                                                                                                     {
//*********************************************************

  // Ratio between two histograms with independent cuts
  DrawRatioTwoCuts(tree, tree, var, nx, xbins, cut1, cut2, root_opt, opt, leg, 1.);
}

DrawRatioVSCut()

void DrawingToolsBase::DrawRatioVSCut	(	TH1_h *	h1,
		TH1_h *	h2,
		int	isel,
		int	branch,
		int	first_cut,
		const std::string &	root_opt,
		const std::string &	opt,
		const std::string &	leg
	)

[DrawingToolsBaseVsCutsMethods]

Draw the ratio between two samples as a function of the cut

Definition at line 1702 of file DrawingToolsBase.cxx.

                                                                                                            {
//**************************************************

  // TODO: The entire method must be simplified using DrawHisto and DrawGraph

  // Read the steps from the config tree
  //  ReadSteps(_config_file);

  // Check if selection exists
  if (!sel().GetSelection(isel,true)) return;

  std::string uopt = drawUtils::ToUpper(opt);
  std::string uroot_opt = drawUtils::ToUpper(root_opt);

  // Check that all user options are valid
  if (!drawUtils::ContainValidOptions(uopt)) return;

  TH1_h* hratio = new TH1_h(GetUniqueName("ratio").c_str(),"",h1->GetNbinsX(),h1->GetXaxis()->GetXmin(),h1->GetXaxis()->GetXmax());
  _saved_histos.push_back(hratio);

  hratio->Divide(h1,h2);

  Int_t cut_offset = 1;
  // First bin corresponds to no cut
  hratio->GetXaxis()->SetBinLabel(1, "NO CUT");

  std::vector<StepBase*> cuts = sel().GetSelection(isel)->GetCutsInBranch(branch);
  // Start from second bin since first corresponds to no cut
  for (int i=cut_offset;i<hratio->GetNbinsX();i++ ){
    int icut = i-cut_offset;
    hratio->GetXaxis()->SetBinLabel(i+1, cuts[icut]->Title().c_str());
  }

  // No stats box
  gStyle->SetOptStat(0);

  // Histogram attributes
  hratio->SetTitle(_title.c_str());
  hratio->GetXaxis()->SetTitle("");
  hratio->GetYaxis()->SetTitle(_titleY.c_str());
  hratio->GetYaxis()->SetNdivisions(520);

  // Efficiency ratio
  if (drawUtils::CheckInternalOption(uopt,"EFF")){

    hratio->GetYaxis()->SetRangeUser(0,1.1);

    // Set the proper range depending on the first_cut
    hratio->GetXaxis()->SetRange(first_cut+cut_offset+1,hratio->GetNbinsX());

    if (uroot_opt.find("SAME")!=std::string::npos)
      hratio->Draw("PHIST same");
    else
      hratio->Draw("PHIST");

    // compute the efficiency
    //    TGraphAsymmErrors* eff = new TGraphAsymmErrors(h1);
    TGraphAsymmErrors* eff = new TGraphAsymmErrors(h1->GetNbinsX());
    eff->SetName(GetUniqueName("eff").c_str());
    _saved_graphs.push_back(eff);
    eff->Divide(h1, h2, (_eff_params + " v").c_str()); //the options are explicitely provided by SetEffDivideParams(const std::string&), root_opt not used to avoid possible confusions 

    eff->SetLineColor(_auto_colors[_same_level]);
    eff->SetMarkerColor(_auto_colors[_same_level]);
    eff->SetMarkerStyle(21);

    //    eff->GetXaxis()->SetRange(first_cut+cut_offset+1,hratio->GetNbinsX());
    eff->GetXaxis()->SetLimits(first_cut+cut_offset+1,hratio->GetNbinsX());

    for (int i=0; i<h1->GetNbinsX();i++){
      eff->SetPointEXhigh(i,0);
      eff->SetPointEXlow(i,0);
    }

    // Draw the efficiency histogram  (TODO: use DrawGraph)
    eff->Draw(("PL "+root_opt).c_str());

    //    Add an entry to the legend if requested
    if (!drawUtils::CheckOption(uopt,"NOLEG") && leg!=""){
      drawUtils::AddLegendEntry(_legends.back(), eff, leg, "LE1P");
    }
  }
  // Normal ratio
  else{
    hratio->SetLineColor(_auto_colors[_same_level]);
    hratio->SetMarkerColor(_auto_colors[_same_level]);
    hratio->SetMarkerStyle(21);

    // Set the proper range depending on the first_cut
    hratio->GetXaxis()->SetRange(first_cut+cut_offset+1,hratio->GetNbinsX());

    // Draw the ratio histogram
    hratio->Draw(("PL "+uroot_opt).c_str());

    // Add an entry to the legend if requested
    if (!drawUtils::CheckOption(uopt,"NOLEG") && leg!=""){
      drawUtils::AddLegendEntry(_legends.back(), hratio, leg, "LE1P");
    }

    // Print numbers on the screen
    char out1[256];  
    char out2[256];  
    for (int i=0;i<hratio->GetNbinsX();i++ ){
      int icut = i-1;    
      std::string cut_name="";
      if (icut==-1) 
        cut_name = "NO CUT";
      else
        cut_name = cuts[icut]->Title();      
      sprintf(out1,"%3s: %-25s %-10s", "#", "cut", "ratio");
      sprintf(out2,"%3d: %-25s %-10.2f", icut, cut_name.c_str(), hratio->GetBinContent(i+1));      
      if (i==0) std::cout << out1 << std::endl;
      std::cout << out2 << std::endl;
    }
  }

  // Draw the legend if requestet
  if (!drawUtils::CheckOption(uopt,"NOLEG") && leg!="")
    _legends.back()->Draw();

  if (!drawUtils::CheckOption(uopt,"NODRAW"))
    gPad->Update();
}

DrawToys()

void DrawingToolsBase::DrawToys	(	TTree *	tree,
		const std::string &	cut = "",
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = ""
	)

[DrawingToolsBaseDrawToyMethods] This method draws the distribution of the number of selected events for all toys (one entry per toy in the histogram), provided a cut This is useful to check that the systematic error bars correspond to the RMS of this distribution

Definition at line 1828 of file DrawingToolsBase.cxx.

                                                                                                                                       {
//*********************************************************

  // Draw the distribution of entries for all toy experiments
  // The rms of this distribution is the systematic error

  std::string uopt = drawUtils::ToUpper(opt);


  // Check that all user options are valid
  if (!drawUtils::ContainValidOptions(uopt)) return;

  int ntoys = drawUtils::GetNToys(tree);

  TH1_h h1("h1","h1",ntoys,0,ntoys);
  TH1_h hw("hw","hw",ntoys,0,ntoys);

  // Apply event weights
  std::string cutp = weightTools::ApplyWeights(tree,FormatCut(cut),(uopt+" NOTOYW").c_str());

  // Project with no toy experiment weights
  tree->Project("h1","toy_index",cutp.c_str());

  std::string cut2=cut;
  if (cut2=="") cut2="1==1";

  // Project the toy experiment PDF weights
  if (drawUtils::TreeHasVar(tree,"toy_weight"))
    tree->Project("hw","toy_index",("("+cutp+")*toy_weight").c_str());
  else
    hw = h1;

  // compute the average toy exp weight
  TH1_h hwa(hw);
  hwa.Divide(&hw,&h1);

  DrawToysBase(h1,hwa,root_opt,uopt,leg);
}

DrawToysBase()

void DrawingToolsBase::DrawToysBase	(	TH1_h &	result,
		TH1_h &	entries,
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = ""
	)

[DrawingToolsBaseDrawToyMethods]

Basic method used by the ones above

Definition at line 1947 of file DrawingToolsBase.cxx.

                                                                                                                                       {
//*********************************************************

  // Draw the distribution of entries for all toy experiments

  std::string slevel = GetSameLevel(root_opt);
  std::string uopt = drawUtils::ToUpper(opt);
  if (slevel=="0" && leg!="")
    CreateLegend();

  // Stat option (entries, MEAN, RMS, and integral)
  int statTemp = _stat_option;
  SetOptStat(1001110);
  gStyle->SetOptStat(1001110);

  const int NTOYS = result.GetNbinsX();

  double nentries[NMAXTOYS];
  double avg_weight[NMAXTOYS];
  double sum_weights=0;
  double avg_nentries=0;
  double hmin = 1e10;
  double hmax = -1;

  // Get the entries
  for (int itoy=0;itoy<NTOYS;itoy++){
    nentries[itoy]=result.GetBinContent(itoy+1);
    // Get the average weight for each toy experiment
    if (nentries[itoy]>0)
      avg_weight[itoy] = weights.GetBinContent(itoy+1);
    else
      avg_weight[itoy] = 0;
    std::cout << "toy_index = "<< itoy << "\t --> #entries = " << nentries[itoy] << "\t w=" << avg_weight[itoy] << std::endl;

    if (nentries[itoy]>hmax) hmax = nentries[itoy];
    if (nentries[itoy]<hmin) hmin = nentries[itoy];

    // compute the total weight and average entries (justfor debugging)
    sum_weights += avg_weight[itoy];
    avg_nentries += nentries[itoy]*avg_weight[itoy];
  }

  std::cout << "avg[#entries] = sum[entries*avg_weight]/sum[avg_weight] = "<< avg_nentries/sum_weights
            << ", sum[avg_weights] = " << sum_weights
            << ", sum[entries*avg_weight] = " << avg_nentries << std::endl;

  //  Create an histogram and fill the distribution
  TH1_h* hentries = new TH1_h(GetUniqueName("hentries").c_str(),leg.c_str(),1000,hmin-(hmax-hmin)/10.,hmax+(hmax-hmin)/10.);
  _saved_histos.push_back(hentries);

  double rms=0;
  double rms2=0;
  for (int itoy=0;itoy<NTOYS;itoy++){
    //    hentries->Fill(nentries[itoy],avg_weight[itoy]);
    hentries->Fill(nentries[itoy],1./NTOYS);

    // this is just for debugging. rms should coincide with the rms given by root
    rms += pow(nentries[itoy]-avg_nentries/sum_weights,2)*avg_weight[itoy]/sum_weights;

    // this is the rms when the weights are not properly normilized to 1
    rms2 += pow(nentries[itoy]-avg_nentries,2)*avg_weight[itoy];
  }

  std::cout << "rms = "<< sqrt(rms) << ", rms' = " << sqrt(rms2) << std::endl;

  // Draw the entries histogram
  DrawHisto(hentries, _line_width, _line_color, _fill_style, root_opt, uopt, "LE1P");

  // Draw the legend
  if (!drawUtils::CheckOption(uopt,"NOLEG") && leg!="")
    _legends.back()->Draw();

  if (!drawUtils::CheckOption(uopt,"NODRAW"))
    gPad->Update();

  // go back to previous stat option
  SetOptStat(statTemp);
}

DrawToysRatio()

void DrawingToolsBase::DrawToysRatio	(	TTree *	tree1,
		TTree *	tree2,
		const std::string &	cut = "",
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = "",
		double	norm = 1
	)

This method draws the distribution of the ratio of number of selected events between two samples for all toys (one entry per toy in the histogram), provided a cut (the same for numerator and denominator)

Definition at line 1869 of file DrawingToolsBase.cxx.

                                                                                                                        {
//*********************************************************

  // Draw the distribution of ratios for all toy experiments
  // The rms of this distribution is the systematic error
  // Use same cut for both data samples

  DrawToysRatioTwoCuts(tree1,tree2,cut,cut,root_opt,opt,leg,norm);
}

DrawToysRatioTwoCuts()

void DrawingToolsBase::DrawToysRatioTwoCuts	(	TTree *	tree1,
		TTree *	tree2,
		const std::string &	cut1,
		const std::string &	cut2,
		const std::string &	root_opt = "",
		const std::string &	opt = "",
		const std::string &	leg = "",
		double	norm = 1
	)

This method draws the distribution of the ratio of number of selected events between two samples for all toys (one entry per toy in the histogram), provided two cuts, one for the numerator and another for the denominator

Definition at line 1881 of file DrawingToolsBase.cxx.

                                                                                                                               {
//*********************************************************

  // Draw the distribution of ratios for all toy experiments
  // The rms of this distribution is the systematic error
  // Use different cuts for both data samples

  int NTOYS1 = drawUtils::GetNToys(tree1);
  int NTOYS2 = drawUtils::GetNToys(tree2);

  // The number of toy experiments must be the same
  if (NTOYS1!=NTOYS2) return;

  std::string uopt = drawUtils::ToUpper(opt);

  // Check that all user options are valid
  if (!drawUtils::ContainValidOptions(uopt)) return;


  // Apply event weights
  std::string cut1p = weightTools::ApplyWeights(tree1,FormatCut(cut1),(uopt+" NOTOYW").c_str());
  std::string cut2p = weightTools::ApplyWeights(tree2,FormatCut(cut2),(uopt+" NOTOYW").c_str());

  // Project the first sample
  TH1_h h1("en1","en2",NTOYS1,0,NTOYS1);
  tree1->Project("en1","toy_index",cut1p.c_str());

  // Project the second sample
  TH1_h h2("en2","en2",NTOYS1,0,NTOYS1);
  tree2->Project("en2","toy_index",cut2p.c_str());

  // compute the ratio
  TH1_h ratio(h1);
  ratio.SetName("ratio");
  ScaleHisto(&h2,norm);
  ratio.Divide(&h1,&h2);

  // Project the weights for the first sample
  TH1_h hw1("hw1","hw1",NTOYS1,0,NTOYS1);
  if (drawUtils::TreeHasVar(tree1,"toy_weight"))
    tree1->Project("hw1","toy_index",("("+cut1p+")*toy_weight").c_str());
  else
    hw1 = h1;

  // Project the weights for the first sample
  TH1_h hw2("hw2","hw2",NTOYS1,0,NTOYS1);
  if (drawUtils::TreeHasVar(tree2,"toy_weight"))
    tree2->Project("hw2","toy_index",("("+cut2p+")*toy_weight").c_str());
  else
    hw2 = h2;


  // compute the average weights for sample 1
  TH1_h hwa1(hw1);
  hwa1.Divide(&hw1,&h1);

  // compute the average weights for sample 2
  TH1_h hwa2(hw2);
  hwa2.Divide(&hw2,&h2);


  DrawToysBase(ratio,hwa2,root_opt,uopt,leg);
}

DumpCategories() [1/2]

void DrawingToolsBase::DumpCategories ( )

inline

[DrawingToolsBase_categ] Print out the list of categories which can be used when plotting stacked histograms

Definition at line 709 of file DrawingToolsBase.hxx.

{cat().DumpCategories();}

DumpCategories() [2/2]

void DrawingToolsBase::DumpCategories ( const std::string &  file )

inline

Print out the list of categories stored in the given file which can be used when plotting stacked histograms

Definition at line 713 of file DrawingToolsBase.hxx.

{ReadCategories(file);cat().DumpCategories();if (_config_file!="") ReadCategories(_config_file);}

DumpCategory()

void DrawingToolsBase::DumpCategory ( std::string  category )

inline

Print the options saved for the given category, including the name of each category, the value stored in the output file for that category, and the colour used to plot the category.

Definition at line 717 of file DrawingToolsBase.hxx.

{cat().DumpCategory(category);}

DumpCuts() [1/3]

void DrawingToolsBase::DumpCuts

(

int

branch = -1

)

[DrawingToolsBase_DumpSelections]

[DrawingToolsBase_DumpSteps] Print to screen the details of cuts for a given branch or selection. Specifying a branch of -1 (the default) will print details for all branches. When there are multiple selections the input index is for the selection

Definition at line 4154 of file DrawingToolsBase.cxx.

                                         {
//********************************************************************
  if (sel().GetNEnabledSelections()>1){
    if (sel().GetSelection(branch)) sel().GetSelection(branch)->DumpCuts();
  }
  else
    sel().GetSelection(0)->DumpCuts(branch);
}

DumpCuts() [2/3]

void DrawingToolsBase::DumpCuts	(	const std::string &	sel_name,
		int	branch = -1
	)

Print to screen the details of cuts for a given branch and selection (name). Specifying a branch of -1 (the default) will print details for all branches.

Definition at line 4174 of file DrawingToolsBase.cxx.

                                                                    {
//********************************************************************
  if (sel().GetSelection(sel_name)) sel().GetSelection(sel_name)->DumpCuts(branch);
}

DumpCuts() [3/3]

void DrawingToolsBase::DumpCuts	(	Int_t	sel_index,
		int	branch
	)

Print to screen the details of cuts for a given branch and selection (index). Specifying a branch of -1 (the default) will print details for all branches.

Definition at line 4186 of file DrawingToolsBase.cxx.

                                                          {
//********************************************************************  
  if (sel().GetSelection(sel_index)) sel().GetSelection(sel_index)->DumpCuts(branch);
}

DumpPOT()

void DrawingToolsBase::DumpPOT

(

TTree *

tree

)

[DrawingToolsBase_POT] Dump the POT information for this sample, provided the header tree

Definition at line 4198 of file DrawingToolsBase.cxx.

                                         {
//********************************************************************
  header().ReadHeader(tree);
  header().DumpPOT();
}

DumpSelections()

void DrawingToolsBase::DumpSelections

(

const std::string &

file = ""

)

[DrawingToolsBase_DumpSelections] Dump the list of Selections

Definition at line 4134 of file DrawingToolsBase.cxx.

                                                          {
//********************************************************************
  if (file!="") sel().ReadSelections(file);
  sel().DumpSelections();
  if (_config_file!="") ReadSelections(_config_file);
}

DumpSoftwareVersions()

void DrawingToolsBase::DumpSoftwareVersions

(

const std::string &

file = ""

)

—— Package versions -------——

Dumps on the screen the highland/psyche software versions used to produce this file

Definition at line 3814 of file DrawingToolsBase.cxx.

                                                                {
//*********************************************************

  // Use the file used to create the DrawingTools if no file is specified
  std::string file2 = file;
  if (file=="") file2 = _config_file;

  if (file2!="") ND::versioning().ReadVersions(file2);
  ND::versioning().DumpVersions();
  DumpOriginalSoftwareVersion(file2, false);
}

DumpSteps() [1/3]

void DrawingToolsBase::DumpSteps

(

int

branch = -1

)

Print to screen the details of steps for a given branch or selection. Specifying a branch of -1 (the default) will print details for all branches. When there are multiple selections the input index is for the selection

Definition at line 4164 of file DrawingToolsBase.cxx.

                                          {
//********************************************************************
  if (sel().GetNEnabledSelections()>1){
    if (sel().GetSelection(branch,true)) sel().GetSelection(branch)->DumpSteps();
  }
  else
    sel().GetSelection(0)->DumpSteps(branch);
}

DumpSteps() [2/3]

void DrawingToolsBase::DumpSteps	(	const std::string &	sel_name,
		int	branch = -1
	)

Print to screen the details of steps for a given branch and selection (name). Specifying a branch of -1 (the default) will print details for all branches.

Definition at line 4180 of file DrawingToolsBase.cxx.

                                                                    {
//********************************************************************
  if (sel().GetSelection(sel_name)) sel().GetSelection(sel_name)->DumpSteps(branch);
}

DumpSteps() [3/3]

void DrawingToolsBase::DumpSteps	(	Int_t	sel_index,
		int	branch
	)

Print to screen the details of steps for a given branch and selection (index). Specifying a branch of -1 (the default) will print details for all branches.

Definition at line 4192 of file DrawingToolsBase.cxx.

                                                          {
//********************************************************************
  if (sel().GetSelection(sel_index)) sel().GetSelection(sel_index)->DumpSteps(branch);
}

ExplainOption()

void DrawingToolsBase::ExplainOption ( std::string  name )

inline

[DrawingToolsBase_ops] Explain the user drawing options

Definition at line 809 of file DrawingToolsBase.hxx.

{drawUtils::ExplainOption(name);}

ExplainVar()

void DrawingToolsBase::ExplainVar ( std::string  name, std::string  tree_name = "default"  )

inline

[DrawingToolsBase_ops]

[DrawingToolsBase_vars] Explain the meaning of a variable stored in a tree. If no tree name is provided the "default" tree is used

Definition at line 817 of file DrawingToolsBase.hxx.

{doc().ExplainVar(name, tree_name);}

FinishDocument()

void DrawingToolsBase::FinishDocument

(

)

Close the PDF document / webpage that was opened with StartDocument. Note that you MUST call this function or your PDF document will be corrupt / the webpage will be empty.

Definition at line 3624 of file DrawingToolsBase.cxx.

                                      {
//*********************************************************
  if (_webpath != "") {
    _webbody += "</body></html>\n";
    std::ofstream outfile;
    outfile.open((_webpath+"/index.html").c_str());
    outfile << _webheader << _webbody;
    outfile.close();
  }
  if (_pdfpath != "") {
    gPad->Print((_pdfpath+"]").c_str());
  }
}

Get2DHistos()

std::vector< TH1* > DrawingToolsBase::Get2DHistos ( )

inline

Get all the 1D histos that have been drawn. Useful if you want to save them to file. NOTE! The "same" plot may appear multiple times due to the way the comparison histograms are drawn.

Definition at line 876 of file DrawingToolsBase.hxx.

{ return _saved_histos; }

GetChi2()

double DrawingToolsBase::GetChi2	(	const TH1 *	h1,
		const TH1 *	h2
	)

Compute the Chi2 without normalizing by area (as Chi2Test of root does) h1/h2 should be already normalized by POT, with errors properly propagated: just get them from your DATA-mc plot with GetLastStackTotal(0) and GetLastStackTotal(1)

Definition at line 4076 of file DrawingToolsBase.cxx.

                                                              {
 //********************************************************************

    if (h1->GetXaxis()->GetNbins() != h2->GetXaxis()->GetNbins())
      std::cout << "WARNING: the two histograms have different number of bins!" << std::endl;

    TH1* h1temp = (TH1*)h1->Clone();
    TH1* h2temp = (TH1*)h2->Clone();

    // Refill to avoid dealing with normalizing factors
    h1temp->Reset();
    h2temp->Reset();
    for (int i=1; i<=h1temp->GetXaxis()->GetNbins(); i++) {
      h1temp->SetBinContent(i,h1->GetBinContent(i));
      h2temp->SetBinContent(i,h2->GetBinContent(i));
      h1temp->SetBinError(i,h1->GetBinError(i));
      h2temp->SetBinError(i,h2->GetBinError(i));
    }

    double chi2=0;
    int ndof=0;
    for (int i=1; i<=h1temp->GetXaxis()->GetNbins(); i++) {
      if (h1temp->GetBinContent(i)==0 && h2temp->GetBinContent(i)==0) continue;
      ndof++;
      double diff = h1temp->GetBinContent(i) - h2temp->GetBinContent(i);
      double err1 = h1temp->GetBinError(i);
      double err2 = h2temp->GetBinError(i);
      double errsq = pow(err1,2) + pow(err2,2);
      if (errsq == 0 || errsq != errsq) {
        if (diff != 0)
          std::cout << "ERROR errsq = 0! \n";
        else {
          std::cout << "WARNING diff=0 and errsq= 0 (set to 1) \n";
          errsq=1;
          diff=1;
        }
      }
      chi2 += pow(diff,2) / errsq;
    }
    ndof--;
/*
    double chi2test;
    int ndoftest;
    int igood;
    double pvalue = h2temp->Chi2TestX(h1temp,chi2test,ndoftest,igood,"WW");

    cout << "my chi2/ndof (pvalue) = " << chi2 << " / " << ndof
         << " (" << TMath::Prob(chi2,ndof) << ")" << endl;
    cout << "my Chi2TestX (pvalue) = " << chi2test << " / " << ndoftest
         << " (" << TMath::Prob(chi2test,ndoftest) << ")" << endl;
*/
    delete h1temp;
    delete h2temp;

    return chi2;
}

GetCutNames()

std::vector<std::string> DrawingToolsBase::GetCutNames ( const std::string &  sel_name, int  branch = 0  )

inline

[DrawingToolsBase_DumpSteps]

Get a vector of cut names for a given branch (in order) in a selection with a given name

Definition at line 782 of file DrawingToolsBase.hxx.

                                                                            {
    if (sel().GetSelection(sel_name)) return sel().GetSelection(sel_name)->GetCutNames(branch);
    return std::vector<std::string>();
  }

GetEff() [1/2]

double DrawingToolsBase::GetEff	(	TTree *	tree,
		const std::string &	var,
		double	xmin,
		double	xmax,
		const std::string &	cut1,
		const std::string &	cut2,
		const std::string &	root_opt = "",
		const std::string &	opt = ""
	)

Get the efficiency (BayesDivide ratio) of two histograms in which the numerator (cut1+cut2) is a subset of the denominator (cut2). Integrate over "var" between xmin and xmax. This is useful for doing quick optimisation studies, where one can loop over several cut options to see the effect they have.

Definition at line 855 of file DrawingToolsBase.cxx.

                                                                                                            {
//*********************************************************
  double errhigh = 0.;
  double errlow = 0.;
  return GetEff(tree, var, xmin, xmax, errlow, errhigh, cut1, cut2, root_opt, opt);
}

GetEff() [2/2]

double DrawingToolsBase::GetEff	(	TTree *	tree,
		const std::string &	var,
		double	xmin,
		double	xmax,
		double &	errlow,
		double &	errhigh,
		const std::string &	cut1,
		const std::string &	cut2,
		const std::string &	root_opt = "",
		const std::string &	opt = ""
	)

See other GetEff() interface for documentation. In this interface, errlow and errhigh will be filled with the upper and lower errors on the efficiency.

Definition at line 864 of file DrawingToolsBase.cxx.

                                                                                                            {
//*********************************************************

  errlow = 0;
  errhigh = 0;
  //  std::string slevel = GetSameLevel(root_opt);
  int nbins = 1;
  double xbins[2] = {xmin, xmax};

  // Histogram for cut1+cut2 (numerator)
  TH1_h* h1 = GetHisto(tree, "eff1",var,nbins,xbins,(cut1+" && "+cut2), root_opt, opt,1);
  h1->Sumw2();
  // Histogram for cut2 (denominator)
  TH1_h* h2 = GetHisto(tree, "eff2",var,nbins,xbins,cut2, root_opt, opt,1);
  h2->Sumw2();

  // compute the efficiency
  TGraphAsymmErrors* eff = new TGraphAsymmErrors(h1);
  _saved_graphs.push_back(eff);
  eff->Divide(h1, h2, _eff_params.c_str()); //the options are explicitely provided by SetEffDivideParams(const std::string&), root_opt not used to avoid possible confusions 

  if (eff->GetN() != 1) {
    std::cout << "Error computing efficiency" << std::endl;
    return 0;
  }

  errlow = eff->GetEYlow()[0];
  errhigh = eff->GetEYhigh()[0];

  return eff->GetY()[0];
}

GetFillStyle()

int DrawingToolsBase::GetFillStyle ( int  i )

protected

Get the fill style to apply to the i'th histogram in a stack. Depends on whether SetDifferentStackFillStyles() has been called.

Definition at line 2627 of file DrawingToolsBase.cxx.

                                        {
//*********************************************************

  if (_different_fill_styles && i < NAUTOCOLORS) {
    return auto_styles[i];
  } else {
    return _stack_fill_style;
  }
}

GetHistos()

std::vector< TH1* > DrawingToolsBase::GetHistos ( )

inline

Get all the 1D histos that have been drawn. Useful if you want to save them to file. NOTE! The "same" plot may appear multiple times due to the way the comparison histograms are drawn.

Definition at line 862 of file DrawingToolsBase.hxx.

{ return _saved_histos; }

GetLastStackTotal()

TH1* DrawingToolsBase::GetLastStackTotal ( int  nexttolast = 0 )

inline

Get the total from the most recently-drawn stacked histogram. Useful if you want to save it to file.

Definition at line 887 of file DrawingToolsBase.hxx.

                                           {
    std::cout << "If it crashes you should maybe use GetLastHisto instead.\n";
    if ( ! _saved_histoStacks.back()) {
      std::cout << "No histoStacks found. You can try GetLastHisto\n"; return NULL; }
    if (nexttolast>0){
      if ((int)_saved_histoStacks.size() <= nexttolast) {
        return NULL;
      } else {
        HistoStack* s = _saved_histoStacks[(int)_saved_histoStacks.size() - nexttolast - 1];
        return s->GetTotal1D();
      }
    }
    else{
      HistoStack* s = _saved_histoStacks.back();
      return s->GetTotal1D();
    }
  }

GetUniqueName()

std::string DrawingToolsBase::GetUniqueName

(

const std::string &

name

)

Get a unique name for a histogram, to avoid name clashes when drawing on multiple canvases.

Definition at line 2668 of file DrawingToolsBase.cxx.

                                                               {
//*********************************************************
  std::stringstream unique;
  unique << _unique++;
  TString name2 = name;
  name2 = name2.ReplaceAll("(","_");
  name2 = name2.ReplaceAll(")","_");
  return std::string(name2.Data()) + "_" + unique.str();
}

PrintPurities()

void DrawingToolsBase::PrintPurities	(	TTree *	tree,
		const std::string &	categ,
		const std::string &	cut,
		double	events_ratio = 1
	)

Print on the screen the purities for the different categories defined by "categ" and with cuts "cut". The expected number of events are also printed, after scaling by events_ratio.

Definition at line 3215 of file DrawingToolsBase.cxx.

                                                                                                                   {
//*********************************************************

  // Read the categories from the config tree
  ReadCategories(_config_file);

  if (!cat().HasCategory(categ) || categ =="all" ) {
    std::cout << " ------------------------------------------ " << std::endl;
    std::cout << "  Invalid category " << categ << std::endl;
    std::cout << " ------------------------------------------ " << std::endl;
    return;
  }

  int i=0;

  TH1_h *ht = new TH1_h("temp"," ",10,0.,10.);

  std::string cut1 = FormatCut(cut);
  if (tree->FindLeaf("toy_ref"))
    cut1 = cut1 + " && toy_index == toy_ref";

  //  std::string cut1w = "("+cut1+")"+w;
  std::string cut1w = weightTools::ApplyWeights(tree,cut,"");

  tree->Project("temp","1.",cut1w.c_str());

  double TotalEntries = ht->GetSumOfWeights();
  delete ht;


  std::cout << " --------------------------------------------------------" << std::endl;
  std::cout << " Purities: " << std::endl;
  std::cout << "  Category: " << categ << std::endl;
  std::cout << "  Cut:      " << cut << std::endl;
  std::cout << "  Events:   " << std::setprecision(8) << TotalEntries << std::endl;
  std::cout << " --------------------------------------------------------" << std::endl;

  // define stuff to print % on the legend
  std::ostringstream percstr, str_tmp;
  const int ntypes = (const int)cat().GetCategoryTypes(categ).size();
  std::string* cattypes = new std::string[ntypes]; // to initialize with const dimension
  int* catcodes = new int[ntypes]; // to initialize with const dimension
  int* catcolors = new int[ntypes]; // to initialize with const dimension
  int itype=0;

  std::vector<TrackTypeDefinition>::iterator it;
  for (it=cat().GetCategoryTypes(categ).begin();it!=cat().GetCategoryTypes(categ).end();it++, i++){
    std::string type = it->_name;
    std::string code = drawUtils::GetString(it->_code);

    std::string cut2 = cut1+"&&"+categ+"=="+code;

    cut2 = weightTools::ApplyWeights(tree,cut2,"");
    //    cut2 = "("+cut2+")"+w;

    TH1_h *ht1 = new TH1_h("temp1"," ",10,0.,10.);

    tree->Project("temp1","1.",cut2.c_str());

    double caseEntries = ht1->GetSumOfWeights();
    double frac = caseEntries/TotalEntries;
    double nev1 = caseEntries * events_ratio;
    delete ht1;

    std::cout << std::setprecision(8) << std::setw(25) << type << std::setw(12) << frac*100. << " % (" << nev1 << " events)" << std::endl;

    // create categ_temp to print % on the legend
    percstr.str(std::string()); // to clear it
    percstr << std::setprecision(2) << std::fixed << frac*100.; // round to 2 decimal
    str_tmp.str(std::string()); // to clear it
    str_tmp << it->_name << std::setw(8) << percstr.str() << " %"; // tab
    cattypes[itype] = str_tmp.str();
    catcodes[itype] = it->_code;
    catcolors[itype] = it->_color;
    itype++;
  }

  // create categories with % in the name
  bool multi = cat().GetCategory(categ).IsMultiType();
  bool noWarning = true, addNOTRUTH = false, addSAND = false;
  cat().AddCategory(categ+"_withPurities",itype,cattypes,catcodes,catcolors,multi,noWarning,addNOTRUTH,addSAND);

  std::cout << " --------------------------------------------------------" << std::endl;
  std::cout << std::endl;

  return;
}

ReadCategories()

void DrawingToolsBase::ReadCategories ( const std::string &  file )

inline

Read the list of categories stored in the given file which can be used when plotting stacked histograms

Definition at line 705 of file DrawingToolsBase.hxx.

{cat().ReadCategories(file);}

ReadConfig()

void DrawingToolsBase::ReadConfig

(

const std::string &

file

)

[DrawingToolsBase_POT]

Read config tree

Definition at line 248 of file DrawingToolsBase.cxx.

                                                       {
//********************************************************************

  _config_file = file;

  ReadCategories(file);
  ReadSelections(file);
  ReadDocStrings(file);
  ReadCorrections(file);
  ReadSystematics(file);
  ReadConfigurations(file);
  ReadOther(file);
  ND::versioning().ReadVersions(file);

  _configTree_tools.Initialize(file);

}

ReadDocStrings()

void DrawingToolsBase::ReadDocStrings ( const std::string &  file )

inline

[DrawingToolsBase_vars]

Read the details of docstrings from a given file. The details will have been read automatically if you passed the path to a valid highland file in the DrawingTools or DrawingToolsBase constructor.

Definition at line 825 of file DrawingToolsBase.hxx.

                                            {
    //    ReadManager(file,"DocMan", &_docStrings);
    doc().ReadDocStrings(file);
  }

SetAllMCLabel()

void DrawingToolsBase::SetAllMCLabel ( const std::string &  label, Color_t  color = kBlack  )

inline

Set the label for the mc when drawing comparison plots. Defaults to "MC all". Setting it to "" (empty string) will disable adding it to the legend.

Definition at line 519 of file DrawingToolsBase.hxx.

{_allmc_label = label; _allmc_color = color;}

SetAllMCStatLabel()

void DrawingToolsBase::SetAllMCStatLabel ( const std::string &  label )

inline

Set the label for the mc with only statistical errors when drawing comparison plots. Defaults to "MC all (stat)". Setting it to "" (empty string) will disable adding it to the legend.

Definition at line 523 of file DrawingToolsBase.hxx.

{_allmcstat_label=label;}

SetAllMCSystLabel()

void DrawingToolsBase::SetAllMCSystLabel ( const std::string &  label )

inline

Set the label for the mc with only systematic errors when drawing comparison plots. Defaults to "MC all (syst)". Setting it to "" (empty string) will disable adding it to the legend.

Definition at line 527 of file DrawingToolsBase.hxx.

{_allmcstat_label=label;}

SetDataLabel()

void DrawingToolsBase::SetDataLabel ( const std::string &  label, Color_t  color = kBlack  )

inline

Set the label for the data when drawing comparison plots. Defaults to "Data". Setting it to "" (empty string) will disable adding it to the legend.

Definition at line 515 of file DrawingToolsBase.hxx.

{_data_label = label; _data_color = color;}

SetLegendEntryHeight()

void DrawingToolsBase::SetLegendEntryHeight ( double  h )

inline

[DrawingToolsCommandLineOptions]

Set the height (in normalized coordinates: NDC) of each legend entry

Definition at line 420 of file DrawingToolsBase.hxx.

{drawUtils::legendEntryHeight=h;}

SetLegendPos()

void DrawingToolsBase::SetLegendPos	(	double	x = -999,
		double	y = -999
	)

Set legend/small legend position by double (-999 keep current value) or by string ("l"=left, "r"=right , "c"=center, "t"=top, "b"=bottom)

Definition at line 282 of file DrawingToolsBase.cxx.

                                                           {
//*********************************************************

  _legendPosS = "";
  if (posX != -999) _legendPos[0] = posX;
  if (posY != -999) _legendPos[1] = posY;
  SetLegendParam(_legendPos[0],_legendPos[1],_legendPos[0]+_legendSize[0], _legendPos[1]+_legendSize[1]);
}

SetMaxY()

void DrawingToolsBase::SetMaxY ( double  maxY = 0 )

inline

Set the maximum of the Y-axis. By default the maximum is set automatically by the DrawingTools. Call SetMaxY() to revert to the default behaviour.

Definition at line 535 of file DrawingToolsBase.hxx.

{_maxY = maxY;}

SetMinY()

void DrawingToolsBase::SetMinY

(

double

minY = 0

)

Set the minimum of the Y-axis. By default the minimum is set to 0. Call SetMinY() to revert to the default behaviour.

Definition at line 3498 of file DrawingToolsBase.cxx.

                                          {
//*********************************************************

  if (minY<=0 && _logY) {
    std::cout << "Cannot set minimum <= 0 in logY scale!  Call SetLogY(false) before calling SetMinY()!" << std::endl;
    return;
  }
  _minY = minY;
}

SetRangeY()

void DrawingToolsBase::SetRangeY ( double  minY = 0, double  maxY = 0  )

inline

Set the minimum and maximum of the Y-axis. See the documentation of SetMinY and SetMaxY for the default behaviour. Call SetRangeY() to revert to the default behaviour.

Definition at line 539 of file DrawingToolsBase.hxx.

{SetMinY(minY); SetMaxY(maxY);}

StartDocument()

void DrawingToolsBase::StartDocument	(	const std::string &	title,
		bool	pdf = true,
		bool	web = false,
		const std::string &	pdffile = "plots.pdf",
		const std::string &	webpath = "plots"
	)

Start the creation of a PDF document and/or webpage which will contain the plots you make. This makes it particularly easy to share many plots. pdffile is the path to the PDF FILE that will be created webpath is the path to the DIRECTORY in which the webpage and images will be placed.

There are two possible use cases for these functions: draw.StartDocument(...); // Will create a canvas for you draw.Draw(...); // Will draw on the right canvas draw.AddDocumentPage(...); // Will save the current page ... draw.FinishDocument(); // Finish and close

OR

TCanvas canvas(...); // Create your own canvas draw.StartDocument(...); // Won't create a canvas for you draw.Draw(...); // Will draw on your canvas draw.AddDocumentPage(...); // Will save the current page ... draw.FinishDocument(); // Finish and close

In the first case, a canvas was automatically created. This canvas is split into two sections - a header and a body. The header will be populated with the "name" you provide in AddDocumentPage. This makes it easier to understand what each plot is. In the second case, it is assumed you know what you want, so we don't create this header section.

Definition at line 3548 of file DrawingToolsBase.cxx.

                                                                                                                                   {
//*********************************************************
  if (_pdfcanvas) {
    delete _pdfcanvas;
  }
  _pdfpath = "";
  _webpath = "";
  _webheader = "";
  _webbody = "";

  if (web) {
    _webpath = webpath;
    MakeDirectory(_webpath, 0755);
    _webheader += "<html><head><title>" + title + "</title></head><body>\n";
    _webheader += "<h2>" + title + "</h2>\n<ol>\n";
    _webbody += "</ol>\n";
  }
  if (pdf) {
    _pdfpath = pdffile;

    if (!gPad) {
      // User hadn't set up a canvas - create one for them.
      // We split it into 2 sections, so we can save useful info
      // in the small top "header" bit.
      _pdfcanvas = new TCanvas("pdfcanvas", "pdfcanvas", 800, 630);
      _headpad = new TPad("header", "header", 0, 0.95, 1, 1, 0);
      _headpad->SetNumber(1);
      _headpad->Draw();
      _bodypad = new TPad("body", "body", 0, 0, 1, 0.95, 0);
      _bodypad->SetNumber(2);
      _bodypad->Draw();
      _pdfcanvas->Draw();
      _bodypad->cd();
    }

    std::cout << _pdfpath << std::endl;

    gPad->Print((_pdfpath+"[").c_str());
  }
}

---

The documentation for this class was generated from the following files:

• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/highlandTools/v2r10/src/DrawingToolsBase.hxx
• /hep/T2K/nd280rep/ANALYSIS/HIGHLAND2/ANAPARTICLE/highland2/highlandTools/v2r10/src/DrawingToolsBase.cxx