void points(TString filename) {
TString cmssw;
// 167
cmssw = "$1.6.7$";
TFile *f = TFile::Open(filename);
std::vector< TString > taggers;
taggers.push_back( "gTC2_udsg" );
taggers.push_back( "gTC3_udsg" );
taggers.push_back( "gTP_udsg" );
taggers.push_back( "gJBP_udsg" );
taggers.push_back( "gSSV_udsg" );
taggers.push_back( "gCSV_udsg" );
std::vector< TString > discriminators;
discriminators.push_back( "discTC2_udsg" );
discriminators.push_back( "discTC3_udsg" );
discriminators.push_back( "discTP_udsg" );
discriminators.push_back( "discJBP_udsg" );
discriminators.push_back( "discSSV_udsg" );
discriminators.push_back( "discCSV_udsg" );
//TCanvas *cv_TC = new TCanvas("cv_TC","cv_TC",700,700);
//TCanvas *cv_TP = new TCanvas("cv_TP","cv_TP",700,700);
std::cout << "Tagger & Point & Discriminator & light mistag & b-efficiency \\\\ \\hline" << std::endl;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = taggers[itagger];
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("Histograms/MCtruth/"+tag);
//if (taggers == "gTC2_udsg" || taggers =
TGraph *dgraph = (TGraph*) gDirectory->Get("Histograms/MCtruth/"+discriminators[itagger]);
dgraph->Sort();
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
//cv[itagger] = new TCanvas("cv","cv",600,600);
//g->Draw("ACP");
TString se = " & ";
std::cout << tag << se << "Loose" << se << std::setprecision(3) << dgraph->Eval(0.1) << se << "0.1" << se << std::setprecision(2) << g->Eval(0.1) << "\\\\" << std::endl;
std::cout << tag << se << "Medium" << se << std::setprecision(3) << dgraph->Eval(0.01) << se << "0.01" << se << std::setprecision(2) << g->Eval(0.01) << "\\\\" << std::endl;
std::cout << tag << se << "Tight" << se << std::setprecision(3) << dgraph->Eval(0.001) << se << "0.001" << se << std::setprecision(2) << g->Eval(0.001) << "\\\\ \\hline" << std::endl;
}
}
void pointsed(TString filename = "btagpatanalyzerpy.root", TString check="") {
TString cmssw;
// 167
cmssw = "$3.1.0_pre9$";
TFile *f = TFile::Open(filename);
/////////////////////////////////////////////////////////////////////////////////////////
std::vector< TString > checks;
checks.push_back("");
checks.push_back("Corr30_");
checks.push_back("Corr30t0_");
checks.push_back("Corr30t1_");
checks.push_back("Corr30t2_");
checks.push_back("Corr30t0_nConstituent_");
checks.push_back("Corr30t1_nConstituent_");
checks.push_back("Corr30t2_nConstituent_");
checks.push_back("Uncor10_");
checks.push_back("Uncor10t0_");
checks.push_back("Uncor10t1_");
checks.push_back("Uncor10t2_");
checks.push_back("Uncor10t0_nConstituent_");
checks.push_back("Uncor10t1_nConstituent_");
checks.push_back("Uncor10t2_nConstituent_");
/////////////////////////////////////////////////////////////////////////////////////////
std::vector< TString > taggers;
std::vector< TString > labeltag;
std::vector< int> colorlines;
taggers.push_back( "TC2" );colorlines.push_back( 1 );labeltag.push_back( "TCHE");
taggers.push_back( "TC3" );colorlines.push_back( 2 );labeltag.push_back( "TCHP");
taggers.push_back( "TP" );colorlines.push_back( 3 );labeltag.push_back( "JP");
taggers.push_back( "SSV" );colorlines.push_back( 4 );labeltag.push_back( "SSV");
taggers.push_back( "CSV" );colorlines.push_back( 5 );labeltag.push_back( "CSV");
taggers.push_back( "MSV" );colorlines.push_back( 6 );labeltag.push_back( "CSVMVAB");
taggers.push_back( "SMT" );colorlines.push_back( 8 );labeltag.push_back( "SMT");
taggers.push_back( "BTP" );colorlines.push_back( 9 );labeltag.push_back( "JBP");
taggers.push_back( "SMTbyIP3d" );colorlines.push_back( 11 );labeltag.push_back( "SMTByIP3d");
taggers.push_back( "SMTbyPt" );colorlines.push_back( 12 );labeltag.push_back( "SMTByPt");
taggers.push_back( "SETbyIP3d" );colorlines.push_back( 13 );labeltag.push_back( "SETByIP3d");
taggers.push_back( "SETbyPt" );colorlines.push_back( 14 );labeltag.push_back( "SETByPt");
// taggers.push_back( "IPM" );colorlines.push_back( 11 );labeltag.push_back( "IPMVAB");
// taggers.push_back( "SMNIPT" );colorlines.push_back( 12 );labeltag.push_back( "SMTNoIP");
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//ed for ( size_t ichks = 0; ichks < checks.size(); ++ichks ) {
//ed TString check = checks[ichks];
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
TString PerfTitle= check;
if (check == "") PerfTitle="uncorr pt>30";
if (check == "Corr30_") PerfTitle="pt>30";
if (check == "Corr30t0_") PerfTitle="pt>30, #tracks > 0";
if (check == "Corr30t1_") PerfTitle="pt>30, #tracks > 1";
if (check == "Corr30t2_") PerfTitle="pt>30, #tracks > 2";
if (check == "Corr30t0_nConstituent_") PerfTitle="pt>30, #tracks > 0 & nConstituents >1";
if (check == "Corr30t1_nConstituent_") PerfTitle="pt>30, #tracks > 1 & nConstituents >1";
if (check == "Corr30t2_nConstituent_") PerfTitle="pt>30, #tracks > 2 & nConstituents >1";
if (check == "Uncor10_") PerfTitle="uncorr pt>10";
if (check == "Uncor10t0_") PerfTitle="uncorr pt>10 #tracks > 0";
if (check == "Uncor10t1_") PerfTitle="uncorr pt>10 #tracks > 1";
if (check == "Uncor10t2_") PerfTitle="uncorr pt>10 #tracks > 2";
if (check == "Uncor10t0_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 0 & nConstituents >1";
if (check == "Uncor10t1_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 1 & nConstituents >1";
if (check == "Uncor10t2_nConstituent_") PerfTitle="uncorr pt>10 #tracks > 2 & nConstituents >1";
std::vector< TString > discriminators;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
discriminators.push_back( check+"disc"+taggers[itagger]+"_udsg" );
}
// discriminators.push_back( "discTC3_udsg" );
// discriminators.push_back( "discTP_udsg" );
TCanvas *cv = new TCanvas("cv","cv",900,900);
TMultiGraph *mg =new TMultiGraph();
TLegend *legend0 = new TLegend(0.68,0.12,0.88,0.32);
// inverted axis
TMultiGraph *mginv =new TMultiGraph();
TLegend *legend1 = new TLegend(0.65,0.18,0.85,0.48);
std::ofstream salida("BTagPATop3"+check+".txt");
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = check+"g"+taggers[itagger]+"_udsg";
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tag);
TGraph *dgraph = (TGraph*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+discriminators[itagger]);
// TGraph *udsgvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),dgraph->GetX());
dgraph->Sort();
// udsgvsdgraph->Sort();
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
g->SetLineColor(itagger+1);
legend0 -> AddEntry(g,taggers[itagger],"l");
mg->Add(g);
//inverted axis
TGraphErrors *ginv = new TGraphErrors(agraph->GetN(),agraph->GetX(),agraph->GetY(),agraph->GetEX(),agraph->GetEY());
ginv->Sort();
ginv->SetLineColor(colorlines[itagger]);
ginv->SetMarkerStyle(8);
ginv->SetMarkerColor(colorlines[itagger]);
legend1 -> AddEntry(ginv,labeltag[itagger],"l");
mginv->Add(ginv);
std::cout << " Tagger: " << tag << std::endl;
std::cout << " Loose(10%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.1) << " b-eff = " << g->Eval(0.1) << std::endl;
std::cout << " Medium(1%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.01) << " b-eff = " << g->Eval(0.01) << std::endl;
std::cout << " Tight(0.1%) = " << " cut > " << std::setprecision(4) << dgraph->Eval(0.001) << " b-eff = " << g->Eval(0.001) << std::endl;
salida << " " << taggers[itagger] << endl;
salida << " #bin \t b-eff \t err-beff \t non-beff \t err-non-b"<< endl;
for ( size_t i=0;i< agraph->GetN();i++){
salida << " " << (i+1) << " \t "
<< agraph->GetX()[i] <<" \t "
<< agraph->GetEX()[i]<<" \t "
<< agraph->GetY()[i] <<" \t "
<< agraph->GetEY()[i]
<< " "<< endl;
}
}
// cv->SetLogx();
mg->Draw("ALP");
mg->GetYaxis()->SetTitle("b-eff");
mg->GetXaxis()->SetTitle("udsg-mistagging");
legend0 -> Draw();
cv-> SetGrid();
cv-> Print ("BTagPATop"+check+".eps");
cv-> Print ("BTagPATop"+check+".png");
cv->cd(0);
cv->SetLogx();
mg->Draw("ALP");
legend0 -> Draw();
cv-> Print ("BTagPATop1"+check+".eps");
cv-> Print ("BTagPATop1"+check+".png");
//inverted axis
TCanvas *cvinv = new TCanvas("cvinv","cvinv",700,700);
cvinv->SetLogy(0);
mginv->Draw("ALP");
mginv->GetXaxis()->SetTitle("b-eff");
mginv->GetYaxis()->SetTitle("udsg-mistagging");
legend1 -> Draw();
cvinv->SetGrid();
cvinv-> Print ("BTagPATop2"+check+".eps");
cvinv-> Print ("BTagPATop2"+check+".png");
cvinv->cd(0);
// cvinv->Update();
// cvinv->SetLogx();
// mginv->SetXmin(10^-4);
// axis range using a histogram helper
TH2D*hpx = new TH2D("hpx",PerfTitle,200,0.0,1.005,200,0.00002,1.05);
hpx->SetStats(kFALSE);
hpx->Draw();
hpx->GetXaxis()->SetTitle("b-eff");
hpx->GetYaxis()->SetTitle("udsg-mistagging");
cvinv->SetLogy(1);
mginv->Draw("AP");
legend1 -> Draw();
cvinv-> Print ("BTagPATop3"+check+".eps");
cvinv-> Print ("BTagPATop3"+check+".png");
//ed}
}
void disceff(TString filename) {
gROOT->SetStyle("Plain");
TString cmssw;
// 167
cmssw = "$3.1.0_pre9$";
TFile *f = TFile::Open(filename);
std::vector< TString > taggers;
taggers.push_back( "TC2" );
taggers.push_back( "TC3" );
taggers.push_back( "TP" );
taggers.push_back( "BTP" );
taggers.push_back( "SSV" );
taggers.push_back( "CSV" );
taggers.push_back( "MSV" );
taggers.push_back( "SMT" );
taggers.push_back( "SETbyIP3d" );
taggers.push_back( "SETbyPt" );
taggers.push_back( "SMTbyIP3d" );
taggers.push_back( "SMTbyPt" );
std::vector< TString > discriminators;
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
discriminators.push_back( "disc"+taggers[itagger]+"_udsg" );
}
// discriminators.push_back( "discTC3_udsg" );
// discriminators.push_back( "discTP_udsg" );
const int dim=taggers.size();
TCanvas *cv[dim];
TMultiGraph* mg[dim];
for ( size_t itagger = 0; itagger < taggers.size(); ++itagger ) {
TString tag = "g"+taggers[itagger]+"_udsg";
TString tagb = "g"+taggers[itagger]+"_b";
TString tagc = "g"+taggers[itagger]+"_c";
cv[itagger] = new TCanvas("cv_"+taggers[itagger],"cv_"+taggers[itagger],700,700);
TLegend *legend0 = new TLegend(0.68,0.70,0.88,0.90);
TGraphErrors *agraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tag);
TGraphErrors *bgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagb);
TGraphErrors *cgraph = (TGraphErrors*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+tagc);
TGraph *dgraph = (TGraph*) gDirectory->Get("BTagPATAnalyzer"+taggers[itagger]+"/"+taggers[itagger]+"/"+discriminators[itagger]);
TGraph *bvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),bgraph->GetY());
TGraph *cvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),cgraph->GetY());
TGraph *lvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),agraph->GetY());
TGraph *udsgvsdgraph = new TGraph(dgraph->GetN(),dgraph->GetY(),dgraph->GetX());
dgraph->Sort();
// udsgvsdgraph->Sort();
// udsgvsdgraph->SetLineColor(1);
// legend0 -> AddEntry(udsgvsdgraph,"control","l");
lvsdgraph->Sort();
lvsdgraph->SetLineColor(2);
legend0 -> AddEntry(lvsdgraph,tag,"l");
cvsdgraph->Sort();
cvsdgraph->SetLineColor(3);
legend0 -> AddEntry(cvsdgraph,tagc,"l");
bvsdgraph->Sort();
bvsdgraph->SetLineColor(4);
legend0 -> AddEntry(bvsdgraph,tagb,"l");
mg[itagger]= new TMultiGraph();
// mg[itagger]->Add(udsgvsdgraph);
mg[itagger]->Add(lvsdgraph);
mg[itagger]->Add(cvsdgraph);
mg[itagger]->Add(bvsdgraph);
// mg[itagger]->Add(dgraph);
cv[itagger]->cd(1);
mg[itagger]->Draw("ALP");
mg[itagger]->GetYaxis()->SetTitle("eff");
mg[itagger]->GetXaxis()->SetTitle("discriminant");
legend0 -> Draw();
cv[itagger]->Update();
cv[itagger]->cd(0);
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".eps");
cv[itagger]-> Print ("BTagPATeff_vs_disc"+taggers[itagger]+".ps");
TGraphErrors *g = new TGraphErrors(agraph->GetN(),agraph->GetY(),agraph->GetX(),agraph->GetEY(),agraph->GetEX());
g->Sort();
g->SetLineColor(itagger+1);
std::cout << " Tagger: " << tag << std::endl;
std::cout << " Loose(10%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.1) << " b-eff = " << g->Eval(0.1) << std::endl;
std::cout << " Medium(1%): " << " cut > " << std::setprecision(4) << dgraph->Eval(0.01) << " b-eff = " << g->Eval(0.01) << std::endl;
std::cout << " Tight(0.1%) = " << " cut > " << std::setprecision(4) << dgraph->Eval(0.001) << " b-eff = " << g->Eval(0.001) << std::endl;
}//end for
}
void mass4Chan(){
//=========Macro generated from canvas: ccc/
//========= (Thu Mar 7 22:11:11 2013) by ROOT version5.34/03
TCanvas *ccc = new TCanvas("ccc", "",0,0,600,600);
gStyle->SetOptFit(1);
gStyle->SetOptStat(0);
gStyle->SetOptTitle(0);
ccc->Range(86.5625,-1.875,92.8125,10.625);
ccc->SetFillColor(0);
ccc->SetBorderMode(0);
ccc->SetBorderSize(2);
ccc->SetLeftMargin(0.15);
ccc->SetRightMargin(0.05);
ccc->SetTopMargin(0.05);
ccc->SetBottomMargin(0.15);
ccc->SetFrameFillStyle(0);
ccc->SetFrameBorderMode(0);
ccc->SetFrameFillStyle(0);
ccc->SetFrameBorderMode(0);
TH2F *hframe = new TH2F("hframe","",100,85,96,100,0,10);
hframe->SetLineStyle(0);
hframe->SetMarkerStyle(20);
hframe->GetXaxis()->SetTitle(" m_{Z} (GeV)");
hframe->GetXaxis()->SetNdivisions(510);
hframe->GetXaxis()->SetLabelFont(42);
hframe->GetXaxis()->SetLabelOffset(0.01);
hframe->GetXaxis()->SetLabelSize(0.05);
hframe->GetXaxis()->SetTitleSize(0.05);
hframe->GetXaxis()->SetTitleOffset(1.15);
hframe->GetXaxis()->SetTitleFont(42);
hframe->GetYaxis()->SetTitle(" -2#Delta ln L");
hframe->GetYaxis()->SetLabelFont(42);
hframe->GetYaxis()->SetLabelOffset(0.01);
hframe->GetYaxis()->SetLabelSize(0.05);
hframe->GetYaxis()->SetTitleSize(0.05);
hframe->GetYaxis()->SetTitleOffset(1.4);
hframe->GetYaxis()->SetTitleFont(42);
hframe->GetZaxis()->SetLabelFont(42);
hframe->GetZaxis()->SetLabelOffset(0.007);
hframe->GetZaxis()->SetLabelSize(0.045);
hframe->GetZaxis()->SetTitleSize(0.05);
hframe->GetZaxis()->SetTitleFont(42);
hframe->Draw("");
//4e
TGraph *graph = new TGraph(211);
graph->SetName("Graph");
graph->SetTitle("Graph");
graph->SetLineColor(kGreen+1);
graph->SetLineWidth(3);
graph->SetMarkerStyle(20);
graph->SetPoint(0,88.01999664,7.234320164);
graph->SetPoint(1,88.05999756,7.121326923);
graph->SetPoint(2,88.09999847,7.008939743);
graph->SetPoint(3,88.13999939,6.897168636);
graph->SetPoint(4,88.18000031,6.786022186);
graph->SetPoint(5,88.22000122,6.67550993);
graph->SetPoint(6,88.26000214,6.565642357);
graph->SetPoint(7,88.30000305,6.456428051);
graph->SetPoint(8,88.33999634,6.347877979);
graph->SetPoint(9,88.37999725,6.240002632);
graph->SetPoint(10,88.41999817,6.1328125);
graph->SetPoint(11,88.45999908,6.026317596);
graph->SetPoint(12,88.5,5.920529366);
graph->SetPoint(13,88.54000092,5.815458775);
graph->SetPoint(14,88.58000183,5.711116314);
graph->SetPoint(15,88.62000275,5.607512951);
graph->SetPoint(16,88.66000366,5.504659653);
graph->SetPoint(17,88.69999695,5.402567387);
graph->SetPoint(18,88.73999786,5.301246643);
graph->SetPoint(19,88.77999878,5.200707436);
graph->SetPoint(20,88.81999969,5.100960732);
graph->SetPoint(21,88.81999969,5.100960732);
graph->SetPoint(22,88.86000061,5.002016068);
graph->SetPoint(23,88.90000153,4.903883457);
graph->SetPoint(24,88.94000244,4.806572437);
graph->SetPoint(25,88.98000336,4.710093021);
graph->SetPoint(26,89.01999664,4.614454269);
graph->SetPoint(27,89.05999756,4.519664764);
graph->SetPoint(28,89.09999847,4.425733089);
graph->SetPoint(29,89.13999939,4.332668304);
graph->SetPoint(30,89.18000031,4.240478516);
graph->SetPoint(31,89.22000122,4.149171829);
graph->SetPoint(32,89.26000214,4.058755875);
graph->SetPoint(33,89.30000305,3.969237804);
graph->SetPoint(34,89.33999634,3.880625486);
graph->SetPoint(35,89.37999725,3.792925596);
graph->SetPoint(36,89.41999817,3.706145048);
graph->SetPoint(37,89.45999908,3.620290518);
graph->SetPoint(38,89.5,3.535368204);
graph->SetPoint(39,89.54000092,3.451384068);
graph->SetPoint(40,89.58000183,3.368344069);
graph->SetPoint(41,89.62000275,3.286253691);
graph->SetPoint(42,89.62000275,3.286253691);
graph->SetPoint(43,89.66000366,3.205118656);
graph->SetPoint(44,89.69999695,3.124943733);
graph->SetPoint(45,89.73999786,3.045734167);
graph->SetPoint(46,89.77999878,2.967494488);
graph->SetPoint(47,89.81999969,2.890229225);
graph->SetPoint(48,89.86000061,2.813942432);
graph->SetPoint(49,89.90000153,2.738638639);
graph->SetPoint(50,89.94000244,2.664321423);
graph->SetPoint(51,89.98000336,2.590994596);
graph->SetPoint(52,90.01999664,2.518661499);
graph->SetPoint(53,90.05999756,2.447325468);
graph->SetPoint(54,90.09999847,2.376989603);
graph->SetPoint(55,90.13999939,2.307657003);
graph->SetPoint(56,90.18000031,2.23933053);
graph->SetPoint(57,90.22000122,2.172012329);
graph->SetPoint(58,90.26000214,2.105705023);
graph->SetPoint(59,90.30000305,2.040410995);
graph->SetPoint(60,90.33999634,1.976132512);
graph->SetPoint(61,90.37999725,1.912871242);
graph->SetPoint(62,90.41999817,1.85062921);
graph->SetPoint(63,90.41999817,1.85062921);
graph->SetPoint(64,90.45999908,1.789408088);
graph->SetPoint(65,90.5,1.729209423);
graph->SetPoint(66,90.54000092,1.670034766);
graph->SetPoint(67,90.58000183,1.611885428);
graph->SetPoint(68,90.62000275,1.554762602);
graph->SetPoint(69,90.66000366,1.498667479);
graph->SetPoint(70,90.69999695,1.443601012);
graph->SetPoint(71,90.73999786,1.389564157);
graph->SetPoint(72,90.77999878,1.336557865);
graph->SetPoint(73,90.81999969,1.284582734);
graph->SetPoint(74,90.86000061,1.233639359);
graph->SetPoint(75,90.90000153,1.183728576);
graph->SetPoint(76,90.94000244,1.134850621);
graph->SetPoint(77,90.98000336,1.087006092);
graph->SetPoint(78,91.01999664,1.040195346);
graph->SetPoint(79,91.05999756,0.9944185615);
graph->SetPoint(80,91.09999847,0.9496760368);
graph->SetPoint(81,91.13999939,0.9059679508);
graph->SetPoint(82,91.18000031,0.8632944226);
graph->SetPoint(83,91.22000122,0.8216554523);
graph->SetPoint(84,91.22000122,0.8216554523);
graph->SetPoint(85,91.26000214,0.7810510397);
graph->SetPoint(86,91.30000305,0.7414811254);
graph->SetPoint(87,91.33999634,0.70294559);
graph->SetPoint(88,91.37999725,0.6654443145);
graph->SetPoint(89,91.41999817,0.6289771199);
graph->SetPoint(90,91.45999908,0.5935436487);
graph->SetPoint(91,91.5,0.5591436625);
graph->SetPoint(92,91.54000092,0.5257768631);
graph->SetPoint(93,91.58000183,0.4934427738);
graph->SetPoint(94,91.62000275,0.462141037);
graph->SetPoint(95,91.66000366,0.431871146);
graph->SetPoint(96,91.69999695,0.4026326835);
graph->SetPoint(97,91.73999786,0.3744250238);
graph->SetPoint(98,91.77999878,0.3472476304);
graph->SetPoint(99,91.81999969,0.3210999072);
graph->SetPoint(100,91.86000061,0.2959812582);
graph->SetPoint(101,91.90000153,0.2718909979);
graph->SetPoint(102,91.94000244,0.2488284409);
graph->SetPoint(103,91.98000336,0.2267929316);
graph->SetPoint(104,92.01999664,0.2057837248);
graph->SetPoint(105,92.01999664,0.2057837248);
graph->SetPoint(106,92.05999756,0.1858001053);
graph->SetPoint(107,92.09999847,0.1668412983);
graph->SetPoint(108,92.13999939,0.1489065737);
graph->SetPoint(109,92.18000031,0.1319951713);
graph->SetPoint(110,92.22000122,0.1161063388);
graph->SetPoint(111,92.26000214,0.1012392938);
graph->SetPoint(112,92.30000305,0.08739329875);
graph->SetPoint(113,92.33999634,0.07456759363);
graph->SetPoint(114,92.37999725,0.06276145577);
graph->SetPoint(115,92.41999817,0.05197418481);
graph->SetPoint(116,92.45999908,0.04220509902);
graph->SetPoint(117,92.5,0.03345353901);
graph->SetPoint(118,92.54000092,0.02571888082);
graph->SetPoint(119,92.58000183,0.01900054142);
graph->SetPoint(120,92.62000275,0.01329800207);
graph->SetPoint(121,92.66000366,0.008610763587);
graph->SetPoint(122,92.69999695,0.004938419908);
graph->SetPoint(123,92.73999786,0.002280603396);
graph->SetPoint(124,92.77999878,0.0006370125338);
graph->SetPoint(125,92.81999969,7.419047051e-06);
//graph->SetPoint(126,92.81999969,7.419047961e-06);
graph->SetPoint(127,92.82485199,0);
graph->SetPoint(128,92.82485199,0);
graph->SetPoint(129,92.82485199,0);
graph->SetPoint(130,92.82485199,0);
graph->SetPoint(131,92.82485199,0);
graph->SetPoint(132,92.82485199,0);
graph->SetPoint(133,92.82485199,0);
graph->SetPoint(134,93.05999756,0.01752127893);
graph->SetPoint(135,93.09999847,0.02399016172);
graph->SetPoint(136,93.13999939,0.0314742066);
graph->SetPoint(137,93.18000031,0.03997394815);
graph->SetPoint(138,93.22000122,0.04949002713);
graph->SetPoint(139,93.26000214,0.06002314016);
graph->SetPoint(140,93.30000305,0.07157406956);
graph->SetPoint(141,93.33999634,0.08414366841);
graph->SetPoint(142,93.37999725,0.09773286432);
graph->SetPoint(143,93.41999817,0.1123426482);
graph->SetPoint(144,93.45999908,0.1279740632);
graph->SetPoint(145,93.5,0.144628197);
graph->SetPoint(146,93.54000092,0.1623062044);
graph->SetPoint(147,93.58000183,0.1810092628);
graph->SetPoint(148,93.62000275,0.200738579);
graph->SetPoint(149,93.62000275,0.200738579);
graph->SetPoint(150,93.66000366,0.2214953899);
graph->SetPoint(151,93.69999695,0.2432809174);
graph->SetPoint(152,93.73999786,0.2660964429);
graph->SetPoint(153,93.77999878,0.2899431586);
graph->SetPoint(154,93.81999969,0.3148224056);
graph->SetPoint(155,93.86000061,0.3407353461);
graph->SetPoint(156,93.90000153,0.367683202);
graph->SetPoint(157,93.94000244,0.3956672251);
graph->SetPoint(158,93.98000336,0.4246885478);
graph->SetPoint(159,94.01999664,0.4547482729);
graph->SetPoint(160,94.05999756,0.4858476222);
graph->SetPoint(161,94.09999847,0.5179876089);
graph->SetPoint(162,94.13999939,0.5511692166);
graph->SetPoint(163,94.18000031,0.585393548);
graph->SetPoint(164,94.22000122,0.6206615567);
graph->SetPoint(165,94.26000214,0.6569740772);
graph->SetPoint(166,94.30000305,0.6943320632);
graph->SetPoint(167,94.33999634,0.7327364087);
graph->SetPoint(168,94.37999725,0.772187829);
graph->SetPoint(169,94.41999817,0.8126871586);
graph->SetPoint(170,94.41999817,0.8126871586);
graph->SetPoint(171,94.45999908,0.8542351723);
graph->SetPoint(172,94.5,0.8968324661);
graph->SetPoint(173,94.54000092,0.940479815);
graph->SetPoint(174,94.58000183,0.985177815);
graph->SetPoint(175,94.62000275,1.030927062);
graph->SetPoint(176,94.66000366,1.077728152);
graph->SetPoint(177,94.69999695,1.125581622);
graph->SetPoint(178,94.73999786,1.174487948);
graph->SetPoint(179,94.77999878,1.224447489);
graph->SetPoint(180,94.81999969,1.27546072);
graph->SetPoint(181,94.86000061,1.327528);
graph->SetPoint(182,94.90000153,1.380649686);
graph->SetPoint(183,94.94000244,1.434825897);
graph->SetPoint(184,94.98000336,1.490056992);
graph->SetPoint(185,95.01999664,1.546342969);
graph->SetPoint(186,95.05999756,1.603683949);
graph->SetPoint(187,95.09999847,1.66207993);
graph->SetPoint(188,95.13999939,1.721530676);
graph->SetPoint(189,95.18000031,1.782036185);
graph->SetPoint(190,95.22000122,1.843595982);
graph->SetPoint(191,95.22000122,1.843595982);
graph->SetPoint(192,95.26000214,1.906209826);
graph->SetPoint(193,95.30000305,1.969877124);
graph->SetPoint(194,95.33999634,2.034597158);
graph->SetPoint(195,95.37999725,2.100369453);
graph->SetPoint(196,95.41999817,2.167192936);
graph->SetPoint(197,95.45999908,2.235066652);
graph->SetPoint(198,95.5,2.30398941);
graph->SetPoint(199,95.54000092,2.37395978);
graph->SetPoint(200,95.58000183,2.44497633);
graph->SetPoint(201,95.62000275,2.517037392);
graph->SetPoint(202,95.66000366,2.590141296);
graph->SetPoint(203,95.69999695,2.66428566);
graph->SetPoint(204,95.73999786,2.739468575);
graph->SetPoint(205,95.77999878,2.815687418);
graph->SetPoint(206,95.81999969,2.892939568);
graph->SetPoint(207,95.86000061,2.971222401);
graph->SetPoint(208,95.90000153,3.050532341);
graph->SetPoint(209,95.94000244,3.130866289);
graph->SetPoint(210,95.98000336,3.212220907);
graph->Sort();
cout << "4e: " << graph->Eval(91.1876) << endl;
//2e2mu
TGraph *graph1 = new TGraph(211);
graph1->SetName("Graph1");
graph1->SetTitle("Graph1");
graph1->SetFillColor(1);
graph1->SetLineWidth(3);
graph1->SetLineColor(kBlue);
graph1->SetMarkerStyle(20);
graph1->SetPoint(0,88.01999664,8.795412064);
graph1->SetPoint(1,88.05999756,8.61370182);
graph1->SetPoint(2,88.09999847,8.43285656);
graph1->SetPoint(3,88.13999939,8.252916336);
graph1->SetPoint(4,88.18000031,8.073918343);
graph1->SetPoint(5,88.22000122,7.895903111);
graph1->SetPoint(6,88.26000214,7.718908787);
graph1->SetPoint(7,88.30000305,7.542974472);
graph1->SetPoint(8,88.33999634,7.36813879);
graph1->SetPoint(9,88.37999725,7.194441795);
graph1->SetPoint(10,88.41999817,7.021921158);
graph1->SetPoint(11,88.45999908,6.850616932);
graph1->SetPoint(12,88.5,6.680567265);
graph1->SetPoint(13,88.54000092,6.51181221);
graph1->SetPoint(14,88.58000183,6.344389915);
graph1->SetPoint(15,88.62000275,6.178339481);
graph1->SetPoint(16,88.66000366,6.013700008);
graph1->SetPoint(17,88.69999695,5.850510597);
graph1->SetPoint(18,88.73999786,5.688809872);
graph1->SetPoint(19,88.77999878,5.528635979);
graph1->SetPoint(20,88.81999969,5.370028496);
graph1->SetPoint(21,88.81999969,5.370028496);
graph1->SetPoint(22,88.86000061,5.21302557);
graph1->SetPoint(23,88.90000153,5.057665825);
graph1->SetPoint(24,88.94000244,4.903987885);
graph1->SetPoint(25,88.98000336,4.752028942);
graph1->SetPoint(26,89.01999664,4.601828575);
graph1->SetPoint(27,89.05999756,4.4534235);
graph1->SetPoint(28,89.09999847,4.306852341);
graph1->SetPoint(29,89.13999939,4.162151814);
graph1->SetPoint(30,89.18000031,4.019360065);
graph1->SetPoint(31,89.22000122,3.87851429);
graph1->SetPoint(32,89.26000214,3.739651203);
graph1->SetPoint(33,89.30000305,3.602807283);
graph1->SetPoint(34,89.33999634,3.468019247);
graph1->SetPoint(35,89.37999725,3.335323095);
graph1->SetPoint(36,89.41999817,3.204754591);
graph1->SetPoint(37,89.45999908,3.076349258);
graph1->SetPoint(38,89.5,2.950142145);
graph1->SetPoint(39,89.54000092,2.82616806);
graph1->SetPoint(40,89.58000183,2.704461336);
graph1->SetPoint(41,89.62000275,2.58505559);
graph1->SetPoint(42,89.62000275,2.58505559);
graph1->SetPoint(43,89.66000366,2.467984438);
graph1->SetPoint(44,89.69999695,2.353280783);
graph1->SetPoint(45,89.73999786,2.240977049);
graph1->SetPoint(46,89.77999878,2.131105185);
graph1->SetPoint(47,89.81999969,2.023696423);
graph1->SetPoint(48,89.86000061,1.918781519);
graph1->SetPoint(49,89.90000153,1.816390634);
graph1->SetPoint(50,89.94000244,1.716553092);
graph1->SetPoint(51,89.98000336,1.619297981);
graph1->SetPoint(52,90.01999664,1.524653077);
graph1->SetPoint(53,90.05999756,1.432646155);
graph1->SetPoint(54,90.09999847,1.343303561);
graph1->SetPoint(55,90.13999939,1.256651402);
graph1->SetPoint(56,90.18000031,1.17271471);
graph1->SetPoint(57,90.22000122,1.091517925);
graph1->SetPoint(58,90.26000214,1.013084531);
graph1->SetPoint(59,90.30000305,0.9374370575);
graph1->SetPoint(60,90.33999634,0.864597559);
graph1->SetPoint(61,90.37999725,0.7945868969);
graph1->SetPoint(62,90.41999817,0.727425158);
graph1->SetPoint(63,90.41999817,0.727425158);
graph1->SetPoint(64,90.45999908,0.6631317139);
graph1->SetPoint(65,90.5,0.6017247438);
graph1->SetPoint(66,90.54000092,0.5432218313);
graph1->SetPoint(67,90.58000183,0.4876395166);
graph1->SetPoint(68,90.62000275,0.4349934459);
graph1->SetPoint(69,90.66000366,0.3852983713);
graph1->SetPoint(70,90.69999695,0.3385681808);
graph1->SetPoint(71,90.73999786,0.2948157787);
graph1->SetPoint(72,90.77999878,0.2540532351);
graph1->SetPoint(73,90.81999969,0.2162916809);
graph1->SetPoint(74,90.86000061,0.1815413088);
graph1->SetPoint(75,90.90000153,0.1498114169);
graph1->SetPoint(76,90.94000244,0.1211103573);
graph1->SetPoint(77,90.98000336,0.09544557333);
graph1->SetPoint(78,91.01999664,0.07282357663);
graph1->SetPoint(79,91.05999756,0.05324992537);
graph1->SetPoint(80,91.09999847,0.0367292501);
graph1->SetPoint(81,91.13999939,0.02326522022);
graph1->SetPoint(82,91.18000031,0.01286056917);
graph1->SetPoint(83,91.22000122,0.005517064128);
graph1->SetPoint(84,91.22000122,0.005517064128);
graph1->SetPoint(85,91.26000214,0.001235519536);
graph1->SetPoint(86,91.29593658,0);
graph1->SetPoint(87,91.29593658,0);
graph1->SetPoint(88,91.29593658,0);
graph1->SetPoint(89,91.29593658,0);
graph1->SetPoint(90,91.29593658,0);
graph1->SetPoint(91,91.29593658,0);
graph1->SetPoint(92,91.29593658,0);
graph1->SetPoint(93,91.5,0.03977194428);
graph1->SetPoint(94,91.54000092,0.05686627701);
graph1->SetPoint(95,91.58000183,0.07699460536);
graph1->SetPoint(96,91.62000275,0.1001491994);
graph1->SetPoint(97,91.66000366,0.1263214052);
graph1->SetPoint(98,91.69999695,0.1555016339);
graph1->SetPoint(99,91.73999786,0.1876795292);
graph1->SetPoint(100,91.77999878,0.2228437364);
graph1->SetPoint(101,91.81999969,0.260982126);
graph1->SetPoint(102,91.86000061,0.3020817041);
graph1->SetPoint(103,91.90000153,0.3461286724);
graph1->SetPoint(104,91.94000244,0.3931084573);
graph1->SetPoint(105,91.98000336,0.443005681);
graph1->SetPoint(106,92.01999664,0.4958042502);
//graph1->SetPoint(107,92.01999664,0.4958042204);
graph1->SetPoint(108,92.05999756,0.551487267);
graph1->SetPoint(109,92.09999847,0.6100373268);
graph1->SetPoint(110,92.13999939,0.671436131);
graph1->SetPoint(111,92.18000031,0.7356648445);
graph1->SetPoint(112,92.22000122,0.802703917);
graph1->SetPoint(113,92.26000214,0.872533381);
graph1->SetPoint(114,92.30000305,0.945132494);
graph1->SetPoint(115,92.33999634,1.020480037);
graph1->SetPoint(116,92.37999725,1.098554254);
graph1->SetPoint(117,92.41999817,1.179333091);
graph1->SetPoint(118,92.45999908,1.262793779);
graph1->SetPoint(119,92.5,1.348913193);
graph1->SetPoint(120,92.54000092,1.437667727);
graph1->SetPoint(121,92.58000183,1.52903378);
graph1->SetPoint(122,92.62000275,1.622986913);
graph1->SetPoint(123,92.66000366,1.719502687);
graph1->SetPoint(124,92.69999695,1.818556309);
graph1->SetPoint(125,92.73999786,1.920122623);
graph1->SetPoint(126,92.77999878,2.024176359);
graph1->SetPoint(127,92.81999969,2.130692005);
graph1->SetPoint(128,92.81999969,2.130692005);
graph1->SetPoint(129,92.86000061,2.239643812);
graph1->SetPoint(130,92.90000153,2.351006031);
graph1->SetPoint(131,92.94000244,2.464752674);
graph1->SetPoint(132,92.98000336,2.580857754);
graph1->SetPoint(133,93.01999664,2.699294806);
graph1->SetPoint(134,93.05999756,2.820037603);
graph1->SetPoint(135,93.09999847,2.94306016);
graph1->SetPoint(136,93.13999939,3.068335533);
graph1->SetPoint(137,93.18000031,3.195837736);
graph1->SetPoint(138,93.22000122,3.325540066);
graph1->SetPoint(139,93.26000214,3.457416296);
graph1->SetPoint(140,93.30000305,3.591439486);
graph1->SetPoint(141,93.33999634,3.727583647);
graph1->SetPoint(142,93.37999725,3.865821838);
graph1->SetPoint(143,93.41999817,4.006127834);
graph1->SetPoint(144,93.45999908,4.148474216);
graph1->SetPoint(145,93.5,4.292835712);
graph1->SetPoint(146,93.54000092,4.439184189);
graph1->SetPoint(147,93.58000183,4.587494373);
graph1->SetPoint(148,93.62000275,4.737738609);
graph1->SetPoint(149,93.62000275,4.737738609);
graph1->SetPoint(150,93.66000366,4.889890194);
graph1->SetPoint(151,93.69999695,5.043922424);
graph1->SetPoint(152,93.73999786,5.199808598);
graph1->SetPoint(153,93.77999878,5.357521057);
graph1->SetPoint(154,93.81999969,5.517033577);
graph1->SetPoint(155,93.86000061,5.678318024);
graph1->SetPoint(156,93.90000153,5.841347694);
graph1->SetPoint(157,93.94000244,6.006094933);
graph1->SetPoint(158,93.98000336,6.172532082);
graph1->SetPoint(159,94.01999664,6.340631485);
graph1->SetPoint(160,94.05999756,6.510365486);
graph1->SetPoint(161,94.09999847,6.681705952);
graph1->SetPoint(162,94.13999939,6.854624748);
graph1->SetPoint(163,94.18000031,7.029093266);
graph1->SetPoint(164,94.22000122,7.205083847);
graph1->SetPoint(165,94.26000214,7.382567883);
graph1->SetPoint(166,94.30000305,7.561516285);
graph1->SetPoint(167,94.33999634,7.741900921);
graph1->SetPoint(168,94.37999725,7.923692226);
graph1->SetPoint(169,94.41999817,8.106862068);
graph1->SetPoint(170,94.41999817,8.106862068);
graph1->SetPoint(171,94.45999908,8.291379929);
graph1->SetPoint(172,94.5,8.477218628);
graph1->SetPoint(173,94.54000092,8.664347649);
graph1->SetPoint(174,94.58000183,8.85273838);
graph1->SetPoint(175,94.62000275,9.042361259);
graph1->SetPoint(176,94.66000366,9.233187675);
graph1->SetPoint(177,94.69999695,9.425187111);
graph1->SetPoint(178,94.73999786,9.618330002);
graph1->SetPoint(179,94.77999878,9.812587738);
graph1->SetPoint(180,94.81999969,10.00793171);
graph1->SetPoint(181,94.86000061,10.20433044);
graph1->SetPoint(182,94.90000153,10.40175724);
graph1->SetPoint(183,94.94000244,10.60017967);
graph1->SetPoint(184,94.98000336,10.79957104);
graph1->SetPoint(185,95.01999664,10.99990082);
graph1->SetPoint(186,95.05999756,11.20113945);
graph1->SetPoint(187,95.09999847,11.40325832);
graph1->SetPoint(188,95.13999939,11.60622883);
graph1->SetPoint(189,95.18000031,11.81002045);
graph1->SetPoint(190,95.22000122,12.01460457);
graph1->SetPoint(191,95.22000122,12.01460457);
graph1->SetPoint(192,95.26000214,12.21995258);
graph1->SetPoint(193,95.30000305,12.42603588);
graph1->SetPoint(194,95.33999634,12.63282394);
graph1->SetPoint(195,95.37999725,12.84028816);
graph1->SetPoint(196,95.41999817,13.04840088);
graph1->SetPoint(197,95.45999908,13.25713253);
graph1->SetPoint(198,95.5,13.46645451);
graph1->SetPoint(199,95.54000092,13.6763382);
graph1->SetPoint(200,95.58000183,13.88675499);
graph1->SetPoint(201,95.62000275,14.09767723);
graph1->SetPoint(202,95.66000366,14.3090744);
graph1->SetPoint(203,95.69999695,14.5209198);
graph1->SetPoint(204,95.73999786,14.73318481);
graph1->SetPoint(205,95.77999878,14.94584179);
graph1->SetPoint(206,95.81999969,15.15886116);
graph1->SetPoint(207,95.86000061,15.37221718);
graph1->SetPoint(208,95.90000153,15.58588123);
graph1->SetPoint(209,95.94000244,15.79982567);
graph1->SetPoint(210,95.98000336,16.01402283);
graph1->Sort();
cout<< "2e2mu: " << graph1->Eval(91.1876) << endl;
//4mu
TGraph *graph2 = new TGraph(216);
graph2->SetName("Graph2");
graph2->SetTitle("Graph2");
graph2->SetFillColor(1);
graph2->SetLineWidth(3);
graph2->SetLineColor(kRed);
graph2->SetMarkerStyle(20);
graph2->SetPoint(0,88.01999664,42.99673462);
graph2->SetPoint(1,88.05999756,42.01807404);
graph2->SetPoint(2,88.09999847,41.04578781);
graph2->SetPoint(3,88.13999939,40.08004379);
graph2->SetPoint(4,88.18000031,39.12101746);
graph2->SetPoint(5,88.22000122,38.16888046);
graph2->SetPoint(6,88.26000214,37.22380447);
graph2->SetPoint(7,88.30000305,36.2859726);
graph2->SetPoint(8,88.33999634,35.35555267);
graph2->SetPoint(9,88.37999725,34.43272781);
graph2->SetPoint(10,88.41999817,33.51767731);
graph2->SetPoint(11,88.45999908,32.61057281);
graph2->SetPoint(12,88.5,31.71160507);
graph2->SetPoint(13,88.54000092,30.82094765);
graph2->SetPoint(14,88.58000183,29.93878746);
graph2->SetPoint(15,88.62000275,29.06530762);
graph2->SetPoint(16,88.66000366,28.20069313);
graph2->SetPoint(17,88.69999695,27.34512901);
graph2->SetPoint(18,88.73999786,26.49880409);
graph2->SetPoint(19,88.77999878,25.66190529);
graph2->SetPoint(20,88.81999969,24.83462334);
graph2->SetPoint(21,88.81999969,24.83462334);
graph2->SetPoint(22,88.86000061,24.01715088);
graph2->SetPoint(23,88.90000153,23.20967865);
graph2->SetPoint(24,88.94000244,22.41239929);
graph2->SetPoint(25,88.98000336,21.62551308);
graph2->SetPoint(26,89.01999664,20.84921074);
graph2->SetPoint(27,89.05999756,20.08369446);
graph2->SetPoint(28,89.09999847,19.32916451);
graph2->SetPoint(29,89.13999939,18.58581734);
graph2->SetPoint(30,89.18000031,17.85385895);
graph2->SetPoint(31,89.22000122,17.13349152);
graph2->SetPoint(32,89.26000214,16.42491913);
graph2->SetPoint(33,89.30000305,15.72835064);
graph2->SetPoint(34,89.33999634,15.04399014);
graph2->SetPoint(35,89.37999725,14.37204742);
graph2->SetPoint(36,89.41999817,13.71273041);
graph2->SetPoint(37,89.45999908,13.0662508);
graph2->SetPoint(38,89.5,12.43281651);
graph2->SetPoint(39,89.54000092,11.81264019);
graph2->SetPoint(40,89.58000183,11.20593262);
graph2->SetPoint(41,89.62000275,10.6129055);
graph2->SetPoint(42,89.62000275,10.6129055);
graph2->SetPoint(43,89.66000366,10.03376961);
graph2->SetPoint(44,89.69999695,9.468736649);
graph2->SetPoint(45,89.73999786,8.918016434);
graph2->SetPoint(46,89.77999878,8.381820679);
graph2->SetPoint(47,89.81999969,7.860357285);
graph2->SetPoint(48,89.86000061,7.353835583);
graph2->SetPoint(49,89.90000153,6.862462997);
graph2->SetPoint(50,89.94000244,6.386445045);
graph2->SetPoint(51,89.98000336,5.92598629);
graph2->SetPoint(52,90.01999664,5.481288433);
graph2->SetPoint(53,90.05999756,5.0525527);
graph2->SetPoint(54,90.09999847,4.639976501);
graph2->SetPoint(55,90.13999939,4.243755817);
graph2->SetPoint(56,90.18000031,3.864083052);
graph2->SetPoint(57,90.22000122,3.501147509);
graph2->SetPoint(58,90.26000214,3.155135393);
graph2->SetPoint(59,90.30000305,2.826228619);
graph2->SetPoint(60,90.33999634,2.514605522);
graph2->SetPoint(61,90.37999725,2.220438957);
graph2->SetPoint(62,90.41999817,1.943897605);
graph2->SetPoint(63,90.41999817,1.943897605);
graph2->SetPoint(64,90.45999908,1.685144305);
graph2->SetPoint(65,90.5,1.444335938);
graph2->SetPoint(66,90.54000092,1.221622825);
graph2->SetPoint(67,90.58000183,1.017148852);
graph2->SetPoint(68,90.62000275,0.8310500383);
graph2->SetPoint(69,90.66000366,0.663454473);
graph2->SetPoint(70,90.69999695,0.5144816637);
graph2->SetPoint(71,90.73999786,0.3842421472);
graph2->SetPoint(72,90.77999878,0.2728365958);
graph2->SetPoint(73,90.81999969,0.1803556085);
graph2->SetPoint(74,90.86000061,0.1068789586);
graph2->SetPoint(75,90.90000153,0.05247514695);
graph2->SetPoint(76,90.94000244,0.01720083691);
graph2->SetPoint(77,90.98000336,0.00110038009);
graph2->SetPoint(78,90.9935379,0);
graph2->SetPoint(79,90.9935379,0);
graph2->SetPoint(80,90.9935379,0);
graph2->SetPoint(81,90.9935379,0);
graph2->SetPoint(82,90.9935379,0);
graph2->SetPoint(83,90.9935379,0);
graph2->SetPoint(84,90.9935379,0);
graph2->SetPoint(85,91.01999664,0.004205350298);
graph2->SetPoint(86,91.05999756,0.02653408609);
graph2->SetPoint(87,91.09999847,0.06809128821);
graph2->SetPoint(88,91.13999939,0.1288676411);
graph2->SetPoint(89,91.18000031,0.208839491);
graph2->SetPoint(90,91.22000122,0.3079685569);
graph2->SetPoint(91,91.22000122,0.3079685569);
graph2->SetPoint(92,91.26000214,0.4262017608);
graph2->SetPoint(93,91.30000305,0.5634709001);
graph2->SetPoint(94,91.33999634,0.7196927667);
graph2->SetPoint(95,91.37999725,0.8947688341);
graph2->SetPoint(96,91.41999817,1.088585615);
graph2->SetPoint(97,91.45999908,1.301014304);
graph2->SetPoint(98,91.5,1.531911612);
graph2->SetPoint(99,91.54000092,1.781119347);
graph2->SetPoint(100,91.58000183,2.048465252);
graph2->SetPoint(101,91.62000275,2.333762884);
graph2->SetPoint(102,91.66000366,2.636813402);
graph2->SetPoint(103,91.69999695,2.957404137);
graph2->SetPoint(104,91.73999786,3.295311213);
graph2->SetPoint(105,91.77999878,3.650299788);
graph2->SetPoint(106,91.81999969,4.022123814);
graph2->SetPoint(107,91.86000061,4.410528183);
graph2->SetPoint(108,91.90000153,4.815249443);
graph2->SetPoint(109,91.94000244,5.23601675);
graph2->SetPoint(110,91.98000336,5.672553062);
graph2->SetPoint(111,92.01999664,6.124575138);
graph2->SetPoint(112,92.01999664,6.124575138);
graph2->SetPoint(113,92.05999756,6.591795921);
graph2->SetPoint(114,92.09999847,7.073926449);
graph2->SetPoint(115,92.13999939,7.570672989);
graph2->SetPoint(116,92.18000031,8.08174324);
graph2->SetPoint(117,92.22000122,8.606842995);
graph2->SetPoint(118,92.26000214,9.145680428);
graph2->SetPoint(119,92.30000305,9.697964668);
graph2->SetPoint(120,92.33999634,10.26340675);
graph2->SetPoint(121,92.37999725,10.84172058);
graph2->SetPoint(122,92.41999817,11.43262482);
graph2->SetPoint(123,92.45999908,12.03584099);
graph2->SetPoint(124,92.5,12.65109539);
graph2->SetPoint(125,92.54000092,13.27812099);
graph2->SetPoint(126,92.58000183,13.91665268);
graph2->SetPoint(127,92.62000275,14.56643105);
graph2->SetPoint(128,92.66000366,15.22720337);
graph2->SetPoint(129,92.69999695,15.89872169);
graph2->SetPoint(130,92.73999786,16.58073997);
graph2->SetPoint(131,92.77999878,17.2730217);
graph2->SetPoint(132,92.81999969,17.97533035);
graph2->SetPoint(133,92.81999969,17.97533035);
graph2->SetPoint(134,92.86000061,18.68743896);
graph2->SetPoint(135,92.90000153,19.40911865);
graph2->SetPoint(136,92.94000244,20.14015007);
graph2->SetPoint(137,92.98000336,20.88031387);
graph2->SetPoint(138,93.01999664,21.62939453);
graph2->SetPoint(139,93.05999756,22.38718414);
graph2->SetPoint(140,93.09999847,23.15346909);
graph2->SetPoint(141,93.13999939,23.92804527);
graph2->SetPoint(142,93.18000031,24.71071243);
graph2->SetPoint(143,93.22000122,25.50126266);
graph2->SetPoint(144,93.26000214,26.29950333);
graph2->SetPoint(145,93.30000305,27.10523224);
graph2->SetPoint(146,93.33999634,27.91825485);
graph2->SetPoint(147,93.37999725,28.73837852);
graph2->SetPoint(148,93.41999817,29.56540871);
graph2->SetPoint(149,93.45999908,30.39915657);
graph2->SetPoint(150,93.5,31.23942947);
graph2->SetPoint(151,93.54000092,32.0860405);
graph2->SetPoint(152,93.58000183,32.93880081);
graph2->SetPoint(153,93.62000275,33.79752731);
graph2->SetPoint(154,93.62000275,33.79752731);
graph2->SetPoint(155,93.66000366,34.66203308);
graph2->SetPoint(156,93.69999695,35.53213501);
graph2->SetPoint(157,93.73999786,36.40764999);
graph2->SetPoint(158,93.77999878,37.28839874);
graph2->SetPoint(159,93.81999969,38.17420197);
graph2->SetPoint(160,93.86000061,39.06488037);
graph2->SetPoint(161,93.90000153,39.96025848);
graph2->SetPoint(162,93.94000244,40.86016464);
graph2->SetPoint(163,93.98000336,41.76441956);
graph2->SetPoint(164,94.01999664,42.67286301);
graph2->SetPoint(165,94.05999756,43.5853157);
graph2->SetPoint(166,94.09999847,44.50161362);
graph2->SetPoint(167,94.13999939,45.42160034);
graph2->SetPoint(168,94.18000031,46.34510422);
graph2->SetPoint(169,94.22000122,47.27197266);
graph2->SetPoint(170,94.26000214,48.20204544);
graph2->SetPoint(171,94.30000305,49.13516998);
graph2->SetPoint(172,94.33999634,50.07119751);
graph2->SetPoint(173,94.37999725,51.00997925);
graph2->SetPoint(174,94.41999817,51.95137024);
graph2->SetPoint(175,94.41999817,51.95137024);
graph2->SetPoint(176,94.45999908,52.89523315);
graph2->SetPoint(177,94.5,53.84142303);
graph2->SetPoint(178,94.54000092,54.789814);
graph2->SetPoint(179,94.58000183,55.74026871);
graph2->SetPoint(180,94.62000275,56.69266129);
graph2->SetPoint(181,94.66000366,57.64687347);
graph2->SetPoint(182,94.69999695,58.60277939);
graph2->SetPoint(183,94.73999786,59.5602684);
graph2->SetPoint(184,94.77999878,60.51922989);
graph2->SetPoint(185,94.81999969,61.47954941);
graph2->SetPoint(186,94.86000061,62.44112778);
graph2->SetPoint(187,94.90000153,63.40386581);
graph2->SetPoint(188,94.94000244,64.36766815);
graph2->SetPoint(189,94.98000336,65.33243561);
graph2->SetPoint(190,95.01999664,66.29808044);
graph2->SetPoint(191,95.05999756,67.264534);
graph2->SetPoint(192,95.09999847,68.23168945);
graph2->SetPoint(193,95.13999939,69.19949341);
graph2->SetPoint(194,95.18000031,70.16786194);
graph2->SetPoint(195,95.22000122,71.13671875);
graph2->SetPoint(196,95.22000122,71.13671875);
graph2->SetPoint(197,95.26000214,72.10600281);
graph2->SetPoint(198,95.30000305,73.07565308);
graph2->SetPoint(199,95.33999634,74.04560852);
graph2->SetPoint(200,95.37999725,75.01580811);
graph2->SetPoint(201,95.41999817,75.98619843);
graph2->SetPoint(202,95.45999908,76.95672607);
graph2->SetPoint(203,95.5,77.92734528);
graph2->SetPoint(204,95.54000092,78.89801788);
graph2->SetPoint(205,95.58000183,79.86868286);
graph2->SetPoint(206,95.62000275,80.83930969);
graph2->SetPoint(207,95.66000366,81.80986023);
graph2->SetPoint(208,95.69999695,82.7802887);
graph2->SetPoint(209,95.73999786,83.7505722);
graph2->SetPoint(210,95.77999878,84.72067261);
graph2->SetPoint(211,95.81999969,85.69055176);
graph2->SetPoint(212,95.86000061,86.6601944);
graph2->SetPoint(213,95.90000153,87.62956238);
graph2->SetPoint(214,95.94000244,88.59862518);
graph2->SetPoint(215,95.98000336,89.56736755);
cout<< "4mu: " << graph2->Eval(91.1876) << endl;
//4l
TGraph *graph3 = new TGraph(212);
graph3->SetName("Graph3");
graph3->SetTitle("Graph3");
graph3->SetFillColor(1);
graph3->SetLineWidth(3);
graph3->SetMarkerStyle(20);
graph3->SetPoint(0,88.01999664,57.33911514);
graph3->SetPoint(1,88.05999756,56.08871841);
graph3->SetPoint(2,88.09999847,54.84604263);
graph3->SetPoint(3,88.13999939,53.61128998);
graph3->SetPoint(4,88.18000031,52.38465881);
graph3->SetPoint(5,88.22000122,51.1663475);
graph3->SetPoint(6,88.26000214,49.95656586);
graph3->SetPoint(7,88.30000305,48.75551605);
graph3->SetPoint(8,88.33999634,47.56340408);
graph3->SetPoint(9,88.37999725,46.38043976);
graph3->SetPoint(10,88.41999817,45.20683289);
graph3->SetPoint(11,88.45999908,44.04279709);
graph3->SetPoint(12,88.5,42.88854218);
graph3->SetPoint(13,88.54000092,41.74428558);
graph3->SetPoint(14,88.58000183,40.61024094);
graph3->SetPoint(15,88.62000275,39.48662186);
graph3->SetPoint(16,88.66000366,38.37365723);
graph3->SetPoint(17,88.69999695,37.27156067);
graph3->SetPoint(18,88.73999786,36.18055725);
graph3->SetPoint(19,88.77999878,35.10086823);
graph3->SetPoint(20,88.81999969,34.03272247);
graph3->SetPoint(21,88.81999969,34.03272247);
graph3->SetPoint(22,88.86000061,32.97634506);
graph3->SetPoint(23,88.90000153,31.93196487);
graph3->SetPoint(24,88.94000244,30.89981461);
graph3->SetPoint(25,88.98000336,29.88012505);
graph3->SetPoint(26,89.01999664,28.87313271);
graph3->SetPoint(27,89.05999756,27.87907028);
graph3->SetPoint(28,89.09999847,26.8981781);
graph3->SetPoint(29,89.13999939,25.93069649);
graph3->SetPoint(30,89.18000031,24.97686577);
graph3->SetPoint(31,89.22000122,24.03692818);
graph3->SetPoint(32,89.26000214,23.11112785);
graph3->SetPoint(33,89.30000305,22.19971466);
graph3->SetPoint(34,89.33999634,21.30293083);
graph3->SetPoint(35,89.37999725,20.42103004);
graph3->SetPoint(36,89.41999817,19.55426025);
graph3->SetPoint(37,89.45999908,18.70287132);
graph3->SetPoint(38,89.5,17.86711502);
graph3->SetPoint(39,89.54000092,17.04724693);
graph3->SetPoint(40,89.58000183,16.24351692);
graph3->SetPoint(41,89.62000275,15.45617962);
graph3->SetPoint(42,89.62000275,15.45617962);
graph3->SetPoint(43,89.66000366,14.6854887);
graph3->SetPoint(44,89.69999695,13.93169785);
graph3->SetPoint(45,89.73999786,13.19505882);
graph3->SetPoint(46,89.77999878,12.47582531);
graph3->SetPoint(47,89.81999969,11.77424908);
graph3->SetPoint(48,89.86000061,11.09057903);
graph3->SetPoint(49,89.90000153,10.4250679);
graph3->SetPoint(50,89.94000244,9.777960777);
graph3->SetPoint(51,89.98000336,9.149505615);
graph3->SetPoint(52,90.01999664,8.539945602);
graph3->SetPoint(53,90.05999756,7.949523926);
graph3->SetPoint(54,90.09999847,7.378479958);
graph3->SetPoint(55,90.13999939,6.827050209);
graph3->SetPoint(56,90.18000031,6.295467854);
graph3->SetPoint(57,90.22000122,5.783964634);
graph3->SetPoint(58,90.26000214,5.292765617);
graph3->SetPoint(59,90.30000305,4.82209301);
graph3->SetPoint(60,90.33999634,4.37216568);
graph3->SetPoint(61,90.37999725,3.943194866);
graph3->SetPoint(62,90.41999817,3.535388231);
graph3->SetPoint(63,90.41999817,3.535388231);
graph3->SetPoint(64,90.45999908,3.148947239);
graph3->SetPoint(65,90.5,2.784065962);
graph3->SetPoint(66,90.54000092,2.440932035);
graph3->SetPoint(67,90.58000183,2.119725466);
graph3->SetPoint(68,90.62000275,1.820617914);
graph3->SetPoint(69,90.66000366,1.543772101);
graph3->SetPoint(70,90.69999695,1.28934145);
graph3->SetPoint(71,90.73999786,1.057468891);
graph3->SetPoint(72,90.77999878,0.8482871056);
graph3->SetPoint(73,90.81999969,0.6619167924);
graph3->SetPoint(74,90.86000061,0.4984668195);
graph3->SetPoint(75,90.90000153,0.3580331504);
graph3->SetPoint(76,90.94000244,0.240698427);
graph3->SetPoint(77,90.98000336,0.1465311348);
graph3->SetPoint(78,91.01999664,0.07558509707);
graph3->SetPoint(79,91.05999756,0.02789884619);
graph3->SetPoint(80,91.09999847,0.003495044075);
graph3->SetPoint(81,91.12191772,0);
graph3->SetPoint(82,91.12191772,0);
graph3->SetPoint(83,91.12191772,0);
graph3->SetPoint(84,91.12191772,0);
graph3->SetPoint(85,91.12191772,0);
graph3->SetPoint(86,91.12191772,0);
graph3->SetPoint(87,91.12191772,0);
graph3->SetPoint(88,91.26000214,0.1385737211);
graph3->SetPoint(89,91.30000305,0.230332002);
graph3->SetPoint(90,91.33999634,0.345148921);
graph3->SetPoint(91,91.37999725,0.4829240143);
graph3->SetPoint(92,91.41999817,0.643538177);
graph3->SetPoint(93,91.45999908,0.8268537521);
graph3->SetPoint(94,91.5,1.032714605);
graph3->SetPoint(95,91.54000092,1.260946751);
graph3->SetPoint(96,91.58000183,1.511358023);
graph3->SetPoint(97,91.62000275,1.783738732);
graph3->SetPoint(98,91.66000366,2.07786274);
graph3->SetPoint(99,91.69999695,2.39348793);
graph3->SetPoint(100,91.73999786,2.730356455);
graph3->SetPoint(101,91.77999878,3.088196516);
graph3->SetPoint(102,91.81999969,3.466723442);
graph3->SetPoint(103,91.86000061,3.865639925);
graph3->SetPoint(104,91.90000153,4.284637928);
graph3->SetPoint(105,91.94000244,4.723400593);
graph3->SetPoint(106,91.98000336,5.181601524);
graph3->SetPoint(107,92.01999664,5.658910275);
graph3->SetPoint(108,92.01999664,5.658910275);
graph3->SetPoint(109,92.05999756,6.154988289);
graph3->SetPoint(110,92.09999847,6.669495583);
graph3->SetPoint(111,92.13999939,7.202087879);
graph3->SetPoint(112,92.18000031,7.752422333);
graph3->SetPoint(113,92.22000122,8.32015419);
graph3->SetPoint(114,92.26000214,8.904941559);
graph3->SetPoint(115,92.30000305,9.506444931);
graph3->SetPoint(116,92.33999634,10.12432957);
graph3->SetPoint(117,92.37999725,10.75826359);
graph3->SetPoint(118,92.41999817,11.40792084);
graph3->SetPoint(119,92.45999908,12.07298279);
graph3->SetPoint(120,92.5,12.75313663);
graph3->SetPoint(121,92.54000092,13.44807529);
graph3->SetPoint(122,92.58000183,14.15750027);
graph3->SetPoint(123,92.62000275,14.88112068);
graph3->SetPoint(124,92.66000366,15.61865044);
graph3->SetPoint(125,92.69999695,16.36981392);
graph3->SetPoint(126,92.73999786,17.13433838);
graph3->SetPoint(127,92.77999878,17.91196251);
graph3->SetPoint(128,92.81999969,18.70242691);
graph3->SetPoint(129,92.81999969,18.70242691);
graph3->SetPoint(130,92.86000061,19.50548172);
graph3->SetPoint(131,92.90000153,20.32088089);
graph3->SetPoint(132,92.94000244,21.14838409);
graph3->SetPoint(133,92.98000336,21.98775864);
graph3->SetPoint(134,93.01999664,22.83877182);
graph3->SetPoint(135,93.05999756,23.70119667);
graph3->SetPoint(136,93.09999847,24.57481003);
graph3->SetPoint(137,93.13999939,25.45939636);
graph3->SetPoint(138,93.18000031,26.35473442);
graph3->SetPoint(139,93.22000122,27.2606163);
graph3->SetPoint(140,93.26000214,28.17682648);
graph3->SetPoint(141,93.30000305,29.10315895);
graph3->SetPoint(142,93.33999634,30.03940773);
graph3->SetPoint(143,93.37999725,30.98536491);
graph3->SetPoint(144,93.41999817,31.94083023);
graph3->SetPoint(145,93.45999908,32.9056015);
graph3->SetPoint(146,93.5,33.87947845);
graph3->SetPoint(147,93.54000092,34.86225891);
graph3->SetPoint(148,93.58000183,35.85375214);
graph3->SetPoint(149,93.62000275,36.85375214);
graph3->SetPoint(150,93.62000275,36.85375214);
graph3->SetPoint(151,93.66000366,37.86207199);
graph3->SetPoint(152,93.69999695,38.87851334);
graph3->SetPoint(153,93.73999786,39.90288162);
graph3->SetPoint(154,93.77999878,40.93498611);
graph3->SetPoint(155,93.81999969,41.97463608);
graph3->SetPoint(156,93.86000061,43.02164078);
graph3->SetPoint(157,93.90000153,44.07581329);
graph3->SetPoint(158,93.94000244,45.13696671);
graph3->SetPoint(159,93.98000336,46.20491409);
graph3->SetPoint(160,94.01999664,47.27947617);
graph3->SetPoint(161,94.05999756,48.360466);
graph3->SetPoint(162,94.09999847,49.44770813);
graph3->SetPoint(163,94.13999939,50.54101944);
graph3->SetPoint(164,94.18000031,51.64023209);
graph3->SetPoint(165,94.22000122,52.74516296);
graph3->SetPoint(166,94.26000214,53.85564804);
graph3->SetPoint(167,94.30000305,54.97151947);
graph3->SetPoint(168,94.33999634,56.09260941);
graph3->SetPoint(169,94.37999725,57.21875763);
graph3->SetPoint(170,94.41999817,58.34980011);
graph3->SetPoint(171,94.41999817,58.34980011);
graph3->SetPoint(172,94.45999908,59.48558426);
graph3->SetPoint(173,94.5,60.62595749);
graph3->SetPoint(174,94.54000092,61.77076721);
graph3->SetPoint(175,94.58000183,62.91986847);
graph3->SetPoint(176,94.62000275,64.07312012);
graph3->SetPoint(177,94.66000366,65.2303772);
graph3->SetPoint(178,94.69999695,66.39151001);
graph3->SetPoint(179,94.73999786,67.55638123);
graph3->SetPoint(180,94.77999878,68.72486877);
graph3->SetPoint(181,94.81999969,69.89684296);
graph3->SetPoint(182,94.86000061,71.07218933);
graph3->SetPoint(183,94.90000153,72.25079346);
graph3->SetPoint(184,94.94000244,73.43252563);
graph3->SetPoint(185,94.98000336,74.61729431);
graph3->SetPoint(186,95.01999664,75.80497742);
graph3->SetPoint(187,95.05999756,76.99549103);
graph3->SetPoint(188,95.09999847,78.18872833);
graph3->SetPoint(189,95.13999939,79.38459015);
graph3->SetPoint(190,95.18000031,80.58299255);
graph3->SetPoint(191,95.22000122,81.78383636);
graph3->SetPoint(192,95.22000122,81.78383636);
graph3->SetPoint(193,95.26000214,82.98705292);
graph3->SetPoint(194,95.30000305,84.19254303);
graph3->SetPoint(195,95.33999634,85.40024567);
graph3->SetPoint(196,95.37999725,86.61006927);
graph3->SetPoint(197,95.41999817,87.82195282);
graph3->SetPoint(198,95.45999908,89.03581238);
graph3->SetPoint(199,95.5,90.25159454);
graph3->SetPoint(200,95.54000092,91.46923065);
graph3->SetPoint(201,95.58000183,92.68865204);
graph3->SetPoint(202,95.62000275,93.90979767);
graph3->SetPoint(203,95.66000366,95.13261414);
graph3->SetPoint(204,95.69999695,96.35704803);
graph3->SetPoint(205,95.73999786,97.58303833);
graph3->SetPoint(206,95.77999878,98.81052399);
graph3->SetPoint(207,95.81999969,100.0394745);
graph3->SetPoint(208,95.86000061,101.2698212);
graph3->SetPoint(209,95.90000153,102.5015259);
graph3->SetPoint(210,95.94000244,103.7345352);
graph3->SetPoint(211,95.98000336,104.9688034);
TH1F *Graph_Graph1 = new TH1F("Graph_Graph1","Graph",212,84.03,95.97);
Graph_Graph1->SetMinimum(0);
Graph_Graph1->SetMaximum(57.47094);
Graph_Graph1->SetDirectory(0);
Graph_Graph1->SetStats(0);
Graph_Graph1->SetLineStyle(0);
Graph_Graph1->SetMarkerStyle(20);
Graph_Graph1->GetXaxis()->SetLabelFont(42);
Graph_Graph1->GetXaxis()->SetLabelOffset(0.01);
Graph_Graph1->GetXaxis()->SetLabelSize(0.045);
Graph_Graph1->GetXaxis()->SetTitleSize(0.055);
Graph_Graph1->GetXaxis()->SetTitleOffset(0.9);
Graph_Graph1->GetXaxis()->SetTitleFont(42);
Graph_Graph1->GetYaxis()->SetLabelFont(42);
Graph_Graph1->GetYaxis()->SetLabelOffset(0.01);
Graph_Graph1->GetYaxis()->SetLabelSize(0.045);
Graph_Graph1->GetYaxis()->SetTitleSize(0.055);
Graph_Graph1->GetYaxis()->SetTitleOffset(1.25);
Graph_Graph1->GetYaxis()->SetTitleFont(42);
Graph_Graph1->GetZaxis()->SetLabelFont(42);
Graph_Graph1->GetZaxis()->SetLabelOffset(0.01);
Graph_Graph1->GetZaxis()->SetLabelSize(0.045);
Graph_Graph1->GetZaxis()->SetTitleSize(0.055);
Graph_Graph1->GetZaxis()->SetTitleFont(42);
Graph_Graph1->GetXaxis()->SetNdivisions(510);
graph->SetHistogram(Graph_Graph1);
graph->Draw("cx");
graph1->Draw("cx");
graph2->Draw("cx");
graph3->Draw("cx");
TPaveText *pt = new TPaveText(0.1577181,0.95,0.9580537,0.99,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.03);
TText *text = pt->AddText(0.01,0.5,"CMS");
text = pt->AddText(0.3,0.6,"#sqrt{s} = 7 TeV, L = 5.1 fb^{-1} #sqrt{s} = 8 TeV, L = 19.7 fb^{-1}");
pt->Draw();
TLegend *leg = new TLegend(0.73,0.77,0.94,0.94);
leg->SetTextSize(0.035);
leg->SetTextFont(42);
leg->SetFillColor(kWhite);
//leg->SetBorderSize(0);
//leg->SetFillStyle(0);
leg->AddEntry(graph3,"Combined","L");
leg->AddEntry(graph,"Z#rightarrow 4e","L");
leg->AddEntry(graph2,"Z#rightarrow 4#mu","L");
leg->AddEntry(graph1,"Z#rightarrow 2e2#mu","L");
double yLow = 0.5;
pt = new TPaveText(0.11,yLow,0.4,yLow+0.04,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.03);
pt->SetTextColor(kBlue);
text = pt->AddText(0.2,0.2,"m_{2e2#mu} = 91.24 #pm 0.46 GeV");
//text = pt->AddText(0.2,0.2,"m_{2e2#mu} = 91.24 #pm 0.40 #pm 0.16 GeV");
//stat 91.4315 +0.405948-0.397679
cout << "Syst 2e2mu: " << findSystErr(0.43,0.40) << endl;
//pt->Draw();
pt = new TPaveText(0.11,yLow+0.06,0.4,yLow+0.1,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.03);
pt->SetTextColor(kRed);
text = pt->AddText(0.2,0.2,"m_{4#mu} = 91.00 #pm 0.26 GeV");
//text = pt->AddText(0.2,0.2,"m_{4#mu} = 91.00 #pm 0.25 #pm 0.09 GeV");
//stat 91.0078 +0.255715-0.25533
cout << "Syst 4mu: " << findSystErr(0.27,0.255) << endl;
//pt->Draw();
pt = new TPaveText(0.11,yLow+0.12,0.4,yLow+0.16,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.03);
pt->SetTextColor(kGreen+1);
text = pt->AddText(0.2,0.2,"m_{4e} = 93.67 #pm 1.08 GeV");
//text = pt->AddText(0.2,0.2,"m_{4e} = 9 #pm 0.74 #pm 0.30 GeV");
//stat 91.8026 +0.745333-0.740755
cout << "Syst 4e: " << findSystErr(0.8,0.74) << endl;
//pt->Draw();
pt = new TPaveText(0.11,yLow+0.18,0.4,yLow+0.22,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.03);
text = pt->AddText(0.2,0.2,"m_{4l} = 91.15 #pm 0.23 GeV");
//text = pt->AddText(0.2,0.2,"m_{4l} = 91.17 #pm 0.18 #pm 0.13 GeV");
//stat 91.1724 +0.168014-0.204439
cout << "Syst 4l: " << findSystErr(0.22,0.18) << endl;
//pt->Draw();
pt = new TPaveText(0.18,yLow+0.24,0.4,yLow+0.28,"brNDC");
pt->SetBorderSize(0);
pt->SetFillStyle(0);
pt->SetTextAlign(12);
pt->SetTextFont(42);
pt->SetTextSize(0.035);
text = pt->AddText(0.2,0.2,"#chi^{2}/ndof = 1.38/3");
//pt->Draw();
gPad->SetTicks(1,1);
TLine *line95 = new TLine(88,3.84,96,3.84);
line95->SetLineColor(kRed);
line95->SetLineWidth(2);
line95->Draw();
TLine *line68 = new TLine(88,1,96,1);
line68->SetLineColor(kRed);
line68->SetLineWidth(3);
line68->Draw();
TLine *lineZ = new TLine(91.1876,0,91.1876,10);
lineZ->SetLineColor(kGray+2);
lineZ->SetLineStyle(7);
lineZ->Draw();
leg->Draw();
hframe->GetXaxis()->SetRangeUser(88,96);
ccc->Modified();
ccc->cd();
ccc->SetSelected(ccc);
ccc->SaveAs("massZ4lScan_MZ2gt12_Legacy_split.eps");
ccc->SaveAs("massZ4lScan_MZ2gt12_Legacy_split.png");
}
void da_scan(TString inFile = "r_spr.root", TString outFile="c_spr.root"){
fSavePath = "data/mirror_old_ng";
TChain ch("dirc"); ch.Add(inFile);
Double_t cangle,spr,trr,nph,par1,par2,par3,par4,par5,par6,test1,test2,theta,phi;
TGraph *gSpr = new TGraph();
TGraph *gNph = new TGraph();
TGraph *gTrr = new TGraph();
ch.SetBranchAddress("spr",&spr);
ch.SetBranchAddress("trr",&trr);
ch.SetBranchAddress("nph",&nph);
ch.SetBranchAddress("cangle",&cangle);
// ch.SetBranchAddress("par4",&par4);
ch.SetBranchAddress("par5",&par5);
ch.SetBranchAddress("par6",&par6);
ch.SetBranchAddress("test1",&test1);
ch.SetBranchAddress("test2",&test2);
ch.SetBranchAddress("theta",&theta);
ch.SetBranchAddress("phi",&phi);
Int_t nent = ch.GetEntries();
std::cout<<"# entries "<< nent <<std::endl;
std::cout<<"infor "<< ch.GetTree()->GetTitle()<<std::endl;
for (Int_t i = 0; i < nent; i++) {
ch.GetEvent(i);
gSpr->SetPoint(i,theta,TMath::Abs(spr));
gNph->SetPoint(i,theta,nph);
gTrr->SetPoint(i,theta,TMath::Abs(trr));
}
gSpr->Sort();
gNph->Sort();
gTrr->Sort();
gSpr->SetLineColor(38);
gNph->SetLineColor(38);
gTrr->SetLineColor(38);
gSpr->SetMarkerStyle(20);
gNph->SetMarkerStyle(20);
gTrr->SetMarkerStyle(20);
gSpr->SetMarkerSize(0.7);
gNph->SetMarkerSize(0.7);
gTrr->SetMarkerSize(0.7);
gNph->GetYaxis()->SetRangeUser(0,140);
gSpr->GetYaxis()->SetRangeUser(0,14);
gTrr->GetYaxis()->SetRangeUser(0,2);
gSpr->GetYaxis()->SetTitle("SPR [mrad]");
gNph->GetYaxis()->SetTitle("multiplicity [#]");
gTrr->GetYaxis()->SetTitle("#sigma_{#theta_{C} tr} [mrad]");
gSpr->GetXaxis()->SetLabelSize(0.05);
gSpr->GetXaxis()->SetTitleSize(0.06);
gSpr->GetXaxis()->SetTitleOffset(0.84);
gTrr->GetXaxis()->SetLabelSize(0.05);
gTrr->GetXaxis()->SetTitleSize(0.06);
gTrr->GetXaxis()->SetTitleOffset(0.84);
gNph->GetXaxis()->SetLabelSize(0.05);
gNph->GetXaxis()->SetTitleSize(0.06);
gNph->GetXaxis()->SetTitleOffset(0.84);
gSpr->GetYaxis()->SetLabelSize(0.05);
gSpr->GetYaxis()->SetTitleSize(0.06);
gSpr->GetYaxis()->SetTitleOffset(0.7);
gTrr->GetYaxis()->SetLabelSize(0.05);
gTrr->GetYaxis()->SetTitleSize(0.06);
gTrr->GetYaxis()->SetTitleOffset(0.7);
gNph->GetYaxis()->SetLabelSize(0.05);
gNph->GetYaxis()->SetTitleSize(0.06);
gNph->GetYaxis()->SetTitleOffset(0.7);
gSpr->GetXaxis()->SetTitle("#theta_{track} [#circ]");
gNph->GetXaxis()->SetTitle("#theta_{track} [#circ]");
gTrr->GetXaxis()->SetTitle("#theta_{track} [#circ]");
TFile *file = new TFile(outFile,"RECREATE");
TCanvas* c1 = new TCanvas("c1","c1",800,500);c1->SetBottomMargin(0.12);
gSpr->Draw("APL");
canvasAdd(c1);
TCanvas* c2 = new TCanvas("c2","c2",800,500);c2->SetBottomMargin(0.12);
gNph->Draw("APL");
canvasAdd(c2);
TCanvas* c3 = new TCanvas("c3","c3",800,500);c3->SetBottomMargin(0.12);
gTrr->Draw("APL");
canvasAdd(c3);
canvasSave(0,1);
file->cd();
c1->Write();
c2->Write();
c3->Write();
file->Close();
}
void Limit_2D_LQ() {
// setTDRStyle();
gStyle->SetPadLeftMargin(0.15);
gStyle->SetLineWidth(2);
gROOT->ForceStyle();
TCanvas *c = new TCanvas("c1", "c1",0,45,600,600);
gStyle->SetOptStat(0);
c->SetHighLightColor(2);
c->Range(0,0,1,1);
c->SetFillColor(0);
c->SetBorderMode(0);
c->SetBorderSize(2);
c->SetLeftMargin(0.12);
c->SetRightMargin(0.04);
c->SetTopMargin(0.06);
c->SetBottomMargin(0.12);
c->SetFrameFillStyle(0);
c->SetFrameLineWidth(2);
c->SetFrameBorderMode(0);
c->SetTickx(1);
c->SetTicky(1);
c->cd();
// const int nMass = 15;
// Double_t mData[] = {200, 250, 300, 350, 400, 450, 500, 550, 600, 650, 700, 750, 800, 850, 900};
// Double_t limit_observed[] = {0.0827284, 0.0981056, 0.0646578, 0.0733808, 0.115078, 0.154828, 0.227671, 0.307448, 0.39362, 0.554267, 0.783352, 1.07813, 1.5539, 2.21602, 3.46142};
// Double_t limit_expected[] = {0.088132, 0.100218, 0.0708202, 0.0703361, 0.090391, 0.131143, 0.175555, 0.247355, 0.34838, 0.487021, 0.693413, 0.979308, 1.406, 2.00591, 3.09258};
////
//
//
//
// // // https://twiki.cern.ch/twiki/bin/view/CMS/Exo2015LQ1AndLQ2Analyses
std::map<int, float> XS;
XS[200]= 60.6;
XS[250]= 20.3;
XS[300]= 8.05E+00;
XS[350]= 3.58E+00;
XS[400]= 1.74E+00;
XS[450]= 9.05E-01;
XS[500]= 4.96E-01;
XS[550]= 2.84E-01;
XS[600]= 1.69E-01;
XS[650]= 1.03E-01;
XS[700]= 6.48E-02;
XS[750]= 4.16E-02;
XS[800]= 2.73E-02;
XS[850]= 1.82E-02;
XS[900]= 1.23E-02;
XS[950]= 8.45E-03;
XS[1000]= 5.86E-03;
XS[1050]= 4.11E-03;
XS[1100]= 2.91E-03;
XS[1150]= 2.08E-03;
XS[1200]= 1.50E-03;
XS[1250]= 1.09E-03;
XS[1300]= 7.95E-04;
XS[1350]= 5.85E-04;
XS[1400]= 4.33E-04;
XS[1450]= 3.21E-04;
XS[1500]= 2.40E-04;
const int nMass = 26;
int mData[nMass] = {
200,
250,
300,
350,
400,
450,
500,
550,
600,
650,
700,
750,
800,
850,
900,
950,
1000,
1050,
1100,
1150,
1200,
1250,
1300,
1350,
1400,
// 1450,
1500};
// Observed!!!!!!!
Double_t ObservedLimitValues[27] = {
5.169031,
2.127156,
1.119, // new
0.554736,
0.279327,
0.164877,
0.10318,
0.0695557,
0.0507156,
0.0386856,
0.031826,
0.0244583,
0.0194931,
0.0175816,
0.0156609,
0.0132805,
0.0108856,
0.00979614,
0.0088028,
0.00763702,
0.00695305,
0.00662155,
0.0061306,
0.0051651,
0.0056942,
0.00519066,
0.00458145};
// Expected !!!!!
Double_t ExpectedLimitValues[27] = {
5.212884,
2.624342,
1.0423, //new
0.39624,
0.206909,
0.113708,
0.0687866,
0.0496826,
0.0375671,
0.028656,
0.0247536,
0.0197548,
0.0155945,
0.0136745,
0.0126492,
0.0102158,
0.00997849,
0.0089798,
0.00806923,
0.00694275,
0.00632095,
0.00601959,
0.00557327,
0.0051651,
0.00517654,
0.00471878,
0.00458145};
//Plus One sigma
Double_t PlusOneSigmaLimitValues[27] = {
2.541088,
1.288593,
0.502809,
0.1918498,
0.103455,
0.051169,
0.0343934,
0.0248413,
0.0187836,
0.014328,
0.0106086,
0.0103477,
0.0077972,
0.0058606,
0.005421,
0.0061294,
0.00362851,
0.0040817,
0.00366787,
0.00485995,
0.00379255,
0.00361176,
0.00334397,
0.00361557,
0.00258828,
0.00377502,
0.00320702};
////////////////////////////////////////////////////////////////
// -1 sigma
////////////////////////////////////////////////////////////////
Double_t MinusOneSigmaLimitValues[27] = {
1.480962,
0.7831655,
0.2920889,
0.09906,
0.051727,
0.0341121,
0.0171966,
0.0149048,
0.0093917,
0.007164,
0.0082512,
0.0056442,
0.0046784,
0.0032558,
0.00421643,
0.00306477,
0.00362854,
0.00326538,
0.0022007,
0.00208283,
0.00126419,
0.00180588,
0.00167198,
0.00154953,
0.0010353,
0.00094376,
0.00091629};
//
Double_t limit_expected[26];
Double_t limit_plusOneSigma[26];
Double_t limit_MinusOneSigma[26];
Double_t limit_observed[26];
for (int i=0; i < 26; i++){
limit_expected[i]=ExpectedLimitValues[i]/XS[mData[i]];
limit_plusOneSigma[i]=(ExpectedLimitValues[i]+PlusOneSigmaLimitValues[i])/XS[mData[i]];
limit_MinusOneSigma[i]=(ExpectedLimitValues[i]-MinusOneSigmaLimitValues[i])/XS[mData[i]];
limit_observed[i]=ObservedLimitValues[i]/XS[mData[i]];
}
/* //Asympt CLs
Double_t limit_observed[] = {0.0594621, 0.0843084, 0.0609738, 0.0718055, 0.110206, 0.147462, 0.217648, 0.294432, 0.367942, 0.525929, 0.739963, 1.01469, 1.45093, 2.07904, 3.25821};
Double_t limit_expected[] = {0.074707, 0.103027, 0.0668945, 0.0737305, 0.0942383, 0.130371, 0.175293, 0.250977, 0.338867, 0.482422, 0.689453, 0.964844, 1.37109, 1.94531, 2.99219};
*/
std::vector<double> limExp;
std::vector<double> betaExp;
std::vector<double> limPlusSigma;
std::vector<double> betaPlusSigma;
std::vector<double> limMinusSigma;
std::vector<double> betaMinusSigma;
std::vector<double> limObs;
std::vector<double> betaObs;
///////////////////////////////////////////////////////////////////////////////////////////
// Expected limit
///////////////////////////////////////////////////////////////////////////////////////////
for(int i = 0; i != 1; ++i) {
double lim1 = limit_expected[i];
double lim2 = limit_expected[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
// cout << m1 <<" "<< m2 <<" "<< 1<<" "<< 1<<" "<< lim1/beta/beta<<" "<< lim2/beta/beta <<" "<< " ---> "<< result<<"\n";
if ( result != 0 ) {
limExp.push_back(result);
betaExp.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 1; i != 2; ++i) {
double lim1 = limit_expected[i];
double lim2 = limit_expected[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 1.001; beta >= 0; beta -= 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limExp.push_back(result);
betaExp.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 2; i != nMass; ++i) {
double lim1 = limit_expected[i];
double lim2 = limit_expected[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limExp.push_back(result);
betaExp.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Expected +1 sigma limit
///////////////////////////////////////////////////////////////////////////////////////////
for(int i = 0; i != 1; ++i) {
double lim1 = limit_plusOneSigma[i];
double lim2 = limit_plusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
// cout << m1 <<" "<< m2 <<" "<< 1<<" "<< 1<<" "<< lim1/beta/beta<<" "<< lim2/beta/beta <<" "<< " ---> "<< result<<"\n";
if ( result != 0 ) {
limPlusSigma.push_back(result);
betaPlusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 1; i != 2; ++i) {
double lim1 = limit_plusOneSigma[i];
double lim2 = limit_plusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 1.001; beta >= 0; beta -= 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limPlusSigma.push_back(result);
betaPlusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 2; i != nMass; ++i) {
double lim1 = limit_plusOneSigma[i];
double lim2 = limit_plusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limPlusSigma.push_back(result);
betaPlusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// Expected -1 sigma limit
///////////////////////////////////////////////////////////////////////////////////////////
for(int i = 0; i != 1; ++i) {
double lim1 = limit_MinusOneSigma[i];
double lim2 = limit_MinusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
// cout << m1 <<" "<< m2 <<" "<< 1<<" "<< 1<<" "<< lim1/beta/beta<<" "<< lim2/beta/beta <<" "<< " ---> "<< result<<"\n";
if ( result != 0 ) {
limMinusSigma.push_back(result);
betaMinusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 1; i != 2; ++i) {
double lim1 = limit_MinusOneSigma[i];
double lim2 = limit_MinusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 1.001; beta >= 0; beta -= 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limMinusSigma.push_back(result);
betaMinusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
for(int i = 2; i != nMass; ++i) {
double lim1 = limit_MinusOneSigma[i];
double lim2 = limit_MinusOneSigma[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limMinusSigma.push_back(result);
betaMinusSigma.push_back(beta);
// cout << beta << '\t' << result << endl; //KK
}
}
}
///////////////////////////////////////////////////////////////////////////////////////////
// observed limit
///////////////////////////////////////////////////////////////////////////////////////////
for(int i = 0; i != 1; ++i) {
double lim1 = limit_observed[i];
double lim2 = limit_observed[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limObs.push_back(result);
betaObs.push_back(beta);
}
}
}
for(int i = 1; i != 2; ++i) {
double lim1 = limit_observed[i];
double lim2 = limit_observed[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 1.001; beta >= 0; beta -= 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limObs.push_back(result);
betaObs.push_back(beta);
}
}
}
for(int i = 2; i != nMass; ++i) {
double lim1 = limit_observed[i];
double lim2 = limit_observed[i+1];
double m1 = mData[i];
double m2 = mData[i+1];
for(double beta = 0.001; beta < 1.001; beta += 0.001) {
double result = intersection(m1, m2, 1, 1, lim1/beta/beta, lim2/beta/beta);
if ( result != 0 ) {
limObs.push_back(result);
betaObs.push_back(beta);
}
}
}
//////////////////////////////////////////////////////////////////
// Expected
//////////////////////////////////////////////////////////////////
const int nexp = limExp.size();
// cout <<"--------------------> "<<nexp <<"\n\n\n\n";
Double_t massExp[nexp+4];
Double_t bExp[nexp+4];
for(int i = 0; i != nexp; ++i) {
massExp[i] = limExp[i];
bExp[i] = betaExp[i];
// cout <<"###### exp massExp[i] "<<massExp[i] << " bExp[i] "<<bExp[i]<<"\n";
}
massExp[nexp] = massExp[nexp-1];
bExp[nexp] = 1;
massExp[nexp+1] = 200;
bExp[nexp+1] = 1;
massExp[nexp+2] = 200;
bExp[nexp+2] = bExp[0];
massExp[nexp+3] = massExp[0];
bExp[nexp+3] = bExp[0];
//////////////////////////////////////////////////////////////////
// Plus One Sigma
//////////////////////////////////////////////////////////////////
const int nplusSig = limPlusSigma.size();
// cout <<"--------------------> "<<nplusSig <<"\n\n\n\n";
Double_t massPlusOneSigma[nplusSig+4];
Double_t bPlusOneSigma[nplusSig+4];
for(int i = 0; i != nplusSig; ++i) {
massPlusOneSigma[i] = limPlusSigma[i];
bPlusOneSigma[i] = betaPlusSigma[i];
// cout <<"###### exp massPlusOneSigma[i] "<<massPlusOneSigma[i] << " bPlusOneSigma[i] "<<bPlusOneSigma[i]<<"\n";
}
massPlusOneSigma[nplusSig] = massPlusOneSigma[nplusSig-1];
bPlusOneSigma[nplusSig] = 1;
massPlusOneSigma[nplusSig+1] = 200;
bPlusOneSigma[nplusSig+1] = 1;
massPlusOneSigma[nplusSig+2] = 200;
bPlusOneSigma[nplusSig+2] = bPlusOneSigma[0];
massPlusOneSigma[nplusSig+3] = massPlusOneSigma[0];
bPlusOneSigma[nplusSig+3] = bPlusOneSigma[0];
Double_t NewbPlusOneSigma[nexp+4];
for(int i = 0; i != nexp+4; ++i) {
NewbPlusOneSigma[i]=bPlusOneSigma[i]-bExp[i];
}
//////////////////////////////////////////////////////////////////
// Minus One Sigma
//////////////////////////////////////////////////////////////////
const int nMinusSig = limMinusSigma.size();
// cout <<"--------------------> "<<nMinusSig <<"\n\n\n\n";
Double_t massMinusOneSigma[nMinusSig+4];
Double_t bMinusOneSigma[nMinusSig+4];
for(int i = 0; i != nMinusSig; ++i) {
massMinusOneSigma[i] = limMinusSigma[i];
bMinusOneSigma[i] = betaMinusSigma[i];
// cout <<"###### exp massMinusOneSigma[i] "<<massMinusOneSigma[i] << " bMinusOneSigma[i] "<<bMinusOneSigma[i]<<"\n";
}
massMinusOneSigma[nMinusSig] = massMinusOneSigma[nMinusSig-1];
bMinusOneSigma[nMinusSig] = 1;
massMinusOneSigma[nMinusSig+1] = 200;
bMinusOneSigma[nMinusSig+1] = 1;
massMinusOneSigma[nMinusSig+2] = 200;
bMinusOneSigma[nMinusSig+2] = bMinusOneSigma[0];
massMinusOneSigma[nMinusSig+3] = massMinusOneSigma[0];
bMinusOneSigma[nMinusSig+3] = bMinusOneSigma[0];
Double_t NewbMinusOneSigma[nexp+4];
for(int i = 0; i != nexp+4; ++i) {
NewbMinusOneSigma[i]=bExp[i]-bMinusOneSigma[i];
// cout<<" mas comaprison "<<massExp[i]<<" "<<massMinusOneSigma[i]<<" "<<massPlusOneSigma[i]<<"\n";
}
//////////////////////////////////////////////////////////////////
// Observed
//////////////////////////////////////////////////////////////////
const int nobs = limObs.size();
float massObs[nobs+4];
float bObs[nobs+4];
for(int i = 0; i != nobs; ++i) {
massObs[i] = limObs[i];
bObs[i] = betaObs[i];
// cout <<"###### obs massObs[i] "<<massObs[i] << " bObs[i] "<<bObs[i]<<"\n";
}
massObs[nobs] = massObs[nobs-1];
bObs[nobs] = 1;
massObs[nobs+1] = 200;
bObs[nobs+1] = 1;
massObs[nobs+2] = 200;
bObs[nobs+2] = bObs[0];
massObs[nobs+3] = massObs[0];
bObs[nobs+3] = bObs[0];
//////////////////////////////////////////////////////////////////
// TGRAPH
//////////////////////////////////////////////////////////////////
// massExp.sort()
TGraph* grExp = new TGraph(nexp+4, massExp, bExp);
grExp->Sort(&TGraph::CompareX, 0, 0,-1111);
TGraph* gPlusOneSigma = new TGraph(nplusSig+4, massPlusOneSigma, bPlusOneSigma);
gPlusOneSigma->Sort(&TGraph::CompareX, 0, 0,-1111);
TGraph* gMinusOneSigma = new TGraph(nMinusSig+4, massMinusOneSigma, bMinusOneSigma);
gMinusOneSigma->Sort(&TGraph::CompareX, 0, 0,-1111);
TGraph* grObs = new TGraph(nobs+4, massObs, bObs);
// grObs->Sort();
// for(int i = 0; i < nexp+3; ++i) {
// cout << i << "\t" << massExp[i] << "\t" << bExp[i] << endl;
// }
// ------------>Primitives in pad: pad_plot
TPad *pad_plot = new TPad("pad_plot", "pad_plot",0,0,1,1);
pad_plot->Draw();
pad_plot->cd();
pad_plot->Range(10.71429,-5.02439,1500,3.512195);
pad_plot->SetFillColor(0);
pad_plot->SetFillStyle(4000);
pad_plot->SetBorderMode(0);
pad_plot->SetBorderSize(2);
// pad_plot->SetLogy();
// pad_plot->SetGridx();
// pad_plot->SetGridy();
pad_plot->SetLeftMargin(0.12);
pad_plot->SetRightMargin(0.04);
pad_plot->SetTopMargin(0.06);
pad_plot->SetBottomMargin(0.12);
pad_plot->SetFrameFillStyle(0);
pad_plot->SetFrameLineWidth(2);
pad_plot->SetFrameBorderMode(0);
pad_plot->SetFrameFillStyle(0);
pad_plot->SetFrameLineWidth(2);
pad_plot->SetFrameBorderMode(0);
pad_plot->SetTickx(1);
pad_plot->SetTicky(1);
TH2F* frame = new TH2F("frame", "", 100, 200, 1000, 100, 0.001, 1);
TAxis* ax = frame->GetXaxis();
TAxis* ay = frame->GetYaxis();
ax->SetTitle("M_{LQ} [GeV]");
// ax->SetLabelOffset(0.01);
ay->SetTitle("#beta");
//ay->SetTitle("#Beta(LQ#rightarrow#tau b)");
// ax->SetTitleFont(132);
ax->SetTitleSize(0.05);
// ay->SetTitleFont(132);
ay->SetTitleSize(0.05);
ay->SetRangeUser(0.,1);
frame->Draw();
// grExp->SetLineColor(TColor::GetColor(0, 0, 333));
// grExp->SetFillColorAlpha(TColor::GetColor(200, 222, 285), 0.65);
// grObs->SetLineColor(TColor::GetColor(0, 0, 333));
grObs->SetFillColorAlpha(TColor::GetColor(200, 222, 285), 0.65);
// grObs->SetLineColor(kBlack);
grObs->SetLineWidth(3);
grExp->SetLineColor(kBlack);
grExp->SetLineWidth(2);
grExp->SetLineStyle(7);
// grObs->SetFillStyle(3005);
// grExp->SetLineWidth(2);
// grObs->SetLineWidth(2);
// grObs->SetFillStyle(3005);
// grObs->Draw("F");
grExp->Draw("L");
// grExp->Draw("Lsame");
// gMinusOneSigma->SetLineColor(kBlue);
gMinusOneSigma->SetLineWidth(0);
// gMinusOneSigma->SetLineStyle(2);
ci = TColor::GetColor("#fcf10f");
gMinusOneSigma->SetFillColorAlpha(15, 0.65);
gMinusOneSigma->Draw("f");
// gPlusOneSigma->SetLineColor(kBlue);
gPlusOneSigma->SetLineWidth(0);
// gPlusOneSigma->SetLineStyle(2);
// ci = TColor::GetColor("#fcf10f");
gPlusOneSigma->SetFillColor(0);
gPlusOneSigma->Draw("fsame");
// gMinusOneSigma->Draw("Lsame");
grObs->Draw("LSame");
grObs->Draw("fsame");
// grExp->Draw("same");
// frame->Draw("same");
frame->Draw("sameaxis");
// grExp->Draw("Lsame");
// grObs->Draw("fsame");
//
// Double_t x[5] = {200,300,400,500,600};
// Double_t y[5] = {5,.1,.9,.7,.5};
// TPolyLine *pline = new TPolyLine(nexp+4,massExp,bExp);
// pline->SetFillColor(38);
// pline->SetLineColor(2);
// pline->SetLineWidth(4);
// pline->Draw("f");
// pline->Draw();
//
// TLatex* tx = new TLatex(250,0.93,"CMS");
// tx->SetTextFont(61);
// tx->SetTextSize(0.05);
// tx->Draw("SAME");
// TLatex* tx2 = new TLatex(1000,1.03101,"12.9 fb^{-1} (13 TeV)");
// tx2->SetTextSize(0.04);
// tx2->SetTextAlign( 12 );
// tx2->SetTextColor( 1 );
// tx2->SetTextFont ( 42 );
// tx2->Draw("SAME");
float lowX=0.65;
float lowY=0.85;
TPaveText * lumi = new TPaveText(lowX, lowY+0.06, lowX+0.30, lowY+0.16, "NDC");
lumi->SetBorderSize( 0 );
lumi->SetFillStyle( 0 );
lumi->SetTextAlign( 12 );
lumi->SetTextColor( 1 );
lumi->SetTextSize(0.04);
lumi->SetTextFont ( 42 );
lumi->AddText("12.9 fb^{-1} (13 TeV)");
lumi->Draw();
lowX=0.15;
lowY=0.75;
TPaveText * lumi1 = new TPaveText(lowX, lowY+0.06, lowX+0.15, lowY+0.16, "NDC");
lumi1->SetTextFont(61);
lumi1->SetTextSize(0.05);
lumi1->SetBorderSize( 0 );
lumi1->SetFillStyle( 0 );
lumi1->SetTextAlign( 12 );
lumi1->SetTextColor( 1 );
lumi1->AddText("CMS");
lumi1->Draw();
Double_t Graph0_felx3001[1000] = {0};
Double_t Graph0_fehx3001[1000] = {0};
// for (int i=0;i < 100; i++){
//
// cout << "check--->>>>>"<<massExp[i]<<" "<<bExp[i]<<" "<<Graph0_felx3001[i]<<" "<<Graph0_fehx3001[i]<<" "<<NewbMinusOneSigma[i]<<" "<<NewbPlusOneSigma[i]<<"\n";
// }
// const Int_t n = 5;
// Double_t x[n] = {200, 250, 300, 350, 400};
// Double_t y[n] = {.2,.3,.4,.5,.6};
// Double_t exl[n] = {0};
// Double_t exh[n] = {0};
// Double_t eyl[n] = {.1,.2,.3,.4,.5};
// Double_t eyh[n] = {.3,.4,.5,.6,.7};
// TGraphAsymmErrors *grae = new TGraphAsymmErrors(n,x,y,exl,exh,eyl,eyh);
TGraphAsymmErrors *grae = new TGraphAsymmErrors(700,massExp,bExp,Graph0_felx3001,Graph0_fehx3001,NewbMinusOneSigma,NewbPlusOneSigma);
grae->Sort(&TGraph::CompareX, 0, 0,-1111);
grae->SetName("");
grae->SetTitle("");
ci = TColor::GetColor("#fcf10f");
grae->SetFillColorAlpha(ci, 0.65);
// grae->SetMarkerStyle(20);
// TH1F *Graph_Graph3002 = new TH1F("Graph_Graph3002","",100,70,1630);
// Graph_Graph3002->SetMinimum(0);
// Graph_Graph3002->SetMaximum(7.043383);
// Graph_Graph3002->SetDirectory(0);
// Graph_Graph3002->SetStats(0);
// Graph_Graph3002->SetLineStyle(0);
// Graph_Graph3002->SetMarkerStyle(20);
// Graph_Graph3002->GetXaxis()->SetNdivisions(506);
// Graph_Graph3002->GetXaxis()->SetLabelFont(42);
// Graph_Graph3002->GetXaxis()->SetTitleSize(0.05);
// Graph_Graph3002->GetXaxis()->SetTickLength(0.02);
// Graph_Graph3002->GetXaxis()->SetTitleOffset(1.08);
// Graph_Graph3002->GetXaxis()->SetTitleFont(42);
// Graph_Graph3002->GetYaxis()->SetNdivisions(506);
// Graph_Graph3002->GetYaxis()->SetLabelFont(42);
// Graph_Graph3002->GetYaxis()->SetLabelOffset(0.007);
// Graph_Graph3002->GetYaxis()->SetTitleSize(0.05);
// Graph_Graph3002->GetYaxis()->SetTickLength(0.02);
// Graph_Graph3002->GetYaxis()->SetTitleOffset(1.08);
// Graph_Graph3002->GetYaxis()->SetTitleFont(42);
// Graph_Graph3002->GetZaxis()->SetNdivisions(506);
// Graph_Graph3002->GetZaxis()->SetLabelFont(42);
// Graph_Graph3002->GetZaxis()->SetLabelOffset(0.007);
// Graph_Graph3002->GetZaxis()->SetTitleSize(0.05);
// Graph_Graph3002->GetZaxis()->SetTickLength(0.02);
// Graph_Graph3002->GetZaxis()->SetTitleFont(42);
// grae->SetHistogram(Graph_Graph3002);
// grae->Draw("3LP");
// TLegend* leg = new TLegend(0.50, 0.14, 0.90, 0.35,"CMS 19.7 fb^{-1}, #sqrt{s} = 8 TeV", "brNDC");
// TLegend* leg = new TLegend(0.50, 0.14, 0.90, 0.35,"19.7 fb^{-1}, #sqrt{s} = 8 TeV", "brNDC");
TLegend* leg = new TLegend(0.45, 0.20, 0.8, 0.35,"", "brNDC");
leg->SetTextFont(42);
leg->SetTextSize(0.04);
leg->SetMargin(0.15);
leg->SetFillColor(0);
leg->SetBorderSize(0);
leg->AddEntry(grObs, "Observed exclusion","f");
leg->AddEntry(grExp, "Median expected limit","L");
leg->AddEntry(gMinusOneSigma, "68% expected limit","f");
leg->Draw();
//gPad->RedrawAxis();
// c->RedrawAxis();
// pad_plot->Modified();
pad_plot->Draw();
c->cd();
c->Modified();
// c->Print("limit_beta_vs_mass.eps");
c->Print("limit_2D_LQ.pdf");
// c->Print("limit_beta_vs_mass.png");
}
