UserCode/mschen/PlotUtilities_standalone.h

#ifndef  PLOTUTILITIES_H
#define  PLOTUTILITIES_H
#include <TString.h>
#include <string>
#include <TPaveText.h>
#include <TLegend.h>
#include <TGraph.h>
#include <TGraphErrors.h>
#include <TGraphAsymmErrors.h>
#include <TH1F.h>
#include <TF1.h>
#include <TFile.h>
#include <TSystem.h>
#include <TObject.h>
#include <TROOT.h>
#include <TCanvas.h>
#include <TArrow.h>
#include <TTree.h>

using namespace std;

void DrawCMS(string cms="CMS Preliminary", double x1=0.7, double y1=0.9, double x2=0.8, double y2=1.0, double txtsize=0.05); //FIXME: don't do this inside class
TPaveText* SetTPaveText       (Double_t           x1,
                Double_t           y1,
                Double_t           x2,
                Double_t           y2);
TLegend*   DrawLegend         (Float_t            x1,
                Float_t            y1,
                TH1F*              hist,
                TString            label,
                TString            option,
                Float_t            tsize   = 0.04,
                Float_t            xoffset = 0.25,
                Float_t            yoffset = 0.15);
TLegend*   DrawLegend         (Float_t            x1,
                Float_t            y1,
                TGraph*              hist,
                TString            label,
                TString            option,
                Float_t            tsize   = 0.04,
                Float_t            xoffset = 0.25,
                Float_t            yoffset = 0.15);
void MoveLegend(TLegend *leg, Float_t x1, 
        Float_t y1, Float_t xoffset=0.25, Float_t yoffset=0.15);
void Save(TCanvas *cCanvas, string _ssave);
void DrawText(double x1, double y1, double x2, double y2, TString text, double size = 0.045);
class PlotWithBelts{
        public:
                PlotWithBelts()
                        :cCanvas(NULL),legend(NULL),pt(NULL),gGreen(NULL),
                        gYellow(NULL),lineOne(NULL),gr(NULL),
                        grobs(NULL),ptCMSPreli(NULL)
                {};
                ~PlotWithBelts();
                PlotWithBelts(
                                double *r1sigLt, double *r1sigHt, 
                                double *r2sigLt, double *r2sigHt, 
                                double *rmeant,  int npointst,  
                                double *xpointst, string ssavetmp, TPaveText *pttmp,
                                double xmintmp =100, double xmaxtmp =260, double ymintmp=0.5, double ymaxtmp=100, bool logYtmp=true,
                                string stitlet ="; Higgs mass, m_{H} (GeV/c^{2}); Exclusion Limit, r = #sigma_{95%}/#sigma_{SM}");
                PlotWithBelts(
                                double *r1sigLt, double *r1sigHt, 
                                double *r2sigLt, double *r2sigHt, 
                                double *rmeant,  double *robst, int npointst,  
                                double *xpointst, string ssavetmp, TPaveText *pttmp,
                                double xmintmp =100, double xmaxtmp =260, double ymintmp=0.5, double ymaxtmp=100, bool logYtmp=true,
                                string stitlet ="; Higgs mass, m_{H} (GeV/c^{2}); Exclusion Limit, r = #sigma_{95%}/#sigma_{SM}");
                TGraph *getGreenGraph(){return gGreen;};
                TGraph *getYellowGraph(){return gYellow;};
                TGraph *getMeanGraph(){return gr;};
                TGraph *getObsGraph(){return grobs;};
                TLine *getLine(){return lineOne;};
                TPaveText *getTitlePT(){return pt;};
                TPaveText *getCMSPT(){return ptCMSPreli;};

