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

Diff Legend

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