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.2 by auterman, Thu Dec 23 12:57:53 2010 UTC vs.
Revision 1.12 by auterman, Wed Mar 2 13:31:32 2011 UTC

#	Line 1 | Line 1
1		#include "SusyScan.h"
2		#include "GeneratorMasses.h"
3
4	+	#include "TGraph.h"
5	+	#include "TLatex.h"
6	+	#include "TF1.h"
7	+	#include "TGraphErrors.h"
8	+	#include "TSpline.h"
9	+	#include "TStyle.h"
10	+	#include "TMath.h"
11	+
12		#include <cmath>
13	+	#include <iostream>
14
15
16	<	double Luminosity = 31.2; //[pb^-1]
16	>	double Luminosity = 36.3; //[pb^-1]
17		double Mzero(const SusyScan* p){ return p->Mzero; }
18		double Mhalf(const SusyScan* p){ return p->Mhalf; }
19		double MGluino(const SusyScan* p){ return p->MGL; }
#	Line 16 | Line 25 | double MChi3(const SusyScan* p){ return
25		double MChi4(const SusyScan* p){ return p->MZ4; }
26		double MCha1(const SusyScan* p){ return p->MW1; }
27		double MCha2(const SusyScan* p){ return p->MW2; }
28	+	double SignalUncertKfactor(const SusyScan* p){return fabs(p->signal_kfactor_UP-p->signal_kfactor_DN)/(2.0*p->signal_kfactor); }
29	+	double SignalUncertJEC(const SusyScan* p){ return (fabs(p->signal_JEC_UP)+fabs(p->signal_JEC_DN))/(2.0*p->signal); }
30	+	double SignalUncertMuIso(const SusyScan* p){ return (fabs(p->signal_MuIso_UP)+fabs(p->signal_MuIso_DN))/(2.0*p->signal); }
31	+	double SignalKfactor(const SusyScan* p){return p->signal_kfactor; }
32	+
33		double Xsection(const SusyScan* p){ return p->Xsection; }
34		double ExpXsecLimit(const SusyScan* p){ return p->ExpXsecLimit; }
35		double ObsXsecLimit(const SusyScan* p){ return p->ObsXsecLimit; }
36	<	double ExpExclusion(const SusyScan* p){ return (ExpXsecLimit(p)<Xsection(p)&&ExpXsecLimit(p)>0.01?1:-1); }
37	<	double ObsExclusion(const SusyScan* p){ return (ObsXsecLimit(p)<Xsection(p)&&ObsXsecLimit(p)>0.01?1:-1); }
36	>	double Signal(const SusyScan* p){ return p->signal; }
37	>	double SignalUncertainty(const SusyScan* p){ return p->signal_uncertainty; }
38	>	double SignalRelUncertainty(const SusyScan* p){ return p->signal_uncertainty/p->signal; }
39	>	double ExpExclusion(const SusyScan* p){ return (ExpXsecLimit(p)<Xsection(p)&&ExpXsecLimit(p)>0.01?1:0.01); }
40	>	double ObsExclusion(const SusyScan* p){ return (ObsXsecLimit(p)<Xsection(p)&&ObsXsecLimit(p)>0.01?1:0.01); }
41	>	double ExpExclCL(const SusyScan* p){ return (p->CLs_b_xsec<=0.05 ? 1:0.01); }
42	>	double ExpExclCLm2sigma(const SusyScan* p){ return (p->CLs_b_n2_xsec<=0.05 ? 1:0.01); }
43	>	double ExpExclCLm1sigma(const SusyScan* p){ return (p->CLs_b_n1_xsec<=0.05 ? 1:0.01); }
44	>	double ExpExclCLp1sigma(const SusyScan* p){ return (p->CLs_b_p1_xsec<=0.05 ? 1:0.01); }
45	>	double ExpExclCLp2sigma(const SusyScan* p){ return (p->CLs_b_p2_xsec<=0.05 ? 1:0.01); }
46	>	double ObsExclCL(const SusyScan* p){ return (p->CLs_xsec<=0.05 ? 1:0.01); }
47		double SoverSqrtB(const SusyScan* p){ return p->signal/(sqrt(p->background)+p->background_uncertainty+p->signal_uncertainty); }
48		double XsecOverObserved(const SusyScan* p){ return (ObsXsecLimit(p)==0 ? 9999. : Xsection(p)/ObsXsecLimit(p)); }
49	<	double XsecOverExpected(const SusyScan* p){ return (ObsXsecLimit(p)==0 ? 9999. : Xsection(p)/ObsXsecLimit(p)); }
49	>	double XsecOverExpected(const SusyScan* p){ return (ExpXsecLimit(p)==0 ? 9999. : Xsection(p)/ExpXsecLimit(p)); }
50		double SignalAcceptance(const SusyScan* p){ return  p->signal / (Luminosity*Xsection(p)); }
51	<	double ExpNSignLimit(const SusyScan* p){ return  p->signal * ExpXsecLimit(p)/Xsection(p); }
52	<	double ObsNSignLimit(const SusyScan* p){ return  p->signal * ObsXsecLimit(p)/Xsection(p); }
53	<
54	<
55	<
51	>	double ExpNSignLimit(const SusyScan* p){ return  p->ExpNsigLimit; }
52	>	double ObsNSignLimit(const SusyScan* p){ return  p->ObsNsigLimit; }
53	>	double PLExpNSignLimit(const SusyScan* p){ return  p->PLExpNsigLimit; }
54	>	double PLObsNSignLimit(const SusyScan* p){ return  p->PLObsNsigLimit; }
55	>	double PLExpXsecLimit(const SusyScan* p){ return p->PLExpXsecLimit; }
56	>	double PLObsXsecLimit(const SusyScan* p){ return p->PLObsXsecLimit; }
57	>	double PLExpExclusion(const SusyScan* p){ return (PLExpXsecLimit(p)<Xsection(p)&&PLExpXsecLimit(p)>0.01?1:0.01); }
58	>	double PLObsExclusion(const SusyScan* p){ return (PLObsXsecLimit(p)<Xsection(p)&&PLObsXsecLimit(p)>0.01?1:0.01); }
59	>	double FCExpNSignLimit(const SusyScan* p){ return  p->FCExpNsigLimit; }
60	>	double FCObsNSignLimit(const SusyScan* p){ return  p->FCObsNsigLimit; }
61	>	double FCExpXsecLimit(const SusyScan* p){ return p->FCExpXsecLimit; }
62	>	double FCObsXsecLimit(const SusyScan* p){ return p->FCObsXsecLimit; }
63	>	double FCExpExclusion(const SusyScan* p){ return (FCExpXsecLimit(p)<Xsection(p)&&FCExpXsecLimit(p)>0.01?1:0.01); }
64	>	double FCObsExclusion(const SusyScan* p){ return (FCObsXsecLimit(p)<Xsection(p)&&FCObsXsecLimit(p)>0.01?1:0.01); }
65	>	double MCMCExpNSignLimit(const SusyScan* p){ return  p->MCMCExpNsigLimit; }
66	>	double MCMCObsNSignLimit(const SusyScan* p){ return  p->MCMCObsNsigLimit; }
67	>	double MCMCExpXsecLimit(const SusyScan* p){ return p->MCMCExpXsecLimit; }
68	>	double MCMCObsXsecLimit(const SusyScan* p){ return p->MCMCObsXsecLimit; }
69	>	double MCMCExpExclusion(const SusyScan* p){ return (MCMCExpXsecLimit(p)<Xsection(p)&&MCMCExpXsecLimit(p)>0.01?1:0.01); }
70	>	double MCMCObsExclusion(const SusyScan* p){ return (MCMCObsXsecLimit(p)<Xsection(p)&&MCMCObsXsecLimit(p)>0.01?1:0.01); }
71	>	double SignalContamination(const SusyScan* p){return p->signal_contamination; }
72
73	+	double NLOXsection(const SusyScan* p){ return p->Xsection * p->signal_kfactor; }
74	+	double NLOExpXsecLimit(const SusyScan* p){ return p->NLO_ExpXsecLimit; }
75	+	double NLOObsXsecLimit(const SusyScan* p){ return p->NLO_ObsXsecLimit; }
76	+	double NLOSignal(const SusyScan* p){ return p->NLO_signal; }
77	+	double NLOSignalUncertainty(const SusyScan* p){ return p->NLO_signal_uncertainty; }
78	+	double NLOSignalRelUncertainty(const SusyScan* p){ return p->NLO_signal_uncertainty/p->NLO_signal; }
79	+	double NLOExpExclusion(const SusyScan* p){ return (NLOExpXsecLimit(p)<NLOXsection(p)&&NLOExpXsecLimit(p)>0.01?1:0.01); }
80	+	double NLOObsExclusion(const SusyScan* p){ return (NLOObsXsecLimit(p)<NLOXsection(p)&&NLOObsXsecLimit(p)>0.01?1:0.01); }
81	+	double NLOExpExclCL(const SusyScan* p){ return (p->NLO_CLs_b_xsec<=0.05 ? 1:0.01); }
82	+	double NLOExpExclCLm2sigma(const SusyScan* p){ return (p->NLO_CLs_b_n2_xsec<=0.05 ? 1:0.01); }
83	+	double NLOExpExclCLm1sigma(const SusyScan* p){ return (p->NLO_CLs_b_n1_xsec<=0.05 ? 1:0.01); }
84	+	double NLOExpExclCLp1sigma(const SusyScan* p){ return (p->NLO_CLs_b_p1_xsec<=0.05 ? 1:0.01); }
85	+	double NLOExpExclCLp2sigma(const SusyScan* p){ return (p->NLO_CLs_b_p2_xsec<=0.05 ? 1:0.01); }
86	+	double NLOObsExclCL(const SusyScan* p){ return (p->NLO_CLs_xsec<=0.05 ? 1:0.01); }
87	+	double NLOSoverSqrtB(const SusyScan* p){ return p->NLO_signal/(sqrt(p->background)+p->background_uncertainty+p->NLO_signal_uncertainty); }
88	+	double NLOXsecOverObserved(const SusyScan* p){ return (NLOObsXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOObsXsecLimit(p)); }
89	+	double NLOXsecOverExpected(const SusyScan* p){ return (NLOExpXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOExpXsecLimit(p)); }
90	+	double NLOSignalAcceptance(const SusyScan* p){ return  p->NLO_signal / (Luminosity*NLOXsection(p)); }
91	+	double NLOExpNSignLimit(const SusyScan* p){ return  p->NLO_ExpNsigLimit; }
92	+	double NLOObsNSignLimit(const SusyScan* p){ return  p->NLO_ObsNsigLimit; }
93	+	double NLOPLExpNSignLimit(const SusyScan* p){ return  p->NLO_PLExpNsigLimit; }
94	+	double NLOPLObsNSignLimit(const SusyScan* p){ return  p->NLO_PLObsNsigLimit; }
95	+	double NLOPLExpXsecLimit(const SusyScan* p){ return p->NLO_PLExpXsecLimit; }
96	+	double NLOPLObsXsecLimit(const SusyScan* p){ return p->NLO_PLObsXsecLimit; }
97	+	double NLOPLExpExclusion(const SusyScan* p){ return (NLOPLExpXsecLimit(p)<NLOXsection(p)&&NLOPLExpXsecLimit(p)>0.01?1:0.01); }
98	+	double NLOPLObsExclusion(const SusyScan* p){ return (NLOPLObsXsecLimit(p)<NLOXsection(p)&&NLOPLObsXsecLimit(p)>0.01?1:0.01); }
99	+	double NLOFCExpNSignLimit(const SusyScan* p){ return  p->NLO_FCExpNsigLimit; }
100	+	double NLOFCObsNSignLimit(const SusyScan* p){ return  p->NLO_FCObsNsigLimit; }
101	+	double NLOFCExpXsecLimit(const SusyScan* p){ return p->NLO_FCExpXsecLimit; }
102	+	double NLOFCObsXsecLimit(const SusyScan* p){ return p->NLO_FCObsXsecLimit; }
103	+	double NLOFCExpExclusion(const SusyScan* p){ return (NLOFCExpXsecLimit(p)<NLOXsection(p)&&NLOFCExpXsecLimit(p)>0.01?1:0.01); }
104	+	double NLOFCObsExclusion(const SusyScan* p){ return (NLOFCObsXsecLimit(p)<NLOXsection(p)&&NLOFCObsXsecLimit(p)>0.01?1:0.01); }
105	+	double NLOMCMCExpNSignLimit(const SusyScan* p){ return  p->NLO_MCMCExpNsigLimit; }
106	+	double NLOMCMCObsNSignLimit(const SusyScan* p){ return  p->NLO_MCMCObsNsigLimit; }
107	+	double NLOMCMCExpXsecLimit(const SusyScan* p){ return p->NLO_MCMCExpXsecLimit; }
108	+	double NLOMCMCObsXsecLimit(const SusyScan* p){ return p->NLO_MCMCObsXsecLimit; }
109	+	double NLOMCMCExpExclusion(const SusyScan* p){ return (NLOMCMCExpXsecLimit(p)<NLOXsection(p)&&NLOMCMCExpXsecLimit(p)>0.01?1:0.01); }
110	+	double NLOMCMCObsExclusion(const SusyScan* p){ return (NLOMCMCObsXsecLimit(p)<NLOXsection(p)&&NLOMCMCObsXsecLimit(p)>0.01?1:0.01); }
111	+	double NLOSignalContamination(const SusyScan* p){return p->NLO_signal_contamination; }
112
113		double Mzero(const GeneratorMasses* p){ return p->Mzero; }
114		double Mhalf(const GeneratorMasses* p){ return p->Mhalf; }
#	Line 43 | Line 121 | double MChi3(const GeneratorMasses* p){
121		double MChi4(const GeneratorMasses* p){ return p->MZ4; }
122		double MCha1(const GeneratorMasses* p){ return p->MW1; }
123		double MCha2(const GeneratorMasses* p){ return p->MW2; }
124	+
125	+	TGraph* set_sneutrino_d0_1(Int_t tanBeta){
126	+	double sn_m0[14]= {0,  0, 48, 55, 80, 90,100,105,109,105,100, 72, 55,0};
127	+	double sn_m12[14]={0,140,210,220,237,241,242,241,230,220,210,170,150,0};
128	+
129	+	TGraph* sn_d0_gr = new TGraph(14,sn_m0,sn_m12);
130	+
131	+	sn_d0_gr->SetFillColor(kGreen+3);
132	+	sn_d0_gr->SetFillStyle(1001);
133	+
134	+	return sn_d0_gr;
135	+	}
136	+
137	+	TGraph* set_sneutrino_d0_2(Int_t tanBeta){
138	+	double sn_m0[9]= {0, 45, 75,115,130,150,163,185,0};
139	+	double sn_m12[9]={0,140,170,213,202,183,168,140,0};
140	+
141	+	TGraph* sn_d0_gr_2 = new TGraph(9,sn_m0,sn_m12);
142	+
143	+	sn_d0_gr_2->SetFillColor(kGreen+3);
144	+	sn_d0_gr_2->SetFillStyle(1001);
145	+
146	+	return sn_d0_gr_2;
147	+	}
148	+
149	+
150	+	TGraph* set_lep_ch_tanBeta10(){
151	+
152	+	double ch_m0[12];
153	+	double ch_m12[12];
154	+
155	+	ch_m0[0] = 0;
156	+	ch_m0[1] = 100;
157	+	ch_m0[2] = 200;
158	+	ch_m0[3] = 300;
159	+	ch_m0[4] = 400;
160	+	ch_m0[5] = 500;
161	+	ch_m0[6] = 600;
162	+	ch_m0[7] = 700;
163	+	ch_m0[8] = 800;
164	+	ch_m0[9] = 1000;
165	+	ch_m0[10] = 1000;
166	+	ch_m0[11] = 0;
167	+
168	+	ch_m12[0] = 163;
169	+	ch_m12[1] = 162;
170	+	ch_m12[2] = 161;
171	+	ch_m12[3] = 160;
172	+	ch_m12[4] = 159;
173	+	ch_m12[5] = 158;
174	+	ch_m12[6] = 157;
175	+	ch_m12[7] = 156;
176	+	ch_m12[8] = 155.4;
177	+	ch_m12[9] = 154;
178	+	ch_m12[10] = 0;
179	+	ch_m12[11] = 0;
180	+
181	+
182	+	TGraph* ch_gr = new TGraph(12,ch_m0,ch_m12);
183	+
184	+	ch_gr->SetFillColor(3);
185	+	ch_gr->SetLineColor(3);
186	+	//  ch_gr->SetLineWidth(3);
187	+	ch_gr->SetFillStyle(1001);
188	+
189	+	return ch_gr;
190	+
191	+	}
192	+
193	+
194	+
195	+	TGraph* set_lep_ch_tanBeta3(){
196	+
197	+	double ch_m0[17];
198	+	double ch_m12[17];
199	+
200	+	ch_m0[0] = 0;
201	+	ch_m0[1] = 100;
202	+	ch_m0[2] = 150;
203	+	ch_m0[3] = 200;
204	+	ch_m0[4] = 250;
205	+	ch_m0[5] = 300;
206	+	ch_m0[6] = 350;
207	+	ch_m0[7] = 400;
208	+	ch_m0[8] = 450;
209	+	ch_m0[9] = 500;
210	+	ch_m0[10] = 550;
211	+	ch_m0[11] = 600;
212	+	ch_m0[12] = 650;
213	+	ch_m0[13] = 700;
214	+	ch_m0[14] = 750;
215	+	ch_m0[15] = 750;
216	+	ch_m0[16] = 0;
217	+
218	+	ch_m12[0] = 170;
219	+	ch_m12[1] = 168;
220	+	ch_m12[2] = 167;
221	+	ch_m12[3] = 165;
222	+	ch_m12[4] = 163;
223	+	ch_m12[5] = 161;
224	+	ch_m12[6] = 158;
225	+	ch_m12[7] = 156;
226	+	ch_m12[8] = 154;
227	+	ch_m12[9] = 152;
228	+	ch_m12[10] = 150;
229	+	ch_m12[11] = 148;
230	+	ch_m12[12] = 147;
231	+	ch_m12[13] = 145;
232	+	ch_m12[14] = 144;
233	+	ch_m12[15] = 0;
234	+	ch_m12[16] = 0;
235	+
236	+	TGraph* ch_gr = new TGraph(17,ch_m0,ch_m12);
237	+
238	+	ch_gr->SetFillColor(3);
239	+	ch_gr->SetLineColor(3);
240	+	// ch_gr->SetLineWidth(3);
241	+	ch_gr->SetFillStyle(1001);
242	+
243	+	return ch_gr;
244	+
245	+	}
246	+
247	+
248	+	TGraph* set_lep_ch_tanBeta50(){
249	+
250	+	double ch_m0[21];
251	+	double ch_m12[21];
252	+
253	+	ch_m0[0] = 200;
254	+	ch_m0[1] = 250;
255	+	ch_m0[2] = 300;
256	+	ch_m0[3] = 350;
257	+	ch_m0[4] = 400;
258	+	ch_m0[5] = 450;
259	+	ch_m0[6] = 500;
260	+	ch_m0[7] = 550;
261	+	ch_m0[8] = 600;
262	+	ch_m0[9] = 650;
263	+	ch_m0[10] = 700;
264	+	ch_m0[11] = 750;
265	+	ch_m0[12] = 800;
266	+	ch_m0[13] =850;
267	+	ch_m0[14] = 900;
268	+	ch_m0[15] = 950;
269	+	ch_m0[16] = 1000;
270	+	ch_m0[17] = 1050;
271	+	ch_m0[18] = 1100;
272	+	ch_m0[19] = 1100;
273	+	ch_m0[20] = 200;
274	+
275	+	ch_m12[0] = 157;
276	+	ch_m12[1] = 156;
277	+	ch_m12[2] = 156;
278	+	ch_m12[3] = 155;
279	+	ch_m12[4] = 155;
280	+	ch_m12[5] = 154;
281	+	ch_m12[6] = 154;
282	+	ch_m12[7] = 153;
283	+	ch_m12[8] = 153;
284	+	ch_m12[9] = 152;
285	+	ch_m12[10] = 152;
286	+	ch_m12[11] = 152;
287	+	ch_m12[12] = 152;
288	+	ch_m12[13] = 152;
289	+	ch_m12[14] = 152;
290	+	ch_m12[15] = 153;
291	+	ch_m12[16] = 153;
292	+	ch_m12[17] = 153;
293	+	ch_m12[18] = 154;
294	+	ch_m12[19] = 0;
295	+	ch_m12[20] = 0;
296	+
297	+
298	+	TGraph* ch_gr = new TGraph(21,ch_m0,ch_m12);
299	+
300	+	ch_gr->SetFillColor(3);
301	+	ch_gr->SetLineColor(3);
302	+	ch_gr->SetFillStyle(1001);
303	+
304	+	return ch_gr;
305	+
306	+	}
307	+
308	+
309	+	TGraph* set_lep_ch(Int_t tanBeta){
310	+	if(tanBeta == 3) return set_lep_ch_tanBeta3();
311	+	if(tanBeta == 10) return set_lep_ch_tanBeta10();
312	+	if(tanBeta == 50) return set_lep_ch_tanBeta50();
313	+	}
314	+
315	+
316	+	TGraph* set_lep_sl(Int_t tanBeta){
317	+
318	+	// CMS SUSY Summer2010 implementation
319	+	//  double sl_m0[] =  {0,  0, 30, 50, 60, 75, 80,90,100};
320	+	//  double sl_m12[] = {0,245,240,220,200,150,100,50,0};
321	+
322	+	//contour from D0 trilepton paper (PLB 680 (2009) 34-43)
323	+
324	+	double *sl_m0 = 0;
325	+	double *sl_m12 = 0;
326	+	int n = 0;
327	+
328	+	double sl_m0_3[] ={0,  0, 10, 20, 30, 40, 50, 60, 70, 77,88,95};
329	+	double sl_m12_3[]={0,245,242,239,232,222,209,189,165,140,60,0};
330	+	int n_3 = 12;
331	+
332	+	double sl_m0_10[]={ 0,  0, 11, 20, 24, 49, 70, 82,88,90};
333	+	double sl_m12_10[]={0,240,237,233,230,200,150,100,50,0};
334	+	int n_10 = 10;
335	+
336	+	if (tanBeta==3){
337	+	sl_m0 = sl_m0_3;
338	+	sl_m12 = sl_m12_3;
339	+	n = n_3;
340	+	}
341	+	//CMS PTDR-II
342	+	//* Selectron_R line mass=99, ISASUGRA7.69, A0=0, m_top=175, tan(beta]=10
343	+	if (tanBeta==10 || tanBeta==50){
344	+	sl_m0 = sl_m0_10;
345	+	sl_m12 = sl_m12_10;
346	+	n = n_10;
347	+	}
348	+
349	+	TGraph* lep_sl = new TGraph(n,sl_m0,sl_m12);
350	+
351	+	lep_sl->SetFillColor(5);
352	+	lep_sl->SetLineColor(5);
353	+	lep_sl->SetFillStyle(1001);
354	+
355	+	return lep_sl;
356	+	}
357	+
358	+
359	+	TGraph* set_tev_sg_cdf(Int_t tanBeta){
360	+
361	+	//  double sg_m0[] =  {0,  0, 20, 50,100,150,200,250,300,350,400,450,500,550,600,600};
362	+	//  double sg_m12[] = {0,160,169,170,160,155,150,122,116,112,110,106,105,100, 98,  0};
363	+	//  int np=16;
364	+	//New CHF from CDF plot in ICHEP2010 talk (E. Halkiadakis)
365	+	double sg_m0[]= {0,  0, 30, 75,150,185,225,310,360,400,430,500,600,600};
366	+	double sg_m12[]={0,162,168,170,160,150,130,120,109,108,100, 96, 95,  0};
367	+	int np=14;
368	+
369	+	TGraph* sg_gr = new TGraph(np,sg_m0,sg_m12);
370	+
371	+	//  gStyle->SetHatchesLineWidth(3);
372	+
373	+	sg_gr->SetFillColor(2);
374	+	sg_gr->SetLineColor(2);
375	+	//  sg_gr->SetLineWidth(3);
376	+	sg_gr->SetFillStyle(1001);
377	+
378	+	return sg_gr;
379	+
380	+	}
381	+
382	+	TGraph* set_tev_sg_d0(Int_t tanBeta){
383	+
384	+	//  double sgd_m0[] = {0, 0,  50, 100,150,200,250,300,350,400,450,500,550,600,600};
385	+	//  double sgd_m12[] = {0,168,167,162,157,145,125,120,110,108,95, 94 ,94 ,93,0};
386	+	//  int np=15;
387	+	double sgd_m0[]= {0,  0, 30, 80,150,240,320,400,500,600,600,0};
388	+	double sgd_m12[]={0,167,166,162,156,138,121,109,105,105,  0,0};
389	+	int npd=12;
390	+
391	+	TGraph* sgd_gr = new TGraph(npd,sgd_m0,sgd_m12);
392	+
393	+	gStyle->SetHatchesLineWidth(3);
394	+
395	+	sgd_gr->SetFillColor(kMagenta+3);
396	+	sgd_gr->SetLineColor(kMagenta+3);
397	+	sgd_gr->SetLineWidth(3);
398	+	sgd_gr->SetFillStyle(3335);
399	+
400	+	return sgd_gr;
401	+
402	+	}
403	+
404	+	// TGraph* set_tev_tlp_cdf(Int_t tanBeta){
405	+	//   double tlp1_m0[] = {   0, 20, 40, 60, 70, 80, 90, 80, 70, 60};
406	+	//   double tlp1_m12[] = {170,185,200,215,220,215,210,190,175,160};
407	+	//   TGraph* tlp1_gr = new TGraph(10,tlp1_m0,tlp1_m12);
408	+
409	+	//   tlp1_gr->SetFillColor(4);
410	+	//   tlp1_gr->SetLineColor(4);
411	+	//   tlp1_gr->SetFillStyle(1001);
412	+
413	+	//   return tlp1_gr;
414	+	// }
415	+
416	+	// TGraph* set_tev_tlp_d0(Int_t tanBeta){
417	+	//   double tlp2_m0[] = {  70, 80, 90,100,105,110,120,130,140};
418	+	//   double tlp2_m12[] = {160,172,184,196,205,195,185,173,160};
419	+	//   TGraph* tlp2_gr = new TGraph(9,tlp2_m0,tlp2_m12);
420	+
421	+	//   tlp2_gr->SetFillColor(4);
422	+	//   tlp2_gr->SetFillStyle(1001);
423	+
424	+	//   return tlp2_gr;
425	+
426	+	// }
427	+
428	+
429	+
430	+
431	+
432	+	TGraph* set_tev_stau(Int_t tanBeta){
433	+
434	+	double st_m0_tanBeta3[] = {0,10,20,30,40,50,60,70,80,90,100,0};
435	+	double st_m12_tanBeta3[] = {337,341,356,378,406,439,473,510,548,587,626,626};
436	+
437	+	double st_m0_tanBeta10[] = {0,10,20,30,40,50,60,70,80,90,100,0};
438	+	double st_m12_tanBeta10[] = {213,220,240,275,312,351,393,435,476,518,559,559};
439	+
440	+	double st_m0_tanBeta50[] = {200,210,220,230,240,250,260,270,280,290,310,325,200,200};
441	+	double st_m12_tanBeta50[] = {206,226,246,267,288,310,332,354,376,399,450,500,500,206};
442	+
443	+
444	+	TGraph* st_gr_tanBeta3 = new TGraph(12,st_m0_tanBeta3,st_m12_tanBeta3);
445	+	TGraph* st_gr_tanBeta10 = new TGraph(12,st_m0_tanBeta10,st_m12_tanBeta10);
446	+	TGraph* st_gr_tanBeta50 = new TGraph(14,st_m0_tanBeta50,st_m12_tanBeta50);
447	+
448	+	st_gr_tanBeta3->SetFillColor(40);
449	+	st_gr_tanBeta3->SetFillStyle(1001);
450	+
451	+	st_gr_tanBeta50->SetFillColor(40);
452	+	st_gr_tanBeta50->SetFillStyle(1001);
453	+
454	+	st_gr_tanBeta10->SetFillColor(40);
455	+	st_gr_tanBeta10->SetFillStyle(1001);
456	+
457	+
458	+	if(tanBeta == 3)return st_gr_tanBeta3;
459	+	if(tanBeta == 10)return st_gr_tanBeta10;
460	+	if(tanBeta == 50)return st_gr_tanBeta50;
461	+
462	+	}
463	+
464	+	TGraph* sq_LEP(){
465	+	double sq[] = {0,0,100,100};
466	+	double gl[] = {0,2000,2000,0};
467	+	TGraph* res = new TGraph(4,sq,gl);
468	+	res->SetFillColor(kBlue);
469	+	return res;
470	+	}
471	+
472	+	TGraph* gl_TEV(){
473	+	double sq[] = {0,2000,2000,0};
474	+	double gl[] = {0,0,190,190};
475	+	TGraph* res = new TGraph(4,sq,gl);
476	+	res->SetFillColor(kGreen+2);
477	+	return res;
478	+	}
479	+
480	+	TGraph* gl_CDF(){
481	+	double sq[] = {0,2000,2000,0};
482	+	double gl[] = {190,190,230,230};
483	+	TGraph* res = new TGraph(4,sq,gl);
484	+	res->SetFillColor(kOrange+5);
485	+	return res;
486	+	}
487	+
488	+	TGraph* gl_DEZ(){
489	+	double sq[] = {0,2000,2000,0};
490	+	double gl[] = {230,230,255,255};
491	+	TGraph* res = new TGraph(4,sq,gl);
492	+	res->SetFillColor(kYellow-5);
493	+	return res;
494	+	}
495	+
496	+	TGraph* gl_WHT(){
497	+	double sq[] = {101,2000,2000,101};
498	+	double gl[] = {256,256,400,400};
499	+	TGraph* res = new TGraph(4,sq,gl);
500	+	res->SetFillColor(kWhite);
501	+	return res;
502	+	}
503	+
504	+
505	+
506	+	TF1* constant_squark(int tanBeta,int i){
507	+	//---lines of constant gluino/squark
508	+	double coef1 = 0.35;
509	+	double coef2[] = {5,5,4.6,4.1};
510	+
511	+	char hname[200];
512	+
513	+	sprintf(hname,"lnsq_%i",i);
514	+
515	+
516	+	TF1* lnsq = new TF1(hname,"sqrt([0]-x*x*[1]-[2])",0,1000);
517	+	lnsq->SetParameter(0,(500+150*(i-1))*(500+150*(i-1))/coef2[i]);
518	+	lnsq->SetParameter(1,1./coef2[i]);
519	+	lnsq->SetParameter(2,-coef1*91*91*(2*TMath::Cos(TMath::ATan(tanBeta)))/coef2[i]);//--tanbeta=10 --> cos2beta = -99/101
520	+	lnsq->SetLineWidth(1);
521	+
522	+
523	+	lnsq->SetLineColor(kGray);
524	+
525	+	return lnsq;
526	+	}
527	+
528	+
529	+	TF1* constant_gluino(int tanBeta,int i){
530	+	//---lines of constant gluino/squark
531	+	double coef1 = 0.35;
532	+	double coef2[] = {5,5,4.6,4.1};
533	+
534	+	char hname[200];
535	+
536	+	sprintf(hname,"lngl_%i",i);
537	+
538	+	TF1* lngl = new TF1(hname,"[0]+x*[1]",0,1000);
539	+	lngl->SetParameter(0,(500+150.*(i-1))/2.4);
540	+	lngl->SetParameter(1,-40./1400);
541	+	lngl->SetLineWidth(1);
542	+	lngl->SetLineColor(kGray);
543	+
544	+	return lngl;
545	+	}
546	+
547	+
548	+	TLatex* constant_squark_text(Int_t it,TF1& lnsq,Int_t tanBeta_){
549	+	char legnm[200];
550	+
551	+	sprintf(legnm,"#font[92]{#tilde{q}(%i)GeV}",500+150*(it-1));
552	+	Double_t place_x = 170;
553	+	if(tanBeta_ == 50)place_x = 290;
554	+	TLatex* t3 = new TLatex(place_x+10*(it-1),lnsq.Eval(place_x+10*(it-1))+5,legnm);
555	+	t3->SetTextSize(0.03);
556	+	t3->SetTextAngle(-8);
557	+	t3->SetTextColor(kGray+2);
558	+
559	+
560	+
561	+	return t3;
562	+	}
563	+
564	+	TLatex* constant_gluino_text(Int_t it,TF1& lngl){
565	+	char legnm[200];
566	+
567	+	sprintf(legnm,"#font[12]{#tilde{g}}#font[92]{(%i)GeV}",500+150*(it-1));
568	+	TLatex* t4 = new TLatex(423,18+lngl.Eval(480),legnm);
569	+	t4->SetTextSize(0.03);
570	+	t4->SetTextAlign(13);
571	+	t4->SetTextColor(kGray+2);
572	+
573	+	return t4;
574	+	}
575	+
576	+
577	+	TGraphErrors* getLO_tanBeta3(){
578	+
579	+
580	+
581	+	Int_t nl = 9;
582	+	Double_t xl[9];
583	+	Double_t yl[9];
584	+	Double_t exl[9];
585	+	Double_t eyl[9];
586	+
587	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
588	+
589	+
590	+	xl[0] = 0;
591	+	yl[0] = 265;
592	+	xl[1] = 100;
593	+	yl[1] = 258;
594	+	xl[2] = 200;
595	+	yl[2] = 250;
596	+	xl[3] = 250;
597	+	yl[3] = 240;
598	+	xl[4] = 300;
599	+	yl[4] = 210;
600	+	xl[5] = 340;
601	+	yl[5] = 177;
602	+	xl[6] = 400;
603	+	yl[6] = 140;
604	+	xl[7] = 450;
605	+	yl[7] = 120;
606	+	xl[8] = 520;
607	+	yl[8] =100;
608	+
609	+
610	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
611	+	gr1->SetMarkerColor(kGreen+2);
612	+	gr1->SetMarkerStyle(21);
613	+
614	+
615	+	//gr1->Draw("LP");
616	+
617	+	TSpline3 *s = new TSpline3("grs",gr1);
618	+	s->SetLineColor(kGreen+2);
619	+	s->SetLineStyle(4);
620	+	s->SetLineWidth(3);
621	+
622	+
623	+	return gr1;
624	+
625	+
626	+
627	+	}
628	+
629	+	TGraphErrors* getLO_tanBeta10(){
630	+
631	+
632	+
633	+	Int_t nl = 10;
634	+	Double_t xl[10];
635	+	Double_t yl[10];
636	+	Double_t exl[10];
637	+	Double_t eyl[10];
638	+
639	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
640	+
641	+	xl[0] = 0;
642	+	yl[0] = 270;
643	+	xl[1] = 100;
644	+	yl[1] = 260;
645	+	xl[2] = 200;
646	+	yl[2] = 250;
647	+	xl[3] = 250;
648	+	yl[3] = 240;
649	+	xl[4] = 300;
650	+	yl[4] = 210;
651	+	xl[5] = 350;
652	+	yl[5] = 174;
653	+	xl[6] = 400;
654	+	yl[6] = 147;
655	+	xl[7] = 450;
656	+	yl[7] = 127;
657	+	xl[8] = 500;
658	+	yl[8] =115;
659	+	xl[9] = 520;
660	+	yl[9] = 112;
661	+
662	+
663	+
664	+
665	+
666	+
667	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
668	+	gr1->SetMarkerColor(kGreen+2);
669	+	gr1->SetMarkerStyle(21);
670	+
671	+
672	+	//gr1->Draw("LP");
673	+
674	+	TSpline3 *s = new TSpline3("grs",gr1);
675	+	s->SetLineColor(kGreen+2);
676	+	s->SetLineStyle(4);
677	+	s->SetLineWidth(3);
678	+
679	+
680	+	return gr1;
681	+
682	+
683	+
684	+	}
685	+
686	+	TGraphErrors* getLO_tanBeta50(){
687	+
688	+
689	+
690	+	Int_t nl = 10;
691	+	Double_t xl[10];
692	+	Double_t yl[10];
693	+	Double_t exl[10];
694	+	Double_t eyl[10];
695	+
696	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
697	+
698	+
699	+	xl[0] = 200;
700	+	yl[0] = 239;
701	+	xl[1] = 210;
702	+	yl[1] = 249;
703	+	xl[2] = 229;
704	+	yl[2] = 260;
705	+	xl[3] = 250;
706	+	yl[3] = 245;
707	+	xl[4] = 300;
708	+	yl[4] = 210;
709	+	xl[5] = 350;
710	+	yl[5] = 180;
711	+	xl[6] = 400;
712	+	yl[6] = 160;
713	+	xl[7] = 450;
714	+	yl[7] = 150;
715	+	xl[8] = 500;
716	+	yl[8] =140;
717	+	xl[9] = 520;
718	+	yl[9] = 137;
719	+
720	+
721	+
722	+
723	+
724	+
725	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
726	+	gr1->SetMarkerColor(kGreen+2);
727	+	gr1->SetMarkerStyle(21);
728	+
729	+
730	+	//gr1->Draw("LP");
731	+
732	+	TSpline3 *s = new TSpline3("grs",gr1);
733	+	s->SetLineColor(kGreen+2);
734	+	s->SetLineStyle(4);
735	+	s->SetLineWidth(3);
736	+
737	+
738	+	return gr1;
739	+
740	+
741	+
742	+	}
743	+
744	+
745	+
746	+	TGraphErrors* getExpected_NLO_tanBeta3(){
747	+
748	+	Int_t nl = 11;
749	+	Double_t xl[11];
750	+	Double_t yl[11];
751	+	Double_t exl[11];
752	+	Double_t eyl[11];
753	+
754	+	xl[0] = 0;
755	+	yl[0] = 283;
756	+	xl[1] = 100;
757	+	yl[1] = 280;
758	+	xl[2] = 150;
759	+	yl[2] = 279;
760	+	xl[3] = 200;
761	+	yl[3] = 275;
762	+	xl[4] = 250;
763	+	yl[4] = 270;
764	+	xl[5] = 300;
765	+	yl[5] = 255;
766	+	xl[6] = 350;
767	+	yl[6] = 225;
768	+	xl[7] = 400;
769	+	yl[7] = 195;
770	+	xl[8] = 450;
771	+	yl[8] = 175;
772	+	xl[9] = 500;
773	+	yl[9] = 155;
774	+	xl[10] = 550;
775	+	yl[10] = 150;
776	+
777	+
778	+
779	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
780	+	gr1->SetMarkerColor(kBlue);
781	+	gr1->SetMarkerStyle(21);
782	+
783	+
784	+	//gr1->Draw("LP");
785	+
786	+	TSpline3 *s = new TSpline3("grs",gr1);
787	+	s->SetLineColor(kBlue);
788	+	s->SetLineStyle(2);
789	+	s->SetLineWidth(3);
790	+
791	+
792	+	return gr1;
793	+
794	+
795	+
796	+
797	+
798	+	}
799	+
800	+	TGraphErrors* getExpected_NLO_tanBeta10(){
801	+
802	+	Int_t nl = 11;
803	+	Double_t xl[11];
804	+	Double_t yl[11];
805	+	Double_t exl[11];
806	+	Double_t eyl[11];
807	+
808	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
809	+
810	+	xl[0] = 0;
811	+	yl[0] = 283;
812	+	xl[1] = 100;
813	+	yl[1] = 280;
814	+	xl[2] = 150;
815	+	yl[2] = 279;
816	+	xl[3] = 200;
817	+	yl[3] = 275;
818	+	xl[4] = 250;
819	+	yl[4] = 270;
820	+	xl[5] = 300;
821	+	yl[5] = 255;
822	+	xl[6] = 350;
823	+	yl[6] = 225;
824	+	xl[7] = 400;
825	+	yl[7] = 195;
826	+	xl[8] = 450;
827	+	yl[8] = 175;
828	+	xl[9] = 500;
829	+	yl[9] = 165;
830	+	xl[10] = 550;
831	+	yl[10] = 150;
832	+
833	+
834	+
835	+
836	+
837	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
838	+	gr1->SetMarkerColor(kBlue);
839	+	gr1->SetMarkerStyle(21);
840	+
841	+
842	+	//gr1->Draw("LP");
843	+
844	+	TSpline3 *s = new TSpline3("grs",gr1);
845	+	s->SetLineColor(kBlue);
846	+	s->SetLineStyle(2);
847	+	s->SetLineWidth(3);
848	+
849	+
850	+	return gr1;
851	+
852	+
853	+
854	+
855	+
856	+	}
857	+
858	+
859	+	TGraphErrors* getExpected_NLO_tanBeta50(){
860	+
861	+	Int_t nl = 10;
862	+	Double_t xl[10];
863	+	Double_t yl[10];
864	+	Double_t exl[10];
865	+	Double_t eyl[10];
866	+
867	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
868	+
869	+	xl[0] = 200;
870	+	yl[0] = 287;
871	+	xl[1] = 220;
872	+	yl[1] = 287;
873	+	xl[2] = 245;
874	+	yl[2] = 287;
875	+	xl[3] = 270;
876	+	yl[3] = 265;
877	+	xl[4] = 300;
878	+	yl[4] = 245;
879	+	xl[5] = 350;
880	+	yl[5] = 222;
881	+	xl[6] = 400;
882	+	yl[6] = 197;
883	+	xl[7] = 450;
884	+	yl[7] = 180;
885	+	xl[8] = 500;
886	+	yl[8] = 168;
887	+	xl[9] = 550;
888	+	yl[9] = 145;
889	+
890	+
891	+
892	+
893	+
894	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
895	+	gr1->SetMarkerColor(kBlue);
896	+	gr1->SetMarkerStyle(21);
897	+
898	+
899	+	//gr1->Draw("LP");
900	+
901	+	TSpline3 *s = new TSpline3("grs",gr1);
902	+	s->SetLineColor(kBlue);
903	+	s->SetLineStyle(2);
904	+	s->SetLineWidth(3);
905	+
906	+
907	+	return gr1;
908	+
909	+
910	+
911	+
912	+
913	+	}
914	+
915	+
916	+	TGraphErrors* getObserved_NLO_tanBeta3(){
917	+
918	+	Int_t nl = 11;
919	+	Double_t xl[11];
920	+	Double_t yl[11];
921	+	Double_t exl[11];
922	+	Double_t eyl[11];
923	+
924	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
925	+
926	+
927	+
928	+	xl[0] = 0;
929	+	yl[0] = 274;
930	+	xl[1] = 100;
931	+	yl[1] = 270;
932	+	xl[2] = 150;
933	+	yl[2] = 268;
934	+	xl[3] = 200;
935	+	yl[3] = 265;
936	+	xl[4] = 250;
937	+	yl[4] = 255;
938	+	xl[5] = 300;
939	+	yl[5] = 230;
940	+	xl[6] = 350;
941	+	yl[6] = 195;
942	+	xl[7] = 400;
943	+	yl[7] = 160;
944	+	xl[8] = 450;
945	+	yl[8] = 140;
946	+	xl[9] = 480;
947	+	yl[9] = 130;
948	+	xl[10] = 530;
949	+	yl[10] = 120;
950	+
951	+
952	+
953	+
954	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
955	+	gr1->SetMarkerColor(kBlue);
956	+	gr1->SetMarkerStyle(21);
957	+
958	+
959	+	//gr1->Draw("LP");
960	+
961	+	TSpline3 *s = new TSpline3("grs",gr1);
962	+	s->SetLineColor(kRed);
963	+	// s->SetLineStyle(2);
964	+	s->SetLineWidth(3);
965	+
966	+
967	+	return gr1;
968	+
969	+
970	+
971	+
972	+
973	+	}
974	+
975	+
976	+
977	+	TGraphErrors* getObserved_NLO_tanBeta10(){
978	+
979	+	Int_t nl = 11;
980	+	Double_t xl[11];
981	+	Double_t yl[11];
982	+	Double_t exl[11];
983	+	Double_t eyl[11];
984	+
985	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
986	+
987	+	xl[0] = 0;
988	+	yl[0] = 278;
989	+	xl[1] = 100;
990	+	yl[1] = 270;
991	+	xl[2] = 150;
992	+	yl[2] = 267;
993	+	xl[3] = 200;
994	+	yl[3] = 262;
995	+	xl[4] = 250;
996	+	yl[4] = 250;
997	+	xl[5] = 300;
998	+	yl[5] = 225;
999	+	xl[6] = 350;
1000	+	yl[6] = 192;
1001	+	xl[7] = 400;
1002	+	yl[7] = 163;
1003	+	xl[8] = 450;
1004	+	yl[8] = 148;
1005	+	xl[9] = 500;
1006	+	yl[9] = 140;
1007	+	xl[10] = 520;
1008	+	yl[10] = 137;
1009	+
1010	+
1011	+
1012	+
1013	+
1014	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
1015	+	gr1->SetMarkerColor(kBlue);
1016	+	gr1->SetMarkerStyle(21);
1017	+
1018	+
1019	+	//gr1->Draw("LP");
1020	+
1021	+	TSpline3 *s = new TSpline3("grs",gr1);
1022	+	s->SetLineColor(kRed);
1023	+	//  s->SetLineStyle(2);
1024	+	s->SetLineWidth(3);
1025	+
1026	+
1027	+	return gr1;
1028	+
1029	+
1030	+
1031	+
1032	+
1033	+	}
1034	+
1035	+
1036	+	TGraphErrors* getObserved_NLO_tanBeta50(){
1037	+
1038	+	Int_t nl = 10;
1039	+	Double_t xl[10];
1040	+	Double_t yl[10];
1041	+	Double_t exl[10];
1042	+	Double_t eyl[10];
1043	+
1044	+	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
1045	+
1046	+
1047	+	xl[0] = 200;
1048	+	yl[0] = 243;
1049	+	xl[1] = 220;
1050	+	yl[1] = 264;
1051	+	xl[2] = 235;
1052	+	yl[2] = 278;
1053	+	xl[3] = 250;
1054	+	yl[3] = 267;
1055	+	xl[4] = 300;
1056	+	yl[4] = 230;
1057	+	xl[5] = 350;
1058	+	yl[5] = 205;
1059	+	xl[6] = 400;
1060	+	yl[6] = 184;
1061	+	xl[7] = 450;
1062	+	yl[7] = 168;
1063	+	xl[8] = 500;
1064	+	yl[8] = 156;
1065	+	xl[9] = 520;
1066	+	yl[9] = 148;
1067	+
1068	+
1069	+
1070	+
1071	+
1072	+	TGraphErrors* gr1 = new TGraphErrors(nl,xl,yl,exl,eyl);
1073	+	gr1->SetMarkerColor(kBlue);
1074	+	gr1->SetMarkerStyle(21);
1075	+
1076	+
1077	+	//gr1->Draw("LP");
1078	+
1079	+	TSpline3 *s = new TSpline3("grs",gr1);
1080	+	s->SetLineColor(kRed);
1081	+	//  s->SetLineStyle(2);
1082	+	s->SetLineWidth(3);
1083	+
1084	+
1085	+	return gr1;
1086	+
1087	+
1088	+
1089	+
1090	+
1091	+	}
1092	+

Diff Legend

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