                TCanvas *getCanvas(){return cCanvas;};
                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){ssave=tmp;};
                void drawLegend(string s_gr, string s_gGreen, string s_gYellow, string s_grobs="");
                void plot();
                void save();
                void clear();

                TH1F * getFrame(){return hframe;};

        private:
                TCanvas *cCanvas;
                TLegend *legend;
                bool logY;
                string stitle;
                string ssave;

                double xmin, xmax, ymin, ymax;
                TPaveText *pt;
                TGraph *gGreen;
                TGraph *gYellow;
                TLine *lineOne;
                TGraph *gr;
                TGraph *grobs;
                TPaveText *ptCMSPreli;

                int bDrawGrobs;
                double *r1sigL, *r1sigH, *r2sigL, *r2sigH, *rmean, *robs, *xpoints;
                int npoints;


                TH1F* hframe;

};
class DrawSigBkgPdfs{
        public:
                DrawSigBkgPdfs(double (*pdfs)(double *, double *), double *pars, int npars,
                        double (*pdfb)(double *, double *), double *parb, int nparb, double Ns, double Nb,
                                double xstart, double xstop, bool logY, string ssave, string stitle, bool debug=0);
                ~DrawSigBkgPdfs();
                void draw();
                void save();
                TCanvas *getCanvas(){return cCanvas;};
                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                void drawLegend(string s_tot, string s_s, string s_b);
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};

                TH1F *getHistS(){return hs;};
                TH1F *getHistB(){return hb;};
                TH1F *getHistTot(){return htot;};
                TF1 *getTf1S(){return fs;};
                TF1 *getTf1B(){return fb;};
        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;

                TF1 *fs;
                TF1 *fb;
                double (*_pdfs)(double *x, double *par); // normalized to unity
                double (*_pdfb)(double *x, double *par); // normalized to unity
                double *_pars;
                double *_parb;
                int _npars, _nparb;
                double _Ns, _Nb;                
                double _xstart, _xstop;
                TH1F *hs, *hb, *htot;
};
class DrawEvolution2D{
        public:
                DrawEvolution2D(vector<double> vx, vector<double> vy, string stitle, string ssave, TPaveText *pt, bool debug=0);
                ~DrawEvolution2D();

                void draw();
                void save();
                TCanvas *getCanvas(){return cCanvas;};
                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                //void drawLegend(string s_tot, string s_s, string s_b){};
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};
                TPaveText *getTitlePT(){return _pt;};
                TGraph *getGraph(){return graph;};
                TLine *getLine(){return lineOne;};
        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;
                TPaveText *_pt;

                vector<double> _vx, _vy;

                TLine *lineOne;
                TGraph *graph;
};
class PlotXvsCummulativeProb{
        public:
                PlotXvsCummulativeProb(
                                double* vx_not_sorted, int nexps,
                                string ssave, string stitle,TPaveText *pt);
                PlotXvsCummulativeProb(
                                vector<double> vx_not_sorted,
                                string ssave, string stitle,TPaveText *pt);
                PlotXvsCummulativeProb(
                                vector<double> vx_sorted,
                                vector<double> vcumulaP_sorted,
                                double m1s, double p1s, double m2s, double p2s,
                                string ssave, string stitle,TPaveText *pt);
                ~PlotXvsCummulativeProb();
                void draw();
                void save();
                TCanvas *getCanvas(){return cCanvas;};
                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                //void drawLegend(string s_tot, string s_s, string s_b){};
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};
                TPaveText *getTitlePT(){return _pt;};
                TGraphErrors *getGraph(){return graph;};
                TLine *getLine(){return lineOne;};
                TH1F *getDifferencialHist(){return diffHist;};
                void setGraphDrawOption(string so){_graphOption=so;};

                // --- to show the error bar of bins
                void setTotalExps(int nexps){_nexps=nexps;};
                void setShowErrorBar(bool b){bShowErrorBar=b;}

                void drawDifferencial(string stitle, string ssave);

        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;
                TPaveText *_pt;

                vector<double> _vx, _vy;

                TLine *lineOne;
                TGraphErrors *graph;
                TH1F *diffHist;

                double _1SigmaLow, _1SigmaHigh, _2SigmaLow, _2SigmaHigh;

                bool bShowErrorBar;
                int _nexps;
        
                string _graphOption;    
};
class DrawPdfM2logQ{
        public:
                DrawPdfM2logQ(vector<double> vPdfM2logQ_sb, vector<double> vPdfM2logQ_b, 
                                double m2lnQ_d, string sdata, string stitle, string ssave, TPaveText *pt); // show the famous -2lnQ with s, b, d
                DrawPdfM2logQ(vector< pair<double,double> > vPdfM2logQ_sb, vector< pair<double,double> > vPdfM2logQ_b, 
                                double m2lnQ_d, string sdata, string stitle, string ssave, TPaveText *pt); // show the famous -2lnQ with s, b, d
                ~DrawPdfM2logQ();
                void draw(); void draw2Hist(); void draw2Graph();
                TCanvas *getCanvas(){return cCanvas;};
                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                void drawLegend(string s_sb, string s_b, string s_d);
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};
                TPaveText *getTitlePT(){return _pt;};
                TLine *getLine(){return lineOne;};
                TGraph *getSignalGraph(){return gSB;};
                TGraph *getBackgroundGraph(){return gB;};
                TH1F *getSignalHist(){return hSB;};
                TH1F *getBackgroundHist(){return hB;};
        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;
                TPaveText *_pt;
                TLine *lineOne;

                TGraph *gSB, *gB;
                TH1F *hSB, *hB;

                string _lineTitle; 
                double _m2lnQ_d;
                vector<double> _vsb, _vb; //inputs from pseudo experiments
                vector< pair<double,double> > _vpsb, _vpb; // inputs from analytic formula
                // tag the inputs are _vsb or _vpsb 
                bool bFromPseudoExps;
};

