ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/auterman/SusyScan/PlotScript/GlobalFunctions.h

Comparing UserCode/auterman/SusyScan/PlotScript/GlobalFunctions.h (file contents):
Revision 1.10 by auterman, Wed Feb 9 21:00:29 2011 UTC vs.
Revision 1.14 by auterman, Fri May 20 07:39:34 2011 UTC

#	Line 1 | Line 1
1		#include "SusyScan.h"
2		#include "GeneratorMasses.h"
3	+	#include "ExclusionPlot.h"
4
5		#include "TGraph.h"
6		#include "TLatex.h"
7		#include "TF1.h"
8	+	#include "TH1F.h"
9		#include "TGraphErrors.h"
10		#include "TSpline.h"
11		#include "TStyle.h"
12		#include "TMath.h"
13	+	#include "TRint.h"
14	+	#include "TROOT.h"
15	+	#include "TPad.h"
16
17		#include <cmath>
18		#include <iostream>
19
20
21	<	double Luminosity = 36.3; //[pb^-1]
21	>	double Luminosity = 36.0; //[pb^-1]
22		double Mzero(const SusyScan* p){ return p->Mzero; }
23		double Mhalf(const SusyScan* p){ return p->Mhalf; }
24		double MGluino(const SusyScan* p){ return p->MGL; }
#	Line 25 | Line 30 | double MChi3(const SusyScan* p){ return
30		double MChi4(const SusyScan* p){ return p->MZ4; }
31		double MCha1(const SusyScan* p){ return p->MW1; }
32		double MCha2(const SusyScan* p){ return p->MW2; }
33	+	double MTAU1(const SusyScan* p){ return p->MTAU1; }
34	+	double SignalUncertKfactor(const SusyScan* p){return fabs(p->signal_kfactor_UP-p->signal_kfactor_DN)/(2.0*p->signal_kfactor); }
35	+	double SignalUncertJEC(const SusyScan* p){ return (fabs(p->signal_JEC_UP)+fabs(p->signal_JEC_DN))/(2.0*p->signal); }
36	+	double SignalUncertMuIso(const SusyScan* p){ return (fabs(p->signal_MuIso_UP)+fabs(p->signal_MuIso_DN))/(2.0*p->signal); }
37	+	double SignalKfactor(const SusyScan* p){return p->signal_kfactor; }
38	+	double ChargedLSP(const SusyScan* p){ return (fabs(p->MTAU1) < fabs(p->MZ1) ? 0.01 : 1); }
39	+
40		double Xsection(const SusyScan* p){ return p->Xsection; }
41		double ExpXsecLimit(const SusyScan* p){ return p->ExpXsecLimit; }
42		double ObsXsecLimit(const SusyScan* p){ return p->ObsXsecLimit; }
#	Line 33 | Line 45 | double SignalUncertainty(const SusyScan*
45		double SignalRelUncertainty(const SusyScan* p){ return p->signal_uncertainty/p->signal; }
46		double ExpExclusion(const SusyScan* p){ return (ExpXsecLimit(p)<Xsection(p)&&ExpXsecLimit(p)>0.01?1:0.01); }
47		double ObsExclusion(const SusyScan* p){ return (ObsXsecLimit(p)<Xsection(p)&&ObsXsecLimit(p)>0.01?1:0.01); }
48	+	double ExpNoSigExclCL(const SusyScan* p){ return (p->CLs_bNoSig_xsec<=0.05 ? 1:0.01); }
49		double ExpExclCL(const SusyScan* p){ return (p->CLs_b_xsec<=0.05 ? 1:0.01); }
50		double ExpExclCLm2sigma(const SusyScan* p){ return (p->CLs_b_n2_xsec<=0.05 ? 1:0.01); }
51		double ExpExclCLm1sigma(const SusyScan* p){ return (p->CLs_b_n1_xsec<=0.05 ? 1:0.01); }
#	Line 65 | Line 78 | double MCMCExpExclusion(const SusyScan*
78		double MCMCObsExclusion(const SusyScan* p){ return (MCMCObsXsecLimit(p)<Xsection(p)&&MCMCObsXsecLimit(p)>0.01?1:0.01); }
79		double SignalContamination(const SusyScan* p){return p->signal_contamination; }
80
81	+	double NLOXsection(const SusyScan* p){ return p->Xsection * p->signal_kfactor; }
82	+	double NLOExpXsecLimit(const SusyScan* p){ return p->NLO_ExpXsecLimit; }
83	+	double NLOObsXsecLimit(const SusyScan* p){ return p->NLO_ObsXsecLimit; }
84	+	double NLOSignal(const SusyScan* p){ return p->NLO_signal; }
85	+	double NLOSignalUncertainty(const SusyScan* p){ return p->NLO_signal_uncertainty; }
86	+	double NLOSignalRelUncertainty(const SusyScan* p){ return p->NLO_signal_uncertainty/p->NLO_signal; }
87	+	double NLOExpExclusion(const SusyScan* p){ return (NLOExpXsecLimit(p)<NLOXsection(p)&&NLOExpXsecLimit(p)>0.01?1:0.01); }
88	+	double NLOObsExclusion(const SusyScan* p){ return (NLOObsXsecLimit(p)<NLOXsection(p)&&NLOObsXsecLimit(p)>0.01?1:0.01); }
89	+	double NLOExpCL(const SusyScan* p){ return (p->NLO_CLs_b_xsec); }
90	+	double NLOExpNoSigExclCL(const SusyScan* p){ return (p->NLO_CLs_bNoSig_xsec<=0.05 ? 1:0.01); }
91	+	double NLOExpExclCL(const SusyScan* p){ return (p->NLO_CLs_b_xsec<=0.05 ? 1:0.01); }
92	+	double NLOExpExclCLm2sigma(const SusyScan* p){ return (p->NLO_CLs_b_n2_xsec<=0.05 ? 1:0.01); }
93	+	double NLOExpExclCLm1sigma(const SusyScan* p){ return (p->NLO_CLs_b_n1_xsec<=0.05 ? 1:0.01); }
94	+	double NLOExpExclCLp1sigma(const SusyScan* p){ return (p->NLO_CLs_b_p1_xsec<=0.05 ? 1:0.01); }
95	+	double NLOExpExclCLp2sigma(const SusyScan* p){ return (p->NLO_CLs_b_p2_xsec<=0.05 ? 1:0.01); }
96	+	double NLOObsExclCL(const SusyScan* p){ return (p->NLO_CLs_xsec<=0.05 ? 1:0.01); }
97	+
98	+	double NLOHybridObsCL(const SusyScan* p){ return p->NLOHybrid_CLs_xsec; }
99	+	double NLOHybridObsExclCL(const SusyScan* p){ return (p->NLOHybrid_CLs_xsec<=0.05 ? 1:0.01); }
100	+	double NLOHybridObsErrorCL(const SusyScan* p){ return (p->NLOHybrid_CLs_xsec_error<=0.05 ? 1:0.01); }
101	+
102	+	double NLOSoverSqrtB(const SusyScan* p){ return p->NLO_signal/(sqrt(p->background)+p->background_uncertainty+p->NLO_signal_uncertainty); }
103	+	double NLOXsecOverObserved(const SusyScan* p){ return (NLOObsXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOObsXsecLimit(p)); }
104	+	double NLOXsecOverExpected(const SusyScan* p){ return (NLOExpXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOExpXsecLimit(p)); }
105	+	double NLOSignalAcceptance(const SusyScan* p){ return  p->NLO_signal / (Luminosity*NLOXsection(p)); }
106	+	double NLOExpNSignLimit(const SusyScan* p){ return  p->NLO_ExpNsigLimit; }
107	+	double NLOObsNSignLimit(const SusyScan* p){ return  p->NLO_ObsNsigLimit; }
108	+	double NLOPLExpNSignLimit(const SusyScan* p){ return  p->NLO_PLExpNsigLimit; }
109	+	double NLOPLObsNSignLimit(const SusyScan* p){ return  p->NLO_PLObsNsigLimit; }
110	+	double NLOPLExpXsecLimit(const SusyScan* p){ return p->NLO_PLExpXsecLimit; }
111	+	double NLOPLObsXsecLimit(const SusyScan* p){ return p->NLO_PLObsXsecLimit; }
112	+	double NLOPLExpExclusion(const SusyScan* p){ return (NLOPLExpXsecLimit(p)<NLOXsection(p)&&NLOPLExpXsecLimit(p)>0.01?1:0.01); }
113	+	double NLOPLObsExclusion(const SusyScan* p){ return (NLOPLObsXsecLimit(p)<NLOXsection(p)&&NLOPLObsXsecLimit(p)>0.01?1:0.01); }
114	+	double NLOFCExpNSignLimit(const SusyScan* p){ return  p->NLO_FCExpNsigLimit; }
115	+	double NLOFCObsNSignLimit(const SusyScan* p){ return  p->NLO_FCObsNsigLimit; }
116	+	double NLOFCExpXsecLimit(const SusyScan* p){ return p->NLO_FCExpXsecLimit; }
117	+	double NLOFCObsXsecLimit(const SusyScan* p){ return p->NLO_FCObsXsecLimit; }
118	+	double NLOFCExpExclusion(const SusyScan* p){ return (NLOFCExpXsecLimit(p)<NLOXsection(p)&&NLOFCExpXsecLimit(p)>0.01?1:0.01); }
119	+	double NLOFCObsExclusion(const SusyScan* p){ return (NLOFCObsXsecLimit(p)<NLOXsection(p)&&NLOFCObsXsecLimit(p)>0.01?1:0.01); }
120	+	double NLOMCMCExpNSignLimit(const SusyScan* p){ return  p->NLO_MCMCExpNsigLimit; }
121	+	double NLOMCMCObsNSignLimit(const SusyScan* p){ return  p->NLO_MCMCObsNsigLimit; }
122	+	double NLOMCMCExpXsecLimit(const SusyScan* p){ return p->NLO_MCMCExpXsecLimit; }
123	+	double NLOMCMCObsXsecLimit(const SusyScan* p){ return p->NLO_MCMCObsXsecLimit; }
124	+	double NLOMCMCExpExclusion(const SusyScan* p){ return (NLOMCMCExpXsecLimit(p)<NLOXsection(p)&&NLOMCMCExpXsecLimit(p)>0.01?1:0.01); }
125	+	double NLOMCMCObsExclusion(const SusyScan* p){ return (NLOMCMCObsXsecLimit(p)<NLOXsection(p)&&NLOMCMCObsXsecLimit(p)>0.01?1:0.01); }
126	+	double NLOSignalContamination(const SusyScan* p){return p->NLO_signal_contamination; }
127	+
128		double Mzero(const GeneratorMasses* p){ return p->Mzero; }
129		double Mhalf(const GeneratorMasses* p){ return p->Mhalf; }
130		double MGluino(const GeneratorMasses* p){ return p->MGL; }
#	Line 77 | Line 137 | double MChi4(const GeneratorMasses* p){
137		double MCha1(const GeneratorMasses* p){ return p->MW1; }
138		double MCha2(const GeneratorMasses* p){ return p->MW2; }
139
140	+
141	+
142	+	void setPlottingStyle(TH1F& hsig){
143	+
144	+	hsig.SetStats(kFALSE);
145	+
146	+	hsig.SetAxisRange(80,500,"Y");
147	+	hsig.SetAxisRange(0,520,"X");
148	+	hsig.SetAxisRange(200,520,"X");
149	+
150	+	hsig.GetXaxis()->SetTitle("m_{0} (GeV)");
151	+	hsig.GetYaxis()->SetTitle("m_{1/2} (GeV)");
152	+	hsig.GetYaxis()->SetTitleOffset(0.8);
153	+	hsig.GetYaxis()->SetTitleSize(0.06);
154	+	hsig.GetYaxis()->SetLabelSize(0.06);
155	+	hsig.GetXaxis()->SetTitleOffset(0.9);
156	+	hsig.GetXaxis()->SetTitleSize(0.06);
157	+	hsig.GetXaxis()->SetLabelSize(0.06);
158	+
159	+	hsig.SetLineWidth(1);
160	+	hsig.SetLineColor(kBlue);
161	+
162	+	}
163	+
164	+
165	+
166	+
167		TGraph* set_sneutrino_d0_1(Int_t tanBeta){
168		double sn_m0[14]= {0,  0, 48, 55, 80, 90,100,105,109,105,100, 72, 55,0};
169		double sn_m12[14]={0,140,210,220,237,241,242,241,230,220,210,170,150,0};
#	Line 84 | Line 171 | TGraph* set_sneutrino_d0_1(Int_t tanBeta
171		TGraph* sn_d0_gr = new TGraph(14,sn_m0,sn_m12);
172
173		sn_d0_gr->SetFillColor(kGreen+3);
174	<	sn_d0_gr->SetFillStyle(1001);
174	>	sn_d0_gr->SetFillStyle(3001);
175
176		return sn_d0_gr;
177		}
#	Line 96 | Line 183 | TGraph* set_sneutrino_d0_2(Int_t tanBeta
183		TGraph* sn_d0_gr_2 = new TGraph(9,sn_m0,sn_m12);
184
185		sn_d0_gr_2->SetFillColor(kGreen+3);
186	<	sn_d0_gr_2->SetFillStyle(1001);
186	>	sn_d0_gr_2->SetFillStyle(3001);
187
188		return sn_d0_gr_2;
189		}
190
191	+	TGraph* set_lep_ch(Int_t tanBeta){
192	+	if(tanBeta == 3) return set_lep_ch_tanBeta3();
193	+	if(tanBeta == 10) return set_lep_ch_tanBeta10();
194	+	if(tanBeta == 50) return set_lep_ch_tanBeta50();
195	+	}
196
197		TGraph* set_lep_ch_tanBeta10(){
198
199	<	double ch_m0[11];
200	<	double ch_m12[11];
199	>	double ch_m0[12];
200	>	double ch_m12[12];
201
202		ch_m0[0] = 0;
203		ch_m0[1] = 100;
#	Line 116 | Line 208 | TGraph* set_lep_ch_tanBeta10(){
208		ch_m0[6] = 600;
209		ch_m0[7] = 700;
210		ch_m0[8] = 800;
211	<	ch_m0[9] = 800;
212	<	ch_m0[10] = 0;
211	>	ch_m0[9] = 1000;
212	>	ch_m0[10] = 1000;
213	>	ch_m0[11] = 0;
214
215		ch_m12[0] = 163;
216		ch_m12[1] = 162;
#	Line 128 | Line 221 | TGraph* set_lep_ch_tanBeta10(){
221		ch_m12[6] = 157;
222		ch_m12[7] = 156;
223		ch_m12[8] = 155.4;
224	<	ch_m12[9] = 0;
224	>	ch_m12[9] = 155.05;
225		ch_m12[10] = 0;
226	+	ch_m12[11] = 0;
227
228
229	<	TGraph* ch_gr = new TGraph(11,ch_m0,ch_m12);
229	>	TGraph* ch_gr = new TGraph(12,ch_m0,ch_m12);
230
231		ch_gr->SetFillColor(3);
232		ch_gr->SetLineColor(3);
233		//  ch_gr->SetLineWidth(3);
234	<	ch_gr->SetFillStyle(1001);
234	>	ch_gr->SetFillStyle(3001);
235
236		return ch_gr;
237
#	Line 191 | Line 285 | TGraph* set_lep_ch_tanBeta3(){
285		ch_gr->SetFillColor(3);
286		ch_gr->SetLineColor(3);
287		// ch_gr->SetLineWidth(3);
288	<	ch_gr->SetFillStyle(1001);
288	>	ch_gr->SetFillStyle(3001);
289
290		return ch_gr;
291
#	Line 252 | Line 346 | TGraph* set_lep_ch_tanBeta50(){
346
347		ch_gr->SetFillColor(3);
348		ch_gr->SetLineColor(3);
349	<	ch_gr->SetFillStyle(1001);
349	>	ch_gr->SetFillStyle(3001);
350
351		return ch_gr;
352
353		}
354
355
262	–	TGraph* set_lep_ch(Int_t tanBeta){
263	–	if(tanBeta == 3) return set_lep_ch_tanBeta3();
264	–	if(tanBeta == 10) return set_lep_ch_tanBeta10();
265	–	if(tanBeta == 50) return set_lep_ch_tanBeta50();
266	–	}
356
357
358		TGraph* set_lep_sl(Int_t tanBeta){
#	Line 273 | Line 362 | TGraph* set_lep_sl(Int_t tanBeta){
362		//  double sl_m12[] = {0,245,240,220,200,150,100,50,0};
363
364		//contour from D0 trilepton paper (PLB 680 (2009) 34-43)
365	<
277	<	double *sl_m0 = 0;
278	<	double *sl_m12 = 0;
279	<	int n = 0;
280	<
281	<	double sl_m0_3[] ={0,  0, 10, 20, 30, 40, 50, 60, 70, 77,88,95};
282	<	double sl_m12_3[]={0,245,242,239,232,222,209,189,165,140,60,0};
283	<	int n_3 = 12;
284	<
285	<	double sl_m0_10[]={ 0,  0, 11, 20, 24, 49, 70, 82,88,90};
286	<	double sl_m12_10[]={0,240,237,233,230,200,150,100,50,0};
287	<	int n_10 = 10;
288	<
365	>	TGraph* lep_sl = 0;
366		if (tanBeta==3){
367	<	sl_m0 = sl_m0_3;
368	<	sl_m12 = sl_m12_3;
369	<	n = n_3;
367	>	double sl_m0[] ={0,  0, 10, 20, 30, 40, 50, 60, 70, 77,88,95};
368	>	double sl_m12[]={0,245,242,239,232,222,209,189,165,140,60,0};
369	>	int n = 12;
370	>	lep_sl = new TGraph(n,sl_m0,sl_m12);
371		}
372		//CMS PTDR-II
373		//* Selectron_R line mass=99, ISASUGRA7.69, A0=0, m_top=175, tan(beta]=10
374		if (tanBeta==10 || tanBeta==50){
375	<	sl_m0 = sl_m0_10;
376	<	sl_m12 = sl_m12_10;
377	<	n = n_10;
375	>	double sl_m0[]={ 0,  0, 11, 20, 24, 49, 70, 82,88,90};
376	>	double sl_m12[]={0,240,237,233,230,200,150,100,50,0};
377	>	int n = 10;
378	>	lep_sl = new TGraph(n,sl_m0,sl_m12);
379		}
380
302	–	TGraph* lep_sl = new TGraph(n,sl_m0,sl_m12);
381
382		lep_sl->SetFillColor(5);
383		lep_sl->SetLineColor(5);
384	<	lep_sl->SetFillStyle(1001);
384	>	lep_sl->SetFillStyle(3001);
385
386		return lep_sl;
387		}
#	Line 326 | Line 404 | TGraph* set_tev_sg_cdf(Int_t tanBeta){
404		sg_gr->SetFillColor(2);
405		sg_gr->SetLineColor(2);
406		//  sg_gr->SetLineWidth(3);
407	<	sg_gr->SetFillStyle(1001);
407	>	sg_gr->SetFillStyle(3001);
408
409		return sg_gr;
410
#	Line 334 | Line 412 | TGraph* set_tev_sg_cdf(Int_t tanBeta){
412
413		TGraph* set_tev_sg_d0(Int_t tanBeta){
414
415	<	//  double sgd_m0[] = {0, 0,  50, 100,150,200,250,300,350,400,450,500,550,600,600};
416	<	//  double sgd_m12[] = {0,168,167,162,157,145,125,120,110,108,95, 94 ,94 ,93,0};
417	<	//  int np=15;
418	<	double sgd_m0[]= {0,  0, 30, 80,150,240,320,400,500,600,600,0};
341	<	double sgd_m12[]={0,167,166,162,156,138,121,109,105,105,  0,0};
342	<	int npd=12;
415	>	//official D0 contour from P. Verdier
416	>	double sgd_m0[]= {0,  0., 25., 80.,100.,150.,192.,250.,300. ,350.,400.,450. ,500.,600.,600.,0.};
417	>	double sgd_m12[]={0,167.,167.,163.,162.,157.,149.,136.,125.5,116.,109.,106.5,105.,105.,  0.,0.};
418	>	int npd=16;
419
420		TGraph* sgd_gr = new TGraph(npd,sgd_m0,sgd_m12);
421
422		gStyle->SetHatchesLineWidth(3);
423
424	<	sgd_gr->SetFillColor(kMagenta+3);
425	<	sgd_gr->SetLineColor(kMagenta+3);
424	>	sgd_gr->SetFillColor(kMagenta+1);
425	>	sgd_gr->SetLineColor(kMagenta+1);
426		sgd_gr->SetLineWidth(3);
427		sgd_gr->SetFillStyle(3335);
428	+	//sgd_gr->SetFillStyle(3001);
429
430		return sgd_gr;
431
#	Line 466 | Line 543 | TLatex* constant_squark_text(Int_t it,TF
543		Double_t place_x = 170;
544		if(tanBeta_ == 50)place_x = 290;
545		TLatex* t3 = new TLatex(place_x+10*(it-1),lnsq.Eval(place_x+10*(it-1))+5,legnm);
546	<	t3->SetTextSize(0.03);
546	>	t3->SetTextSize(0.02);
547		t3->SetTextAngle(-8);
548		t3->SetTextColor(kGray+2);
549
#	Line 480 | Line 557 | TLatex* constant_gluino_text(Int_t it,TF
557
558		sprintf(legnm,"#font[12]{#tilde{g}}#font[92]{(%i)GeV}",500+150*(it-1));
559		TLatex* t4 = new TLatex(423,18+lngl.Eval(480),legnm);
560	<	t4->SetTextSize(0.03);
560	>	t4->SetTextSize(0.02);
561		t4->SetTextAlign(13);
562		t4->SetTextColor(kGray+2);
563
#	Line 488 | Line 565 | TLatex* constant_gluino_text(Int_t it,TF
565		}
566
567
491	–	TGraphErrors* getLO_tanBeta3(){
492	–
493	–
494	–
495	–	Int_t nl = 9;
496	–	Double_t xl[9];
497	–	Double_t yl[9];
498	–	Double_t exl[9];
499	–	Double_t eyl[9];
500	–
501	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
502	–
503	–
504	–	xl[0] = 0;
505	–	yl[0] = 265;
506	–	xl[1] = 100;
507	–	yl[1] = 258;
508	–	xl[2] = 200;
509	–	yl[2] = 250;
510	–	xl[3] = 250;
511	–	yl[3] = 240;
512	–	xl[4] = 300;
513	–	yl[4] = 210;
514	–	xl[5] = 340;
515	–	yl[5] = 177;
516	–	xl[6] = 400;
517	–	yl[6] = 140;
518	–	xl[7] = 450;
519	–	yl[7] = 120;
520	–	xl[8] = 520;
521	–	yl[8] =100;
522	–
523	–
524	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
525	–	gr1->SetMarkerColor(kGreen+2);
526	–	gr1->SetMarkerStyle(21);
527	–
528	–
529	–	//gr1->Draw("LP");
530	–
531	–	TSpline3 *s = new TSpline3("grs",gr1);
532	–	s->SetLineColor(kGreen+2);
533	–	s->SetLineStyle(4);
534	–	s->SetLineWidth(3);
535	–
536	–
537	–	return gr1;
538	–
539	–
540	–
541	–	}
542	–
543	–	TGraphErrors* getLO_tanBeta10(){
544	–
545	–
546	–
547	–	Int_t nl = 10;
548	–	Double_t xl[10];
549	–	Double_t yl[10];
550	–	Double_t exl[10];
551	–	Double_t eyl[10];
552	–
553	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
554	–
555	–	xl[0] = 0;
556	–	yl[0] = 270;
557	–	xl[1] = 100;
558	–	yl[1] = 260;
559	–	xl[2] = 200;
560	–	yl[2] = 250;
561	–	xl[3] = 250;
562	–	yl[3] = 240;
563	–	xl[4] = 300;
564	–	yl[4] = 210;
565	–	xl[5] = 350;
566	–	yl[5] = 174;
567	–	xl[6] = 400;
568	–	yl[6] = 147;
569	–	xl[7] = 450;
570	–	yl[7] = 127;
571	–	xl[8] = 500;
572	–	yl[8] =115;
573	–	xl[9] = 520;
574	–	yl[9] = 112;
575	–
576	–
577	–
578	–
579	–
580	–
581	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
582	–	gr1->SetMarkerColor(kGreen+2);
583	–	gr1->SetMarkerStyle(21);
584	–
585	–
586	–	//gr1->Draw("LP");
587	–
588	–	TSpline3 *s = new TSpline3("grs",gr1);
589	–	s->SetLineColor(kGreen+2);
590	–	s->SetLineStyle(4);
591	–	s->SetLineWidth(3);
592	–
593	–
594	–	return gr1;
595	–
596	–
597	–
598	–	}
599	–
600	–	TGraphErrors* getLO_tanBeta50(){
601	–
602	–
603	–
604	–	Int_t nl = 10;
605	–	Double_t xl[10];
606	–	Double_t yl[10];
607	–	Double_t exl[10];
608	–	Double_t eyl[10];
609	–
610	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
611	–
612	–
613	–	xl[0] = 200;
614	–	yl[0] = 239;
615	–	xl[1] = 210;
616	–	yl[1] = 249;
617	–	xl[2] = 229;
618	–	yl[2] = 260;
619	–	xl[3] = 250;
620	–	yl[3] = 245;
621	–	xl[4] = 300;
622	–	yl[4] = 210;
623	–	xl[5] = 350;
624	–	yl[5] = 180;
625	–	xl[6] = 400;
626	–	yl[6] = 160;
627	–	xl[7] = 450;
628	–	yl[7] = 150;
629	–	xl[8] = 500;
630	–	yl[8] =140;
631	–	xl[9] = 520;
632	–	yl[9] = 137;
633	–
634	–
635	–
636	–
637	–
638	–
639	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
640	–	gr1->SetMarkerColor(kGreen+2);
641	–	gr1->SetMarkerStyle(21);
642	–
643	–
644	–	//gr1->Draw("LP");
645	–
646	–	TSpline3 *s = new TSpline3("grs",gr1);
647	–	s->SetLineColor(kGreen+2);
648	–	s->SetLineStyle(4);
649	–	s->SetLineWidth(3);
650	–
651	–
652	–	return gr1;
653	–
568
569	+	TLegend* makeStauLegend(Double_t txtsz,Int_t tanBeta_){
570	+	Double_t ypos_1 = 0.86;
571	+	Double_t ypos_2 = 0.88;
572	+	Double_t xpos_1 = 0.16;
573	+	Double_t xpos_2 = 0.17;
574	+	if(tanBeta_ == 50){
575	+	xpos_1 = 0.17;
576	+	xpos_2 = 0.18;
577	+	ypos_1 = 0.76;
578	+	ypos_2 = 0.78;
579
580	+	}
581	+	TLegend* legst = new TLegend(xpos_1,ypos_1,xpos_2,ypos_2);
582	+	legst->SetHeader("#tilde{#tau} = LSP");
583	+	legst->SetFillStyle(0);
584	+	legst->SetBorderSize(0);
585	+	legst->SetTextSize(0.03);
586	+
587	+	return legst;
588		}
589
590
591	<
592	<	TGraphErrors* getExpected_NLO_tanBeta3(){
593	<
594	<	Int_t nl = 11;
595	<	Double_t xl[11];
596	<	Double_t yl[11];
597	<	Double_t exl[11];
598	<	Double_t eyl[11];
599	<
600	<	xl[0] = 0;
601	<	yl[0] = 283;
602	<	xl[1] = 100;
603	<	yl[1] = 280;
604	<	xl[2] = 150;
605	<	yl[2] = 279;
606	<	xl[3] = 200;
607	<	yl[3] = 275;
608	<	xl[4] = 250;
609	<	yl[4] = 270;
678	<	xl[5] = 300;
679	<	yl[5] = 255;
680	<	xl[6] = 350;
681	<	yl[6] = 225;
682	<	xl[7] = 400;
683	<	yl[7] = 195;
684	<	xl[8] = 450;
685	<	yl[8] = 175;
686	<	xl[9] = 500;
687	<	yl[9] = 155;
688	<	xl[10] = 550;
689	<	yl[10] = 150;
690	<
591	>	TLegend* makeExpLegend(TGraph& sg_gr, TGraph& sgd_gr,TGraph& ch_gr,TGraph& sl_gr,TGraph& tev_sn,Double_t txtsz,Int_t tanbeta){
592	>	TLegend* legexp = new TLegend(0.64,0.65,0.99,0.9,NULL,"brNDC");
593	>	legexp->SetFillColor(0);
594	>	legexp->SetShadowColor(0);
595	>	legexp->SetTextSize(txtsz);
596	>	legexp->SetBorderSize(0);
597	>
598	>	sg_gr.SetLineColor(1);
599	>	legexp->AddEntry(&sg_gr,"CDF  #tilde{#font[12]{g}}, #tilde{#font[12]{q}}, #scale[0.8]{tan#beta=5, #mu<0}","f");
600	>	//  sgd_gr.SetLineColor(1);
601	>	//  sgd_gr.SetLineWidth(1);
602	>
603	>	legexp->AddEntry(&sgd_gr,"D0   #tilde{#font[12]{g}}, #tilde{#font[12]{q}}, #scale[0.8]{tan#beta=3, #mu<0}","f");
604	>	ch_gr.SetLineColor(1);
605	>	legexp->AddEntry(&ch_gr,"LEP2   #tilde{#chi}_{1}^{#pm}","f");
606	>
607	>	sl_gr.SetLineColor(1);
608	>	if(tanbeta != 50) legexp->AddEntry(&sl_gr,"LEP2   #tilde{#font[12]{l}}^{#pm}","f");
609	>	if(tanbeta == 3) legexp->AddEntry(&tev_sn,"D0  #chi^{#pm}_{1}, #chi^{0}_{2}","f");
610
692	–
693	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
694	–	gr1->SetMarkerColor(kBlue);
695	–	gr1->SetMarkerStyle(21);
696	–
697	–
698	–	//gr1->Draw("LP");
699	–
700	–	TSpline3 *s = new TSpline3("grs",gr1);
701	–	s->SetLineColor(kBlue);
702	–	s->SetLineStyle(2);
703	–	s->SetLineWidth(3);
704	–
705	–
706	–	return gr1;
707	–
708	–
709	–
611
612	+	return legexp;
613
614		}
615
714	–	TGraphErrors* getExpected_NLO_tanBeta10(){
715	–
716	–	Int_t nl = 11;
717	–	Double_t xl[11];
718	–	Double_t yl[11];
719	–	Double_t exl[11];
720	–	Double_t eyl[11];
721	–
722	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
723	–
724	–	xl[0] = 0;
725	–	yl[0] = 283;
726	–	xl[1] = 100;
727	–	yl[1] = 280;
728	–	xl[2] = 150;
729	–	yl[2] = 279;
730	–	xl[3] = 200;
731	–	yl[3] = 275;
732	–	xl[4] = 250;
733	–	yl[4] = 270;
734	–	xl[5] = 300;
735	–	yl[5] = 255;
736	–	xl[6] = 350;
737	–	yl[6] = 225;
738	–	xl[7] = 400;
739	–	yl[7] = 195;
740	–	xl[8] = 450;
741	–	yl[8] = 175;
742	–	xl[9] = 500;
743	–	yl[9] = 165;
744	–	xl[10] = 550;
745	–	yl[10] = 150;
746	–
747	–
748	–
749	–
750	–
751	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
752	–	gr1->SetMarkerColor(kBlue);
753	–	gr1->SetMarkerStyle(21);
754	–
755	–
756	–	//gr1->Draw("LP");
757	–
758	–	TSpline3 *s = new TSpline3("grs",gr1);
759	–	s->SetLineColor(kBlue);
760	–	s->SetLineStyle(2);
761	–	s->SetLineWidth(3);
762	–
763	–
764	–	return gr1;
765	–
766	–
767	–
616
617	+	TGraph* getGraph(TH2F* h1, double level){
618
619	+	h1->SetContour(1);
620	+	h1->SetContourLevel(0,level);
621	+	h1->Draw("CONT LIST");
622	+	gPad->Update();
623	+
624	+	TObjArray* contours = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
625	+
626	+	std::cout << "contours: " << contours << std::endl;
627	+	// Draw contours
628	+	TList* graphList = (TList*)(contours->At(0));
629	+	std::cout << "number of graphs: " << graphList->GetSize() << std::endl;
630	+	TGraph* myGraph = 0;
631	+	for (int igraph = 0; igraph<graphList->GetSize();++igraph) {
632	+	myGraph = (TGraph*)graphList->At(igraph);
633	+
634	+	std::cout << " - graph " << igraph << " has " << myGraph->GetN() << " points" << std::endl;
635	+	if (myGraph->GetN() > 50){
636	+	std::cout << "Drawing " << myGraph->GetN() <<" points" << std::endl;
637	+	//      myGraph->Print("all");
638	+	//      myGraph->SetLineColor(9);
639	+	//      myGraph->SetLineColor(46);
640	+	//myGraph->SetLineWidth(3);
641	+	//      myGraph->SetLineStyle(2);
642	+	//      myGraph->SetMarkerStyle(20);
643	+	//      myGraph->SetMarkerColor(9);
644	+
645	+	//      myGraph->Draw("C");
646	+	//      cvsSys->Update();
647	+
648	+	//    TString graphName("graph"+name+"_");
649	+	//    graphName += igraph;
650	+	//    myGraph->SetName(graphName);
651	+	break;
652	+	}
653	+	}
654	+	return myGraph;
655		}
656
657	+	TH2F* fillHoles(TH2F* h2){
658
659	<	TGraphErrors* getExpected_NLO_tanBeta50(){
660	<
661	<	Int_t nl = 10;
662	<	Double_t xl[10];
663	<	Double_t yl[10];
664	<	Double_t exl[10];
665	<	Double_t eyl[10];
666	<
667	<	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
668	<
669	<	xl[0] = 200;
670	<	yl[0] = 287;
671	<	xl[1] = 220;
672	<	yl[1] = 287;
673	<	xl[2] = 245;
674	<	yl[2] = 287;
675	<	xl[3] = 270;
676	<	yl[3] = 265;
677	<	xl[4] = 300;
678	<	yl[4] = 245;
679	<	xl[5] = 350;
680	<	yl[5] = 222;
681	<	xl[6] = 400;
682	<	yl[6] = 197;
683	<	xl[7] = 450;
684	<	yl[7] = 180;
685	<	xl[8] = 500;
686	<	yl[8] = 168;
687	<	xl[9] = 550;
688	<	yl[9] = 145;
803	<
804	<
805	<
806	<
807	<
808	<	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
809	<	gr1->SetMarkerColor(kBlue);
810	<	gr1->SetMarkerStyle(21);
811	<
812	<
813	<	//gr1->Draw("LP");
814	<
815	<	TSpline3 *s = new TSpline3("grs",gr1);
816	<	s->SetLineColor(kBlue);
817	<	s->SetLineStyle(2);
818	<	s->SetLineWidth(3);
819	<
820	<
821	<	return gr1;
822	<
823	<
824	<
825	<
826	<
659	>	int nx = h2->GetNbinsX();
660	>	int ny = h2->GetNbinsY();
661	>	std::cout << "Nbins: " << nx << " " << ny << std::endl;
662	>
663	>	for (int i=1;i<nx+1;i++){
664	>	for (int j=ny;j>0;j--){
665	>	int pos = j;
666	>	int count =0;
667	>	if (h2->GetBinContent(i,j)==0 && h2->GetBinContent(i-1,j)==-1 && h2->GetBinContent(i+1,j)==-1) h2->SetBinContent(i,j,-1.);
668	>
669	>	if (h2->GetBinContent(i,j)==1
670	>	&& h2->GetBinContent(i-1,j)==-1
671	>	&& h2->GetBinContent(i+1,j)==-1
672	>	&& h2->GetBinContent(i,j+1)==-1
673	>	&& h2->GetBinContent(i,j-1)==-1)
674	>	h2->SetBinContent(i,j,-1.);
675	>
676	>	//      if (h2->GetBinContent(i,j)<0){
677	>	if (h2->GetBinContent(i,j)<0 && h2->GetBinContent(i,j-1)<0){
678	>	//      cout <<" bin content " << i <<" " <<  j<< " " << pos << " " << h2->GetBinContent(i,j) <<endl;
679	>	for (int k=pos;k>0;k--){
680	>	h2->SetBinContent(i,k,-1.);
681	>	}
682	>	break;
683	>	}
684	>
685	>
686	>	}
687	>	}
688	>	return h2;
689		}
690
691
830	–	TGraphErrors* getObserved_NLO_tanBeta3(){
831	–
832	–	Int_t nl = 11;
833	–	Double_t xl[11];
834	–	Double_t yl[11];
835	–	Double_t exl[11];
836	–	Double_t eyl[11];
837	–
838	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
839	–
840	–
841	–
842	–	xl[0] = 0;
843	–	yl[0] = 274;
844	–	xl[1] = 100;
845	–	yl[1] = 270;
846	–	xl[2] = 150;
847	–	yl[2] = 268;
848	–	xl[3] = 200;
849	–	yl[3] = 265;
850	–	xl[4] = 250;
851	–	yl[4] = 255;
852	–	xl[5] = 300;
853	–	yl[5] = 230;
854	–	xl[6] = 350;
855	–	yl[6] = 195;
856	–	xl[7] = 400;
857	–	yl[7] = 160;
858	–	xl[8] = 450;
859	–	yl[8] = 140;
860	–	xl[9] = 480;
861	–	yl[9] = 130;
862	–	xl[10] = 530;
863	–	yl[10] = 120;
864	–
865	–
866	–
867	–
868	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
869	–	gr1->SetMarkerColor(kBlue);
870	–	gr1->SetMarkerStyle(21);
871	–
872	–
873	–	//gr1->Draw("LP");
874	–
875	–	TSpline3 *s = new TSpline3("grs",gr1);
876	–	s->SetLineColor(kRed);
877	–	// s->SetLineStyle(2);
878	–	s->SetLineWidth(3);
879	–
880	–
881	–	return gr1;
882	–
883	–
692
693
694
887	–	}
888	–
889	–
890	–
891	–	TGraphErrors* getObserved_NLO_tanBeta10(){
892	–
893	–	Int_t nl = 11;
894	–	Double_t xl[11];
895	–	Double_t yl[11];
896	–	Double_t exl[11];
897	–	Double_t eyl[11];
898	–
899	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
900	–
901	–	xl[0] = 0;
902	–	yl[0] = 278;
903	–	xl[1] = 100;
904	–	yl[1] = 270;
905	–	xl[2] = 150;
906	–	yl[2] = 267;
907	–	xl[3] = 200;
908	–	yl[3] = 262;
909	–	xl[4] = 250;
910	–	yl[4] = 250;
911	–	xl[5] = 300;
912	–	yl[5] = 225;
913	–	xl[6] = 350;
914	–	yl[6] = 192;
915	–	xl[7] = 400;
916	–	yl[7] = 163;
917	–	xl[8] = 450;
918	–	yl[8] = 148;
919	–	xl[9] = 500;
920	–	yl[9] = 140;
921	–	xl[10] = 520;
922	–	yl[10] = 137;
923	–
924	–
925	–
926	–
927	–
928	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
929	–	gr1->SetMarkerColor(kBlue);
930	–	gr1->SetMarkerStyle(21);
931	–
932	–
933	–	//gr1->Draw("LP");
695
935	–	TSpline3 *s = new TSpline3("grs",gr1);
936	–	s->SetLineColor(kRed);
937	–	//  s->SetLineStyle(2);
938	–	s->SetLineWidth(3);
939	–
696
941	–	return gr1;
697
698
699
700
701
702	+	//old------------------------------------------------------------------------
703	+
704	+	TGraph* sq_LEP(){//sq-gl
705	+	double sq[] = {0,0,100,100};
706	+	double gl[] = {0,2000,2000,0};
707	+	TGraph* res = new TGraph(4,sq,gl);
708	+	res->SetFillColor(kBlue);
709	+	return res;
710	+	}
711	+	TGraph* gl_TEV(){//sq-gl
712	+	double sq[] = {0,2000,2000,0};
713	+	double gl[] = {0,0,190,190};
714	+	TGraph* res = new TGraph(4,sq,gl);
715	+	res->SetFillColor(kGreen+2);
716	+	return res;
717	+	}
718	+
719	+	TGraph* gl_CDF(){//sq-gl
720	+	double sq[] = {0,2000,2000,0};
721	+	double gl[] = {190,190,230,230};
722	+	TGraph* res = new TGraph(4,sq,gl);
723	+	res->SetFillColor(kOrange+5);
724	+	return res;
725	+	}
726	+
727	+	TGraph* gl_DEZ(){//sq-gl
728	+	double sq[] = {0,2000,2000,0};
729	+	double gl[] = {230,230,255,255};
730	+	TGraph* res = new TGraph(4,sq,gl);
731	+	res->SetFillColor(kYellow-5);
732	+	return res;
733	+	}
734	+
735	+	TGraph* gl_WHT(){//sq-gl
736	+	double sq[] = {101,2000,2000,101};
737	+	double gl[] = {256,256,400,400};
738	+	TGraph* res = new TGraph(4,sq,gl);
739	+	res->SetFillColor(kWhite);
740	+	return res;
741	+	}
742	+
743	+
744	+	////////////////////////////////////////////
745	+	TGraph* gl_LEP(){//gl-sq
746	+	double sq[] = {0,0,100,100};
747	+	double gl[] = {0,2000,2000,0};
748	+	TGraph* res = new TGraph(4,gl,sq);
749	+	res->SetFillColor(kBlue);
750	+	return res;
751	+	}
752	+
753	+	TGraph* sq_TEV(){//gl-sq
754	+	double sq[] = {0,2000,2000,330,250,300,200,150,100,0};
755	+	double gl[] = {0,0,190,190,260,300,500,560,500,500};
756	+
757	+	TGraph* res = new TGraph(10,gl,sq);
758	+	res->SetFillColor(kGreen+2);
759	+	return res;
760	+	}
761	+
762	+	TGraph* sq_CDF(){//gl-sq
763	+	double sq[] = {0,2000,2000,480,460,420,410,380,390,290,0};
764	+	double gl[] = {0,0,280,280,300,310,330,340,440,320,320};
765	+	TGraph* res = new TGraph(11,gl,sq);
766	+	res->SetFillColor(kOrange+5);
767	+	return res;
768	+	}
769	+	TGraph* sq_DEZ(){//gl-sq
770	+	double sq[] = {0,2000,2000,460,430,400,390,290,0};
771	+	double gl[] = {0,0,305,305,320,350,440,320,320};
772	+	TGraph* res = new TGraph(9,gl,sq);
773	+	res->SetFillColor(kYellow-5);
774	+	return res;
775	+	}
776	+
777	+	TGraph* glsq_NoSol(){//sq-gl
778	+	gStyle->SetHatchesSpacing(2.0);
779	+	gStyle->SetHatchesLineWidth(1);
780	+	double sq[] = {83,83,110,1297.6,0,   0};
781	+	double gl[] = { 0,63,120,1466,  1466,0};
782	+	TGraph* res = new TGraph(6,gl,sq);
783	+	res->SetLineColor(1);
784	+	res->SetLineWidth(2);
785	+	res->SetFillStyle(3354);
786	+	return res;
787	+	}
788	+
789	+
790	+
791	+
792	+
793	+	TGraph * Atlas_m0_m12_tb3_obs()
794	+	{
795	+	TGraph *graph = new TGraph(71);
796	+	graph->SetLineWidth(2);
797	+	graph->SetPoint(0,54,357.341);
798	+	graph->SetPoint(1,82,358.4171);
799	+	graph->SetPoint(2,110,359.8179);
800	+	graph->SetPoint(3,110.934,359.875);
801	+	graph->SetPoint(4,138,361.5302);
802	+	graph->SetPoint(5,166,362.5696);
803	+	graph->SetPoint(6,189.0676,359.875);
804	+	graph->SetPoint(7,194,359.1415);
805	+	graph->SetPoint(8,222,354.5211);
806	+	graph->SetPoint(9,248.1714,351.625);
807	+	graph->SetPoint(10,250,351.4583);
808	+	graph->SetPoint(11,278,349.4991);
809	+	graph->SetPoint(12,306,343.4051);
810	+	graph->SetPoint(13,306.1313,343.375);
811	+	graph->SetPoint(14,334,335.3855);
812	+	graph->SetPoint(15,334.7966,335.125);
813	+	graph->SetPoint(16,350.8793,326.875);
814	+	graph->SetPoint(17,362,319.7823);
815	+	graph->SetPoint(18,364.6568,318.625);
816	+	graph->SetPoint(19,383.5969,310.375);
817	+	graph->SetPoint(20,390,308.6978);
818	+	graph->SetPoint(21,415.0931,302.125);
819	+	graph->SetPoint(22,418,300.2992);
820	+	graph->SetPoint(23,423.9359,293.875);
821	+	graph->SetPoint(24,431.0348,285.625);
822	+	graph->SetPoint(25,441.6066,277.375);
823	+	graph->SetPoint(26,446,275.3629);
824	+	graph->SetPoint(27,468.0485,269.125);
825	+	graph->SetPoint(28,474,267.2393);
826	+	graph->SetPoint(29,486.3632,260.875);
827	+	graph->SetPoint(30,495.8534,252.625);
828	+	graph->SetPoint(31,502,244.7684);
829	+	graph->SetPoint(32,502.3699,244.375);
830	+	graph->SetPoint(33,508.424,236.125);
831	+	graph->SetPoint(34,514.4781,227.875);
832	+	graph->SetPoint(35,518.8059,219.625);
833	+	graph->SetPoint(36,521.5056,211.375);
834	+	graph->SetPoint(37,524.324,203.125);
835	+	graph->SetPoint(38,527.1424,194.875);
836	+	graph->SetPoint(39,530,193.5052);
837	+	graph->SetPoint(40,552.5782,186.625);
838	+	graph->SetPoint(41,558,185.8767);
839	+	graph->SetPoint(42,586,180.1476);
840	+	graph->SetPoint(43,592.2836,178.375);
841	+	graph->SetPoint(44,614,171.422);
842	+	graph->SetPoint(45,617.5927,170.125);
843	+	graph->SetPoint(46,627.5396,161.875);
844	+	graph->SetPoint(47,642,157.9876);
845	+	graph->SetPoint(48,658.2277,153.625);
846	+	graph->SetPoint(49,670,151.1225);
847	+	graph->SetPoint(50,698,146.9886);
848	+	graph->SetPoint(51,711.5425,145.375);
849	+	graph->SetPoint(52,726,143.6935);
850	+	graph->SetPoint(53,754,140.0648);
851	+	graph->SetPoint(54,782,137.4563);
852	+	graph->SetPoint(55,783.0426,137.125);
853	+	graph->SetPoint(56,796.0326,128.875);
854	+	graph->SetPoint(57,810,125.0328);
855	+	graph->SetPoint(58,826.0235,120.625);
856	+	graph->SetPoint(59,838,117.3305);
857	+	graph->SetPoint(60,866,116.7462);
858	+	graph->SetPoint(61,894,116.1044);
859	+	graph->SetPoint(62,922,114.6645);
860	+	graph->SetPoint(63,950,116.937);
861	+	graph->SetPoint(64,978,117.6956);
862	+	graph->SetPoint(65,1006,115.198);
863	+	graph->SetPoint(66,1034,113.1166);
864	+	graph->SetPoint(67,1038.967,112.375);
865	+	graph->SetPoint(68,1062,108.0997);
866	+	graph->SetPoint(69,1090,104.373);
867	+	graph->SetPoint(70,1096.429,104.125);
868	+	graph->SetFillColor(0);
869	+	return graph;
870	+	}
871	+	TGraph * Atlas_mGl_mSq_obs()
872	+	{
873	+	//x:gluino mass, y:squark mass
874	+	TGraph *graph = new TGraph(64);
875	+	graph->SetLineWidth(2);
876	+	graph->SetPoint(0,511.2569,1976.25);
877	+	graph->SetPoint(1,513.125,1936.181);
878	+	graph->SetPoint(2,513.4714,1928.75);
879	+	graph->SetPoint(3,515.6859,1881.25);
880	+	graph->SetPoint(4,517.9004,1833.75);
881	+	graph->SetPoint(5,520.1148,1786.25);
882	+	graph->SetPoint(6,522.3293,1738.75);
883	+	graph->SetPoint(7,524.5438,1691.25);
884	+	graph->SetPoint(8,526.1095,1643.75);
885	+	graph->SetPoint(9,526.5267,1596.25);
886	+	graph->SetPoint(10,526.9924,1548.75);
887	+	graph->SetPoint(11,527.2745,1501.25);
888	+	graph->SetPoint(12,526.9487,1453.75);
889	+	graph->SetPoint(13,526.6228,1406.25);
890	+	graph->SetPoint(14,532.902,1358.75);
891	+	graph->SetPoint(15,540.182,1311.25);
892	+	graph->SetPoint(16,547.4619,1263.75);
893	+	graph->SetPoint(17,558.0438,1216.25);
894	+	graph->SetPoint(18,561.875,1203.002);
895	+	graph->SetPoint(19,579.4475,1168.75);
896	+	graph->SetPoint(20,603.8166,1121.25);
897	+	graph->SetPoint(21,610.625,1107.979);
898	+	graph->SetPoint(22,630.8311,1073.75);
899	+	graph->SetPoint(23,658.8712,1026.25);
900	+	graph->SetPoint(24,659.375,1025.691);
901	+	graph->SetPoint(25,703.8609,978.75);
902	+	graph->SetPoint(26,708.125,975.5966);
903	+	graph->SetPoint(27,756.875,945.0332);
904	+	graph->SetPoint(28,778.5082,931.25);
905	+	graph->SetPoint(29,805.625,916.3566);
906	+	graph->SetPoint(30,847.5791,883.75);
907	+	graph->SetPoint(31,854.375,879.4212);
908	+	graph->SetPoint(32,903.125,848.0476);
909	+	graph->SetPoint(33,927.7959,836.25);
910	+	graph->SetPoint(34,951.875,823.2943);
911	+	graph->SetPoint(35,1000.625,790.1523);
912	+	graph->SetPoint(36,1004.488,788.75);
913	+	graph->SetPoint(37,1049.375,774.2142);
914	+	graph->SetPoint(38,1098.125,755.1404);
915	+	graph->SetPoint(39,1130.904,741.25);
916	+	graph->SetPoint(40,1146.875,736.2226);
917	+	graph->SetPoint(41,1195.625,720.3208);
918	+	graph->SetPoint(42,1244.375,701.1234);
919	+	graph->SetPoint(43,1266.694,693.75);
920	+	graph->SetPoint(44,1293.125,685.9941);
921	+	graph->SetPoint(45,1341.875,668.9126);
922	+	graph->SetPoint(46,1390.625,652.8072);
923	+	graph->SetPoint(47,1439.375,647.4204);
924	+	graph->SetPoint(48,1448.107,646.25);
925	+	graph->SetPoint(49,1488.125,638.5908);
926	+	graph->SetPoint(50,1536.875,620.8084);
927	+	graph->SetPoint(51,1585.625,603.026);
928	+	graph->SetPoint(52,1597.347,598.75);
929	+	graph->SetPoint(53,1634.375,581.9133);
930	+	graph->SetPoint(54,1683.125,559.7463);
931	+	graph->SetPoint(55,1701.81,551.25);
932	+	graph->SetPoint(56,1731.875,537.5793);
933	+	graph->SetPoint(57,1780.625,515.4123);
934	+	graph->SetPoint(58,1806.273,503.75);
935	+	graph->SetPoint(59,1829.375,493.2101);
936	+	graph->SetPoint(60,1878.125,471.0784);
937	+	graph->SetPoint(61,1910.736,456.25);
938	+	graph->SetPoint(62,1926.875,448.241);
939	+	graph->SetPoint(63,1975.625,426.7444);
940	+	return graph;
941	+	}
942	+
943	+
944	+	//- Jim Lungu ----------------------------------------------
945	+
946	+	TGraph* Jim_mht_tb3(int mode){
947	+	Int_t n = 10;
948	+	Double_t x[10] = {15,65,115,165,215,265,315,365,415,465};
949	+	Double_t yobs[10] = {330,330,340,340,330,320,310,300,280,260};
950	+	Double_t yexp[10] = {330,320,320,320,320,310,300,290,270,250};
951	+	Double_t yexpp[10] = {350,350,350,340,340,330,330,310,300,280};
952	+	Double_t yexpn[10] = {310,310,310,300,300,300,280,270,240,240};
953	+	Double_t y[10];
954	+	for (int i=0;i<n;i++) {
955	+	if (mode==0) y[i] = yobs[i];
956	+	if (mode==1) y[i] = yexp[i];
957	+	if (mode==2) y[i] = yexpp[i];
958	+	if (mode==3) y[i] = yexpn[i];
959	+	}
960	+	TGraph* gr = new TGraph(n,x,y);
961	+	gr->SetLineWidth(2);
962	+	if (mode==1) gr->SetLineStyle(2);
963	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
964	+	else
965	+	gr->SetLineColor(2);
966	+	return gr;
967	+	}
968	+
969	+	TGraph* Jim_ht_tb3(int mode){
970	+	Int_t n = 10;
971	+	Double_t x[10] = {15,65,115,165,215,265,315,365,415,465};
972	+	Double_t yobs[10] = {300,300,290,290,300,290,280,270,260,250};
973	+	Double_t yexp[10] = {300,300,290,300,300,290,280,270,260,250};
974	+	Double_t yexpp[10] = {320,320,320,320,310,310,300,290,280,270};
975	+	Double_t yexpn[10] = {290,290,280,290,280,280,270,250,250,240};
976	+	Double_t y[10];
977	+	for (int i=0;i<n;i++) {
978	+	if (mode==0) y[i] = yobs[i];
979	+	if (mode==1) y[i] = yexp[i];
980	+	if (mode==2) y[i] = yexpp[i];
981	+	if (mode==3) y[i] = yexpn[i];
982	+	}
983	+	TGraph* gr = new TGraph(n,x,y);
984	+	gr->SetLineWidth(2);
985	+	if (mode==1) gr->SetLineStyle(2);
986	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
987	+	else
988	+	gr->SetLineColor(2);
989	+	return gr;
990	+	}
991	+
992	+	TGraph* Jim_mht_tb50(int mode){
993	+	Int_t n = 9;
994	+	Double_t x[9] = {205,255,305,355,405,455,505,555,605};
995	+	Double_t yobs[9] = {330,330,310,300,300,270,250,240,210};
996	+	Double_t yexp[9] = {320,320,300,290,280,250,240,230,210};
997	+	Double_t yexpp[9] = {350,340,330,320,310,290,260,250,230};
998	+	Double_t yexpn[9] = {300,300,290,280,260,240,230,200,190};
999	+	Double_t y[9];
1000	+	for (int i=0;i<n;i++) {
1001	+	if (mode==0) y[i] = yobs[i];
1002	+	if (mode==1) y[i] = yexp[i];
1003	+	if (mode==2) y[i] = yexpp[i];
1004	+	if (mode==3) y[i] = yexpn[i];
1005	+	}
1006	+	TGraph* gr = new TGraph(n,x,y);
1007	+	gr->SetLineWidth(2);
1008	+	if (mode==1) gr->SetLineStyle(2);
1009	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
1010	+	else
1011	+	gr->SetLineColor(2);
1012	+	return gr;
1013	+	}
1014	+
1015	+	TGraph* Jim_ht_tb50(int mode){
1016	+	Int_t n = 9;
1017	+	Double_t x[9] = {205,255,305,355,405,455,505,555,605};
1018	+	Double_t yobs[9] = {300,290,280,280,260,250,230,220,220};
1019	+	Double_t yexp[9] = {300,290,280,280,260,250,240,230,220};
1020	+	Double_t yexpp[9] = {320,310,300,290,290,270,260,250,240};
1021	+	Double_t yexpn[9] = {280,270,270,260,250,240,230,220,210};
1022	+	Double_t y[10];
1023	+	for (int i=0;i<n;i++) {
1024	+	if (mode==0) y[i] = yobs[i];
1025	+	if (mode==1) y[i] = yexp[i];
1026	+	if (mode==2) y[i] = yexpp[i];
1027	+	if (mode==3) y[i] = yexpn[i];
1028	+	}
1029	+	TGraph* gr = new TGraph(n,x,y);
1030	+	gr->SetLineWidth(2);
1031	+	if (mode==1) gr->SetLineStyle(2);
1032	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
1033	+	else
1034	+	gr->SetLineColor(2);
1035	+	return gr;
1036	+	}
1037	+
1038	+	TGraph* Jim_mht_tb10(int mode){
1039	+	Int_t n = 20;
1040	+	Double_t x[20] = {15,65,115,165,215,265,315,365,415,465,515,565,615,665,715,765,815,865,915,965};
1041	+	Double_t yobs[20] = {330,340,330,330,330,320,310,280,280,260,240,230,220,220,210,190,190,180,180,180};
1042	+	Double_t yexp[20] = {330,320,320,320,320,310,300,280,270,250,240,220,220,200,190,190,180,160,170,160};
1043	+	Double_t yexpp[20] = {330,340,350,340,330,330,330,310,300,280,270,240,240,230,220,210,200,180,190,180};
1044	+	Double_t yexpn[20] = {290,280,310,300,300,290,280,270,250,240,220,210,200,190,160,170,160,150,150,140};
1045	+	Double_t y[20];
1046	+	for (int i=0;i<n;i++) {
1047	+	if (mode==0) y[i] = yobs[i];
1048	+	if (mode==1) y[i] = yexp[i];
1049	+	if (mode==2) y[i] = yexpp[i];
1050	+	if (mode==3) y[i] = yexpn[i];
1051	+	}
1052	+	TGraph* gr = new TGraph(n,x,y);
1053	+	gr->SetLineWidth(2);
1054	+	if (mode==1) gr->SetLineStyle(2);
1055	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
1056	+	else
1057	+	gr->SetLineColor(2);
1058	+	return gr;
1059	+	}
1060	+
1061	+	TGraph* Jim_ht_tb10(int mode){
1062	+	Int_t n = 20;
1063	+	Double_t x[20] = {15,65,115,165,215,265,315,365,415,465,515,565,615,665,715,765,815,865,915,965};
1064	+	Double_t yobs[20] = {290,280,300,290,300,290,280,270,250,250,240,230,220,220,210,190,200,180,190,180};
1065	+	Double_t yexp[20] = {290,280,290,300,300,290,280,270,250,250,240,240,220,220,210,190,200,180,190,180};
1066	+	Double_t yexpp[20] = {330,320,310,310,310,310,300,280,280,260,260,250,240,230,220,220,210,210,200,190};
1067	+	Double_t yexpn[20] = {290,280,280,280,280,280,270,260,240,240,230,220,200,200,190,190,180,180,170,170};
1068	+	Double_t y[20];
1069	+	for (int i=0;i<n;i++) {
1070	+	if (mode==0) y[i] = yobs[i];
1071	+	if (mode==1) y[i] = yexp[i];
1072	+	if (mode==2) y[i] = yexpp[i];
1073	+	if (mode==3) y[i] = yexpn[i];
1074	+	}
1075	+	TGraph* gr = new TGraph(n,x,y);
1076	+	gr->SetLineWidth(2);
1077	+	if (mode==1) gr->SetLineStyle(2);
1078	+	if (mode>2) {gr->SetFillColor(8); gr->SetLineColor(8);}
1079	+	else
1080	+	gr->SetLineColor(2);
1081	+	return gr;
1082		}
1083
1084
950	–	TGraphErrors* getObserved_NLO_tanBeta50(){
951	–
952	–	Int_t nl = 10;
953	–	Double_t xl[10];
954	–	Double_t yl[10];
955	–	Double_t exl[10];
956	–	Double_t eyl[10];
957	–
958	–	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
959	–
960	–
961	–	xl[0] = 200;
962	–	yl[0] = 243;
963	–	xl[1] = 220;
964	–	yl[1] = 264;
965	–	xl[2] = 235;
966	–	yl[2] = 278;
967	–	xl[3] = 250;
968	–	yl[3] = 267;
969	–	xl[4] = 300;
970	–	yl[4] = 230;
971	–	xl[5] = 350;
972	–	yl[5] = 205;
973	–	xl[6] = 400;
974	–	yl[6] = 184;
975	–	xl[7] = 450;
976	–	yl[7] = 168;
977	–	xl[8] = 500;
978	–	yl[8] = 156;
979	–	xl[9] = 520;
980	–	yl[9] = 148;
981	–
982	–
983	–
984	–
985	–
986	–	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
987	–	gr1->SetMarkerColor(kBlue);
988	–	gr1->SetMarkerStyle(21);
989	–
990	–
991	–	//gr1->Draw("LP");
992	–
993	–	TSpline3 *s = new TSpline3("grs",gr1);
994	–	s->SetLineColor(kRed);
995	–	//  s->SetLineStyle(2);
996	–	s->SetLineWidth(3);
997	–
998	–
999	–	return gr1;
1000	–
1001	–
1002	–
1003	–
1004	–
1005	–	}
1085

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines