#include <HistoStack.hxx>

Public Member Functions
	HistoStack (const std::string &title, const std::string &titleX, const std::string &titleY)

virtual	~HistoStack ()

bool	Is1D ()
	Tells whether this is a 1D histo.

bool	Is2D ()
	Tells whether this is a 2D histo.

void	Add (TH1_h *h1, int lc, int lw, int fc, int fs, const std::string &leg)
	Add a new 1D histogram to the stack, with fill colour "fc", line colour "lc".

void	Add (TH2_h *h2, int fc, int lc, const std::string &leg="")
	Add a new 2D histogram to the stack, with fill colour "fc", line colour "lc".

void	Draw (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	Draw (const std::string &root_opt="", const std::string &opt="")
	Same as above but with a predefined style.

void	SetTotal (TH1_h *h1)

void	SetTotal (TH2_h *h2)

TH1_h *	GetTotal1D ()
	Return the total 1D histo.

TH1_h *	GetTotalStat1D ()
	Return the total 1D histo with only stat errors.

TH1_h *	GetTotalSyst1D ()
	Return the total 1D histo with only systematic errors.

TH2_h *	GetTotal2D ()
	Return the total 2D histo.

void	AddTotal (TH1_h h1, TH1_h hsyst=NULL)
	Sets the total 1D histo if it does not exists or adds to the previous one when it exists.

void	AddSystHistos (TH2_h h1, TH2_h h2, TH2_h *h1w)
	Add histos for updating systematics when using several files.

void	GetSystHistos (const std::string &group, TH2_h &h1, TH2_h &h2, TH2_h *&h1w)
	Get Histos for updating systematics when using several files.

void	AddSystHistosGroup (const std::string &group)
	Add a new group of systemtic histos.

void	SetCurrentSystGroup (const std::string &group)
	Set the current Systematics group.

const std::string &	GetCurrentSystGroup ()

std::vector< std::string >	GetSystHistosGroups () const
	get the vector of groups of systemtic histos

void	AddTotal (TH2_h *h2)
	Sets the total 2D histo if it does not exists or adds to the previous one when it exists.

void	FillLegend (TLegend *leg)
	Fill the legend with info in the HistoStack.

TH1_h *	GetHisto1D (const std::string &title)
	Returns one of the histos in the 1D stack. The title is used for comparison.

TH1_h *	GetHisto1D (Int_t index)
	Returns the 1D histo with a given index.

TH2_h *	GetHisto2D (const std::string &title)
	Returns one of the histos in the 2D stack. The title is used for comparison.

TH2_h *	GetHisto2D (Int_t index)
	Returns the 2D histo with a given index.

void	Print () const
	Dump the stack contents.

void	NormalizeByArea (const std::string &uopt, double area=1)
	normalize all histos in the stack by area

void	ResetDrawHistos ()
	delete all temporary histos used for drawing the stak (with variable binning normalization)

double	GetMaximum (const std::string &opt="")
	Get the maximum for the HistoStack.

double	GetMaximumWithError (const std::string &opt="")
	Get the maximum for the HistoStack taking into account the upper error.

void	SetMaximum (double max)
	Set the maximum for the HistoStack.

void	SetMinimum (double min)
	Set the minimum for the HistoStack.

Protected Attributes
std::vector< TH1_h * >	_histos1D
	The TH1_hs that were added to the stack.

std::vector< TH1_h * >	_histos1D_draw
	The TH1_hs that were added to the stack. Temporary histos used for drawing the stack (with variable binning normalization)

std::vector< TH2_h * >	_histos2D
	The TH2_hs that were added to the stack.

THStack *	_stack
	The root stack.

TH1_h *	_hall1D

TH1_h *	_hall1D_stat
	The "total" 1D histogram with only stat errors.

TH1_h *	_hall1D_syst
	The "total" 1D histogram with only systematic errors.

TH1_h *	_hall1D_draw
	temporary histo used for drawing the total (with variable binning normalization)

TH2_h *	_hall2D

std::string	_title
	The title of the plot.

std::string	_titleX
	The title of the X axis.

std::string	_titleY
	The title of the Y axis.

bool	_is1D
	is it 1D ?

bool	_is2D
	is it 2D ?

std::vector< std::string >	_systHistosGroups
	Histos for updating systematics when using several files.

std::string	_currentSystGroup

std::map< std::string, TH2_h * >	_h1

std::map< std::string, TH2_h * >	_h1w

std::map< std::string, TH2_h * >	_h2

Detailed Description

This class is used by the DrawingTools and DrawingToolsBase classes to aid the creation of stacked histograms.

The stacked histograms are created based on track categories (for example, "particle") and track types within those categories (for example, "muon" and "electron"). The track categories are from the TrackCategoryDefinition class, and the types from the TrackTypeDefinition class.

The underlying implementation does not use a THStack, but overlaid histograms. This means we the same logic can be used to stack both TH1 and TH2 histograms.

Definition at line 25 of file HistoStack.hxx.

Constructor & Destructor Documentation

§ HistoStack()

HistoStack::HistoStack	(	const std::string &	title,
		const std::string &	titleX,
		const std::string &	titleY
	)

Instantiate the object, setting the title of the plot, the X axis, and the Y axis.

Definition at line 6 of file HistoStack.cxx.

                                                                                                {
 //*******************************************************
 
   _title = title;
   _titleX = titleX;
   _titleY = titleY;
 
   _hall1D = NULL;
   _hall2D = NULL;
 
   _hall1D_stat = NULL;
   _hall1D_syst = NULL;
 
   _is1D = false;
   _is2D = false;
 
   _stack = NULL;
   _hall1D_draw = NULL;
 
   //  _h1 = _h2 = _h1w = NULL;
 
   _systHistosGroups.clear();
 
   _currentSystGroup ="default";
 
 }

§ ~HistoStack()

HistoStack::~HistoStack ( )

virtual

Destructor, which cleans up the cumulative histograms used internally by the class. The user should delete the histograms that were added to the stack.

Definition at line 34 of file HistoStack.cxx.

                         {
 //*******************************************************
 
   if (_hall1D) delete _hall1D;
   if (_hall2D) delete _hall2D;
 
   if (_hall1D_syst) delete _hall1D_syst;
   if (_hall1D_stat) delete _hall1D_stat;
 
   std::map<std::string, TH1_h*>::iterator itm1;
   std::map<std::string, TH2_h*>::iterator itm2;
   for (itm2 = _h1.begin(); itm2 != _h1.end(); itm2++)
     if (itm2->second) delete itm2->second;
   _h1.clear();
 
   for (itm2 = _h2.begin(); itm2 != _h2.end(); itm2++)
     if (itm2->second) delete itm2->second;
   _h2.clear();
 
   for (itm2 = _h1w.begin(); itm2 != _h1w.end(); itm2++)
     if (itm2->second) delete itm2->second;
   _h1w.clear();
 
   _systHistosGroups.clear();
 
   std::vector<TH1_h*>::iterator it1;
   for (it1 = _histos1D.begin(); it1 != _histos1D.end(); it1++) delete *it1;
   _histos1D.clear();
 
   std::vector<TH2_h*>::iterator it2;
   for (it2 = _histos2D.begin(); it2 != _histos2D.end(); it2++) delete *it2;
   _histos2D.clear();
 
   // delete also the histograms created for drawing
   ResetDrawHistos();
 }

Member Function Documentation

§ Draw()

void HistoStack::Draw	(	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`
	)

Draw the stack of histograms that have been added. If "root_opt" contains "same", then the current active pad is re-used. If "opt" contains "ETOT", then error bars are drawn on the total stack.

Definition at line 148 of file HistoStack.cxx.

                                                                                                                                        {
 //*******************************************************
 
   (void)leg_opt;
   (void)mode;
 
   // Delete all histos used for drawing the stack, just in case this stack was drawn before 
   ResetDrawHistos();
 
   if (_is1D) {
     bool makeTotal = (!_hall1D);
 
     std::vector<TH1_h*>::reverse_iterator rit1;
     int i = 0;
     for (rit1 = _histos1D.rbegin(); rit1 != _histos1D.rend(); rit1++, i++) {
       TH1_h* ht = *rit1;
 
       if (makeTotal) {
         if (i == 0) {
           _hall1D = new TH1_h(*ht);
           _hall1D->SetName((std::string(ht->GetName()) + "_cum").c_str());
           _hall1D->SetTitle(ht->GetTitle());
         } else {
           _hall1D->Add(_hall1D, ht);
         }
       }
       if (i == 0) {
         if (_stack) delete _stack;
         _stack = new THStack((std::string(ht->GetName()) + "_stack").c_str(), _title.c_str());
       }
     }
 
     // Copy the histogram before normalizing
     _hall1D_draw = new TH1_h(*_hall1D);
     Double_t min_width;
     drawUtils::NormalizeVariableBinning(_hall1D_draw,2,opt, min_width);
 
     for (rit1 = _histos1D.rbegin(); rit1 != _histos1D.rend(); rit1++) {
       TH1_h* ht = *rit1;
       // Clone the histograms before normalizing
       TH1_h* htp = new TH1_h(*ht);
       _histos1D_draw.push_back(htp);
       drawUtils::NormalizeVariableBinning(htp,2,opt+" USEMINWIDTH",min_width);
       // Add the normalized histo to the stack
       _stack->Add(htp);
     }
 
 
     // Set the maximum and minimum Y
     //    double maxy = _hall1D_draw->GetBinContent(_hall1D_draw->GetMaximumBin()) * 1.1;
     //    if (_stack && opt.find("ETOT")) {
     //      maxy += _hall1D_draw->GetBinError(_hall1D_draw->GetMaximumBin()) * 1.1;
     //    }    
 
     //    if (fabs(usermaxY) > 1e-6 && usermaxY > userminY) {
     //      maxy = usermaxY;
     //    }
     //    double miny = userminY;
 
     // If the stack is pressent (colore drawing) just draw it
     if (_stack){
       if (root_opt.find("same") == std::string::npos) {
         _stack->Draw(("HIST"+root_opt).c_str());
         _stack->GetXaxis()->SetTitle(_titleX.c_str());
         _stack->GetYaxis()->SetTitle(_titleY.c_str());
         _stack->Draw(("HIST"+root_opt).c_str());
       } else {
         _stack->Draw("HIST same");
       }
     }
 
     // This is just to draw the stats box before doing the variable bin normalization
     _hall1D->GetXaxis()->SetTitle(_titleX.c_str());
     _hall1D->GetYaxis()->SetTitle(_titleY.c_str());
     _hall1D->SetTitle(_title.c_str());
 
 
     if (_stack)
       _hall1D->Draw((root_opt+"sames AXIS").c_str());
     else
       _hall1D->Draw((root_opt+"AXIS").c_str());
 
     
     // Style for the total histo in the case it has to be drawn
     _hall1D_draw->SetLineColor(lc);
     _hall1D_draw->SetMarkerColor(lc);
     _hall1D_draw->SetLineWidth(lw);
     _hall1D_draw->SetFillColor(fc);
     _hall1D_draw->SetFillStyle(fs);
 
     // Draw error bars for the total stack when requested
     if (_stack && drawUtils::CheckOption(opt, "ETOT")) {
       _hall1D_draw->Draw("same e2");
     }
     // Draw the total when there is no stack
     if (!_stack){
       _hall1D_draw->SetMarkerStyle(20);
       _hall1D_draw->SetMarkerSize(1);
       _hall1D_draw->Draw((root_opt+"same").c_str());
 
       if (_hall1D_stat){
         _hall1D_stat->SetLineColor(4);
         _hall1D_stat->SetFillColor(4);
         _hall1D_stat->Draw((root_opt+"same").c_str());
       }
     }
 
   } else if (_is2D) {
     bool makeTotal = (!_hall2D);
 
     std::vector<TH2_h*>::reverse_iterator rit1;
     int i = 0;
     for (rit1 = _histos2D.rbegin(); rit1 != _histos2D.rend(); rit1++, i++) {
       TH2_h* ht = *rit1;
 
       if (makeTotal) {
         if (i == 0) {
           _hall2D = new TH2_h(*ht);
           _hall2D->SetName((std::string(ht->GetName()) + "_cum").c_str());
           _hall2D->SetTitle(ht->GetTitle());
         } else {
           _hall2D->Add(_hall2D, ht);
         }
       }
       if (i == 0) {
         if (_stack) delete _stack;
         _stack = new THStack((std::string(ht->GetName()) + "_stack").c_str(), _title.c_str());
       }
       _stack->Add(ht);
 
     }
 
 
     // Style for the total histo in the case it has to be drawn
     _hall2D->SetLineColor(lc);
     _hall2D->SetMarkerColor(lc);
     _hall2D->SetLineWidth(lw);
     _hall2D->SetFillColor(fc);
     _hall2D->SetFillStyle(fs);
 
     if (_stack){
       if (root_opt.find("same") == std::string::npos) {
         _stack->Draw(("HIST "+root_opt).c_str());
         _stack->GetXaxis()->SetTitle(_titleX.c_str());
         _stack->GetYaxis()->SetTitle(_titleY.c_str());
         _stack->Draw(("HIST "+root_opt).c_str());
       } else {
         _stack->Draw("HIST same");
       }
     }
     else{
       _hall2D->Draw(root_opt.c_str());
     }
   }
 
 }

§ SetTotal() [1/2]

void HistoStack::SetTotal ( TH1_h * h1 )

inline

The total histogram is normally the sum of all the histograms that were added to the stack. This can be overriden (before calling Draw()).

Definition at line 60 of file HistoStack.hxx.

60 { _hall1D = h1; }

HistoStack::_hall1D

TH1_h * _hall1D

Definition: HistoStack.hxx:154

§ SetTotal() [2/2]

void HistoStack::SetTotal ( TH2_h * h2 )

inline

The total histogram is normally the sum of all the histograms that were added to the stack. This can be overriden (before calling Draw()).

Definition at line 64 of file HistoStack.hxx.

64 { _hall2D = h2; }

HistoStack::_hall2D

TH2_h * _hall2D

Definition: HistoStack.hxx:167

Member Data Documentation

§ _hall1D

TH1_h* HistoStack::_hall1D

protected

The "total" 1D histogram. Nominally the sum of all the stacked histograms, but can be set by the user.

Definition at line 154 of file HistoStack.hxx.

§ _hall2D

TH2_h* HistoStack::_hall2D