const int maxNumGraphs=10;
const int _glineStyle[maxNumGraphs]={2,2,8,8,1,1, 1,1,1,1};
const int _glineColor[maxNumGraphs]={4,2,6,1,5,3, 3, 3, 3, 3};
const int _gmarkerStyle[maxNumGraphs]={20,24,3,26,22,23, 23,23,23,23};
class DrawMultiGraph{
        public:
                DrawMultiGraph(double *x1, double *y1, int n1, string title1,
                                string stitle, string ssave, TPaveText *pt,
                                double xmin, double xmax, double ymin, double ymax, bool logY);
                DrawMultiGraph(double *x1, double *y1, int n1, string title1,
                                double *x2, double *y2, int n2, string title2, string stitle, string ssave, TPaveText *pt,
                                double xmin, double xmax, double ymin, double ymax, bool logY);
                ~DrawMultiGraph();
                void add(double *x, double *y, int n, string title);
                void draw();
                TGraph* getGraph(int i){if(i<maxNumGraphs && i>=0) return _gr[i];else return 0;};

                TLegend *getLegend(){
                        //cout<<"delete me2 legendY2="<<legend->GetY2()<<endl;
                return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                //void drawLegend(string s_sb, string s_b, string s_d);
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};
                TPaveText *getTitlePT(){return _pt;};
                TLine *getLine(){return lineOne;};
                TCanvas *getCanvas(){return cCanvas;};
                void drawOption(int i, string op){if(i<maxNumGraphs && i>=0)_drawOptions[i]=op;};
                void setLegendXY(double x, double y){legendX=x; legendY=y;};
                //void save();
        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;
                TPaveText *_pt;
                TLine *lineOne;

                TGraph *_gr[maxNumGraphs];//currenly limit to maxNumGraphs graphs..
                int _numGraphAdded;
                double *_x[maxNumGraphs], *_y[maxNumGraphs];
                int _n[maxNumGraphs];
                string _title[maxNumGraphs];
                double _xmin,_xmax,_ymin,_ymax;
                string _drawOptions[maxNumGraphs];
                double legendX, legendY;
};
class DrawPdfRLikelihood{
        public:
                DrawPdfRLikelihood(double r95, double *par, int npar, string stitle, string ssave, TPaveText *pt);
                ~DrawPdfRLikelihood();
                void draw();
                TH1F* getHist(){return hist;};

                TLegend *getLegend(){return legend;};
                void setSavePath(string tmp){_ssave=tmp;};
                //void drawLegend(string s_hist, string s_arrow){};
                void setLogY(bool b){_logY=b;};
                void setDebug(bool b){_debug=b;};
                TPaveText *getTitlePT(){return _pt;};
                TArrow *getArrow(){return arrow;};
                
        private:
                TCanvas *cCanvas;
                string _ssave;
                string _stitle;
                bool _logY;
                TLegend *legend;
                bool _debug;
                TPaveText *_pt;
                TArrow *arrow;
                TH1F *hist;
                bool _bUnbinned;
                double _r95;
                double *_par;
                int _npar;
};
void GetMuHat(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits );
void GetMuHat(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits , vector<double> & inputLimitErrsUp, vector<double>& inputLimitErrsDn );
void GetLimits(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitErrs );
void GetPValues(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitErrs_m2s, vector<double> & inputLimitErrs_m1s, vector<double>&inputLimitErrs_p1s, vector<double>&inputLimitErrs_p2s );
void GetLimitBands(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitsM2S, vector<double>& inputLimitsM1S, 
                vector<double>& inputLimitsMEDIAN, vector<double>& inputLimitsP1S, vector<double>& inputLimitsP2S);     
