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.12 by auterman, Wed Mar 2 13:31:32 2011 UTC vs.
Revision 1.13 by auterman, Thu Mar 10 20:59:52 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>
#	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; }
#	Line 78 | Line 85 | double NLOSignalUncertainty(const SusySc
85		double NLOSignalRelUncertainty(const SusyScan* p){ return p->NLO_signal_uncertainty/p->NLO_signal; }
86		double NLOExpExclusion(const SusyScan* p){ return (NLOExpXsecLimit(p)<NLOXsection(p)&&NLOExpXsecLimit(p)>0.01?1:0.01); }
87		double NLOObsExclusion(const SusyScan* p){ return (NLOObsXsecLimit(p)<NLOXsection(p)&&NLOObsXsecLimit(p)>0.01?1:0.01); }
88	+
89	+	double NLOExpCL(const SusyScan* p){ return (p->NLO_CLs_b_xsec); }
90	+
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 NLOSoverSqrtB(const SusyScan* p){ return p->NLO_signal/(sqrt(p->background)+p->background_uncertainty+p->NLO_signal_uncertainty); }
99		double NLOXsecOverObserved(const SusyScan* p){ return (NLOObsXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOObsXsecLimit(p)); }
100		double NLOXsecOverExpected(const SusyScan* p){ return (NLOExpXsecLimit(p)==0 ? 9999. : NLOXsection(p)/NLOExpXsecLimit(p)); }
#	Line 122 | Line 133 | double MChi4(const GeneratorMasses* p){
133		double MCha1(const GeneratorMasses* p){ return p->MW1; }
134		double MCha2(const GeneratorMasses* p){ return p->MW2; }
135
136	+
137	+
138	+	void setPlottingStyle(TH1F& hsig){
139	+
140	+	hsig.SetStats(kFALSE);
141	+
142	+	hsig.SetAxisRange(80,500,"Y");
143	+	hsig.SetAxisRange(0,520,"X");
144	+	hsig.SetAxisRange(200,520,"X");
145	+
146	+	hsig.GetXaxis()->SetTitle("m_{0} (GeV)");
147	+	hsig.GetYaxis()->SetTitle("m_{1/2} (GeV)");
148	+	hsig.GetYaxis()->SetTitleOffset(0.8);
149	+	hsig.GetYaxis()->SetTitleSize(0.06);
150	+	hsig.GetYaxis()->SetLabelSize(0.06);
151	+	hsig.GetXaxis()->SetTitleOffset(0.9);
152	+	hsig.GetXaxis()->SetTitleSize(0.06);
153	+	hsig.GetXaxis()->SetLabelSize(0.06);
154	+
155	+	hsig.SetLineWidth(1);
156	+	hsig.SetLineColor(kBlue);
157	+
158	+	}
159	+
160	+
161	+
162	+
163		TGraph* set_sneutrino_d0_1(Int_t tanBeta){
164		double sn_m0[14]= {0,  0, 48, 55, 80, 90,100,105,109,105,100, 72, 55,0};
165		double sn_m12[14]={0,140,210,220,237,241,242,241,230,220,210,170,150,0};
#	Line 129 | Line 167 | TGraph* set_sneutrino_d0_1(Int_t tanBeta
167		TGraph* sn_d0_gr = new TGraph(14,sn_m0,sn_m12);
168
169		sn_d0_gr->SetFillColor(kGreen+3);
170	<	sn_d0_gr->SetFillStyle(1001);
170	>	sn_d0_gr->SetFillStyle(3001);
171
172		return sn_d0_gr;
173		}
#	Line 141 | Line 179 | TGraph* set_sneutrino_d0_2(Int_t tanBeta
179		TGraph* sn_d0_gr_2 = new TGraph(9,sn_m0,sn_m12);
180
181		sn_d0_gr_2->SetFillColor(kGreen+3);
182	<	sn_d0_gr_2->SetFillStyle(1001);
182	>	sn_d0_gr_2->SetFillStyle(3001);
183
184		return sn_d0_gr_2;
185		}
186
187	+	TGraph* set_lep_ch(Int_t tanBeta){
188	+	if(tanBeta == 3) return set_lep_ch_tanBeta3();
189	+	if(tanBeta == 10) return set_lep_ch_tanBeta10();
190	+	if(tanBeta == 50) return set_lep_ch_tanBeta50();
191	+	}
192
193		TGraph* set_lep_ch_tanBeta10(){
194
#	Line 174 | Line 217 | TGraph* set_lep_ch_tanBeta10(){
217		ch_m12[6] = 157;
218		ch_m12[7] = 156;
219		ch_m12[8] = 155.4;
220	<	ch_m12[9] = 154;
220	>	ch_m12[9] = 155.05;
221		ch_m12[10] = 0;
222		ch_m12[11] = 0;
223
#	Line 184 | Line 227 | TGraph* set_lep_ch_tanBeta10(){
227		ch_gr->SetFillColor(3);
228		ch_gr->SetLineColor(3);
229		//  ch_gr->SetLineWidth(3);
230	<	ch_gr->SetFillStyle(1001);
230	>	ch_gr->SetFillStyle(3001);
231
232		return ch_gr;
233
#	Line 238 | Line 281 | TGraph* set_lep_ch_tanBeta3(){
281		ch_gr->SetFillColor(3);
282		ch_gr->SetLineColor(3);
283		// ch_gr->SetLineWidth(3);
284	<	ch_gr->SetFillStyle(1001);
284	>	ch_gr->SetFillStyle(3001);
285
286		return ch_gr;
287
#	Line 299 | Line 342 | TGraph* set_lep_ch_tanBeta50(){
342
343		ch_gr->SetFillColor(3);
344		ch_gr->SetLineColor(3);
345	<	ch_gr->SetFillStyle(1001);
345	>	ch_gr->SetFillStyle(3001);
346
347		return ch_gr;
348
349		}
350
351
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	–	}
352
353
354		TGraph* set_lep_sl(Int_t tanBeta){
#	Line 320 | Line 358 | TGraph* set_lep_sl(Int_t tanBeta){
358		//  double sl_m12[] = {0,245,240,220,200,150,100,50,0};
359
360		//contour from D0 trilepton paper (PLB 680 (2009) 34-43)
361	<
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	<
361	>	TGraph* lep_sl = 0;
362		if (tanBeta==3){
363	<	sl_m0 = sl_m0_3;
364	<	sl_m12 = sl_m12_3;
365	<	n = n_3;
363	>	double sl_m0[] ={0,  0, 10, 20, 30, 40, 50, 60, 70, 77,88,95};
364	>	double sl_m12[]={0,245,242,239,232,222,209,189,165,140,60,0};
365	>	int n = 12;
366	>	lep_sl = new TGraph(n,sl_m0,sl_m12);
367		}
368		//CMS PTDR-II
369		//* Selectron_R line mass=99, ISASUGRA7.69, A0=0, m_top=175, tan(beta]=10
370		if (tanBeta==10 || tanBeta==50){
371	<	sl_m0 = sl_m0_10;
372	<	sl_m12 = sl_m12_10;
373	<	n = n_10;
371	>	double sl_m0[]={ 0,  0, 11, 20, 24, 49, 70, 82,88,90};
372	>	double sl_m12[]={0,240,237,233,230,200,150,100,50,0};
373	>	int n = 10;
374	>	lep_sl = new TGraph(n,sl_m0,sl_m12);
375		}
376
349	–	TGraph* lep_sl = new TGraph(n,sl_m0,sl_m12);
377
378		lep_sl->SetFillColor(5);
379		lep_sl->SetLineColor(5);
380	<	lep_sl->SetFillStyle(1001);
380	>	lep_sl->SetFillStyle(3001);
381
382		return lep_sl;
383		}
#	Line 373 | Line 400 | TGraph* set_tev_sg_cdf(Int_t tanBeta){
400		sg_gr->SetFillColor(2);
401		sg_gr->SetLineColor(2);
402		//  sg_gr->SetLineWidth(3);
403	<	sg_gr->SetFillStyle(1001);
403	>	sg_gr->SetFillStyle(3001);
404
405		return sg_gr;
406
#	Line 381 | Line 408 | TGraph* set_tev_sg_cdf(Int_t tanBeta){
408
409		TGraph* set_tev_sg_d0(Int_t tanBeta){
410
411	<	//  double sgd_m0[] = {0, 0,  50, 100,150,200,250,300,350,400,450,500,550,600,600};
412	<	//  double sgd_m12[] = {0,168,167,162,157,145,125,120,110,108,95, 94 ,94 ,93,0};
413	<	//  int np=15;
414	<	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;
411	>	//official D0 contour from P. Verdier
412	>	double sgd_m0[]= {0,  0., 25., 80.,100.,150.,192.,250.,300. ,350.,400.,450. ,500.,600.,600.,0.};
413	>	double sgd_m12[]={0,167.,167.,163.,162.,157.,149.,136.,125.5,116.,109.,106.5,105.,105.,  0.,0.};
414	>	int npd=16;
415
416		TGraph* sgd_gr = new TGraph(npd,sgd_m0,sgd_m12);
417
418		gStyle->SetHatchesLineWidth(3);
419
420	<	sgd_gr->SetFillColor(kMagenta+3);
421	<	sgd_gr->SetLineColor(kMagenta+3);
420	>	sgd_gr->SetFillColor(kMagenta+1);
421	>	sgd_gr->SetLineColor(kMagenta+1);
422		sgd_gr->SetLineWidth(3);
423		sgd_gr->SetFillStyle(3335);
424	+	//sgd_gr->SetFillStyle(3001);
425
426		return sgd_gr;
427
#	Line 461 | Line 487 | TGraph* set_tev_stau(Int_t tanBeta){
487
488		}
489
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	–	}
490
491
492
#	Line 552 | Line 539 | TLatex* constant_squark_text(Int_t it,TF
539		Double_t place_x = 170;
540		if(tanBeta_ == 50)place_x = 290;
541		TLatex* t3 = new TLatex(place_x+10*(it-1),lnsq.Eval(place_x+10*(it-1))+5,legnm);
542	<	t3->SetTextSize(0.03);
542	>	t3->SetTextSize(0.02);
543		t3->SetTextAngle(-8);
544		t3->SetTextColor(kGray+2);
545
#	Line 566 | Line 553 | TLatex* constant_gluino_text(Int_t it,TF
553
554		sprintf(legnm,"#font[12]{#tilde{g}}#font[92]{(%i)GeV}",500+150*(it-1));
555		TLatex* t4 = new TLatex(423,18+lngl.Eval(480),legnm);
556	<	t4->SetTextSize(0.03);
556	>	t4->SetTextSize(0.02);
557		t4->SetTextAlign(13);
558		t4->SetTextColor(kGray+2);
559
#	Line 574 | Line 561 | TLatex* constant_gluino_text(Int_t it,TF
561		}
562
563
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	–
564
565	+	TLegend* makeStauLegend(Double_t txtsz,Int_t tanBeta_){
566	+	Double_t ypos_1 = 0.86;
567	+	Double_t ypos_2 = 0.88;
568	+	Double_t xpos_1 = 0.16;
569	+	Double_t xpos_2 = 0.17;
570	+	if(tanBeta_ == 50){
571	+	xpos_1 = 0.17;
572	+	xpos_2 = 0.18;
573	+	ypos_1 = 0.76;
574	+	ypos_2 = 0.78;
575
576	+	}
577	+	TLegend* legst = new TLegend(xpos_1,ypos_1,xpos_2,ypos_2);
578	+	legst->SetHeader("#tilde{#tau} = LSP");
579	+	legst->SetFillStyle(0);
580	+	legst->SetBorderSize(0);
581	+	legst->SetTextSize(0.03);
582	+
583	+	return legst;
584		}
585
586
587	<
588	<	TGraphErrors* getExpected_NLO_tanBeta3(){
589	<
590	<	Int_t nl = 11;
591	<	Double_t xl[11];
592	<	Double_t yl[11];
593	<	Double_t exl[11];
594	<	Double_t eyl[11];
595	<
596	<	xl[0] = 0;
597	<	yl[0] = 283;
598	<	xl[1] = 100;
599	<	yl[1] = 280;
600	<	xl[2] = 150;
601	<	yl[2] = 279;
602	<	xl[3] = 200;
603	<	yl[3] = 275;
604	<	xl[4] = 250;
605	<	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	<
587	>	TLegend* makeExpLegend(TGraph& sg_gr, TGraph& sgd_gr,TGraph& ch_gr,TGraph& sl_gr,TGraph& tev_sn,Double_t txtsz,Int_t tanbeta){
588	>	TLegend* legexp = new TLegend(0.64,0.65,0.99,0.9,NULL,"brNDC");
589	>	legexp->SetFillColor(0);
590	>	legexp->SetShadowColor(0);
591	>	legexp->SetTextSize(txtsz);
592	>	legexp->SetBorderSize(0);
593	>
594	>	sg_gr.SetLineColor(1);
595	>	legexp->AddEntry(&sg_gr,"CDF  #tilde{#font[12]{g}}, #tilde{#font[12]{q}}, #scale[0.8]{tan#beta=5, #mu<0}","f");
596	>	//  sgd_gr.SetLineColor(1);
597	>	//  sgd_gr.SetLineWidth(1);
598	>
599	>	legexp->AddEntry(&sgd_gr,"D0   #tilde{#font[12]{g}}, #tilde{#font[12]{q}}, #scale[0.8]{tan#beta=3, #mu<0}","f");
600	>	ch_gr.SetLineColor(1);
601	>	legexp->AddEntry(&ch_gr,"LEP2   #tilde{#chi}_{1}^{#pm}","f");
602	>
603	>	sl_gr.SetLineColor(1);
604	>	if(tanbeta != 50) legexp->AddEntry(&sl_gr,"LEP2   #tilde{#font[12]{l}}^{#pm}","f");
605	>	if(tanbeta == 3) legexp->AddEntry(&tev_sn,"D0  #chi^{#pm}_{1}, #chi^{0}_{2}","f");
606
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	–
607
608	+	return legexp;
609
610		}
611
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	–
612
613	+	TGraph* getGraph(TH2F* h1, double level){
614
615	+	h1->SetContour(1);
616	+	h1->SetContourLevel(0,level);
617	+	h1->Draw("CONT LIST");
618	+	gPad->Update();
619	+
620	+	TObjArray* contours = (TObjArray*)gROOT->GetListOfSpecials()->FindObject("contours");
621	+
622	+	std::cout << "contours: " << contours << std::endl;
623	+	// Draw contours
624	+	TList* graphList = (TList*)(contours->At(0));
625	+	std::cout << "number of graphs: " << graphList->GetSize() << std::endl;
626	+	TGraph* myGraph = 0;
627	+	for (int igraph = 0; igraph<graphList->GetSize();++igraph) {
628	+	myGraph = (TGraph*)graphList->At(igraph);
629	+
630	+	std::cout << " - graph " << igraph << " has " << myGraph->GetN() << " points" << std::endl;
631	+	if (myGraph->GetN() > 50){
632	+	std::cout << "Drawing " << myGraph->GetN() <<" points" << std::endl;
633	+	//      myGraph->Print("all");
634	+	//      myGraph->SetLineColor(9);
635	+	//      myGraph->SetLineColor(46);
636	+	//myGraph->SetLineWidth(3);
637	+	//      myGraph->SetLineStyle(2);
638	+	//      myGraph->SetMarkerStyle(20);
639	+	//      myGraph->SetMarkerColor(9);
640	+
641	+	//      myGraph->Draw("C");
642	+	//      cvsSys->Update();
643	+
644	+	//    TString graphName("graph"+name+"_");
645	+	//    graphName += igraph;
646	+	//    myGraph->SetName(graphName);
647	+	break;
648	+	}
649	+	}
650	+	return myGraph;
651	+	}
652
653	+	TH2F* fillHoles(TH2F* h2){
654
655	+	int nx = h2->GetNbinsX();
656	+	int ny = h2->GetNbinsY();
657	+	std::cout << "Nbins: " << nx << " " << ny << std::endl;
658	+
659	+	for (int i=1;i<nx+1;i++){
660	+	for (int j=ny;j>0;j--){
661	+	int pos = j;
662	+	int count =0;
663	+	if (h2->GetBinContent(i,j)==0 && h2->GetBinContent(i-1,j)==-1 && h2->GetBinContent(i+1,j)==-1) h2->SetBinContent(i,j,-1.);
664	+
665	+	if (h2->GetBinContent(i,j)==1
666	+	&& h2->GetBinContent(i-1,j)==-1
667	+	&& h2->GetBinContent(i+1,j)==-1
668	+	&& h2->GetBinContent(i,j+1)==-1
669	+	&& h2->GetBinContent(i,j-1)==-1)
670	+	h2->SetBinContent(i,j,-1.);
671	+
672	+	//      if (h2->GetBinContent(i,j)<0){
673	+	if (h2->GetBinContent(i,j)<0 && h2->GetBinContent(i,j-1)<0){
674	+	//      cout <<" bin content " << i <<" " <<  j<< " " << pos << " " << h2->GetBinContent(i,j) <<endl;
675	+	for (int k=pos;k>0;k--){
676	+	h2->SetBinContent(i,k,-1.);
677	+	}
678	+	break;
679	+	}
680	+
681	+
682	+	}
683	+	}
684	+	return h2;
685		}
686
687
859	–	TGraphErrors* getExpected_NLO_tanBeta50(){
688
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;
689
690
691
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");
692
901	–	TSpline3 *s = new TSpline3("grs",gr1);
902	–	s->SetLineColor(kBlue);
903	–	s->SetLineStyle(2);
904	–	s->SetLineWidth(3);
905	–
693
907	–	return gr1;
694
695
696
697
698	+	//old------------------------------------------------------------------------
699
700	+	TGraph* sq_LEP(){//sq-gl
701	+	double sq[] = {0,0,100,100};
702	+	double gl[] = {0,2000,2000,0};
703	+	TGraph* res = new TGraph(4,sq,gl);
704	+	res->SetFillColor(kBlue);
705	+	return res;
706		}
707	<
708	<
709	<	TGraphErrors* getObserved_NLO_tanBeta3(){
710	<
711	<	Int_t nl = 11;
712	<	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	<
707	>	TGraph* gl_TEV(){//sq-gl
708	>	double sq[] = {0,2000,2000,0};
709	>	double gl[] = {0,0,190,190};
710	>	TGraph* res = new TGraph(4,sq,gl);
711	>	res->SetFillColor(kGreen+2);
712	>	return res;
713		}
714
715	+	TGraph* gl_CDF(){//sq-gl
716	+	double sq[] = {0,2000,2000,0};
717	+	double gl[] = {190,190,230,230};
718	+	TGraph* res = new TGraph(4,sq,gl);
719	+	res->SetFillColor(kOrange+5);
720	+	return res;
721	+	}
722
723	+	TGraph* gl_DEZ(){//sq-gl
724	+	double sq[] = {0,2000,2000,0};
725	+	double gl[] = {230,230,255,255};
726	+	TGraph* res = new TGraph(4,sq,gl);
727	+	res->SetFillColor(kYellow-5);
728	+	return res;
729	+	}
730
731	<	TGraphErrors* getObserved_NLO_tanBeta10(){
732	<
733	<	Int_t nl = 11;
734	<	Double_t xl[11];
735	<	Double_t yl[11];
736	<	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	<
731	>	TGraph* gl_WHT(){//sq-gl
732	>	double sq[] = {101,2000,2000,101};
733	>	double gl[] = {256,256,400,400};
734	>	TGraph* res = new TGraph(4,sq,gl);
735	>	res->SetFillColor(kWhite);
736	>	return res;
737		}
738
739
740	<	TGraphErrors* getObserved_NLO_tanBeta50(){
740	>	////////////////////////////////////////////
741	>	TGraph* gl_LEP(){//gl-sq
742	>	double sq[] = {0,0,100,100};
743	>	double gl[] = {0,2000,2000,0};
744	>	TGraph* res = new TGraph(4,gl,sq);
745	>	res->SetFillColor(kBlue);
746	>	return res;
747	>	}
748
749	<	Int_t nl = 10;
750	<	Double_t xl[10];
751	<	Double_t yl[10];
1041	<	Double_t exl[10];
1042	<	Double_t eyl[10];
1043	<
1044	<	// cout << " n " << hist->GetXaxis()->GetNbins() << endl;
1045	<
749	>	TGraph* sq_TEV(){//gl-sq
750	>	double sq[] = {0,2000,2000,330,250,300,200,150,100,0};
751	>	double gl[] = {0,0,190,190,260,300,500,560,500,500};
752
753	<	xl[0] = 200;
754	<	yl[0] = 243;
755	<	xl[1] = 220;
756	<	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");
753	>	TGraph* res = new TGraph(10,gl,sq);
754	>	res->SetFillColor(kGreen+2);
755	>	return res;
756	>	}
757
758	<	TSpline3 *s = new TSpline3("grs",gr1);
759	<	s->SetLineColor(kRed);
760	<	//  s->SetLineStyle(2);
761	<	s->SetLineWidth(3);
762	<
758	>	TGraph* sq_CDF(){//gl-sq
759	>	double sq[] = {0,2000,2000,480,460,420,410,380,390,290,0};
760	>	double gl[] = {0,0,280,280,300,310,330,340,440,320,320};
761	>	TGraph* res = new TGraph(11,gl,sq);
762	>	res->SetFillColor(kOrange+5);
763	>	return res;
764	>	}
765	>	TGraph* sq_DEZ(){//gl-sq
766	>	double sq[] = {0,2000,2000,460,430,400,390,290,0};
767	>	double gl[] = {0,0,305,305,320,350,440,320,320};
768	>	TGraph* res = new TGraph(9,gl,sq);
769	>	res->SetFillColor(kYellow-5);
770	>	return res;
771	>	}
772
773	<	return gr1;
773	>	TGraph* glsq_NoSol(){//sq-gl
774	>	gStyle->SetHatchesSpacing(2.0);
775	>	gStyle->SetHatchesLineWidth(1);
776	>	double sq[] = {83,83,110,1297.6,0,   0};
777	>	double gl[] = { 0,63,120,1466,  1466,0};
778	>	TGraph* res = new TGraph(6,gl,sq);
779	>	res->SetLineColor(1);
780	>	res->SetLineWidth(2);
781	>	res->SetFillStyle(3354);
782	>	return res;
783	>	}
784
785
786
787
788
789	+	TGraph * Atlas_m0_m12_tb3_obs()
790	+	{
791	+	TGraph *graph = new TGraph(71);
792	+	graph->SetLineWidth(2);
793	+	graph->SetPoint(0,54,357.341);
794	+	graph->SetPoint(1,82,358.4171);
795	+	graph->SetPoint(2,110,359.8179);
796	+	graph->SetPoint(3,110.934,359.875);
797	+	graph->SetPoint(4,138,361.5302);
798	+	graph->SetPoint(5,166,362.5696);
799	+	graph->SetPoint(6,189.0676,359.875);
800	+	graph->SetPoint(7,194,359.1415);
801	+	graph->SetPoint(8,222,354.5211);
802	+	graph->SetPoint(9,248.1714,351.625);
803	+	graph->SetPoint(10,250,351.4583);
804	+	graph->SetPoint(11,278,349.4991);
805	+	graph->SetPoint(12,306,343.4051);
806	+	graph->SetPoint(13,306.1313,343.375);
807	+	graph->SetPoint(14,334,335.3855);
808	+	graph->SetPoint(15,334.7966,335.125);
809	+	graph->SetPoint(16,350.8793,326.875);
810	+	graph->SetPoint(17,362,319.7823);
811	+	graph->SetPoint(18,364.6568,318.625);
812	+	graph->SetPoint(19,383.5969,310.375);
813	+	graph->SetPoint(20,390,308.6978);
814	+	graph->SetPoint(21,415.0931,302.125);
815	+	graph->SetPoint(22,418,300.2992);
816	+	graph->SetPoint(23,423.9359,293.875);
817	+	graph->SetPoint(24,431.0348,285.625);
818	+	graph->SetPoint(25,441.6066,277.375);
819	+	graph->SetPoint(26,446,275.3629);
820	+	graph->SetPoint(27,468.0485,269.125);
821	+	graph->SetPoint(28,474,267.2393);
822	+	graph->SetPoint(29,486.3632,260.875);
823	+	graph->SetPoint(30,495.8534,252.625);
824	+	graph->SetPoint(31,502,244.7684);
825	+	graph->SetPoint(32,502.3699,244.375);
826	+	graph->SetPoint(33,508.424,236.125);
827	+	graph->SetPoint(34,514.4781,227.875);
828	+	graph->SetPoint(35,518.8059,219.625);
829	+	graph->SetPoint(36,521.5056,211.375);
830	+	graph->SetPoint(37,524.324,203.125);
831	+	graph->SetPoint(38,527.1424,194.875);
832	+	graph->SetPoint(39,530,193.5052);
833	+	graph->SetPoint(40,552.5782,186.625);
834	+	graph->SetPoint(41,558,185.8767);
835	+	graph->SetPoint(42,586,180.1476);
836	+	graph->SetPoint(43,592.2836,178.375);
837	+	graph->SetPoint(44,614,171.422);
838	+	graph->SetPoint(45,617.5927,170.125);
839	+	graph->SetPoint(46,627.5396,161.875);
840	+	graph->SetPoint(47,642,157.9876);
841	+	graph->SetPoint(48,658.2277,153.625);
842	+	graph->SetPoint(49,670,151.1225);
843	+	graph->SetPoint(50,698,146.9886);
844	+	graph->SetPoint(51,711.5425,145.375);
845	+	graph->SetPoint(52,726,143.6935);
846	+	graph->SetPoint(53,754,140.0648);
847	+	graph->SetPoint(54,782,137.4563);
848	+	graph->SetPoint(55,783.0426,137.125);
849	+	graph->SetPoint(56,796.0326,128.875);
850	+	graph->SetPoint(57,810,125.0328);
851	+	graph->SetPoint(58,826.0235,120.625);
852	+	graph->SetPoint(59,838,117.3305);
853	+	graph->SetPoint(60,866,116.7462);
854	+	graph->SetPoint(61,894,116.1044);
855	+	graph->SetPoint(62,922,114.6645);
856	+	graph->SetPoint(63,950,116.937);
857	+	graph->SetPoint(64,978,117.6956);
858	+	graph->SetPoint(65,1006,115.198);
859	+	graph->SetPoint(66,1034,113.1166);
860	+	graph->SetPoint(67,1038.967,112.375);
861	+	graph->SetPoint(68,1062,108.0997);
862	+	graph->SetPoint(69,1090,104.373);
863	+	graph->SetPoint(70,1096.429,104.125);
864	+	graph->SetFillColor(0);
865	+	return graph;
866	+	}
867	+	TGraph * Atlas_mGl_mSq_obs()
868	+	{
869	+	//x:gluino mass, y:squark mass
870	+	TGraph *graph = new TGraph(64);
871	+	graph->SetLineWidth(2);
872	+	graph->SetPoint(0,511.2569,1976.25);
873	+	graph->SetPoint(1,513.125,1936.181);
874	+	graph->SetPoint(2,513.4714,1928.75);
875	+	graph->SetPoint(3,515.6859,1881.25);
876	+	graph->SetPoint(4,517.9004,1833.75);
877	+	graph->SetPoint(5,520.1148,1786.25);
878	+	graph->SetPoint(6,522.3293,1738.75);
879	+	graph->SetPoint(7,524.5438,1691.25);
880	+	graph->SetPoint(8,526.1095,1643.75);
881	+	graph->SetPoint(9,526.5267,1596.25);
882	+	graph->SetPoint(10,526.9924,1548.75);
883	+	graph->SetPoint(11,527.2745,1501.25);
884	+	graph->SetPoint(12,526.9487,1453.75);
885	+	graph->SetPoint(13,526.6228,1406.25);
886	+	graph->SetPoint(14,532.902,1358.75);
887	+	graph->SetPoint(15,540.182,1311.25);
888	+	graph->SetPoint(16,547.4619,1263.75);
889	+	graph->SetPoint(17,558.0438,1216.25);
890	+	graph->SetPoint(18,561.875,1203.002);
891	+	graph->SetPoint(19,579.4475,1168.75);
892	+	graph->SetPoint(20,603.8166,1121.25);
893	+	graph->SetPoint(21,610.625,1107.979);
894	+	graph->SetPoint(22,630.8311,1073.75);
895	+	graph->SetPoint(23,658.8712,1026.25);
896	+	graph->SetPoint(24,659.375,1025.691);
897	+	graph->SetPoint(25,703.8609,978.75);
898	+	graph->SetPoint(26,708.125,975.5966);
899	+	graph->SetPoint(27,756.875,945.0332);
900	+	graph->SetPoint(28,778.5082,931.25);
901	+	graph->SetPoint(29,805.625,916.3566);
902	+	graph->SetPoint(30,847.5791,883.75);
903	+	graph->SetPoint(31,854.375,879.4212);
904	+	graph->SetPoint(32,903.125,848.0476);
905	+	graph->SetPoint(33,927.7959,836.25);
906	+	graph->SetPoint(34,951.875,823.2943);
907	+	graph->SetPoint(35,1000.625,790.1523);
908	+	graph->SetPoint(36,1004.488,788.75);
909	+	graph->SetPoint(37,1049.375,774.2142);
910	+	graph->SetPoint(38,1098.125,755.1404);
911	+	graph->SetPoint(39,1130.904,741.25);
912	+	graph->SetPoint(40,1146.875,736.2226);
913	+	graph->SetPoint(41,1195.625,720.3208);
914	+	graph->SetPoint(42,1244.375,701.1234);
915	+	graph->SetPoint(43,1266.694,693.75);
916	+	graph->SetPoint(44,1293.125,685.9941);
917	+	graph->SetPoint(45,1341.875,668.9126);
918	+	graph->SetPoint(46,1390.625,652.8072);
919	+	graph->SetPoint(47,1439.375,647.4204);
920	+	graph->SetPoint(48,1448.107,646.25);
921	+	graph->SetPoint(49,1488.125,638.5908);
922	+	graph->SetPoint(50,1536.875,620.8084);
923	+	graph->SetPoint(51,1585.625,603.026);
924	+	graph->SetPoint(52,1597.347,598.75);
925	+	graph->SetPoint(53,1634.375,581.9133);
926	+	graph->SetPoint(54,1683.125,559.7463);
927	+	graph->SetPoint(55,1701.81,551.25);
928	+	graph->SetPoint(56,1731.875,537.5793);
929	+	graph->SetPoint(57,1780.625,515.4123);
930	+	graph->SetPoint(58,1806.273,503.75);
931	+	graph->SetPoint(59,1829.375,493.2101);
932	+	graph->SetPoint(60,1878.125,471.0784);
933	+	graph->SetPoint(61,1910.736,456.25);
934	+	graph->SetPoint(62,1926.875,448.241);
935	+	graph->SetPoint(63,1975.625,426.7444);
936	+	return graph;
937		}
1092	–

Diff Legend

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