TGraph* GetBeltGraph(const vector<double>& xpoints, const vector<double>& vup, const vector<double> & vdn);

TGraph* GetMuHatGraph(TTree *tree );
TGraphAsymmErrors* GetMuHatGraphAsymm(TTree *tree );
TGraph* GetLimitsGraph(TTree *tree );
TGraph* GetPValuesGraph(TTree *tree );
TObject* GetTObject(string filename, string objname);
#endif   /* ----- #ifndef PLOTUTILITIES_H  ----- */
Revision:	1.1
Committed:	Tue Sep 4 15:58:08 2012 UTC (12 years, 7 months ago) by mschen
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	for plotting
#	User	Rev	Content
1	mschen	1.1	#ifndef PLOTUTILITIES_H
2			#define PLOTUTILITIES_H
3			#include <TString.h>
4			#include <string>
5			#include <TPaveText.h>
6			#include <TLegend.h>
7			#include <TGraph.h>
8			#include <TGraphErrors.h>
9			#include <TGraphAsymmErrors.h>
10			#include <TH1F.h>
11			#include <TF1.h>
12			#include <TFile.h>
13			#include <TSystem.h>
14			#include <TObject.h>
15			#include <TROOT.h>
16			#include <TCanvas.h>
17			#include <TArrow.h>
18			#include <TTree.h>
19
20			using namespace std;
21
22			void DrawCMS(string cms="CMS Preliminary", double x1=0.7, double y1=0.9, double x2=0.8, double y2=1.0, double txtsize=0.05); //FIXME: don't do this inside class
23			TPaveText* SetTPaveText (Double_t x1,
24			Double_t y1,
25			Double_t x2,
26			Double_t y2);
27			TLegend* DrawLegend (Float_t x1,
28			Float_t y1,
29			TH1F* hist,
30			TString label,
31			TString option,
32			Float_t tsize = 0.04,
33			Float_t xoffset = 0.25,
34			Float_t yoffset = 0.15);
35			TLegend* DrawLegend (Float_t x1,
36			Float_t y1,
37			TGraph* hist,
38			TString label,
39			TString option,
40			Float_t tsize = 0.04,
41			Float_t xoffset = 0.25,
42			Float_t yoffset = 0.15);
43			void MoveLegend(TLegend *leg, Float_t x1,
44			Float_t y1, Float_t xoffset=0.25, Float_t yoffset=0.15);
45			void Save(TCanvas *cCanvas, string _ssave);
46			void DrawText(double x1, double y1, double x2, double y2, TString text, double size = 0.045);
47			class PlotWithBelts{
48			public:
49			PlotWithBelts()
50			:cCanvas(NULL),legend(NULL),pt(NULL),gGreen(NULL),
51			gYellow(NULL),lineOne(NULL),gr(NULL),
52			grobs(NULL),ptCMSPreli(NULL)
53			{};
54			~PlotWithBelts();
55			PlotWithBelts(
56			double r1sigLt, double r1sigHt,
57			double r2sigLt, double r2sigHt,
58			double *rmeant, int npointst,
59			double xpointst, string ssavetmp, TPaveText pttmp,
60			double xmintmp =100, double xmaxtmp =260, double ymintmp=0.5, double ymaxtmp=100, bool logYtmp=true,
61			string stitlet ="; Higgs mass, m_{H} (GeV/c^{2}); Exclusion Limit, r = #sigma_{95%}/#sigma_{SM}");
62			PlotWithBelts(
63			double r1sigLt, double r1sigHt,
64			double r2sigLt, double r2sigHt,
65			double rmeant, double robst, int npointst,
66			double xpointst, string ssavetmp, TPaveText pttmp,
67			double xmintmp =100, double xmaxtmp =260, double ymintmp=0.5, double ymaxtmp=100, bool logYtmp=true,
68			string stitlet ="; Higgs mass, m_{H} (GeV/c^{2}); Exclusion Limit, r = #sigma_{95%}/#sigma_{SM}");
69			TGraph *getGreenGraph(){return gGreen;};
70			TGraph *getYellowGraph(){return gYellow;};
71			TGraph *getMeanGraph(){return gr;};
72			TGraph *getObsGraph(){return grobs;};
73			TLine *getLine(){return lineOne;};
74			TPaveText *getTitlePT(){return pt;};
75			TPaveText *getCMSPT(){return ptCMSPreli;};
76
77			TCanvas *getCanvas(){return cCanvas;};
78			TLegend *getLegend(){return legend;};
79			void setSavePath(string tmp){ssave=tmp;};
80			void drawLegend(string s_gr, string s_gGreen, string s_gYellow, string s_grobs="");
81			void plot();
82			void save();
83			void clear();
84
85			TH1F * getFrame(){return hframe;};
86
87			private:
88			TCanvas *cCanvas;
89			TLegend *legend;
90			bool logY;
91			string stitle;
92			string ssave;
93
94			double xmin, xmax, ymin, ymax;
95			TPaveText *pt;
96			TGraph *gGreen;
97			TGraph *gYellow;
98			TLine *lineOne;
99			TGraph *gr;
100			TGraph *grobs;
101			TPaveText *ptCMSPreli;
102
103			int bDrawGrobs;
104			double r1sigL, r1sigH, r2sigL, r2sigH, rmean, robs, *xpoints;
105			int npoints;
106
107
108			TH1F* hframe;
109
110			};
111			class DrawSigBkgPdfs{
112			public:
113			DrawSigBkgPdfs(double (pdfs)(double , double ), double pars, int npars,
114			double (pdfb)(double , double ), double parb, int nparb, double Ns, double Nb,
115			double xstart, double xstop, bool logY, string ssave, string stitle, bool debug=0);
116			~DrawSigBkgPdfs();
117			void draw();
118			void save();
119			TCanvas *getCanvas(){return cCanvas;};
120			TLegend *getLegend(){return legend;};
121			void setSavePath(string tmp){_ssave=tmp;};
122			void drawLegend(string s_tot, string s_s, string s_b);
123			void setLogY(bool b){_logY=b;};
124			void setDebug(bool b){_debug=b;};
125
126			TH1F *getHistS(){return hs;};
127			TH1F *getHistB(){return hb;};
128			TH1F *getHistTot(){return htot;};
129			TF1 *getTf1S(){return fs;};
130			TF1 *getTf1B(){return fb;};
131			private:
132			TCanvas *cCanvas;
133			string _ssave;
134			string _stitle;
135			bool _logY;
136			TLegend *legend;
137			bool _debug;
138
139			TF1 *fs;
140			TF1 *fb;
141			double (_pdfs)(double x, double *par); // normalized to unity
142			double (_pdfb)(double x, double *par); // normalized to unity
143			double *_pars;
144			double *_parb;
145			int _npars, _nparb;
146			double _Ns, _Nb;
147			double _xstart, _xstop;
148			TH1F hs, hb, *htot;
149			};
150			class DrawEvolution2D{
151			public:
152			DrawEvolution2D(vector<double> vx, vector<double> vy, string stitle, string ssave, TPaveText *pt, bool debug=0);
153			~DrawEvolution2D();
154
155			void draw();
156			void save();
157			TCanvas *getCanvas(){return cCanvas;};
158			TLegend *getLegend(){return legend;};
159			void setSavePath(string tmp){_ssave=tmp;};
160			//void drawLegend(string s_tot, string s_s, string s_b){};
161			void setLogY(bool b){_logY=b;};
162			void setDebug(bool b){_debug=b;};
163			TPaveText *getTitlePT(){return _pt;};
164			TGraph *getGraph(){return graph;};
165			TLine *getLine(){return lineOne;};
166			private:
167			TCanvas *cCanvas;
168			string _ssave;
169			string _stitle;
170			bool _logY;
171			TLegend *legend;
172			bool _debug;
173			TPaveText *_pt;
174
175			vector<double> _vx, _vy;
176
177			TLine *lineOne;
178			TGraph *graph;
179			};
180			class PlotXvsCummulativeProb{
181			public:
182			PlotXvsCummulativeProb(
183			double* vx_not_sorted, int nexps,
184			string ssave, string stitle,TPaveText *pt);
185			PlotXvsCummulativeProb(
186			vector<double> vx_not_sorted,
187			string ssave, string stitle,TPaveText *pt);
188			PlotXvsCummulativeProb(
189			vector<double> vx_sorted,
190			vector<double> vcumulaP_sorted,
191			double m1s, double p1s, double m2s, double p2s,
192			string ssave, string stitle,TPaveText *pt);
193			~PlotXvsCummulativeProb();
194			void draw();
195			void save();
196			TCanvas *getCanvas(){return cCanvas;};
197			TLegend *getLegend(){return legend;};
198			void setSavePath(string tmp){_ssave=tmp;};
199			//void drawLegend(string s_tot, string s_s, string s_b){};
200			void setLogY(bool b){_logY=b;};
201			void setDebug(bool b){_debug=b;};
202			TPaveText *getTitlePT(){return _pt;};
203			TGraphErrors *getGraph(){return graph;};
204			TLine *getLine(){return lineOne;};
205			TH1F *getDifferencialHist(){return diffHist;};
206			void setGraphDrawOption(string so){_graphOption=so;};
207
208			// --- to show the error bar of bins
209			void setTotalExps(int nexps){_nexps=nexps;};
210			void setShowErrorBar(bool b){bShowErrorBar=b;}
211
212			void drawDifferencial(string stitle, string ssave);
213
214			private:
215			TCanvas *cCanvas;
216			string _ssave;
217			string _stitle;
218			bool _logY;
219			TLegend *legend;
220			bool _debug;
221			TPaveText *_pt;
222
223			vector<double> _vx, _vy;
224
225			TLine *lineOne;
226			TGraphErrors *graph;
227			TH1F *diffHist;
228
229			double _1SigmaLow, _1SigmaHigh, _2SigmaLow, _2SigmaHigh;
230
231			bool bShowErrorBar;
232			int _nexps;
233
234			string _graphOption;
235			};
236			class DrawPdfM2logQ{
237			public:
238			DrawPdfM2logQ(vector<double> vPdfM2logQ_sb, vector<double> vPdfM2logQ_b,
239			double m2lnQ_d, string sdata, string stitle, string ssave, TPaveText *pt); // show the famous -2lnQ with s, b, d
240			DrawPdfM2logQ(vector< pair<double,double> > vPdfM2logQ_sb, vector< pair<double,double> > vPdfM2logQ_b,
241			double m2lnQ_d, string sdata, string stitle, string ssave, TPaveText *pt); // show the famous -2lnQ with s, b, d
242			~DrawPdfM2logQ();
243			void draw(); void draw2Hist(); void draw2Graph();
244			TCanvas *getCanvas(){return cCanvas;};
245			TLegend *getLegend(){return legend;};
246			void setSavePath(string tmp){_ssave=tmp;};
247			void drawLegend(string s_sb, string s_b, string s_d);
248			void setLogY(bool b){_logY=b;};
249			void setDebug(bool b){_debug=b;};
250			TPaveText *getTitlePT(){return _pt;};
251			TLine *getLine(){return lineOne;};
252			TGraph *getSignalGraph(){return gSB;};
253			TGraph *getBackgroundGraph(){return gB;};
254			TH1F *getSignalHist(){return hSB;};
255			TH1F *getBackgroundHist(){return hB;};
256			private:
257			TCanvas *cCanvas;
258			string _ssave;
259			string _stitle;
260			bool _logY;
261			TLegend *legend;
262			bool _debug;
263			TPaveText *_pt;
264			TLine *lineOne;
265
266			TGraph gSB, gB;
267			TH1F hSB, hB;
268
269			string _lineTitle;
270			double _m2lnQ_d;
271			vector<double> _vsb, _vb; //inputs from pseudo experiments
272			vector< pair<double,double> > _vpsb, _vpb; // inputs from analytic formula
273			// tag the inputs are _vsb or _vpsb
274			bool bFromPseudoExps;
275			};
276
277			const int maxNumGraphs=10;
278			const int _glineStyle[maxNumGraphs]={2,2,8,8,1,1, 1,1,1,1};
279			const int _glineColor[maxNumGraphs]={4,2,6,1,5,3, 3, 3, 3, 3};
280			const int _gmarkerStyle[maxNumGraphs]={20,24,3,26,22,23, 23,23,23,23};
281			class DrawMultiGraph{
282			public:
283			DrawMultiGraph(double x1, double y1, int n1, string title1,
284			string stitle, string ssave, TPaveText *pt,
285			double xmin, double xmax, double ymin, double ymax, bool logY);
286			DrawMultiGraph(double x1, double y1, int n1, string title1,
287			double x2, double y2, int n2, string title2, string stitle, string ssave, TPaveText *pt,
288			double xmin, double xmax, double ymin, double ymax, bool logY);
289			~DrawMultiGraph();
290			void add(double x, double y, int n, string title);
291			void draw();
292			TGraph* getGraph(int i){if(i<maxNumGraphs && i>=0) return _gr[i];else return 0;};
293
294			TLegend *getLegend(){
295			//cout<<"delete me2 legendY2="<<legend->GetY2()<<endl;
296			return legend;};
297			void setSavePath(string tmp){_ssave=tmp;};
298			//void drawLegend(string s_sb, string s_b, string s_d);
299			void setLogY(bool b){_logY=b;};
300			void setDebug(bool b){_debug=b;};
301			TPaveText *getTitlePT(){return _pt;};
302			TLine *getLine(){return lineOne;};
303			TCanvas *getCanvas(){return cCanvas;};
304			void drawOption(int i, string op){if(i<maxNumGraphs && i>=0)_drawOptions[i]=op;};
305			void setLegendXY(double x, double y){legendX=x; legendY=y;};
306			//void save();
307			private:
308			TCanvas *cCanvas;
309			string _ssave;
310			string _stitle;
311			bool _logY;
312			TLegend *legend;
313			bool _debug;
314			TPaveText *_pt;
315			TLine *lineOne;
316
317			TGraph *_gr[maxNumGraphs];//currenly limit to maxNumGraphs graphs..
318			int _numGraphAdded;
319			double _x[maxNumGraphs], _y[maxNumGraphs];
320			int _n[maxNumGraphs];
321			string _title[maxNumGraphs];
322			double _xmin,_xmax,_ymin,_ymax;
323			string _drawOptions[maxNumGraphs];
324			double legendX, legendY;
325			};
326			class DrawPdfRLikelihood{
327			public:
328			DrawPdfRLikelihood(double r95, double par, int npar, string stitle, string ssave, TPaveText pt);
329			~DrawPdfRLikelihood();
330			void draw();
331			TH1F* getHist(){return hist;};
332
333			TLegend *getLegend(){return legend;};
334			void setSavePath(string tmp){_ssave=tmp;};
335			//void drawLegend(string s_hist, string s_arrow){};
336			void setLogY(bool b){_logY=b;};
337			void setDebug(bool b){_debug=b;};
338			TPaveText *getTitlePT(){return _pt;};
339			TArrow *getArrow(){return arrow;};
340
341			private:
342			TCanvas *cCanvas;
343			string _ssave;
344			string _stitle;
345			bool _logY;
346			TLegend *legend;
347			bool _debug;
348			TPaveText *_pt;
349			TArrow *arrow;
350			TH1F *hist;
351			bool _bUnbinned;
352			double _r95;
353			double *_par;
354			int _npar;
355			};
356			void GetMuHat(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits );
357			void GetMuHat(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits , vector<double> & inputLimitErrsUp, vector<double>& inputLimitErrsDn );
358			void GetLimits(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitErrs );
359			void GetPValues(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitErrs_m2s, vector<double> & inputLimitErrs_m1s, vector<double>&inputLimitErrs_p1s, vector<double>&inputLimitErrs_p2s );
360			void GetLimitBands(TTree *tree, vector<double>& inputMH, vector<double>& inputLimits, vector<double> & inputLimitsM2S, vector<double>& inputLimitsM1S,
361			vector<double>& inputLimitsMEDIAN, vector<double>& inputLimitsP1S, vector<double>& inputLimitsP2S);
362			TGraph* GetBeltGraph(const vector<double>& xpoints, const vector<double>& vup, const vector<double> & vdn);
363
364			TGraph* GetMuHatGraph(TTree *tree );
365			TGraphAsymmErrors* GetMuHatGraphAsymm(TTree *tree );
366			TGraph* GetLimitsGraph(TTree *tree );
367			TGraph* GetPValuesGraph(TTree *tree );
368			TObject* GetTObject(string filename, string objname);
369			#endif /* ----- #ifndef PLOTUTILITIES_H ----- */