void MakeSpinPlots::DrawIndFit(TString tag, TString mcName){
TCanvas *cv = new TCanvas(Form("%s_%s",mcName.Data(),tag.Data()));
if(ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) ) == 0) return;
RooRealVar* mass = ws->var("mass");
mass->setBins( (mass->getMax() - mass->getMin())/1.5 ); //enfore 1.5GeV bin width
RooPlot* frame = mass->frame();
tPair lbl(mcName,tag);
double Ns = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getVal();
double Nb = ws->var( Form("Data_%s_INDFIT_%s_Nbkg",mcName.Data(),tag.Data()) )->getVal();
double Nblind = ws->data("Data_Combined")->reduce("(mass>100 && mass<119) || (mass>135.5 && mass<170)")->sumEntries(TString("evtcat==evtcat::")+tag);
double Ntot = ws->data("Data_Combined")->sumEntries(TString("evtcat==evtcat::")+tag);
RooFitResult* fitres = (RooFitResult*)ws->obj(Form("Data_%s_INDFIT_fitResult",mcName.Data()));
std::cout << fitres << std::endl;
ws->data("Data_Combined")->reduce(TString("evtcat==evtcat::")+tag)->plotOn(frame,RooFit::LineColor(kWhite),RooFit::MarkerColor(kWhite));
//Data_Hgg125_INDFIT_EB_0
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::FillColor(kGreen),RooFit::VisualizeError(*fitres,2.0));
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::FillColor(kYellow),RooFit::VisualizeError(*fitres,1.0));
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::LineColor(kRed));
std::cout << "1" << std::endl;
ws->pdf(Form("Data_BKGFIT_%s_bkgModel",tag.Data()))->plotOn(frame, RooFit::Normalization(Nb/(Nb+Ns)),RooFit::LineColor(kRed),RooFit::LineStyle(kDashed));
std::cout << "2" << std::endl;
ws->data("Data_Combined")->reduce(TString("evtcat==evtcat::")+tag)->plotOn(frame);
frame->Draw();
//TLatex *prelim = new TLatex(250,x->GetXmax()-40.,"CMS Preliminary");
TLatex *prelim = new TLatex(0.12,0.96,"CMS Preliminary");
TLatex *lum = new TLatex(0.7,0.96,Form("#sqrt{s}=8 TeV L = %0.1f fb^{-1}",lumi));
prelim->SetNDC();
lum->SetNDC();
prelim->SetTextSize(0.045);
prelim->SetTextColor(kBlack);
lum->SetTextSize(0.045);
lum->SetTextColor(kBlack);
TLatex *owner = new TLatex(0.6,0.88,"Alex Mott (Nov. 13, 2012)");
owner->SetNDC();
owner->SetTextSize(0.045);
owner->SetTextColor(kBlack);
TLatex *mu = new TLatex(0.7,0.8,Form("#mu = %0.1f #pm %0.2f", fitMean[lbl].first,fitMean[lbl].second));
mu->SetNDC();
mu->SetTextSize(0.045);
TLatex *sig = new TLatex(0.7,0.72,Form("#sigma_{eff} = %0.1f #pm %0.2f", fitSigEff[lbl].first,fitSigEff[lbl].second));
sig->SetNDC();
sig->SetTextSize(0.045);
float nSig = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getVal();
float nSigErr = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getError();
TLatex *Nsig = new TLatex(0.7,0.64,Form("N_{sig}= %0.1f #pm %0.1f",nSig,nSigErr));
Nsig->SetNDC();
Nsig->SetTextSize(0.045);
frame->addObject(prelim);
frame->addObject(lum);
//frame->addObject(owner);
frame->addObject(mu);
frame->addObject(sig);
frame->addObject(Nsig);
frame->Draw();
cv->SaveAs( basePath+Form("/mgg-FloatedFraction-%s-%s-%s.png",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/C/mgg-FloatedFraction-%s-%s-%s.C",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/mgg-FloatedFraction-%s-%s-%s.pdf",outputTag.Data(),mcName.Data(),tag.Data()) );
delete cv;
}
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 PlotShapeSystematics2() {
TFile *file = 0;
TH1F *DefaultShape = 0;
TH1F *UpShape = 0;
TH1F *DownShape = 0;
TCanvas *cv = 0;
TLegend *legend = 0;
//*********************************************************
//0 Jet Bin - OF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwof_0j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.25);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_OF0Jet.png");
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_OF0Jet.eps");
//*********************************************************
//0 Jet Bin - SF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwsf_0j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.25);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_SF0Jet.png");
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_SF0Jet.eps");
//*********************************************************
//1 Jet Bin - OF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwof_1j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.4);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_OF1Jet.png");
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_OF1Jet.eps");
//*********************************************************
//1 Jet Bin - SF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwsf_1j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWNLOBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.4);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_SF1Jet.png");
cv->SaveAs("WWBkgShapeVariation_MCAtNLOScaleVariation_SF1Jet.eps");
//*********************************************************
//0 Jet Bin - OF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwof_0j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.25);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_OF0Jet.png");
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_OF0Jet.eps");
//*********************************************************
//0 Jet Bin - SF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwsf_0j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.25);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_SF0Jet.png");
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_SF0Jet.eps");
//*********************************************************
//1 Jet Bin - OF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwof_1j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.4);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_OF1Jet.png");
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_OF1Jet.eps");
//*********************************************************
//1 Jet Bin - SF
//*********************************************************
file = new TFile("/data/smurf/sixie/data/Thesis/cards/120/hwwsf_1j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_qqWW");
UpShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwUp");
DownShape = (TH1F*)file->Get("histo_qqWW_CMS_MVAWWBounding_hwwDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
NormalizeHist(DefaultShape);
NormalizeHist(UpShape);
NormalizeHist(DownShape);
cv = new TCanvas("cv","cv",800,600);
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Bounding Shape (Up)", "L");
legend->AddEntry(DownShape, "Bounding Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Fraction of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.4);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,0.4);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_SF1Jet.png");
cv->SaveAs("WWBkgShapeVariation_MadgraphVsMCAtNLO_SF1Jet.eps");
}
void plot_pll(TString fname="monoh_withsm_SRCR_bg11.7_bgslop-0.0_nsig0.0.root")
{
SetAtlasStyle();
TFile* file = TFile::Open(fname);
RooWorkspace* wspace = (RooWorkspace*) file->Get("wspace");
cout << "\n\ncheck that eff and reco terms included in BSM component to make fiducial cross-section" <<endl;
wspace->function("nsig")->Print();
RooRealVar* reco = wspace->var("reco");
if( wspace->function("nsig")->dependsOn(*reco) ) {
cout << "all good." <<endl;
} else {
cout << "need to rerun fit_withsm using DO_FIDUCIAL_LIMIT true" <<endl;
return;
}
/*
// DANGER
// TEST WITH EXAGGERATED UNCERTAINTY
wspace->var("unc_theory")->setMax(1);
wspace->var("unc_theory")->setVal(1);
wspace->var("unc_theory")->Print();
*/
// this was for making plot about decoupling/recoupling approach
TCanvas* tc = new TCanvas("tc","",400,400);
RooPlot *frame = wspace->var("xsec_bsm")->frame();
RooAbsPdf* pdfc = wspace->pdf("jointModeld");
RooAbsData* data = wspace->data("data");
RooAbsReal *nllJoint = pdfc->createNLL(*data, RooFit::Constrained()); // slice with fixed xsec_bsm
RooAbsReal *profileJoint = nllJoint->createProfile(*wspace->var("xsec_bsm"));
wspace->allVars().Print("v");
pdfc->fitTo(*data);
wspace->allVars().Print("v");
wspace->var("xsec_bsm")->Print();
double nllmin = 2*nllJoint->getVal();
wspace->var("xsec_bsm")->setVal(0);
double nll0 = 2*nllJoint->getVal();
cout << Form("nllmin = %f, nll0 = %f, Z=%f", nllmin, nll0, sqrt(nll0-nllmin)) << endl;
nllJoint->plotOn(frame, RooFit::LineColor(kGreen), RooFit::LineStyle(kDotted), RooFit::ShiftToZero(), RooFit::Name("nll_statonly")); // no error
profileJoint->plotOn(frame,RooFit::Name("pll") );
wspace->var("xsec_sm")->Print();
wspace->var("theory")->Print();
wspace->var("theory")->setConstant();
profileJoint->plotOn(frame, RooFit::LineColor(kRed), RooFit::LineStyle(kDashed), RooFit::Name("pll_smfixed") );
frame->GetXaxis()->SetTitle("#sigma_{BSM, fid} [fb]");
frame->GetYaxis()->SetTitle("-log #lambda ( #sigma_{BSM, fid} )");
double temp = frame->GetYaxis()->GetTitleOffset();
frame->GetYaxis()->SetTitleOffset( 1.1* temp );
frame->SetMinimum(1e-7);
frame->SetMaximum(4);
// Legend
double x1,y1,x2,y2;
GetX1Y1X2Y2(tc,x1,y1,x2,y2);
TLegend *legend_sr=FastLegend(x2-0.75,y2-0.3,x2-0.25,y2-0.5,0.045);
legend_sr->AddEntry(frame->findObject("pll"),"with #sigma_{SM} uncertainty","L");
legend_sr->AddEntry(frame->findObject("pll_smfixed"),"with #sigma_{SM} constant","L");
legend_sr->AddEntry(frame->findObject("nll_statonly"),"no systematics","L");
frame->Draw();
legend_sr->Draw("SAME");
// descriptive text
vector<TString> pavetext11;
pavetext11.push_back("#bf{#it{ATLAS Internal}}");
pavetext11.push_back("#sqrt{#it{s}} = 8 TeV #scale[0.6]{#int}Ldt = 20.3 fb^{-1}");
pavetext11.push_back("#it{H}+#it{E}_{T}^{miss} , #it{H #rightarrow #gamma#gamma}, #it{m}_{#it{H}} = 125.4 GeV");
TPaveText* text11=CreatePaveText(x2-0.75,y2-0.25,x2-0.25,y2-0.05,pavetext11,0.045);
text11->Draw();
tc->SaveAs("pll.pdf");
/*
wspace->var("xsec_bsm")->setConstant(true);
wspace->var("eff" )->setConstant(true);
wspace->var("mh" )->setConstant(true);
wspace->var("sigma_h" )->setConstant(true);
wspace->var("lumi" )->setConstant(true);
wspace->var("xsec_sm" )->setVal(v_xsec_sm);
wspace->var("eff" )->setVal(1.0);
wspace->var("lumi" )->setVal(v_lumi);
TH1* nllHist = profileJoint->createHistogram("xsec_bsm",100);
TFile* out = new TFile("nllHist.root","REPLACE");
nllHist->Write()
out->Write();
out->Close();
*/
}
void PlotEfficiencyMap(const string Label = "")
{
gBenchmark->Start("HZZTemplate");
string label = Label;
if (Label != "") label = "_" + Label;
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
//********************************************************
// Create Arrays to store the map
//********************************************************
const UInt_t NPtBins = 15;
const UInt_t NEtaBins = 16;
const UInt_t NPhiBins = 12;
double ptBins[NPtBins+1] = { 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 25, 30, 35, 40, 50};
double etaBins[NEtaBins+1] = { 0.0, 0.2, 0.4, 0.6, 0.8, 1.0, 1.2, 1.4442, 1.566, 1.8, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6};
double phiBins[NPhiBins+1] = { -3.2, -2.5, -2, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, 2, 2.5, 3.2 };
TH2F *ElectronEfficiencyMap = new TH2F("ElectronEfficiencyMap", ";p_{T} [GeV/c];#eta;Efficiency", 50, 0, 100, 50, 0, 2.5);
TH2F *MuonEfficiencyMap = new TH2F("MuonEfficiencyMap", ";p_{T} [GeV/c];|#eta|;Efficiency", 50, 0, 100, 50, 0, 2.5);
for (int i=0; i<ElectronEfficiencyMap->GetXaxis()->GetNbins()+1; ++i) {
for (int j=0; j<ElectronEfficiencyMap->GetYaxis()->GetNbins()+1; ++j) {
double x = ElectronEfficiencyMap->GetXaxis()->GetBinCenter(i);
double y = ElectronEfficiencyMap->GetYaxis()->GetBinCenter(j);
double weightModifier = 1.0;
if (x < 8) weightModifier = 1.25;
if (x>= 8 && x < 10) weightModifier = 1.03;
if (x >= 10 && x < 16) weightModifier = 1.02;
if (x >= 16 && x < 20) weightModifier = 1.01;
if (x >= 20 && x < 40) weightModifier = 0.975;
if (x >= 40 ) weightModifier = 0.97;
ElectronEfficiencyMap->SetBinContent(i,j, weightModifier*GetElectronEfficiencyPtEta(x,y));
//cout << x << " " << y << " : " << weightModifier*GetElectronEfficiencyPtEta(x,y) << "\n";
}
}
for (int i=0; i<MuonEfficiencyMap->GetXaxis()->GetNbins()+1; ++i) {
for (int j=0; j<MuonEfficiencyMap->GetYaxis()->GetNbins()+1; ++j) {
double x = MuonEfficiencyMap->GetXaxis()->GetBinCenter(i);
double y = MuonEfficiencyMap->GetYaxis()->GetBinCenter(j);
double weightModifier = 1.0;
if (x < 6) weightModifier *= 1.15;
if (x >= 6 && x < 7) weightModifier *= 1.05;
if (x >= 7 && x < 10) weightModifier *= 1.015;
if (x >= 10 && x < 20) weightModifier *= 1.015;
if (x >= 20 && x < 40) weightModifier *= 1.00;
if (x >= 40 ) weightModifier *= 0.985;
MuonEfficiencyMap->SetBinContent(i,j, weightModifier*GetMuonEfficiencyPtEta(x,y));
//cout << x << " " << y << " : " << weightModifier*GetMuonEfficiencyPtEta(x,y) << "\n";
}
}
TCanvas *cv = new TCanvas("cv","cv", 800, 600);
cv->SetRightMargin(0.15);
ElectronEfficiencyMap->SetMinimum(0.5);
ElectronEfficiencyMap->Draw("colz");
cv->SaveAs("ElectronEfficiencyMap.gif");
cv = new TCanvas("cv","cv", 800, 600);
cv->SetRightMargin(0.15);
MuonEfficiencyMap->SetMinimum(0.5);
MuonEfficiencyMap->Draw("colz");
cv->SaveAs("MuonEfficiencyMap.gif");
}
void v2ExpClose_pt(bool bSavePlots = true,
float rangeYAxis = 0.6,
float rangeXAxis = 30,
bool bDrawCh = true,
const char* inputDir = "../macro_v2/outRoot", // the place where the input root files, with the histograms are
const char* figNamePrefix="v2ExpClose_pt")
{
gSystem->mkdir(Form("./figs/png"), kTRUE);
gSystem->mkdir(Form("./figs/pdf"), kTRUE);
setTDRStyle();
// read CMS graphs
TFile *pfV2Cms_cent = new TFile(Form("%s/Prp_v2_pt_plotter.root",inputDir));
TGraphAsymmErrors *pgV2Low = (TGraphAsymmErrors *)pfV2Cms_cent->Get("pgV2_low");
TGraphErrors *pgV2LowSyst = (TGraphErrors *)pfV2Cms_cent->Get("pgV2_low_sys");
TGraphErrors *pgV2LowP = (TGraphErrors *)pfV2Cms_cent->Get("pgV2_low_cont");
TGraphAsymmErrors *pgV2High = (TGraphAsymmErrors *)pfV2Cms_cent->Get("pgV2");
TGraphErrors *pgV2HighSyst = (TGraphErrors *)pfV2Cms_cent->Get("pgV2_sys");
TGraphErrors *pgV2HighP = (TGraphErrors *)pfV2Cms_cent->Get("pgV2_cont");
pgV2Low->SetName("pgV2Low");
pgV2LowSyst->SetFillColorAlpha(kViolet-9,0.5);
pgV2High->SetName("pgV2High");
pgV2HighSyst->SetFillColorAlpha(kRed-9,0.5);
// -----------------------------------------------------------------------------------------
// ----- charged hadrons
TGraphErrors *gChar = new TGraphErrors(19, pTChar, v2Char, chxerr, v2CharSt);
TGraphErrors *gChar2 = new TGraphErrors(19, pTChar, v2Char, chxerr, v2CharSt2);
TGraphErrors *gCharSys = new TGraphErrors(19, pTChar, v2Char, chxerr2, v2CharSys);
gChar->SetName("gChar");
gChar->SetMarkerStyle(20);
gChar->SetMarkerColor(kTeal+3);
gChar->SetLineColor(kTeal+3);
gChar->SetMarkerSize(1.3);
gChar2->SetMarkerStyle(24);
gChar2->SetMarkerColor(kTeal+4);
gChar2->SetLineColor(kTeal+4);
gChar2->SetMarkerSize(1.3);
gCharSys->SetFillColor(kTeal-9);
//----------- D from ALICE
TGraphErrors *pgAlice = new TGraphErrors(6, v2AliceX_pt, v2Alice_pt, v2AliceXl, v2AliceStat_pt);
TGraphErrors *pgAliceSys = new TGraphErrors(6, v2AliceX_pt, v2Alice_pt, v2AliceXl, v2AliceSyst_pt);
TGraphAsymmErrors *pgAliceSysB = new TGraphAsymmErrors(6, v2AliceX_pt, v2Alice_pt, v2AliceXl2, v2AliceXl2, v2AliceSystBLow_pt, v2AliceSystBHigh_pt);
pgAlice->SetName("pgAlice");
pgAlice->SetMarkerStyle(kOpenSquare);
pgAlice->SetMarkerColor(kGray+2);
pgAlice->SetLineColor(kGray+2);
pgAlice->SetMarkerSize(1.0);
pgAliceSys->SetFillStyle(0);
pgAliceSys->SetMarkerColor(kGray+2);
pgAliceSys->SetLineColor(kGray+2);
pgAliceSys->SetMarkerSize(1.7);
pgAliceSysB->SetFillColor(kGray);
// drawing
//------------------------------------------------------------------------
// put everything on one plot
TH1D *phAxis_v2 = new TH1D("phAxis_v2",";p_{T} (GeV/c);v_{2}",1,0,rangeXAxis);
phAxis_v2->SetDirectory(0);
phAxis_v2->GetXaxis()->CenterTitle(true);
phAxis_v2->GetXaxis()->LabelsOption("h");
phAxis_v2->GetYaxis()->SetRangeUser(0,rangeYAxis);
phAxis_v2->GetYaxis()->SetTitleOffset(1.25);
TCanvas *pcCombi = new TCanvas("pcCombi","pcCombi");
phAxis_v2->Draw();
CMS_lumi(pcCombi,12001000,0);
pgAliceSysB->Draw("2");
pgAliceSys->Draw("2");
pgAlice->Draw("pz");
if (bDrawCh) {
gCharSys->Draw("2");
gChar->Draw("pz");
gChar2->Draw("p");
}
pgV2LowSyst->Draw("2");
pgV2Low->Draw("PZ");
pgV2LowP->Draw("P");
pgV2HighSyst->Draw("2");
pgV2High->Draw("PZ");
pgV2HighP->Draw("P");
// --------- legends ----
TLegend *leg = new TLegend(0.2,0.77,0.7,0.89,NULL,"brNDC"); // at top center
leg->SetBorderSize(0);
leg->SetTextFont(132);
leg->SetTextSize(0.03);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(19);
leg->SetFillStyle(0);
TLegendEntry *entry, *entry11;
entry=leg->AddEntry("cmspr","Hidden charm: prompt J/#psi","");
entry->SetTextFont(132);
entry->SetTextSize(ltxSetTextSize3);
entry=leg->AddEntry("pgV2Low", "1.6 < |y| < 2.4","p");
entry->SetTextFont(42);
entry->SetTextSize(entrySize);
entry=leg->AddEntry("pgV2High", "|y| < 2.4","P");
entry->SetTextFont(42);
entry->SetTextSize(entrySize);
TLegend *leg1 = new TLegend(0.2,0.685,0.7,0.765,NULL,"brNDC");
leg1->SetBorderSize(0);
leg1->SetTextFont(132);
leg1->SetTextSize(ltxSetTextSize3);
if (bDrawCh) {
TLegendEntry *entry1;
entry1=leg1->AddEntry("hpm","Charged hadron","");
entry1->SetTextFont(132);
entry1->SetTextSize(ltxSetTextSize3);
entry1=leg1->AddEntry("gChar","|#eta| < 0.8","P");
entry1->SetTextFont(42);
entry1->SetTextSize(entrySize);
}
//---------------------------
TLegend *leg_alice;
if (bDrawCh) {
leg_alice = new TLegend(0.2,0.60,0.7,0.68,NULL,"brNDC");
} else {
leg_alice = new TLegend(0.2,0.685,0.7,0.765,NULL,"brNDC");
}
leg_alice->SetBorderSize(0);
leg_alice->SetTextFont(132);
leg_alice->SetLineColor(1);
leg_alice->SetLineStyle(1);
leg_alice->SetLineWidth(1);
leg_alice->SetFillColor(19);
leg_alice->SetFillStyle(0);
TLegendEntry *entry_alice=leg_alice->AddEntry("pgAlice","Open charm: prompt D (ALICE)","");
entry_alice->SetTextFont(132);
entry_alice->SetTextSize(ltxSetTextSize3);
entry_alice=leg_alice->AddEntry("pgAlice","|y| < 0.8, Cent. 30-50\%","P");
entry_alice->SetTextFont(42);
entry_alice->SetTextSize(entrySize);
TLatex *lat = new TLatex();
lat->SetNDC();
lat->SetTextFont(42);
lat->SetTextSize(ltxSetTextSize2);
if (bDrawCh) lat->DrawLatex(0.63,0.52,"Cent. 10-60%");
else lat->DrawLatex(0.63,0.58,"Cent. 10-60%");
leg->Draw();
if (bDrawCh) leg1->Draw();
leg_alice->Draw();
gPad->RedrawAxis();
if(bSavePlots)
{
pcCombi->SaveAs(Form("figs/pdf/%s_RaaCh%d.pdf",figNamePrefix,bDrawCh));
pcCombi->SaveAs(Form("figs/png/%s_RaaCh%d.png",figNamePrefix,bDrawCh));
}
return;
}
int main(int ac, char *av[]) {
gROOT->SetStyle("Plain");
try {
typedef funct::FunctExpression Expr;
typedef fit::HistoChiSquare<funct::FunctExpression> ExprChi2;
typedef fit::MultiHistoChiSquare<ExprChi2, ExprChi2, ExprChi2, ExprChi2, ExprChi2> ChiSquared;
double fMin, fMax;
string ext;
po::options_description desc("Allowed options");
desc.add_options()
("help,h", "produce help message")
("input-file,i", po::value< vector<string> >(), "input file")
("min,m", po::value<double>(&fMin)->default_value(60), "minimum value for fit range")
("max,M", po::value<double>(&fMax)->default_value(120), "maximum value for fit range")
("plot-format,p", po::value<string>(&ext)->default_value("eps"),
"output plot format");
po::positional_options_description p;
p.add("input-file", -1);
po::variables_map vm;
po::store(po::command_line_parser(ac, av).
options(desc).positional(p).run(), vm);
po::notify(vm);
if (vm.count("help")) {
cout << "Usage: options_description [options]\n";
cout << desc;
return 0;
}
fit::RootMinuitCommands<ChiSquared> commands("zFitToyMc.txt");
cout << "minuit command file completed" << endl;
const unsigned int rebinMuMuNoIso = 2,rebinMuMu = 1, rebinMuMu1HLT = 1, rebinMuMu2HLT = 1, rebinMuTk = 2, rebinMuSa = 10;
// assume that the bin size is 1 GeV!!!
funct::Constant rebinMuMuNoIsoConst(rebinMuMuNoIso), rebinMuMuConst(rebinMuMu),
rebinMuMu1HLTConst(rebinMuMu1HLT), rebinMuMu2HLTConst(rebinMuMu2HLT),
rebinMuTkConst(rebinMuTk), rebinMuSaConst(rebinMuSa);
if (vm.count("input-file")) {
cout << "Input files are: "
<< vm["input-file"].as< vector<string> >() << "\n";
vector<string> v_file = vm["input-file"].as< vector<string> >();
for(vector<string>::const_iterator it = v_file.begin();
it != v_file.end(); ++it) {
TFile * root_file = new TFile(it->c_str(), "read");
TH1 * histoZMuMuNoIso = getHisto(root_file, "nonIsolatedZToMuMuPlots/zMass_noIso",rebinMuMuNoIso);
TH1 * histoZMuMu = getHisto(root_file, "goodZToMuMuPlots/zMass_golden",rebinMuMu);
TH1 * histoZMuMu1HLT = getHisto(root_file, "goodZToMuMu1HLTPlots/zMass_1hlt", rebinMuMu1HLT);
TH1 * histoZMuMu2HLT = getHisto(root_file, "goodZToMuMu2HLTPlots/zMass_2hlt", rebinMuMu2HLT);
TH1 * histoZMuTk = getHisto(root_file, "goodZToMuMuOneTrackPlots/zMass_tk", rebinMuTk);
TH1 * histoZMuSa = getHisto(root_file, "goodZToMuMuOneStandAloneMuonPlots/zMass_sa", rebinMuSa);
TH1 * histoZMuSaFromMuMu = getHisto(root_file, "zmumuSaMassHistogram/zMass_safromGolden", rebinMuSa);
cout << ">>> histogram loaded\n";
string f_string = *it;
replace(f_string.begin(), f_string.end(), '.', '_');
replace(f_string.begin(), f_string.end(), '/', '_');
string plot_string = f_string + "." + ext;
cout << ">>> Input files loaded\n";
const char * kYieldZMuMu = "YieldZMuMu";
const char * kEfficiencyTk = "EfficiencyTk";
const char * kEfficiencySa = "EfficiencySa";
const char * kEfficiencyIso = "EfficiencyIso";
const char * kEfficiencyHLT = "EfficiencyHLT";
const char * kYieldBkgZMuTk = "YieldBkgZMuTk";
const char * kYieldBkgZMuSa = "YieldBkgZMuSa";
const char * kYieldBkgZMuMuNotIso = "YieldBkgZMuMuNotIso";
const char * kAlpha = "Alpha";
const char * kBeta = "Beta";
const char * kLambda = "Lambda";
const char * kA0 = "A0";
const char * kA1 = "A1";
const char * kA2 = "A2";
const char * kB0 = "B0";
const char * kB1 = "B1";
const char * kB2 = "B2";
funct::Parameter yieldZMuMu(kYieldZMuMu, commands.par(kYieldZMuMu));
funct::Parameter effTk(kEfficiencyTk, commands.par(kEfficiencyTk));
funct::Parameter effSa(kEfficiencySa, commands.par(kEfficiencySa));
funct::Parameter effIso(kEfficiencyIso, commands.par(kEfficiencyIso));
funct::Parameter effHLT(kEfficiencyHLT, commands.par(kEfficiencyHLT));
funct::Parameter yieldBkgZMuTk(kYieldBkgZMuTk, commands.par(kYieldBkgZMuTk));
funct::Parameter yieldBkgZMuSa(kYieldBkgZMuSa, commands.par(kYieldBkgZMuSa));
funct::Parameter yieldBkgZMuMuNotIso(kYieldBkgZMuMuNotIso, commands.par(kYieldBkgZMuMuNotIso));
funct::Parameter alpha(kAlpha, commands.par(kAlpha));
funct::Parameter beta(kBeta, commands.par(kBeta));
funct::Parameter lambda(kLambda, commands.par(kLambda));
funct::Parameter a0(kA0, commands.par(kA0));
funct::Parameter a1(kA1, commands.par(kA1));
funct::Parameter a2(kA2, commands.par(kA2));
funct::Parameter b0(kB0, commands.par(kB0));
funct::Parameter b1(kB1, commands.par(kB1));
funct::Parameter b2(kB2, commands.par(kB2));
funct::Constant cFMin(fMin), cFMax(fMax);
// count ZMuMu Yield
double nZMuMu = 0, nZMuMu1HLT = 0, nZMuMu2HLT = 0;
{
unsigned int nBins = histoZMuMu->GetNbinsX();
double xMin = histoZMuMu->GetXaxis()->GetXmin();
double xMax = histoZMuMu->GetXaxis()->GetXmax();
double deltaX =(xMax - xMin) / nBins;
for(unsigned int i = 0; i < nBins; ++i) {
double x = xMin + (i +.5) * deltaX;
if(x > fMin && x < fMax){
nZMuMu += histoZMuMu->GetBinContent(i+1);
nZMuMu1HLT += histoZMuMu1HLT->GetBinContent(i+1);
nZMuMu2HLT += histoZMuMu2HLT->GetBinContent(i+1);
}
}
}
// aggiungi 1HLT 2HLT
cout << ">>> count of ZMuMu yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu << endl;
cout << ">>> count of ZMuMu (1HLT) yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu1HLT << endl;
cout << ">>> count of ZMuMu (2HLT) yield in the range [" << fMin << ", " << fMax << "]: " << nZMuMu2HLT << endl;
funct::RootHistoPdf zPdfMuMuNonIso(*histoZMuMu, fMin, fMax);//imposto le pdf a quella di ZMuMu
funct::RootHistoPdf zPdfMuTk = zPdfMuMuNonIso;
funct::RootHistoPdf zPdfMuMu1HLT = zPdfMuMuNonIso;
funct::RootHistoPdf zPdfMuMu2HLT = zPdfMuMuNonIso;
funct::RootHistoPdf zPdfMuSa(*histoZMuSaFromMuMu, fMin, fMax);
zPdfMuMuNonIso.rebin(rebinMuMuNoIso/rebinMuMu);
zPdfMuTk.rebin(rebinMuTk/rebinMuMu);
zPdfMuMu1HLT.rebin(rebinMuMu1HLT/rebinMuMu);
zPdfMuMu2HLT.rebin(rebinMuMu2HLT/rebinMuMu);
funct::Numerical<2> _2;
funct::Numerical<1> _1;
//Efficiency term
Expr zMuMuEff1HLTTerm = _2 * (effTk ^ _2) * (effSa ^ _2) * (effIso ^ _2) * effHLT * (_1 - effHLT);
Expr zMuMuEff2HLTTerm = (effTk ^ _2) * (effSa ^ _2) * (effIso ^ _2) * (effHLT ^ _2) ;
Expr zMuMuNoIsoEffTerm = (effTk ^ _2) * (effSa ^ _2) * (_1 - (effIso ^ _2)) * (_1 - ((_1 - effHLT)^_2));
Expr zMuTkEffTerm = _2 * (effTk ^ _2) * effSa * (_1 - effSa) * (effIso ^ _2) * effHLT;
Expr zMuSaEffTerm = _2 * (effSa ^ _2) * effTk * (_1 - effTk) * (effIso ^ _2) * effHLT;
Expr zMuMu1HLT = rebinMuMu1HLTConst * zMuMuEff1HLTTerm * yieldZMuMu;
Expr zMuMu2HLT = rebinMuMu2HLTConst * zMuMuEff2HLTTerm * yieldZMuMu;
Expr zMuTkBkg = yieldBkgZMuTk * funct::Exponential(lambda)* funct::Polynomial<2>(a0, a1, a2);
Expr zMuTkBkgScaled = rebinMuTkConst * zMuTkBkg;
Expr zMuTk = rebinMuTkConst * (zMuTkEffTerm * yieldZMuMu * zPdfMuTk + zMuTkBkg);
Expr zMuMuNoIsoBkg = yieldBkgZMuMuNotIso * funct::Exponential(alpha)* funct::Polynomial<2>(b0, b1, b2);
Expr zMuMuNoIsoBkgScaled = rebinMuMuNoIsoConst * zMuMuNoIsoBkg;
Expr zMuMuNoIso = rebinMuMuNoIsoConst * (zMuMuNoIsoEffTerm * yieldZMuMu * zPdfMuMuNonIso + zMuMuNoIsoBkg);
Expr zMuSa = rebinMuSaConst * (zMuSaEffTerm * yieldZMuMu * zPdfMuSa); // + (yieldBkgZMuSa * funct::Exponential(beta) ));
TH1D histoZCount1HLT("histoZCount1HLT", "", 1, fMin, fMax);
histoZCount1HLT.Fill(100, nZMuMu1HLT);
TH1D histoZCount2HLT("histoZCount2HLT", "", 1, fMin, fMax);
histoZCount2HLT.Fill(100, nZMuMu2HLT);
ChiSquared chi2(zMuMu1HLT, & histoZCount1HLT,
zMuMu2HLT, & histoZCount2HLT,
zMuTk, histoZMuTk,
zMuSa, histoZMuSa,
zMuMuNoIso,histoZMuMuNoIso,
fMin, fMax);
fit::RootMinuit<ChiSquared> minuit(chi2, true);
commands.add(minuit, yieldZMuMu);
commands.add(minuit, effTk);
commands.add(minuit, effSa);
commands.add(minuit, effIso);
commands.add(minuit, effHLT);
commands.add(minuit, yieldBkgZMuTk);
commands.add(minuit, yieldBkgZMuSa);
commands.add(minuit, yieldBkgZMuMuNotIso);
commands.add(minuit, lambda);
commands.add(minuit, alpha);
commands.add(minuit, beta);
commands.add(minuit, a0);
commands.add(minuit, a1);
commands.add(minuit, a2);
commands.add(minuit, b0);
commands.add(minuit, b1);
commands.add(minuit, b2);
commands.run(minuit);
const unsigned int nPar = 17;//WARNIG: this must be updated manually for now
ROOT::Math::SMatrix<double, nPar, nPar, ROOT::Math::MatRepSym<double, nPar> > err;
minuit.getErrorMatrix(err);
std::cout << "error matrix:" << std::endl;
for(unsigned int i = 0; i < nPar; ++i) {
for(unsigned int j = 0; j < nPar; ++j) {
std::cout << err(i, j) << "\t";
}
std::cout << std::endl;
}
minuit.printFitResults();
ofstream myfile;
myfile.open ("fitResult.txt", ios::out | ios::app);
myfile<<"\n";
double Y = minuit.getParameterError("YieldZMuMu");
double dY = minuit.getParameterError("YieldZMuMu", Y);
double tk_eff = minuit.getParameterError("EfficiencyTk");
double dtk_eff = minuit.getParameterError("EfficiencyTk", tk_eff);
double sa_eff = minuit.getParameterError("EfficiencySa");
double dsa_eff = minuit.getParameterError("EfficiencySa", sa_eff);
double iso_eff = minuit.getParameterError("EfficiencyIso");
double diso_eff = minuit.getParameterError("EfficiencyIso", iso_eff);
double hlt_eff = minuit.getParameterError("EfficiencyHLT");
double dhlt_eff = minuit.getParameterError("EfficiencyHLT",hlt_eff);
myfile<< Y <<" "<< dY <<" "<< tk_eff <<" "<< dtk_eff <<" "<< sa_eff << " " << dsa_eff << " " << iso_eff <<" " << diso_eff<< " " << hlt_eff << " " << dhlt_eff << " " <<chi2()/(chi2.numberOfBins()- minuit.numberOfFreeParameters());
myfile.close();
//Plot
double s;
s = 0;
for(int i = 1; i <= histoZMuMuNoIso->GetNbinsX(); ++i)
s += histoZMuMuNoIso->GetBinContent(i);
histoZMuMuNoIso->SetEntries(s);
s = 0;
for(int i = 1; i <= histoZMuMu->GetNbinsX(); ++i)
s += histoZMuMu->GetBinContent(i);
histoZMuMu->SetEntries(s);
s = 0;
for(int i = 1; i <= histoZMuMu1HLT->GetNbinsX(); ++i)
s += histoZMuMu1HLT->GetBinContent(i);
histoZMuMu1HLT->SetEntries(s);
s = 0;
for(int i = 1; i <= histoZMuMu2HLT->GetNbinsX(); ++i)
s += histoZMuMu2HLT->GetBinContent(i);
histoZMuMu2HLT->SetEntries(s);
s = 0;
for(int i = 1; i <= histoZMuTk->GetNbinsX(); ++i)
s += histoZMuTk->GetBinContent(i);
histoZMuTk->SetEntries(s);
s = 0;
for(int i = 1; i <= histoZMuSa->GetNbinsX(); ++i)
s += histoZMuSa->GetBinContent(i);
histoZMuSa->SetEntries(s);
string ZMuMu1HLTPlot = "ZMuMu1HLTFit_" + plot_string;
root::plot<Expr>(ZMuMu1HLTPlot.c_str(), *histoZMuMu1HLT, zMuMu1HLT, fMin, fMax,
effTk, effSa, effIso, effHLT, yieldZMuMu,
kRed, 2, kDashed, 100,
"Z -> #mu #mu mass", "#mu #mu invariant mass (GeV/c^{2})",
"Events");
string ZMuMu2HLTPlot = "ZMuMu2HLTFit_" + plot_string;
root::plot<Expr>(ZMuMu2HLTPlot.c_str(), *histoZMuMu2HLT, zMuMu2HLT, fMin, fMax,
effTk, effSa, effIso, effHLT, yieldZMuMu,
kRed, 2, kDashed, 100,
"Z -> #mu #mu mass", "#mu #mu invariant mass (GeV/c^{2})",
"Events");
string ZMuMuNoIsoPlot = "ZMuMuNoIsoFit_" + plot_string;
root::plot<Expr>(ZMuMuNoIsoPlot.c_str(), *histoZMuMuNoIso, zMuMuNoIso, fMin, fMax,
effTk, effSa, effIso, effHLT, yieldZMuMu,
kRed, 2, kDashed, 100,
"Z -> #mu #mu Not Iso mass", "#mu #mu invariant mass (GeV/c^{2})",
"Events");
string ZMuTkPlot = "ZMuTkFit_X_" + plot_string;
root::plot<Expr>(ZMuTkPlot.c_str(), *histoZMuTk, zMuTk, fMin, fMax,
effTk, effSa, effIso, effHLT, yieldZMuMu,
yieldBkgZMuTk, lambda, a0, a1, a2,
kRed, 2, kDashed, 100,
"Z -> #mu + (unmatched) track mass", "#mu #mu invariant mass (GeV/c^{2})",
"Events");
ZMuTkPlot = "ZMuTkFit_" + plot_string;
TF1 funZMuTk = root::tf1_t<sig_tag, Expr>("ZMuTkFunction", zMuTk, fMin, fMax,
effTk, effSa, effIso, effHLT, yieldZMuMu,
yieldBkgZMuTk, lambda, a0, a1, a2);
funZMuTk.SetLineColor(kRed);
funZMuTk.SetLineWidth(2);
funZMuTk.SetLineStyle(kDashed);
funZMuTk.SetNpx(10000);
TF1 funZMuTkBkg = root::tf1_t<bkg_tag, Expr>("ZMuTkBack", zMuTkBkgScaled, fMin, fMax,
yieldBkgZMuTk, lambda, a0, a1, a2);
funZMuTkBkg.SetLineColor(kGreen);
funZMuTkBkg.SetLineWidth(2);
funZMuTkBkg.SetLineStyle(kDashed);
funZMuTkBkg.SetNpx(10000);
histoZMuTk->SetTitle("Z -> #mu + (unmatched) track mass");
histoZMuTk->SetXTitle("#mu + (unmatched) track invariant mass (GeV/c^{2})");
histoZMuTk->SetYTitle("Events");
TCanvas *canvas = new TCanvas("canvas");
histoZMuTk->Draw("e");
funZMuTkBkg.Draw("same");
funZMuTk.Draw("same");
canvas->SaveAs(ZMuTkPlot.c_str());
canvas->SetLogy();
string logZMuTkPlot = "log_" + ZMuTkPlot;
canvas->SaveAs(logZMuTkPlot.c_str());
string ZMuSaPlot = "ZMuSaFit_" + plot_string;
root::plot<Expr>(ZMuSaPlot.c_str(), *histoZMuSa, zMuSa, fMin, fMax,
effSa, effTk, effIso,
yieldZMuMu, yieldBkgZMuSa,
kRed, 2, kDashed, 10000,
"Z -> #mu + (unmatched) standalone mass",
"#mu + (unmatched) standalone invariant mass (GeV/c^{2})",
"Events");
}
}
}
catch(std::exception& e) {
cerr << "error: " << e.what() << "\n";
return 1;
}
catch(...) {
cerr << "Exception of unknown type!\n";
}
return 0;
}
void plotScaleFactor(string label) {
TFile *inf = new TFile(Form("data/ScaleFactors/RazorMADD2015/RazorScaleFactors_%s.root",label.c_str()),"READ");
inf->ls();
TH2Poly *ttbarNominal = (TH2Poly*)inf->Get("TTJetsScaleFactors");
TH2Poly *ttbarUp = (TH2Poly*)inf->Get("TTJetsScaleFactorsUp");
TH2Poly *ttbarDown = (TH2Poly*)inf->Get("TTJetsScaleFactorsDown");
TH2Poly *wNominal = (TH2Poly*)inf->Get("WJetsScaleFactors");
TH2Poly *wUp = (TH2Poly*)inf->Get("WJetsScaleFactorsUp");
TH2Poly *wDown = (TH2Poly*)inf->Get("WJetsScaleFactorsDown");
TH2Poly *wInvNominal = (TH2Poly*)inf->Get("WJetsInvScaleFactors");
TH2Poly *wInvUp = (TH2Poly*)inf->Get("WJetsInvScaleFactorsUp");
TH2Poly *wInvDown = (TH2Poly*)inf->Get("WJetsInvScaleFactorsDown");
TH2Poly *GJetInvNominal = (TH2Poly*)inf->Get("GJetsInvScaleFactors");
TCanvas *cv = 0;
gStyle->SetPaintTextFormat("4.2f");
//****************************************************
//Plot GJetsInv Scale Factors
//****************************************************
cv = new TCanvas("cv","cv", 800,600);
cv->cd();
gStyle->SetPalette(53);
GJetInvNominal->Draw("colztexte1");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
GJetInvNominal->GetXaxis()->SetRangeUser(400,4000);
GJetInvNominal->GetYaxis()->SetRangeUser(0.25,1.5);
GJetInvNominal->GetZaxis()->SetTitle("Data to MC Correction Factor");
GJetInvNominal->GetXaxis()->SetTitle("M_{R} [GeV/c^{2}]");
GJetInvNominal->GetYaxis()->SetTitle("R^{2}");
GJetInvNominal->SetTitle("");
GJetInvNominal->GetZaxis()->SetLabelSize(0.05);
GJetInvNominal->GetZaxis()->SetTitleSize(0.05);
GJetInvNominal->GetXaxis()->SetLabelSize(0.05);
GJetInvNominal->GetXaxis()->SetTitleSize(0.05);
GJetInvNominal->GetXaxis()->SetTitleOffset(0.8);
GJetInvNominal->GetYaxis()->SetLabelSize(0.05);
GJetInvNominal->GetYaxis()->SetTitleSize(0.05);
GJetInvNominal->GetYaxis()->SetTitleOffset(0.8);
GJetInvNominal->SetStats(false);
GJetInvNominal->SetMaximum(1.8);
GJetInvNominal->SetMinimum(0.35);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("GJetsInvScaleFactor_CorrectedToMultiJet_%s.png",label.c_str()));
cv->SaveAs(Form("GJetsInvScaleFactor_CorrectedToMultiJet_%s.pdf",label.c_str()));
TH2Poly *GJetInvUncertainties = (TH2Poly*)GJetInvNominal->Clone("GJetInvUncertainties");
for (int i=1; i<GJetInvUncertainties->GetNumberOfBins()+1; ++i) {
GJetInvUncertainties->SetBinContent(i,100*GJetInvNominal->GetBinError(i) / GJetInvNominal->GetBinContent(i));
cout << i << " : " << GJetInvNominal->GetBinError(i) << " " << GJetInvNominal->GetBinContent(i) << " : " << GJetInvNominal->GetBinError(i) / GJetInvNominal->GetBinContent(i) << "\n";
}
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(1);
gStyle->SetPaintTextFormat("4.0f");
GJetInvUncertainties->Draw("colztext");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
GJetInvUncertainties->SetMarkerSize(2.0);
GJetInvUncertainties->SetTitle("");
GJetInvUncertainties->GetXaxis()->SetTitle("M_{R} [GeV/c^{2}]");
GJetInvUncertainties->GetYaxis()->SetTitle("R^{2}");
GJetInvUncertainties->GetXaxis()->SetRangeUser(400,4000);
GJetInvUncertainties->GetYaxis()->SetRangeUser(0.25,1.5);
GJetInvUncertainties->GetZaxis()->SetTitle("Systematic Uncertainty (%)");
GJetInvUncertainties->GetZaxis()->SetLabelSize(0.05);
GJetInvUncertainties->GetZaxis()->SetTitleSize(0.05);
GJetInvUncertainties->GetXaxis()->SetLabelSize(0.05);
GJetInvUncertainties->GetXaxis()->SetTitleSize(0.05);
GJetInvUncertainties->GetXaxis()->SetTitleOffset(0.8);
GJetInvUncertainties->GetYaxis()->SetLabelSize(0.05);
GJetInvUncertainties->GetYaxis()->SetTitleSize(0.05);
GJetInvUncertainties->GetYaxis()->SetTitleOffset(0.8);
GJetInvUncertainties->SetStats(false);
GJetInvUncertainties->SetMaximum(50);
GJetInvUncertainties->SetMinimum(0.0);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("GJetsInvScaleFactorUncertainty_%s.png",label.c_str()));
cv->SaveAs(Form("GJetsInvScaleFactorUncertainty_%s.pdf",label.c_str()));
//****************************************************
//Plot WJetsInv Scale Factors
//****************************************************
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(53);
gStyle->SetPaintTextFormat("4.2f");
wInvNominal->Draw("colztexte1");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
wInvNominal->GetXaxis()->SetRangeUser(300,4000);
wInvNominal->GetYaxis()->SetRangeUser(0.15,1.5);
wInvNominal->GetZaxis()->SetTitle("Data to MC Correction Factor");
wInvNominal->GetZaxis()->SetLabelSize(0.05);
wInvNominal->GetZaxis()->SetTitleSize(0.05);
wInvNominal->GetXaxis()->SetLabelSize(0.05);
wInvNominal->GetXaxis()->SetTitleSize(0.05);
wInvNominal->GetXaxis()->SetTitleOffset(0.8);
wInvNominal->GetYaxis()->SetLabelSize(0.05);
wInvNominal->GetYaxis()->SetTitleSize(0.05);
wInvNominal->GetYaxis()->SetTitleOffset(0.8);
wInvNominal->SetStats(false);
wInvNominal->SetMaximum(1.8);
wInvNominal->SetMinimum(0.0);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("WJetsInvScaleFactor_CorrectedToMultiJet_%s.png",label.c_str()));
cv->SaveAs(Form("WJetsInvScaleFactor_CorrectedToMultiJet_%s.pdf",label.c_str()));
//****************************************************
//Plot WJets Scale Factors
//****************************************************
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(53);
wNominal->Draw("colztexte1");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
wNominal->GetXaxis()->SetRangeUser(300,4000);
wNominal->GetYaxis()->SetRangeUser(0.15,1.5);
wNominal->GetZaxis()->SetTitle("Data to MC Correction Factor");
wNominal->GetZaxis()->SetLabelSize(0.05);
wNominal->GetZaxis()->SetTitleSize(0.05);
wNominal->GetXaxis()->SetLabelSize(0.05);
wNominal->GetXaxis()->SetTitleSize(0.05);
wNominal->GetXaxis()->SetTitleOffset(0.8);
wNominal->GetYaxis()->SetLabelSize(0.05);
wNominal->GetYaxis()->SetTitleSize(0.05);
wNominal->GetYaxis()->SetTitleOffset(0.8);
wNominal->SetStats(false);
wNominal->SetMaximum(1.8);
wNominal->SetMinimum(0.35);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("WJetsScaleFactor_CorrectedToMultiJet_%s.png",label.c_str()));
cv->SaveAs(Form("WJetsScaleFactor_CorrectedToMultiJet_%s.pdf",label.c_str()));
TH2Poly *WJetsUncertainties = (TH2Poly*)wNominal->Clone("WJetsUncertainties");
for (int i=1; i<WJetsUncertainties->GetNumberOfBins()+1; ++i) {
WJetsUncertainties->SetBinContent(i,100*wNominal->GetBinError(i) / wNominal->GetBinContent(i));
}
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(1);
gStyle->SetPaintTextFormat("4.0f");
WJetsUncertainties->Draw("colztext");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
WJetsUncertainties->SetMarkerSize(2.0);
WJetsUncertainties->SetTitle("");
WJetsUncertainties->GetXaxis()->SetTitle("M_{R} [GeV/c^{2}]");
WJetsUncertainties->GetYaxis()->SetTitle("R^{2}");
WJetsUncertainties->GetXaxis()->SetRangeUser(300,4000);
WJetsUncertainties->GetYaxis()->SetRangeUser(0.15,1.5);
WJetsUncertainties->GetZaxis()->SetTitle("Systematic Uncertainty (%)");
WJetsUncertainties->GetZaxis()->SetLabelSize(0.05);
WJetsUncertainties->GetZaxis()->SetTitleSize(0.05);
WJetsUncertainties->GetXaxis()->SetLabelSize(0.05);
WJetsUncertainties->GetXaxis()->SetTitleSize(0.05);
WJetsUncertainties->GetXaxis()->SetTitleOffset(0.8);
WJetsUncertainties->GetYaxis()->SetLabelSize(0.05);
WJetsUncertainties->GetYaxis()->SetTitleSize(0.05);
WJetsUncertainties->GetYaxis()->SetTitleOffset(0.8);
WJetsUncertainties->SetStats(false);
WJetsUncertainties->SetMaximum(50);
WJetsUncertainties->SetMinimum(0.0);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("WJetsScaleFactorUncertainty_%s.png",label.c_str()));
cv->SaveAs(Form("WJetsScaleFactorUncertainty_%s.pdf",label.c_str()));
//****************************************************
//Plot TTBar Scale Factors
//****************************************************
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(53);
gStyle->SetPaintTextFormat("4.2f");
ttbarNominal->Draw("colztexte1");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
ttbarNominal->GetXaxis()->SetRangeUser(400,4000);
ttbarNominal->GetYaxis()->SetRangeUser(0.25,1.5);
ttbarNominal->GetZaxis()->SetTitle("Data to MC Correction Factor");
ttbarNominal->GetZaxis()->SetLabelSize(0.05);
ttbarNominal->GetZaxis()->SetTitleSize(0.05);
ttbarNominal->GetXaxis()->SetLabelSize(0.05);
ttbarNominal->GetXaxis()->SetTitleSize(0.05);
ttbarNominal->GetXaxis()->SetTitleOffset(0.8);
ttbarNominal->GetYaxis()->SetLabelSize(0.05);
ttbarNominal->GetYaxis()->SetTitleSize(0.05);
ttbarNominal->GetYaxis()->SetTitleOffset(0.8);
ttbarNominal->SetStats(false);
// ttbarNominal->SetMaximum(10000);
// ttbarNominal->SetMinimum(0.0);
ttbarNominal->SetMaximum(1.8);
ttbarNominal->SetMinimum(0.35);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("TTBarScaleFactor_CorrectedToMultiJet_%s.png",label.c_str()));
cv->SaveAs(Form("TTBarScaleFactor_CorrectedToMultiJet_%s.pdf",label.c_str()));
TH2Poly *TTBarUncertainties = (TH2Poly*)ttbarNominal->Clone("TTBarUncertainties");
for (int i=1; i<TTBarUncertainties->GetNumberOfBins()+1; ++i) {
TTBarUncertainties->SetBinContent(i,100*ttbarNominal->GetBinError(i) / ttbarNominal->GetBinContent(i));
}
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(1);
gStyle->SetPaintTextFormat("4.0f");
TTBarUncertainties->Draw("colztext");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
TTBarUncertainties->SetMarkerSize(2.0);
TTBarUncertainties->SetTitle("");
TTBarUncertainties->GetXaxis()->SetTitle("M_{R} [GeV/c^{2}]");
TTBarUncertainties->GetYaxis()->SetTitle("R^{2}");
TTBarUncertainties->GetXaxis()->SetRangeUser(300,4000);
TTBarUncertainties->GetYaxis()->SetRangeUser(0.15,1.5);
TTBarUncertainties->GetZaxis()->SetTitle("Systematic Uncertainty (%)");
TTBarUncertainties->GetZaxis()->SetLabelSize(0.05);
TTBarUncertainties->GetZaxis()->SetTitleSize(0.05);
TTBarUncertainties->GetXaxis()->SetLabelSize(0.05);
TTBarUncertainties->GetXaxis()->SetTitleSize(0.05);
TTBarUncertainties->GetXaxis()->SetTitleOffset(0.8);
TTBarUncertainties->GetYaxis()->SetLabelSize(0.05);
TTBarUncertainties->GetYaxis()->SetTitleSize(0.05);
TTBarUncertainties->GetYaxis()->SetTitleOffset(0.8);
TTBarUncertainties->SetStats(false);
TTBarUncertainties->SetMaximum(50);
TTBarUncertainties->SetMinimum(0.0);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("TTBarScaleFactorUncertainty_%s.png",label.c_str()));
cv->SaveAs(Form("TTBarScaleFactorUncertainty_%s.pdf",label.c_str()));
}
void plotGJetsScaleFactorSystematics(string label) {
TFile *inf = new TFile(Form("data/ScaleFactors/RazorMADD2015/RazorScaleFactors_%s.root",label.c_str()),"READ");
TH2Poly *ttbarNominal = (TH2Poly*)inf->Get("TTJetsScaleFactors");
TH2Poly *ttbarUp = (TH2Poly*)inf->Get("TTJetsScaleFactorsUp");
TH2Poly *ttbarDown = (TH2Poly*)inf->Get("TTJetsScaleFactorsDown");
TH2Poly *wNominal = (TH2Poly*)inf->Get("WJetsScaleFactors");
TH2Poly *wUp = (TH2Poly*)inf->Get("WJetsScaleFactorsUp");
TH2Poly *wDown = (TH2Poly*)inf->Get("WJetsScaleFactorsDown");
TH2Poly *wInvNominal = (TH2Poly*)inf->Get("WJetsInvScaleFactors");
TH2Poly *wInvUp = (TH2Poly*)inf->Get("WJetsInvScaleFactorsUp");
TH2Poly *wInvDown = (TH2Poly*)inf->Get("WJetsInvScaleFactorsDown");
TH2Poly *GJetInvNominal = (TH2Poly*)inf->Get("GJetsInvScaleFactors");
TCanvas *cv = 0;
gStyle->SetPaintTextFormat("4.2f");
//****************************************************
//Systematic Uncertainty and GJets Down SF Histogram
//****************************************************
TH2Poly *GJetsSystematicUnc = (TH2Poly*)GJetInvNominal->Clone("GJetsSystematicUnc");
TH2Poly *GJetsScaleFactor_Down = (TH2Poly*)GJetInvNominal->Clone("GJetsInvScaleFactors_Down");
//Get bins of each histogram
TList *wInvBins = wInvNominal->GetBins();
TList *gInvBins = GJetInvNominal->GetBins();
//Loop over GJets bins
TH2PolyBin *gBin, *wBin; //temp variables to hold bin info
for (int i = 1; i < GJetsSystematicUnc->GetNumberOfBins()+1; ++i) {
//Get GJets bin
gBin = (TH2PolyBin*)gInvBins->At(i-1);
cout << "In bin " << i << " of GJets histogram" << endl;
//cout << gBin->GetXMin() << " " << gBin->GetXMax() << " " << gBin->GetYMin() << " " << gBin->GetYMax() << endl;
//Find out which WJets bin we are in
int wBinNum = -1;
for (int j = 1; j < wInvNominal->GetNumberOfBins()+1; ++j) {
//Get WJets bin
wBin = (TH2PolyBin*)wInvBins->At(j-1);
//cout << "In bin " << j << " of WJets histogram" << endl;
//cout << wBin->GetXMin() << " " << wBin->GetXMax() << " " << wBin->GetYMin() << " " << wBin->GetYMax() << endl;
//Check if this GJets bin is inside this WJets bin
if ( gBin->GetXMin() >= wBin->GetXMin() &&
gBin->GetXMax() <= wBin->GetXMax() &&
gBin->GetYMin() >= wBin->GetYMin() &&
gBin->GetYMax() <= wBin->GetYMax() ) {
cout << "This GJets bin is inside bin " << j << " of WJets histogram" << endl;
wBinNum = j;
break;
}
}
double gjet = GJetInvNominal->GetBinContent(i);
double wjet = wInvNominal->GetBinContent(wBinNum);
//Set bin content of each histogram
GJetsSystematicUnc->SetBinContent(i, (gjet - wjet)/gjet );
GJetsScaleFactor_Down->SetBinContent(i, gjet - (wjet - gjet) );
cout << "Bin " << i << " : " << gjet << " , " << wjet << " , " << gjet - (wjet - gjet) << "\n";
}
cv = new TCanvas("cv","cv", 800,600);
gStyle->SetPalette(1);
GJetsSystematicUnc->Draw("colztext");
cv->SetLogx();
cv->SetLogy();
cv->SetRightMargin(0.175);
cv->SetBottomMargin(0.12);
GJetsSystematicUnc->GetXaxis()->SetRangeUser(400,4000);
GJetsSystematicUnc->GetYaxis()->SetRangeUser(0.25,1.5);
GJetsSystematicUnc->GetZaxis()->SetTitle("Systematic Uncertainty");
GJetsSystematicUnc->GetXaxis()->SetTitle("M_{R} [GeV/c^{2}]");
GJetsSystematicUnc->GetYaxis()->SetTitle("R^{2}");
GJetsSystematicUnc->SetTitle("");
GJetsSystematicUnc->GetZaxis()->SetLabelSize(0.05);
GJetsSystematicUnc->GetZaxis()->SetTitleSize(0.05);
GJetsSystematicUnc->GetXaxis()->SetLabelSize(0.05);
GJetsSystematicUnc->GetXaxis()->SetTitleSize(0.05);
GJetsSystematicUnc->GetXaxis()->SetTitleOffset(0.8);
GJetsSystematicUnc->GetYaxis()->SetLabelSize(0.05);
GJetsSystematicUnc->GetYaxis()->SetTitleSize(0.05);
GJetsSystematicUnc->GetYaxis()->SetTitleOffset(0.8);
GJetsSystematicUnc->SetStats(false);
GJetsSystematicUnc->SetMaximum(1.0);
GJetsSystematicUnc->SetMinimum(-1.0);
lumi_13TeV = "35.9 fb^{-1}";
writeExtraText = true;
relPosX = 0.13;
lumiTextSize = 0.5;
cmsTextSize = 0.6;
extraOverCmsTextSize = 0.85;
CMS_lumi(cv,4,0);
cv->SaveAs(Form("GJetsVsWJetsSystematic_%s.png",label.c_str()));
cv->SaveAs(Form("GJetsVsWJetsSystematic_%s.pdf",label.c_str()));
TFile *outf = new TFile(Form("data/ScaleFactors/RazorMADD2015/RazorScaleFactors_%s.root",label.c_str()),"UPDATE");
outf->WriteTObject(GJetsScaleFactor_Down, GJetsScaleFactor_Down->GetName(), "WRITEDELETE");
outf->Close();
}
void Unfold2(int algo= 3,bool useSpectraFromFile=0, bool useMatrixFromFile=0, int doToy = 0, int isMC = 0,char *spectraFileName = (char*)"pbpb_spectra_akPu3PF.root",double recoJetPtCut = 60,double trackMaxPtCut = 0, int nBayesianIter = 4, int doBjets=0) // algo 2 =akpu2 ; 3 =akpu3 ; 4 =akpu4 ;1 = icpu5
{
gStyle->SetErrorX(0.5);
gStyle->SetPaintTextFormat("3.2f");
gStyle->SetOptLogz(1);
gStyle->SetPadRightMargin(0.13);
gStyle->SetOptTitle(0);
const float pplumi=5.3e9;
const bool SavePlot=kTRUE;
TH1::SetDefaultSumw2();
TH2::SetDefaultSumw2();
// input files
char *fileNamePP_data = (char*)"/net/hidsk0001/d00/scratch/maoyx/pPb/Btag/CodeMatt/NewFormatV4_bFractionMCTemplate_pppp1_SSVHEat2.0FixCL0_bin_0_40_eta_0_2.root";
char *fileNamePbPb_data = (char*)"/net/hidsk0001/d00/scratch/maoyx/pPb/Btag/CodeMatt/AltBinningV6_bFractionMCTemplate_ppPbPb1_SSVHEat2.0FixCL0_bin_0_40_eta_0_2.root";
char *fileNamePP_mc = NULL;
if(doBjets) fileNamePP_mc = (char*)"/net/hidsk0001/d00/scratch/kjung/histos/ppMC_ppReco_ak3PF_BjetTrig_noIPupperCut.root";
else fileNamePP_mc = (char*)"/net/hidsk0001/d00/scratch/kjung/histos//ppMC_ppReco_ak3PF_QCDjetTrig_noIPupperCut.root";
char *fileNamePbPb_mc = NULL;
if(doBjets)fileNamePbPb_mc = (char*) "/net/hisrv0001/home/mnguyen/scratch/bTaggingOutput/ntuples/PbPbBMC_pt30by3_ipHICalibCentWeight_noTrig.root";
else fileNamePbPb_mc = (char*) "/net/hisrv0001/home/mnguyen/scratch/bTaggingOutput/ntuples/PbPbQCDMC_pt30by3_ipHICalibCentWeight_noTrig.root";
// grab ntuples
TFile *infPbPb_mc = new TFile(fileNamePbPb_mc);
TFile *infPP_mc = new TFile(fileNamePP_mc);
// Output file
TFile *pbpb_Unfo;
if (isMC) pbpb_Unfo = new TFile(Form("pbpb_Unfo_%s_MC.root",algoName[algo]),"RECREATE");
else pbpb_Unfo = new TFile(Form("pbpb_Unfo_%s_jtpt%.0f_trk%.0f.root",algoName[algo],recoJetPtCut,trackMaxPtCut),"RECREATE");
// Histograms used by RooUnfold
UnfoldingHistos *uhist[nbins_cent+1];
// Initialize Histograms
for (int i=0;i<=nbins_cent;i++) uhist[i] = new UnfoldingHistos(i);
// Initialize reweighting functions
TCut dataSelection;
TCut dataSelectionPP;
TCut TriggerSelectionPP;
TCut TriggerSelectionPbPb80;
if(doBjets)dataSelection = "weight*(abs(refparton_flavorForB)==5&&abs(jteta)<2)";
else dataSelection = "weight*(abs(jteta)<2)";
if (isMC) cout<<"This is a MC closure test"<<endl;
else cout<< "This is a data analysis"<<endl;
// Setup jet data branches, basically the jet tree branches are assigned to this object when we loop over the events
JetDataPbPb *dataPbPb = new JetDataPbPb(fileNamePbPb_mc,(char*)"nt"); // PbPb data
JetDataPP *dataPP = new JetDataPP(fileNamePP_mc,(char*)"nt"); // pp data
TFile *fSpectra(0);
if (useSpectraFromFile||useMatrixFromFile){
fSpectra = new TFile(spectraFileName,"read");
}
// Come back to the output file dir
pbpb_Unfo->cd();
// Get Jet spectra from data file
cout <<"Reading data..."<<endl;
// This doesn't seem to be relevant for the moment -Matt
/*
TTree *tPbPbJet = (TTree*)infPbPb_mc->Get("nt");
TTree *tPPJet = (TTree*)infPP_mc->Get("nt");
TCanvas * cInput = new TCanvas("cInput","Input",800,400);
cInput->Divide(2,1);
cout <<"Spectra..."<<endl;
for (int i=0;i<=nbins_cent;i++){
cout <<nbins_cent<<endl;
TCut centCut = Form("bin<%.0f&&bin>=%.0f",boundaries_cent[i+1],boundaries_cent[i]);
if (useSpectraFromFile) {
uhist[i]->hMeas = (TH1F*)fSpectra->Get(Form("hMeas_cent%d",i));
} else {
if (!isMC) {
tPbPbJet->Project(Form("hMeas_cent%d",i),"jtptB", dataSelection&¢Cut&&TriggerSelectionPbPb80);
}
}
if (useMatrixFromFile) {
cout <<"Matrix"<<endl;
uhist[i]->hMatrixFit = (TH2F*) fSpectra->Get(Form("hMatrixFit_cent%d",i));
uhist[i]->hMeasMatch = (TH1F*)((TH2F*) fSpectra->Get(Form("hMatrixFit_cent%d",i)))->ProjectionY();
uhist[i]->hMeasMatch->Divide(uhist[i]->hMeas);
} else {
uhist[i]->hMeasMatch = 0;
}
uhist[i]->hMeas->Draw();
}
if (!isMC) tPPJet->Project(Form("hMeas_cent%d",nbins_cent),"jtpt",dataSelectionPP&&TriggerSelectionPP);
*/
cout <<"MC..."<<endl;
TH1F *hCent = new TH1F("hCent","",nbins_cent,boundaries_cent);
// Fill PbPb MC
if (!useMatrixFromFile) {
for (Long64_t jentry2=0; jentry2<dataPbPb->tJet->GetEntries();jentry2++) {
dataPbPb->tJet->GetEntry(jentry2);
// change when we switch to centrality binning
int cBin = 0;
//int cBin = hCent->FindBin(dataPbPb->bin)-1;
/*
if (cBin>=nbins_cent) continue;
if (cBin==-1) continue;
*/
if ( dataPbPb->refpt < 0. ) continue;
if ( dataPbPb->jteta > 2. || dataPbPb->jteta < -2. ) continue;
if ( dataPbPb->refpt<0) dataPbPb->refpt=0;
if (doBjets && fabs(dataPbPb->refparton_flavorForB)!=5) continue;
if (doBjets&& dataPbPb->discr_ssvHighEff<2) continue;
if (doBjets && dataPbPb->jtptB < recoJetPtCut) continue;
if (!doBjets && dataPbPb->jtptA < recoJetPtCut) continue;
//if ( dataPbPb->isTrig <1) continue;
if(!doBjets)if(dataPbPb->refpt < 50 && dataPbPb->jtptA>120) continue;
if(doBjets)if(dataPbPb->refpt < 50 && dataPbPb->jtptB>120) continue;
if (!isMC||jentry2 % 2 == 1) {
if(doBjets)uhist[cBin]-> hMatrix->Fill(dataPbPb->refpt,dataPbPb->jtptB,dataPbPb->weight);
else uhist[cBin]-> hMatrix->Fill(dataPbPb->refpt,dataPbPb->jtptA,dataPbPb->weight);
}
if (jentry2 % 2 == 0) {
uhist[cBin]-> hGen->Fill(dataPbPb->refpt,dataPbPb->weight);
if(doBjets)uhist[cBin]-> hMeas->Fill(dataPbPb->jtptB,dataPbPb->weight);
else uhist[cBin]-> hMeas->Fill(dataPbPb->jtptA,dataPbPb->weight);
//uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtpt*(1.+0.02/nbins_cent*(nbins_cent-i)),dataPbPb->weight);
// FIXME!!!!!! i is supposed to be a loop over centrality !!!!
if(doBjets)uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtptB*(1.+0.02/nbins_cent*(nbins_cent-0)),dataPbPb->weight);
else uhist[cBin]-> hMeasJECSys->Fill(dataPbPb->jtptA*(1.+0.02/nbins_cent*(nbins_cent-0)),dataPbPb->weight);
}
}
//pp will just fill the last index of the centrality array
// fill pp MC
for (Long64_t jentry2=0; jentry2<dataPP->tJet->GetEntries();jentry2++) {
dataPP->tJet->GetEntry(jentry2);
if ( dataPP->refpt<0) continue;
if ( dataPP->jteta > 2. || dataPP->jteta < -2. ) continue;
if ( dataPP->refpt<0) dataPP->refpt=0;
if ( doBjets && fabs(dataPP->refparton_flavorForB)!=5) continue;
if ( doBjets && dataPP->discr_ssvHighEff<2) continue;
if ( dataPP->jtpt < recoJetPtCut) continue;
if (!isMC||jentry2 % 2 == 1) {
uhist[nbins_cent]-> hMatrix->Fill(dataPP->refpt,dataPP->jtpt,dataPP->weight);
}
if (jentry2 % 2 == 0) {
uhist[nbins_cent]-> hGen->Fill(dataPP->refpt,dataPP->weight);
uhist[nbins_cent]-> hMeas->Fill(dataPP->jtpt,dataPP->weight);
}
}
}
cout <<"Response Matrix..."<<endl;
TCanvas * cMatrix = new TCanvas("cMatrix","Matrix",800,400);
cMatrix->Divide(2,1);
for (int i=0;i<=nbins_cent;i++){
cMatrix->cd(i+1);
if (!useMatrixFromFile) {
TF1 *f = new TF1("f","[0]*pow(x+[2],[1])");
f->SetParameters(1e10,-8.8,40);
for (int y=1;y<=uhist[i]->hMatrix->GetNbinsY();y++) {
double sum=0;
for (int x=1;x<=uhist[i]->hMatrix->GetNbinsX();x++) {
if (uhist[i]->hMatrix->GetBinContent(x,y)<=1*uhist[i]->hMatrix->GetBinError(x,y)) {
uhist[i]->hMatrix->SetBinContent(x,y,0);
uhist[i]->hMatrix->SetBinError(x,y,0);
}
sum+=uhist[i]->hMatrix->GetBinContent(x,y);
}
for (int x=1;x<=uhist[i]->hMatrix->GetNbinsX();x++) {
double ratio = 1;
uhist[i]->hMatrix->SetBinContent(x,y,uhist[i]->hMatrix->GetBinContent(x,y)*ratio);
uhist[i]->hMatrix->SetBinError(x,y,uhist[i]->hMatrix->GetBinError(x,y)*ratio);
}
}
}
uhist[i]->hResponse = (TH2F*)uhist[i]->hMatrix->Clone(Form("hResponse_cent%d",i));
for (int y=1;y<=uhist[i]->hResponse->GetNbinsY();y++) {
double sum=0;
for (int x=1;x<=uhist[i]->hResponse->GetNbinsX();x++) {
if (uhist[i]->hResponse->GetBinContent(x,y)<=0*uhist[i]->hResponse->GetBinError(x,y)) {
uhist[i]->hResponse->SetBinContent(x,y,0);
uhist[i]->hResponse->SetBinError(x,y,0);
}
sum+=uhist[i]->hResponse->GetBinContent(x,y);
}
for (int x=1;x<=uhist[i]->hResponse->GetNbinsX();x++) {
if (sum==0) continue;
double ratio = uhist[i]->hMeas->GetBinContent(y)/sum;
if (uhist[i]->hMeas->GetBinContent(y)==0) ratio = 1e-100/sum;
}
}
uhist[i]->hResponseNorm = (TH2F*)uhist[i]->hMatrix->Clone(Form("hResponseNorm_cent%d",i));
for (int x=1;x<=uhist[i]->hResponseNorm->GetNbinsX();x++) {
double sum=0;
for (int y=1;y<=uhist[i]->hResponseNorm->GetNbinsY();y++) {
if (uhist[i]->hResponseNorm->GetBinContent(x,y)<=0*uhist[i]->hResponseNorm->GetBinError(x,y)) {
uhist[i]->hResponseNorm->SetBinContent(x,y,0);
uhist[i]->hResponseNorm->SetBinError(x,y,0);
}
sum+=uhist[i]->hResponseNorm->GetBinContent(x,y);
}
for (int y=1;y<=uhist[i]->hResponseNorm->GetNbinsY();y++) {
if (sum==0) continue;
double ratio = 1./sum;
uhist[i]->hResponseNorm->SetBinContent(x,y,uhist[i]->hResponseNorm->GetBinContent(x,y)*ratio);
uhist[i]->hResponseNorm->SetBinError(x,y,uhist[i]->hResponseNorm->GetBinError(x,y)*ratio);
}
}
uhist[i]->hResponse->Draw("col");
if (!useMatrixFromFile) uhist[i]->hMatrixFit = uhist[i]->hMatrix;
uhist[i]->hMatrixFit->SetName(Form("hMatrixFit_cent%d",i));
}
cMatrix->Update();
if (isMC==0) {
// Use measured histogram from Matt & Kurt's file
// PbPb file:
TFile *infMatt = new TFile(fileNamePbPb_data);
TH1F *hMattPbPb = NULL;
if(doBjets) hMattPbPb = (TH1F*) infMatt->Get("hRawBData");
else hMattPbPb = (TH1F*) infMatt->Get("hIncJetsData");
divideBinWidth(hMattPbPb);
// Need to match the binning carefully, please double check whenever you change the binning
for (int i=1;i<=hMattPbPb->GetNbinsX();i++)
{
uhist[0]->hMeas->SetBinContent(i+uhist[0]->hMeas->FindBin(61)-1,hMattPbPb->GetBinContent(i));
uhist[0]->hMeas->SetBinError(i+uhist[0]->hMeas->FindBin(61)-1,hMattPbPb->GetBinError(i));
}
// pp file:
// The file name needs to be updated!!!!!
TFile *infMattPP = new TFile(fileNamePP_data);
TH1F *hMattPP = NULL;
if(doBjets)hMattPP = (TH1F*) infMattPP->Get("hRawBData");
else hMattPP = (TH1F*) infMattPP->Get("hIncJetsData");
divideBinWidth(hMattPP);
// Need to match the binning carefully, please double check whenever you change the binning
for (int i=1;i<=hMattPP->GetNbinsX();i++)
{
uhist[nbins_cent]->hMeas->SetBinContent(i+uhist[nbins_cent]->hMeas->FindBin(61)-1,hMattPP->GetBinContent(i));
uhist[nbins_cent]->hMeas->SetBinError(i+uhist[nbins_cent]->hMeas->FindBin(61)-1,hMattPP->GetBinError(i));
}
}
pbpb_Unfo->cd();
cout << "==================================== UNFOLD ===================================" << endl;
//char chmet[100];
// ======================= Reconstructed pp and PbPb spectra =========================================================
TCanvas * cPbPb = new TCanvas("cPbPb","Comparison",1200,600);
cPbPb->Divide(2,1);
cPbPb->cd(1);
for (int i=0;i<=nbins_cent;i++) {
cPbPb->cd(i+1)->SetLogy();
// Do Bin-by-bin
TH1F *hBinByBinCorRaw = (TH1F*)uhist[i]->hResponse->ProjectionY();
TH1F *hMCGen = (TH1F*)uhist[i]->hResponse->ProjectionX(); // gen
hBinByBinCorRaw->Divide(hMCGen);
TF1 *f = new TF1("f","[0]+[1]*x");
hBinByBinCorRaw->Fit("f","LL ","",90,300);
TH1F* hBinByBinCor = (TH1F*)hBinByBinCorRaw->Clone();//functionHist(f,hBinByBinCorRaw,Form("hBinByBinCor_cent%d",i));
delete hBinByBinCorRaw;
delete hMCGen;
uhist[i]->hRecoBinByBin = (TH1F*) uhist[i]->hMeas->Clone(Form("hRecoBinByBin_cent%d",i));
uhist[i]->hRecoBinByBin->Divide(hBinByBinCor);
// Do unfolding
//if (isMC) uhist[i]->hMeas = (TH1F*)uhist[i]->hMatrix->ProjectionY()->Clone(Form("hMeas_cent%d",i));
prior myPrior(uhist[i]->hMatrixFit,uhist[i]->hMeas,0);
// myPrior.unfold(uhist[i]->hMeas,1);
myPrior.unfold(uhist[i]->hMeas,nBayesianIter);
TH1F *hPrior;//=(TH1F*) functionHist(fPow,uhist[i]->hMeas,Form("hPrior_cent%d",i));
hPrior = (TH1F*)uhist[i]->hGen->Clone("hPrior");//(TH1F*)uhist[i]->hMeas->Clone(Form("hPrior_cent%d",i));
removeZero(hPrior);
bayesianUnfold myUnfoldingJECSys(uhist[i]->hMatrixFit,hPrior,0);
myUnfoldingJECSys.unfold(uhist[i]->hMeasJECSys,nBayesianIter);
bayesianUnfold myUnfoldingSmearSys(uhist[i]->hMatrixFit,hPrior,0);
myUnfoldingSmearSys.unfold(uhist[i]->hMeasSmearSys,nBayesianIter);
bayesianUnfold myUnfolding(uhist[i]->hMatrixFit,myPrior.hPrior,0);
myUnfolding.unfold(uhist[i]->hMeas,nBayesianIter);
cout <<"Unfolding bin "<<i<<endl;
// Iteration Systematics
for (int j=2;j<=40;j++)
{
bayesianUnfold myUnfoldingSys(uhist[i]->hMatrixFit,hPrior,0);
myUnfoldingSys.unfold(uhist[i]->hMeas,j);
uhist[i]->hRecoIterSys[j] = (TH1F*) myUnfoldingSys.hPrior->Clone(Form("hRecoRAA_IterSys%d_cent%d",j,i));
}
uhist[i]->hReco = (TH1F*) uhist[i]->hRecoIterSys[nBayesianIter]->Clone(Form("Unfolded_cent%i",i));
uhist[i]->hRecoJECSys = (TH1F*) myUnfoldingJECSys.hPrior->Clone(Form("UnfoldedJeCSys_cent%i",i));
uhist[i]->hRecoSmearSys = (TH1F*) myUnfoldingSmearSys.hPrior->Clone(Form("UnfoldedSmearSys_cent%i",i));
uhist[i]->hRecoBinByBin->SetName(Form("UnfoldedBinByBin_cent%i",i));
if (doToy) {
TCanvas *cToy = new TCanvas("cToy","toy",600,600);
cToy->cd();
int nExp=1000;
TH1F *hTmp[nbins_truth+1];
TH1F *hTmp2[nbins_truth+1];
for (int j=1;j<=nbins_truth;j++) {
hTmp[j] = new TH1F(Form("hTmp%d",j),"",200,0,10.+uhist[i]->hReco->GetBinContent(j)*2);
hTmp2[j] = new TH1F(Form("hTmp2%d",j),"",200,0,10.+uhist[i]->hRecoBinByBin->GetBinContent(j)*2);
}
for (int exp =0; exp<nExp; exp++) {
TH1F *hToy = (TH1F*)uhist[i]->hMeas->Clone();
TH2F *hMatrixToy = (TH2F*)uhist[i]->hMatrixFit->Clone();
hToy->SetName("hToy");
if (exp%100==0) cout <<"Pseudo-experiment "<<exp<<endl;
for (int j=1;j<=hToy->GetNbinsX();j++) {
double value = gRandom->Poisson(uhist[i]->hMeas->GetBinContent(j));
hToy->SetBinContent(j,value);
}
for (int j=1;j<=hMatrixToy->GetNbinsX();j++) {
for (int k=1;k<=hMatrixToy->GetNbinsY();k++) {
double value = gRandom->Gaus(uhist[i]->hMatrixFit->GetBinContent(j,k),uhist[i]->hMatrixFit->GetBinError(j,k));
hMatrixToy->SetBinContent(j,k,value);
}
}
prior myPriorToy(hMatrixToy,hToy,0.0);
myPriorToy.unfold(hToy,1);
bayesianUnfold myUnfoldingToy(hMatrixToy,myPriorToy.hPrior,0.0);
myUnfoldingToy.unfold(hToy,nBayesianIter);
TH1F *hRecoTmp = (TH1F*) myUnfoldingToy.hPrior->Clone();
for (int j=1;j<=hRecoTmp->GetNbinsX();j++) {
hTmp[j]->Fill(hRecoTmp->GetBinContent(j));
}
delete hToy;
delete hRecoTmp;
delete hMatrixToy;
}
TF1 *fGaus = new TF1("fGaus","[0]*TMath::Gaus(x,[1],[2])");
for (int j=1;j<=nbins_truth;j++)
{
f->SetParameters(hTmp[j]->GetMaximum(),hTmp[j]->GetMean(),hTmp[j]->GetRMS());
if (hTmp[j]->GetMean()>0) {
hTmp[j]->Fit(fGaus,"LL Q ");
hTmp[j]->Fit(fGaus,"LL Q ");
uhist[i]->hReco->SetBinError(j,f->GetParameter(2));
}
f->SetParameters(hTmp2[j]->GetMaximum(),hTmp2[j]->GetMean(),hTmp2[j]->GetRMS());
if (hTmp2[j]->GetMean()>0) {
hTmp2[j]->Fit(fGaus,"LL Q ");
hTmp2[j]->Fit(fGaus,"LL Q ");
uhist[i]->hRecoBinByBin->SetBinError(j,f->GetParameter(2));
}
delete hTmp[j];
delete hTmp2[j];
}
cPbPb->cd(i+1);
}
uhist[i]->hMeas->SetMarkerStyle(20);
uhist[i]->hMeas->SetMarkerColor(1);
uhist[i]->hReco->SetMarkerStyle(24);
uhist[i]->hReco->SetMarkerColor(2);
uhist[i]->hReco->SetLineColor(2);
uhist[i]->hReco->SetName(Form("hReco_cent%d",i));
uhist[i]->hReco->Draw("");
makeHistTitle(uhist[i]->hReco,"","Jet p_{T} (GeV/c)","dN_{jets} / dp_{T}");
uhist[i]->hReco->GetYaxis()->SetTitleOffset(1.3);
uhist[i]->hReco->GetXaxis()->SetTitleOffset(1.2);
uhist[i]->hGen->SetLineWidth(1);
uhist[i]->hGen->SetLineColor(1);
if(isMC)uhist[i]->hGen->Draw("hist same");
uhist[i]->hReco->Draw("same");
uhist[i]->hRecoBinByBin->SetMarkerStyle(28);
uhist[i]->hRecoBinByBin->SetMarkerColor(4);
uhist[i]->hRecoBinByBin->SetLineColor(4);
uhist[i]->hRecoBinByBin->Draw("same");
uhist[i]->hReco->SetAxisRange(60,300);
TH1F *hReproduced = (TH1F*)myUnfolding.hReproduced->Clone(Form("hReproduced_cent%d",i));
hReproduced->SetMarkerColor(4);
hReproduced->SetMarkerStyle(24);
uhist[i]->hMeas->Draw("same");
TLegend *leg = new TLegend(0.5,0.5,0.9,0.9);
leg->SetBorderSize(0);
leg->SetFillStyle(0);
leg->AddEntry(uhist[i]->hMeas,"Measured","pl");
leg->AddEntry(uhist[i]->hReco,"Bayesian unfolded","pl");
leg->AddEntry(uhist[i]->hRecoBinByBin,"Bin-by-bin unfolded","pl");
if(isMC)leg->AddEntry(uhist[i]->hGen,"Generator level truth","l");
leg->Draw();
}
cPbPb->Update();
// ======================= Unfolding closure in MC =========================================================
TCanvas * cRatio = new TCanvas("cRatio","Ratio",1200,600);
TH1F * hReco[nbins_cent+1];
TH1F * hRecoBinByBin[nbins_cent+1];
TH1F * hMeas[nbins_cent+1];
TH1F * hGen[nbins_cent+1];
TLegend *leg[nbins_cent+1];
TLine *line = new TLine(60,1,250,1);
line->SetLineStyle(2);
line->SetLineWidth(2);
for (int i=0;i<=nbins_cent;i++) {
hReco[i] = (TH1F*)uhist[i]->hReco->Clone(Form("hReco_Cen%d", i));
hRecoBinByBin[i] = (TH1F*)uhist[i]->hRecoBinByBin->Clone(Form("hRecoBinByBin_Cen%d", i));
hMeas[i] = (TH1F*)uhist[i]->hMeas->Clone(Form("hMeas_Cen%d", i));
if(isMC) hGen[i] = (TH1F*)uhist[i]->hGen->Clone(Form("hGen_Cen%d", i));
}
if(isMC){
cRatio->Divide(2,1);
for (int i=0;i<=nbins_cent;i++) {
hMeas[i]->Divide(hGen[i]);
hRecoBinByBin[i]->Divide(hGen[i]);
hReco[i]->Divide(hGen[i]);
cRatio->cd(i+1);
//hRecoPP->SetAxisRange(90,300,"X");
hReco[i]->SetAxisRange(0,2,"Y");
hReco[i]->SetMarkerStyle(24);
hReco[i] ->SetLineColor(2);
hReco[i] ->SetMarkerColor(2);
hMeas[i]->SetMarkerStyle(20);
hMeas[i]->SetLineColor(1);
hMeas[i]->SetMarkerColor(1);
hRecoBinByBin[i]->SetMarkerStyle(28);
hRecoBinByBin[i]->SetLineColor(4);
hRecoBinByBin[i]->SetMarkerColor(4);
makeHistTitle(hReco[i],"","Jet p_{T} (GeV/c)","Reco / Truth");
hReco[i]->GetYaxis()->SetTitleOffset(1.4);
hReco[i]->GetXaxis()->SetTitleOffset(1.2);
hReco[i]->Draw("");
hRecoBinByBin[i]->Draw("same");
hMeas[i]->Draw("same");
line->Draw();
leg[i] = myLegend(0.52,0.65,0.85,0.9);
leg[i]->AddEntry(hReco[i],"Bayesian","pl");
leg[i]->AddEntry(hRecoBinByBin[i],"Bin-by-bin","pl");
leg[i]->AddEntry(hMeas[i],"no unfolding","pl");
leg[i]->Draw();
putCMSPrel(0.2,0.83,0.06);
drawText("Anti-k_{T} Particle Flow Jets R = 0.3",0.2,0.23,20);
drawText("CMS Simulation",0.6,0.4,22);
drawText("| #eta | <2 ",0.6,0.31,22);
}
}
else {
hMeas[nbins_cent]->Scale(1./CorFac[6]/5.3e9);
hRecoBinByBin[nbins_cent]->Scale(1./CorFac[6]/5.3e9);
hReco[nbins_cent]->Scale(1./CorFac[6]/5.3e9);
cRatio->cd(1);
for (int i=0;i<nbins_cent;i++) {
hMeas[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]);
hRecoBinByBin[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]);
hReco[i] ->Scale(1./CorFac[i]/1.0908e9/TAA[i]);
hMeas[i]->Divide(hMeas[nbins_cent]);
hRecoBinByBin[i]->Divide(hRecoBinByBin[nbins_cent]);
hReco[i]->Divide(hReco[nbins_cent]);
hReco[i]->SetAxisRange(0,2,"Y");
hReco[i]->SetMarkerStyle(24);
hReco[i] ->SetLineColor(2);
hReco[i] ->SetMarkerColor(2);
hMeas[i]->SetMarkerStyle(20);
hMeas[i]->SetLineColor(1);
hMeas[i]->SetMarkerColor(1);
hRecoBinByBin[i]->SetMarkerStyle(28);
hRecoBinByBin[i]->SetLineColor(4);
hRecoBinByBin[i]->SetMarkerColor(4);
// if(i==0){
makeHistTitle(hReco[i],"","Jet p_{T} (GeV/c)","Spectra Ratio");
hReco[i]->GetYaxis()->SetTitleOffset(1.4);
hReco[i]->GetXaxis()->SetTitleOffset(1.2);
hReco[i]->Draw("");
leg[i] = myLegend(0.52,0.65,0.85,0.9);
leg[i]->AddEntry(hReco[i],"Bayesian","pl");
leg[i]->AddEntry(hRecoBinByBin[i],"Bin-by-bin","pl");
leg[i]->AddEntry(hMeas[i],"no unfolding","pl");
leg[i]->Draw();
// }
// else {
hReco[i]->Draw("same");
hRecoBinByBin[i]->Draw("same");
hMeas[i]->Draw("same");
// }
}
line->Draw();
putCMSPrel(0.2,0.83,0.06);
drawText(Form("#intL dt = %.f #mub^{-1}",150.),0.2,0.78,22);
drawText("Anti-k_{T} Particle Flow Jets R = 0.3",0.2,0.73,20);
drawText("| #eta | <2 ",0.6,0.69,22);
}
cRatio->Update();
pbpb_Unfo->Write();
SysData systematics;
// Iteration systematics
TCanvas *cIterSys = new TCanvas("cIterSys","IterSys",1200,600);
cIterSys->Divide(2,1);
cIterSys->cd(2);
TH1F *hRecoIterSysPP[100];
TH1F *hRebinPP_tmp = rebin(uhist[nbins_cent]->hReco, (char*)"hRebinPP_tmp");
TLegend *legBayesianIterPP = myLegend(0.4,0.7,0.9,0.9);
legBayesianIterPP->AddEntry("","PP","");
for (int j=2;j<7;j++) {
hRecoIterSysPP[j] = rebin(uhist[nbins_cent]->hRecoIterSys[j],Form("hRecoIterSysPP_IterSys%d",j));
hRecoIterSysPP[j]->SetLineColor(colorCode[j-2]);
hRecoIterSysPP[j]->SetMarkerColor(colorCode[j-2]);
hRecoIterSysPP[j]->Divide(hRebinPP_tmp);
if (j==2){
// makeHistTitle(hRecoIterSysPP[j],(char*)"",(char*)"Jet p_{T} (GeV/c)",(char*)"Ratio (Unfolded / Nominal)");
makeHistTitle(hRecoIterSysPP[j],"","Jet p_{T} (GeV/c)","Ratio (Unfolded / Nominal)");
hRecoIterSysPP[j]->SetTitleOffset(1.3,"Y");
hRecoIterSysPP[j]->SetTitleOffset(1.2,"X");
hRecoIterSysPP[j]->SetAxisRange(0,2,"Y");
hRecoIterSysPP[j]->Draw();
} else {
hRecoIterSysPP[j]->Draw("same");
}
checkMaximumSys(systematics.hSysIter[nbins_cent],hRecoIterSysPP[j],0,1.1);
legBayesianIterPP->AddEntry(hRecoIterSysPP[j],Form("Iteration %d",j),"pl");
}
legBayesianIterPP->Draw();
line->Draw();
drawEnvelope(systematics.hSysIter[nbins_cent],(char*)"hist same");
cIterSys->cd(1);
TH1F *hRecoIterSysPbPb[100];
TH1F *hRebinPbPb_tmp = rebin(uhist[0]->hReco, (char*)"hRebinPbPb_tmp");
TLegend *legBayesianIterPbPb = myLegend(0.4,0.7,0.9,0.9);
legBayesianIterPbPb->AddEntry("","PbPb","");
for (int j=2;j<7;j++) {
hRecoIterSysPbPb[j] = rebin(uhist[0]->hRecoIterSys[j],Form("hRecoIterSysPbPb_IterSys%d",j));
hRecoIterSysPbPb[j]->SetLineColor(colorCode[j-2]);
hRecoIterSysPbPb[j]->SetMarkerColor(colorCode[j-2]);
hRecoIterSysPbPb[j]->Divide(hRebinPbPb_tmp);
if (j==2){
// makeHistTitle(hRecoIterSysPbPb[j],(char*)"",(char*)"Jet p_{T} (GeV/c)",(char*)"Ratio (Unfolded / Nominal)");
makeHistTitle(hRecoIterSysPbPb[j],"","Jet p_{T} (GeV/c)","Ratio (Unfolded / Nominal)");
hRecoIterSysPbPb[j]->SetTitleOffset(1.3,"Y");
hRecoIterSysPbPb[j]->SetTitleOffset(1.2,"X");
hRecoIterSysPbPb[j]->SetAxisRange(0,2,"Y");
hRecoIterSysPbPb[j]->Draw();
} else {
hRecoIterSysPbPb[j]->Draw("same");
}
checkMaximumSys(systematics.hSysIter[0],hRecoIterSysPbPb[j],0,1.1);
legBayesianIterPbPb->AddEntry(hRecoIterSysPbPb[j],Form("Iteration %d",j),"pl");
}
legBayesianIterPbPb->Draw();
line->Draw();
drawEnvelope(systematics.hSysIter[0],(char*)"hist same");
cIterSys->Update();
TString data ;
if(isMC) data="MC";
else data="Data";
TString anaType ;
if(doBjets) anaType="Bjet";
else anaType="Inclusive";
if(SavePlot){
cMatrix->SaveAs(Form("plots/%s%s%sResponseMatrix.gif", data.Data(), anaType.Data(), algoName[algo]));
cPbPb->SaveAs(Form("plots/%s%s%sJetSpectra.gif", data.Data(), anaType.Data(), algoName[algo]));
cRatio->SaveAs(Form("plots/%s%s%sJetRatio.gif", data.Data(), anaType.Data(), algoName[algo]));
cIterSys->SaveAs(Form("plots/%s%s%sIterationSys.gif", data.Data(), anaType.Data(), algoName[algo]));
}
}
void Draw(const char* pairName, const char* canvasName, std::vector<CorrelationFunction> &plots, bool isIdentical)
{
unsigned int i, k;
int canvasNumber1 = -1, canvasNumber2 = 0;
TLegend *hHKMlegend, *EPOSlegend;
TCanvas *canv = new TCanvas(canvasName, canvasName, 1300, 2000);
if(isIdentical)
canv->Divide(2,4);
else
canv->Divide(2,5);
//
// hHKM
//
hHKMlegend = new TLegend(legendX1, legendY1, legendX2, legendY2);
k = 0;
canv->cd(++++canvasNumber1);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("hHKM") == 0)
{
DrawSinglePlot(plots[i].cf1D, (std::string(pairName) + std::string(" - hHKM - 1D;q_{inv} (GeV/c);C(q_{inv})")).c_str(), k);
SetRanges(plots[i].cf1D, canvasName, "1D");
hHKMlegend->AddEntry(plots[i].cf1D, plots[i].centrality.c_str(),"P");
}
if(plots.size() > 0)
{
hHKMlegend->Draw();
hHKMlegend->SetFillColor(0);
}
k = 0;
canv->cd(++++canvasNumber1);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("hHKM") == 0)
{
DrawSinglePlot(plots[i].cfSH00, (std::string(pairName) + std::string(" - hHKM - Spherical Harmonics;k* (GeV/c);#RgothicC^{0}_{0}")).c_str(), k);
SetRanges(plots[i].cfSH00, canvasName, "SH00");
}
if(!isIdentical)
{
k = 0;
canv->cd(++++canvasNumber1);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("hHKM") == 0)
{
DrawSinglePlot(plots[i].cfSH11, (std::string(pairName) + std::string(" - hHKM - Spherical Harmonics;k* (GeV/c);#RgothicC^{1}_{1}")).c_str(), k);
SetRanges(plots[i].cfSH11, canvasName, "SH11");
}
}
k = 0;
canv->cd(++++canvasNumber1);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("hHKM") == 0)
{
DrawSinglePlot(plots[i].cfSH20, (std::string(pairName) + std::string(" - hHKM - Spherical Harmonics;k* (GeV/c);#RgothicC^{0}_{2}")).c_str(), k);
SetRanges(plots[i].cfSH20, canvasName, "SH20");
}
k = 0;
canv->cd(++++canvasNumber1);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("hHKM") == 0)
{
DrawSinglePlot(plots[i].cfSH22, (std::string(pairName) + std::string(" - hHKM - Spherical Harmonics;k* (GeV/c);#RgothicC^{2}_{2}")).c_str(), k);
SetRanges(plots[i].cfSH22, canvasName, "SH22");
}
//
// EPOS
//
EPOSlegend = new TLegend(legendX1, legendY1, legendX2, legendY2);
k = 0;
canv->cd(++++canvasNumber2);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("EPOS") == 0)
{
DrawSinglePlot(plots[i].cf1D, (std::string(pairName) + std::string(" - EPOS - 1D;q_{inv} (GeV/c);C(q_{inv})")).c_str(), k);
SetRanges(plots[i].cf1D, canvasName, "1D");
EPOSlegend->AddEntry(plots[i].cf1D, plots[i].centrality.c_str(),"P");
}
if(plots.size() > 0)
{
EPOSlegend->Draw();
EPOSlegend->SetFillColor(0);
}
k = 0;
canv->cd(++++canvasNumber2);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("EPOS") == 0)
{
DrawSinglePlot(plots[i].cfSH00, (std::string(pairName) + std::string(" - EPOS - Spherical Harmonics;k* (GeV/c);#RgothicC^{0}_{0}")).c_str(), k);
SetRanges(plots[i].cfSH00, canvasName, "SH00");
}
if(!isIdentical)
{
k = 0;
canv->cd(++++canvasNumber2);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("EPOS") == 0)
{
DrawSinglePlot(plots[i].cfSH11, (std::string(pairName) + std::string(" - EPOS - Spherical Harmonics;k* (GeV/c);#RgothicC^{1}_{1}")).c_str(), k);
SetRanges(plots[i].cfSH11, canvasName, "SH11");
}
}
k = 0;
canv->cd(++++canvasNumber2);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("EPOS") == 0)
{
DrawSinglePlot(plots[i].cfSH20, (std::string(pairName) + std::string(" - EPOS - Spherical Harmonics;k* (GeV/c);#RgothicC^{0}_{2}")).c_str(), k);
SetRanges(plots[i].cfSH20, canvasName, "SH20");
}
k = 0;
canv->cd(++++canvasNumber2);
for(i = 0 ; i < plots.size(); ++i)
if(plots[i].model.compare("EPOS") == 0)
{
DrawSinglePlot(plots[i].cfSH22, (std::string(pairName) + std::string(" - EPOS - Spherical Harmonics;k* (GeV/c);#RgothicC^{2}_{2}")).c_str(), k);
SetRanges(plots[i].cfSH22, canvasName, "SH22");
}
canv->SaveAs((std::string(canvasName)+std::string(".eps")).c_str());
canv->SaveAs((std::string(canvasName)+std::string(".png")).c_str());
canv->SaveAs((std::string(canvasName)+std::string(".root")).c_str());
}
void pythia6_gammagamma_leptons( int Nevts = 25000, double sqrts = 90, int MSTP14_val=10)
{
//Luminosity and bunches definitions according to FCC-ee project specifications
Double_t Luminosity=1;
Double_t Luminosity_c=1; //with opt crab waist
Double_t FCC_Circumference = 100000; // meters
Double_t speed_of_light = 299792458; // m/s
Int_t N_bunch = 1; //number of bunches per beam
Int_t N_bunch_c= 1;//with opt Crab waist
if (sqrts==90){
N_bunch = 16700;
Luminosity = 0.28; //pb^-1 s^-1
N_bunch_c = 59581;
Luminosity_c = 2.15;
}
else if (sqrts==160){
N_bunch = 4490;
Luminosity = 0.12; //pb^-1 s^-1
N_bunch_c =3143;
Luminosity_c =0.38;
}
else if (sqrts==240){
N_bunch = 1360;
Luminosity = 0.06; //pb^-1 s^-1
N_bunch_c = 625;
Luminosity_c = 0.087;
}
else if (sqrts==350){
N_bunch = 98;
Luminosity = 0.0018; //pb^-1 s^-1
N_bunch_c = 68;
Luminosity_c = 0.021;
}
// Instance of the Pythia event generator
TPythia6* pythia = new TPythia6();
PDG = TDatabasePDG::Instance(); // TDataBasePDG contains info on all particle properties
// Random seeding
int seed = (int)(time(NULL)/3);
if( (seed>=0) && (seed<=900000000) ) {
pythia->SetMRPY(1,seed); // set seed
pythia->SetMRPY(2,0); // use new seed
cout << endl << "<I> Random Seed : " << seed << endl;
}
else{
cout << endl << "<I> Default random seed ... "<< seed << endl;
}
//____________________________________________________________________
//
// PYTHIA GENERATION SETTINGS
//____________________________________________________________________
// *******************************************************************
// PHYSICS PROCESS SELECTION
pythia->SetMSEL(0); // we choose the process by hand below
pythia->SetMSTP(81, 1); // Multiple parton interactions for resolved gamma-gamma colls.
// *******************************************************************
// Final-state:
pythia->SetMSTJ(22,2); //! Decay those unstable particles',
pythia->SetPARJ(71,10.); //! for which ctau < 10 mm',
// *******************************************************************
// Detailed process selection
pythia->SetMSTP(14,MSTP14_val); // gamma gamma -> hadrons (30=FULL)
//pythia->SetMSEL(2); // min-bias QCD
pythia->SetMSEL(1); //less accuracy in hadronic simulation but faster(usefull if intereted in leptonic)
// ******************************************************************
book_histos();
// ******************************************************************
// Initialise it to run e+/e- --> gamma gamma --> X
pythia->Initialize("cms", "gamma/e+", "gamma/e-", sqrts);
//pythia->Initialize("cms", "e+", "e-", sqrts);
cout << "SYSTEM: e+e- at sqrt(s)=" << sqrts << " GeV" << endl;
TClonesArray* particlesArray = 0;
// ******************************************************************
// EVENT LOOP
int exclEvts = 0;
std::ofstream myfile;
myfile.open("_txt/generation_time.txt");
int execution_time[Nevts/1000];
Int_t n_lepton_total=0; //counter for the total number of charged leptons (sum on the events)
for (int ievt = 0; ievt < Nevts; ievt++) {
if (ievt ==0) cout << "Generating event #: " << flush;
if (ievt % 1000 == 0) {
cout << ievt << " " << flush;
execution_time[ievt/1000]=time(NULL);
if (ievt !=0)
myfile << execution_time[ievt/1000] << "\t" << ievt << "\t" << 1000/(float)(execution_time[ievt/1000]-execution_time[ievt/1000 -1])<< endl;
}
// ******************************************************************
// Generate event
pythia->GenerateEvent();
// ***********************************************************************************************
// Check if event passes trigger selection
//
// if (debug) cout << "############ EVENT " << ievt << " #############" << endl;
// dumpEvent( pythia );
if ( passEvtSelection(pythia)==false ) { ///Cut on W!!!!!!!!!!!!!!!
exclEvts++;
continue;
}
// Loop over particles and fill histos
particlesArray = (TClonesArray*)pythia->GetListOfParticles();
int N = particlesArray->GetEntriesFast();
//cout << "<I> PYTHIA particles in event: " << N << " " << flush;
TMCParticle *part;
TParticle *partic;
Int_t n_leptons = 0;
for (int ip = 0; ip < N; ip++ ) {
part = (TMCParticle*)particlesArray->At(ip);
int status = part->GetKS();
if (status!=1) continue; // Only consider final-state particles
int pdg = part->GetKF();
double charge = PDG->GetParticle(pdg)->Charge();
if(charge==0) continue; // only charged particles
if ( abs(pdg)!=11 && abs(pdg)!=13 && abs(pdg)!=15) continue;// only leptons
partic = (TParticle*)TMCParticle2TParticle(part);
double ptPartic = partic->Pt();
double etaPartic = partic->Eta();
//phiPartic = partic->Phi();
//if ( ptPartic<0.15 ) continue; //cut on Pt!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
//if (abs(etaPartic)>1.5) continue; //Fill only if |eta|<1.5!!!!!!!!!!!!!!!!!!!!!
// Histo filling
h_id_part->Fill(abs(pdg));
hdsigmadeta->Fill(etaPartic);
hdsigmadpT->Fill(ptPartic);
n_leptons++; //Count the total number of charged hadrons in this event
delete partic;
// if (TMath::Abs(etaPartic)<1.) Nch++;
} // End loop over all particles in event
h_lep_per_ev->Fill(n_leptons);
n_lepton_total += n_leptons;
} // END EVENT GENERATION LOOP
myfile.close();
// **********************************************************************************
// FINAL GENERATION MESSAGES:
pythia->Pystat(1);
double xsection = pythia->GetPARI(1) * 1e9;//conversion form mb to pb
int ntrials = pythia->GetMSTI(5);
double sigmaweight = xsection/ntrials;
double total_lepton_xsection = sigmaweight*n_lepton_total;
cout << endl << "#######################" << endl
<< endl << "<I> Event summary: " << Nevts << " generated." << endl ;
//double evts = hdsigmadeta->Integral();
double triggEff = (Nevts-exclEvts)/(float)Nevts;
cout << "<I> Num. of total valid events = " << Nevts-exclEvts << " (Effic="<< triggEff*100. << "%)" << endl;
cout << "<I> Pythia cross section: " << xsection << " mb || number of trials: " << ntrials << " || sigmaweight = "<< sigmaweight <<endl;
cout << endl << "Hadrons per events: " << endl << "Mean = " << h_lep_per_ev->GetMean() << endl << "Max = " << h_lep_per_ev->GetMaximumBin() <<endl;
cout << endl << endl << endl << "Total number of leptons = " << n_lepton_total << endl;
cout << "Cross section = " << total_lepton_xsection << "pb in e+e- --> gamma gamma --> X at sqrt(s) = " << sqrts << " GeV " << endl << endl << endl;
Double_t N_rate = total_lepton_xsection*Luminosity;
Double_t Pileup = (N_rate*FCC_Circumference)/(N_bunch*speed_of_light);
Double_t N_rate_c = total_lepton_xsection*Luminosity_c;
Double_t Pileup_c = (N_rate_c*FCC_Circumference)/(N_bunch_c*speed_of_light);
ofstream file_out;
char file_out_name[150];
sprintf(file_out_name, "_txt/pythia6_gammagamma_leptons_%iGeV_seed%d_Nevts%d_output.txt",(int)TMath::Ceil(sqrts),seed,Nevts);
file_out.open(file_out_name);
file_out << Nevts-exclEvts << " // Total event generated" << endl;
file_out << xsection << " // [pb] Pythia6 total cross section" << endl;
file_out << total_lepton_xsection << " // [pb] Cross section for e+e- --> gamma gamma --> l"<< endl;
file_out << sqrts << " // [GeV] sqrt(s)" << endl;
file_out << n_lepton_total <<" // Total Lepton produced" << endl;
file_out << N_rate << " // [Hz] Production Rate (Sigma*Lum)" << endl;
file_out << N_rate_c << " // [Hz] Production Rate (Sigma*Lum) (Crab waist)" << endl << endl << endl;
file_out << Pileup << " // Interactions e/gamma e/gamma -> l per bunch" << endl;
file_out << Pileup_c << " // Interactions e/gamma e/gamma -> l per bunch (Crab Waist)" << endl;
file_out.close();
// double dNchdeta = hdsigmadeta->GetBinContent(11)/ntrials;
// cout << "<I> dN_ch/deta|_{eta=0} = " << dNchdeta << " in e+e- --> gamma gamma --> X at sqrt(s) = " << sqrts << " GeV " << endl ;
// **********************************************************************************
// Normalize histos by weighted cross-section, pseudorapidity range, and the pT bin size
hdNdeta=(TH1F*)hdsigmadeta->Clone("hdNdeta");
hdNdeta->Scale(1./(float)Nevts);
hdNdeta->SetTitle("hdNdeta");
hdNdeta->SetXTitle("|#eta|");
hdNdeta->SetYTitle("dN/d|#eta| (nb)");
double etabinsize = 20/20; // eta binning: 20 within -10<eta<10
hdsigmadeta->Scale(1e-3*sigmaweight/etabinsize);
//hdsigmadeta->Scale(1/Nevts);
double ptbinsize = (pt_max-pt_min)/n_bin_pt;
hdsigmadpT->Scale(sigmaweight/ptbinsize);
//hdsigmadetaTruth->Scale(sigmaweight*0.01); // eta binning: 2000 in -10<eta<10
//hEdsigmadpT->Scale(ptbinsize/ntrials);
//ntFFdsigmadeta->SetWeight(sigmaweight);
// **********************************************************************************
// Plot distributions for cross-check
char title[300];
sprintf(title, "cinvdsigmadpT_%iGeV",(int)sqrts);
TCanvas *cinvdsigmadpT = new TCanvas(title,title,700,600);
cinvdsigmadpT->SetLogy();
cinvdsigmadpT->SetLogx();
cinvdsigmadpT->cd();
hdsigmadpT->Draw();
cinvdsigmadpT->SaveAs("_png/histo_hdsigmadpT.png");
sprintf(title, "cinvdsigmadeta_%iGeV",(int)sqrts);
TCanvas *cinvdsigmadeta = new TCanvas(title,title,700,600);
cinvdsigmadeta->cd();
hdsigmadeta->Draw();
cinvdsigmadeta->SaveAs("_png/histo_hdsigmadeta.png");
sprintf(title, "cinvdNdeta_%iGeV",(int)sqrts);
TCanvas *cinvdNdeta = new TCanvas(title,title,700,600);
cinvdNdeta->cd();
hdNdeta->Draw();
cinvdNdeta->SaveAs("_png/histo_hdNdeta.png");
// sprintf(title, "cinvW_%iGeV",(int)sqrts);
// TCanvas *cinvW = new TCanvas(title,title,700,600);
// cinvW->cd();
// hW->Draw();
// cinvW->SaveAs("_png/histo_hW.png");
sprintf(title, "cinvn_had_%iGeV",(int)sqrts);
TCanvas *cinvn_had = new TCanvas(title,title,700,600);
cinvn_had->cd();
h_lep_per_ev->Draw();
cinvn_had->SaveAs("_png/histo_charged_leptons_per_ev.png");
// sprintf(title, "cinvp_id_%iGeV",(int)sqrts);
// TCanvas *cinvp_id = new TCanvas(title,title,700,600);
// cinvp_id->cd();
// cinvp_id->SetLogy();
// h_id_part->Draw();
// cinvp_id->SaveAs("_png/histo_particle_id.png");
// **********************************************************************************
// Open output file and Close file
char filename[200];
sprintf(filename, "_root/pythia6_gammagamma_leptons_%iGeV_seed%d_Nevts%d.root",(int)TMath::Ceil(sqrts),seed,Nevts);
TFile* file = TFile::Open(filename, "RECREATE");
if (!file || !file->IsOpen()) {
Error("pythia6_gammagamma_leptons", "Couldn;t open file %s", filename);
return;
}
file->cd();
hdsigmadeta->Write();
hdsigmadpT->Write();
hdNdeta->Write();
h_lep_per_ev->Write();
hW->Write();
h_id_part->Write();
file->Close();
cout << endl << "#######<I> File " << filename << " created. Take a look ... ##############" << endl << endl;
file = TFile::Open(filename);
file->ls();
file->Close();
}
int main(){
/*Toy Model with following True parameters
Guess 20 events in Lb->pketa' (1)
and 15 events in Lb->pketa'->pipieta (2)
Lb Efficiencies=0.0002637
B+ Efficiency=0.000411 (3)
B(eta'->pi pi g)=0.291
B(eta'->pi pi eta)=0.16
fd/fL= 2.5
*/
int GenRare=40;
int GenRare2=30;
int GenControl=11000;
RooRealVar Mode2EfficiencyRatio("Mode2EfficiencyRatio","Mode2EfficiencyRatio",1.558589);
RooRealVar ModeEfficiencyRatio("ModeEfficiencyRatio","ModeEfficiencyRatio",1.558589);
RooRealVar SubBRRatio("SubBRRatio","SubBRRatio",0.645);
RooRealVar fdFl("fdFl","fdFl",2.5);
RooRealVar YieldRatio("YieldRatio","YieldRatio",0.1,0.000001,1.0);
RooRealVar YieldRatio2("YieldRatio2","YieldRatio2",0.1,0.000001,1.0);
//RooFormulaVar ObservableBFRatio("ObservableBFRatio","ObservableBFRatio","((@0*@1)+(@2*@3))*@4*@5",RooArgSet(YieldRatio,ModeEfficiencyRatio,YieldRatio2,Mode2EfficiencyRatio,SubBRRatio,fdFl));
RooRealVar ObservableBFRatio("ObservableBFRatio","ObservableBFRatio",0.5,0.00000001,10.0);
// RooRealVar ControlYield("ControlYield","ControlYield",10000.0,0.0,20000.0);
//RooRealVar RareYield("RareYield","RareYield",30.0,0.0,1100.0);
//RooFormulaVar RareArg("RareArg","RareArg","@1*@2",RooArgSet(ControlYield,YieldRatio));
RooRealVar ControlMean("ControlMean","ControlMean",5279.0,5200.0,5350.0);
RooRealVar SigmaCorrection("SigmaCorrection","SigmaCorrection",1.1,0.9,1.8);
RooRealVar LambdaMass("LambdaMass","LambdaMass",5000,6200.0);
// RooRealVar RareMean("RareMean","RareMean",5619.0,5600.0,5650.0);
RooFormulaVar RareMean("RareMean","RareMean","@0+339.72",RooArgSet(ControlMean));
RooRealVar MCRareSigma("MCRareSigma","MCRareSigma",25.0);
// RooRealVar RareSigma("RareSigma","RareSigma",29.0,20.0,40.0);
RooFormulaVar RareSigma("RareSigma","RareSigma","@0*@1",RooArgSet(MCRareSigma,SigmaCorrection));
RooGaussian RareMode("RareMode","RareMode",LambdaMass,RareMean,RareSigma);
RooRealVar K("K","K",-0.003,-0.010,-0.001);
RooExponential RareBkg("RareBkg","RareBkg",LambdaMass,K);
RooRealVar RareBkgYield("RareBkgYield","RareBkgYield",1000.0,0.0,2000.0);
RooExtendPdf ExtRareBkg("ExtRareBkg","ExtRareBkg",RareBkg,RareBkgYield);
// RooFormulaVar RareYield("RareYield","RareYield","@0*@1",RooArgSet(ControlYield,YieldRatio));
RooRealVar RareYield("RareYield","RareYield",1.0,0.0,600.0);
RooExtendPdf ExtRareSig("ExtRareSig","ExtRareSig",RareMode,RareYield);
RooAddPdf ExtRare("ExtRare","ExtRare",RooArgSet(ExtRareSig,ExtRareBkg));
RooDataSet* RareSigData=RareMode.generate(RooArgSet(LambdaMass),GenRare);
RooDataSet* RareBkgData=RareBkg.generate(RooArgSet(LambdaMass),500);
RooDataSet* RareData= new RooDataSet(*RareSigData,"RareData");
RareData->append(*RareBkgData);
RooRealVar MCRare2Sigma("MCRare2Sigma","MCRare2Sigma",17.0);
//RooRealVar Rare2Sigma("Rare2Sigma","Rare2Sigma",20.0,10.0,30.0);
RooFormulaVar Rare2Sigma("Rare2Sigma","Rare2Sigma","@0*@1",RooArgSet(MCRare2Sigma,SigmaCorrection));
RooGaussian RareMode2("RareMode2","RareMode2",LambdaMass,RareMean,Rare2Sigma);
RooDataSet* RareData2=RareMode2.generate(RooArgSet(LambdaMass),GenRare2);
//RooFormulaVar RareYield2("RareYield2","RareYield2","@0*@1",RooArgSet(ControlYield,YieldRatio2));
//RooFormulaVar RareYield2("RareYield2","RareYield2","(ControlYield*(1/Mode2EfficiencyRatio))*((ObservableBFRatio/(SubBRRatio*fdFl))-(YieldRatio*ModeEfficiencyRatio))",RooArgSet(ControlYield,Mode2EfficiencyRatio,ObservableBFRatio,SubBRRatio,fdFl,YieldRatio,ModeEfficiencyRatio));
RooRealVar RareYield2("RareYield2","RareYield2",1.0,0.0,100.0);
RooExtendPdf ExtRare2("ExtRare2","ExtRare2",RareMode2,RareYield2);
RooRealVar BMass("BMass","BMass",5000.0,5500.0);
// RooFormulaVar ControlMean("ControlMean","ControlMean","@0-339.72",RooArgSet(RareMean));
RooRealVar MCControlSigma("MCControlSigma","MCControlSigma",17.0);
RooFormulaVar ControlSigma("ControlSigma","ControlSigma","@0*@1",RooArgSet(MCControlSigma,SigmaCorrection));
//RooRealVar ControlSigma("ControlSigma","ControlSigma",20.0,10.0,40.0);
RooGaussian ControlMode("ControlMode","ControlMode",BMass,ControlMean,ControlSigma);
RooFormulaVar ControlYield("ControlYield","ControlYield","(1/ObservableBFRatio)*((ModeEfficiencyRatio*RareYield)+(Mode2EfficiencyRatio*RareYield2))*SubBRRatio*fdFl",RooArgSet(ObservableBFRatio,ModeEfficiencyRatio,RareYield,Mode2EfficiencyRatio,RareYield2,SubBRRatio,fdFl));
RooExtendPdf ExtControl("ExtControl","ExtControl",ControlMode,ControlYield);
RooDataSet* ControlData=ControlMode.generate(RooArgSet(BMass),GenControl);
RooCategory Mode("Mode","Mode");
Mode.defineType("Rare");
Mode.defineType("Rare2");
Mode.defineType("Control");
RooDataSet CombData("CombData","CombData",RooArgSet(BMass,LambdaMass),Index(Mode),Import("Rare2",*RareData2),Import("Rare",*RareData),Import("Control",*ControlData));
RooSimultaneous SimPdf("SimPdf","SimPdf",Mode);
SimPdf.addPdf(ExtRare,"Rare");
SimPdf.addPdf(ExtRare2,"Rare2");
SimPdf.addPdf(ExtControl,"Control");
RooFitResult* SimResult=SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));
/* double FreeYield=-1*SimResult->minNll();
std::cout<<"With free yield = "<<SimResult->minNll()<<std::endl;
RareYield.setVal(0);
RareYield.setConstant(kTRUE);
RooFitResult* Rare1Fixed=SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));
double NullYield=-1*Rare1Fixed->minNll();
std::cout<<"With not free yield = "<<Rare1Fixed->minNll()<<std::endl;
double DeltaLogLikelihood=NullYield-FreeYield;
std::cout<<"DeltaNll= "<<DeltaLogLikelihood<<std::endl;
double Significance=TMath::Sqrt(-2*DeltaLogLikelihood);
std::cout<<"Significance= "<<Significance<<std::endl;
SimPdf.fitTo(CombData,Save(kTRUE),Minos(kTRUE));*/
RooPlot* BFrame= BMass.frame(Bins(50),Title("B Mass"),Range(5200.0,5400.0));
ControlData->plotOn(BFrame);
ControlMode.plotOn(BFrame);
RooPlot* LambdaFrame = LambdaMass.frame(Bins(50),Title("Lambda mass"),Range(5200.0,6100.0));
RareData->plotOn(LambdaFrame);
ExtRare.plotOn(LambdaFrame);
RooPlot* LambdaFrame2 = LambdaMass.frame(Bins(50),Title("Lambda mass"),Range(5200.0,6100.0));
RareData2->plotOn(LambdaFrame2);
RareMode2.plotOn(LambdaFrame2);
TCanvas BCanvas;
BFrame->Draw();
BCanvas.SaveAs("BCanvas.pdf");
TCanvas LambdaCanvas;
LambdaFrame->Draw();
LambdaCanvas.SaveAs("LambdaCanvas.pdf");
TCanvas LambdaCanvas2;
LambdaFrame2->Draw();
LambdaCanvas2.SaveAs("LambdaCanvas2.pdf");
SimResult->Print("v");
// S imPdf.graphVizTree("model.dot");
std::cout<<"Real Ratio = "<<GenRare/(double)GenControl<<std::endl;
ObservableBFRatio.Print("v");
std::cout<<"Lb BF = "<<ObservableBFRatio.getVal()*7.06E-5<<" + "<<ObservableBFRatio.getErrorHi()*7.06E-5<<" - "<<ObservableBFRatio.getErrorLo()*7.06E-5<<std::endl;
//________________________________________________ATTEMPT TO SWEIGHT____________________________________________
RooStats::SPlot* sDataMass = new RooStats::SPlot("sData","An SPlot",*RareData,&ExtRare,RooArgList(RareYield,RareBkgYield));
std::cout << std::endl << "Yield of signal is " << RareYield.getVal() << ". From sWeights it is " << sDataMass->GetYieldFromSWeight("RareYield") << std::endl;
std::cout << "Yield of background is " << RareBkgYield.getVal() << ". From sWeights it is " << sDataMass->GetYieldFromSWeight("RareBkgYield") << std::endl << std::endl;
RooAbsReal* nll = SimPdf.createNLL(CombData);
RooMinuit(*nll).migrad();
RooPlot* LLFrame=ObservableBFRatio.frame(Title("Some Title"),Range(0.005,0.03));
nll->plotOn(LLFrame,ShiftToZero());
LLFrame->GetYaxis()->SetRangeUser(0.0,1000.0);
TCanvas LLCanvas;
LLFrame->Draw();
LLCanvas.SaveAs("LLCanvas.pdf");
}
void ElectronTagAndProbeMC(const string dataInputFilename, const string Label,
Int_t ChargeSelection = 0) {
gBenchmark->Start("ElectronTagAndProbe");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
string label = Label;
if (Label != "") label = "_" + label;
Double_t lumi; // luminosity (pb^-1)
//********************************************************
// Define Bins
//********************************************************
vector<string> ptbinLabel;
vector<Double_t> ptbinLowEdge;
vector<Double_t> ptbinUpEdge;
ptbinLabel.push_back("Pt20ToInf"); ptbinLowEdge.push_back(20.0); ptbinUpEdge.push_back(14000.0);
// ptbinLabel.push_back("Pt10To15"); ptbinLowEdge.push_back(10.0); ptbinUpEdge.push_back(15.0);
// ptbinLabel.push_back("Pt15To20"); ptbinLowEdge.push_back(15.0); ptbinUpEdge.push_back(20.0);
// ptbinLabel.push_back("Pt20To30"); ptbinLowEdge.push_back(20.0); ptbinUpEdge.push_back(30.0);
// ptbinLabel.push_back("Pt30To40"); ptbinLowEdge.push_back(30.0); ptbinUpEdge.push_back(40.0);
// ptbinLabel.push_back("Pt40To50"); ptbinLowEdge.push_back(40.0); ptbinUpEdge.push_back(50.0);
// ptbinLabel.push_back("Pt50ToInf"); ptbinLowEdge.push_back(50.0); ptbinUpEdge.push_back(14000.0);
vector<string> etabinLabel;
vector<Double_t> etabinLowEdge;
vector<Double_t> etabinUpEdge;
etabinLabel.push_back("EE"); etabinLowEdge.push_back(1.5); etabinUpEdge.push_back(2.5);
etabinLabel.push_back("EB"); etabinLowEdge.push_back(0); etabinUpEdge.push_back(1.5);
vector<string> chargebinLabel;
vector<Double_t> chargeSelection;
chargebinLabel.push_back("All"); chargeSelection.push_back(0);
chargebinLabel.push_back("Plus"); chargeSelection.push_back(1);
chargebinLabel.push_back("Minus"); chargeSelection.push_back(-1);
vector<vector<vector<Double_t> > > EventCount_TagPlusRecoFailWWTightIdIso_binned;
vector<vector<vector<Double_t> > > EventCount_TagPlusRecoPassWWTightIdIso_binned;
vector<vector<vector<Double_t> > > EventCount_TagPlusWWTightIdIsoPassHLT_binned;
vector<vector<vector<Double_t> > > EventCount_TagPlusWWTightIdIsoFailHLT_binned;
for (int k=0; k < chargebinLabel.size(); ++k) {
vector<vector<Double_t> > tmp_tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned;
vector<vector<Double_t> > tmp_tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned;
vector<vector<Double_t> > tmp_tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned;
vector<vector<Double_t> > tmp_tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned;
for (int i=0; i < etabinLabel.size(); ++i) {
vector<Double_t> tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned;
vector<Double_t> tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned;
vector<Double_t> tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned;
vector<Double_t> tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned;
for (int j=0; j < ptbinLabel.size(); ++j) {
Double_t tmp_EventCount_TagPlusRecoFailWWTightIdIso = 0;
tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned.push_back(tmp_EventCount_TagPlusRecoFailWWTightIdIso);
Double_t tmp_EventCount_TagPlusRecoPassWWTightIdIso = 0;
tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned.push_back(tmp_EventCount_TagPlusRecoPassWWTightIdIso);
Double_t tmp_EventCount_TagPlusWWTightIdIsoFailHLT = 0;
tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned.push_back(tmp_EventCount_TagPlusWWTightIdIsoFailHLT);
Double_t tmp_EventCount_TagPlusWWTightIdIsoPassHLT = 0;
tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned.push_back(tmp_EventCount_TagPlusWWTightIdIsoPassHLT);
cout << "make bins : " << k << " " << i << " " << j << " " << endl;
}
tmp_tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned.push_back(tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned);
tmp_tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned.push_back(tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned);
tmp_tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned.push_back(tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned);
tmp_tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned.push_back(tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned);
}
EventCount_TagPlusRecoFailWWTightIdIso_binned.push_back(tmp_tmp_EventCount_TagPlusRecoFailWWTightIdIso_binned);
EventCount_TagPlusRecoPassWWTightIdIso_binned.push_back(tmp_tmp_EventCount_TagPlusRecoPassWWTightIdIso_binned);
EventCount_TagPlusWWTightIdIsoPassHLT_binned.push_back(tmp_tmp_EventCount_TagPlusWWTightIdIsoPassHLT_binned);
EventCount_TagPlusWWTightIdIsoFailHLT_binned.push_back(tmp_tmp_EventCount_TagPlusWWTightIdIsoFailHLT_binned);
}
//--------------------------------------------------------------------------------------------------------------
// Histograms
//==============================================================================================================
Double_t EventCount_TagPlusRecoFailWWTightIdIso = 0;
Double_t EventCount_TagPlusRecoPassWWTightIdIso = 0;
Double_t EventCount_TagPlusWWTightIdIsoFailHLT = 0;
Double_t EventCount_TagPlusWWTightIdIsoPassHLT = 0;
Int_t nbins = 20;
TH1F *histogram = new TH1F ("histogram", "; xaxis; yaxis; ", 100, 0 , 200);
TH1F *ProbePt = new TH1F ("ProbePt", "; xaxis; yaxis; ", 100, 0 , 200);
TH1F *TagPt = new TH1F ("TagPt", "; xaxis; yaxis; ", 100, 0 , 200);
TH1F *TagPlusRecoFailWWTightIdIso = new TH1F ("TagPlusRecoFailWWTightIdIso", "; xaxis; yaxis; ", nbins, 60 , 120);
TH1F *TagPlusRecoPassWWTightIdIso = new TH1F ("TagPlusRecoPassWWTightIdIso", "; xaxis; yaxis; ", nbins, 60 , 120);
TH1F *TagPlusWWTightIdIsoFailHLT = new TH1F ("TagPlusWWTightIdIsoFailHLT", "; xaxis; yaxis; ", nbins, 60 , 120);
TH1F *TagPlusWWTightIdIsoPassHLT = new TH1F ("TagPlusWWTightIdIsoPassHLT", "; xaxis; yaxis; ", nbins, 60 , 120);
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
//
// Access samples and fill histograms
//
TFile *infile=0;
TTree *eventTree=0;
// Data structures to store info from TTrees
mithep::TEventInfo *info = new mithep::TEventInfo();
TClonesArray *electronArr = new TClonesArray("mithep::TElectron");
//********************************************************
// Get Tree
//********************************************************
eventTree = getTreeFromFile(dataInputFilename.c_str(),"Events");
// Set branch address to structures that will store the info
eventTree->SetBranchAddress("Info", &info); TBranch *infoBr = eventTree->GetBranch("Info");
eventTree->SetBranchAddress("Electron", &electronArr); TBranch *electronBr = eventTree->GetBranch("Electron");
//*****************************************************************************************
//Loop over Data Tree
//*****************************************************************************************
Double_t nsel=0, nselvar=0;
for(UInt_t ientry=0; ientry<eventTree->GetEntries(); ientry++) {
infoBr->GetEntry(ientry);
if (ientry % 100000 == 0) cout << "Event " << ientry << endl;
//********************************************************
// Load the branches
//********************************************************
electronArr->Clear();
electronBr->GetEntry(ientry);
//********************************************************
// TcMet
//********************************************************
TVector3 met;
if(info->tcMEx!=0 || info->tcMEy!=0) {
met.SetXYZ(info->tcMEx, info->tcMEy, 0);
}
//******************************************************************************
//dilepton preselection
//******************************************************************************
if (electronArr->GetEntries() < 2) continue;
//******************************************************************************
//loop over electron pairs
//******************************************************************************
for(Int_t i=0; i<electronArr->GetEntries(); i++) {
const mithep::TElectron *tag = (mithep::TElectron*)((*electronArr)[i]);
if ( !(
fabs(tag->eta) < 2.5
&&
tag->pt > 20.0
&&
passElectronTagCuts(tag)
)
) continue;
for(Int_t j=0; j<electronArr->GetEntries(); j++) {
if (i==j) continue;
const mithep::TElectron *probe = (mithep::TElectron*)((*electronArr)[j]);
if ( !(
fabs(probe->eta) < 2.5
&& probe->pt > 10.0
&& probe->isEcalDriven
)
) continue;
mithep::FourVectorM tagVector;
mithep::FourVectorM probeVector;
tagVector.SetCoordinates(tag->pt, tag->eta, tag->phi, 0.51099892e-3 );
probeVector.SetCoordinates(probe->pt, probe->eta, probe->phi, 0.51099892e-3 );
mithep::FourVectorM dilepton = tagVector+probeVector;
if (dilepton.M() > 60 && dilepton.M() < 120
) {
//For binned efficiencies
for (int q=0; q < chargebinLabel.size(); ++q) {
for (int e=0; e < etabinLabel.size(); ++e) {
for (int p=0; p < ptbinLabel.size(); ++p) {
//Require the probe is in the right pt and eta bin
if (
(probe->pt >= ptbinLowEdge[p] && probe->pt < ptbinUpEdge[p])
&&
(fabs(probe->eta) >= etabinLowEdge[e] && fabs(probe->eta) < etabinUpEdge[e])
&&
(probe->q == chargeSelection[q] || chargeSelection[q] == 0)
// &&
// met.Pt() < 20.0
) {
//*****************************************************************************************************
//Reco -> WWTight
//*****************************************************************************************************
if (passElectronCuts(probe)) {
EventCount_TagPlusRecoPassWWTightIdIso_binned[q][e][p]++;
} else {
EventCount_TagPlusRecoFailWWTightIdIso_binned[q][e][p]++;
}
//*****************************************************************************************************
//WWTight -> HLT
//*****************************************************************************************************
if (passElectronCuts(probe)) {
if (passHLT(probe, info->runNum)) {
EventCount_TagPlusWWTightIdIsoPassHLT_binned[q][e][p]++;
} else {
EventCount_TagPlusWWTightIdIsoFailHLT_binned[q][e][p]++;
}
}
}
}
}
}
//*****************************************************************************************************
//Reco -> WWTight
//*****************************************************************************************************
if (passElectronCuts(probe)) {
EventCount_TagPlusRecoPassWWTightIdIso++;
TagPlusRecoPassWWTightIdIso->Fill(dilepton.M());
} else {
EventCount_TagPlusRecoFailWWTightIdIso++;
TagPlusRecoFailWWTightIdIso->Fill(dilepton.M());
}
//*****************************************************************************************************
//WWTight -> HLT
//*****************************************************************************************************
if (passElectronCuts(probe)) {
if (passHLT(probe, info->runNum)) {
EventCount_TagPlusWWTightIdIsoPassHLT++;
TagPlusWWTightIdIsoPassHLT->Fill(dilepton.M());
ProbePt->Fill(probe->pt);
} else {
EventCount_TagPlusWWTightIdIsoFailHLT++;
TagPlusWWTightIdIsoPassHLT->Fill(dilepton.M());
}
}
} //passes T&P selection
} //loop over probes
} //loop over tags
} //end loop over data
delete info;
delete electronArr;
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
TCanvas *cv = new TCanvas("cv","cv", 800,600);
TagPlusRecoPassWWTightIdIso->Draw();
cv->SaveAs("TagPlusRecoPassWWTightIdIso.gif");
TagPlusRecoFailWWTightIdIso->Draw();
cv->SaveAs("TagPlusRecoFailWWTightIdIso.gif");
TagPlusWWTightIdIsoPassHLT->Draw();
cv->SaveAs("TagPlusWWTightIdIsoPassHLT.gif");
TagPlusWWTightIdIsoFailHLT->Draw();
cv->SaveAs("TagPlusWWTightIdIsoFailHLT.gif");
ProbePt->Draw();
cv->SaveAs("ProbePt.gif");
TagPt->Draw();
cv->SaveAs("TagPt.gif");
//*****************************************************************************************
//Summarize Efficiencies
//*****************************************************************************************
cout << "**********************************************************************\n";
cout << "Summarize MC Efficiencies\n";
TFile *file = new TFile("Efficiencies.root", "UPDATE");
for (int q=0; q < chargebinLabel.size(); ++q) {
for (int e=0; e < etabinLabel.size(); ++e) {
vector<Double_t> efficiency_RecoToWWTight;
vector<Double_t> efficiency_RecoToWWTight_lowErr;
vector<Double_t> efficiency_RecoToWWTight_highErr;
vector<Double_t> efficiency_WWTightToHLT;
vector<Double_t> efficiency_WWTightToHLT_lowErr;
vector<Double_t> efficiency_WWTightToHLT_highErr;
for (int p=0; p < ptbinLabel.size(); ++p) {
cout << etabinLabel[e] << " " << ptbinLabel[p] << " Charge = " << chargeSelection[q] << endl;
cout << endl;
Int_t errorType = 2; //Clopper Pearson intervals
Double_t ratio;
Double_t errLow;
Double_t errHigh;
Double_t n1;
Double_t n2;
n1 = TMath::Nint(EventCount_TagPlusRecoPassWWTightIdIso_binned[q][e][p]);
n2 = TMath::Nint(EventCount_TagPlusRecoPassWWTightIdIso_binned[q][e][p] + EventCount_TagPlusRecoFailWWTightIdIso_binned[q][e][p]);
if (n1 > n2) n1 = n2;
mithep::MathUtils::CalcRatio(n1 , n2, ratio, errLow, errHigh, errorType);
cout << "Reco -> WWTight Efficiency (MC) : " << n1 << " / " << n2 << " = " << ratio << " + " << errHigh << " - " << errLow << endl;
cout << "\n";
efficiency_RecoToWWTight.push_back(ratio);
efficiency_RecoToWWTight_lowErr.push_back(errLow);
efficiency_RecoToWWTight_highErr.push_back(errHigh);
n1 = TMath::Nint(EventCount_TagPlusWWTightIdIsoPassHLT_binned[q][e][p]);
n2 = TMath::Nint(EventCount_TagPlusWWTightIdIsoPassHLT_binned[q][e][p] + EventCount_TagPlusWWTightIdIsoFailHLT_binned[q][e][p]);
if (n1 > n2) n1 = n2;
mithep::MathUtils::CalcRatio(n1 , n2, ratio, errLow, errHigh, errorType);
cout << "WWTight -> HLT : " << n1 << " / " << n2 << " = " << ratio << " + " << errHigh << " - " << errLow << endl;
cout << "\n";
efficiency_WWTightToHLT.push_back(ratio);
efficiency_WWTightToHLT_lowErr.push_back(errLow);
efficiency_WWTightToHLT_highErr.push_back(errHigh);
cout << "\n\n\n";
}
//Make Efficiency Graphs
const Int_t nbins = efficiency_RecoToWWTight.size();
Double_t x[nbins];
Double_t y[nbins];
Double_t xErr[nbins];
Double_t yErrLow[nbins];
Double_t yErrHigh[nbins];
//***********************************************************
//Reco -> WW Tight
//***********************************************************
for (int b=0; b< efficiency_RecoToWWTight.size(); ++b) {
x[b] = (ptbinUpEdge[b] + ptbinLowEdge[b]) / 2;
xErr[b] = fabs(ptbinUpEdge[b] - ptbinLowEdge[b]) / 2;
if (b==efficiency_RecoToWWTight.size() - 1) {
x[b] = (100 + ptbinLowEdge[b]) / 2;
xErr[b] = fabs(100 - ptbinLowEdge[b]) / 2;
}
y[b] = efficiency_RecoToWWTight[b];
yErrLow[b] = fabs(efficiency_RecoToWWTight_lowErr[b]);
yErrHigh[b] = efficiency_RecoToWWTight_highErr[b];
}
TGraphAsymmErrors *efficiencyGraph_RecoToWWTight = new TGraphAsymmErrors(nbins, x, y, xErr, xErr, yErrLow,yErrHigh );
efficiencyGraph_RecoToWWTight->SetName(("MCEfficiency_RecoToWWTight_" + chargebinLabel[q] + "_" + etabinLabel[e]).c_str());
efficiencyGraph_RecoToWWTight->SetTitle("");
efficiencyGraph_RecoToWWTight->GetXaxis()->SetTitle("p_{T} [GeV/c]");
efficiencyGraph_RecoToWWTight->GetYaxis()->SetTitle("Efficiency");
efficiencyGraph_RecoToWWTight->SetMaximum(1.0);
efficiencyGraph_RecoToWWTight->SetMinimum(0.0);
efficiencyGraph_RecoToWWTight->SetMarkerSize(1);
efficiencyGraph_RecoToWWTight->SetLineWidth(2);
efficiencyGraph_RecoToWWTight->GetXaxis()->SetRangeUser(0,100);
file->WriteTObject(efficiencyGraph_RecoToWWTight, efficiencyGraph_RecoToWWTight->GetName(), "WriteDelete");
//***********************************************************
//WW Tight -> HLT
//***********************************************************
for (int b=0; b< efficiency_WWTightToHLT.size(); ++b) {
x[b] = (ptbinUpEdge[b] + ptbinLowEdge[b]) / 2;
xErr[b] = fabs(ptbinUpEdge[b] - ptbinLowEdge[b]) / 2;
if (b==efficiency_RecoToWWTight.size() - 1) {
x[b] = (100 + ptbinLowEdge[b]) / 2;
xErr[b] = fabs(100 - ptbinLowEdge[b]) / 2;
}
y[b] = efficiency_WWTightToHLT[b];
yErrLow[b] = fabs(efficiency_WWTightToHLT_lowErr[b]);
yErrHigh[b] = efficiency_WWTightToHLT_highErr[b];
}
TGraphAsymmErrors *efficiencyGraph_WWTightToHLT = new TGraphAsymmErrors(nbins, x, y, xErr, xErr, yErrLow,yErrHigh );
efficiencyGraph_WWTightToHLT->SetName(("MCEfficiency_WWTightToHLT_" + chargebinLabel[q] + "_" + etabinLabel[e]).c_str());
efficiencyGraph_WWTightToHLT->SetTitle("");
efficiencyGraph_WWTightToHLT->GetXaxis()->SetTitle("p_{T} [GeV/c]");
efficiencyGraph_WWTightToHLT->GetYaxis()->SetTitle("Efficiency");
efficiencyGraph_WWTightToHLT->SetMaximum(1.0);
efficiencyGraph_WWTightToHLT->SetMinimum(0.0);
efficiencyGraph_WWTightToHLT->SetMarkerSize(1);
efficiencyGraph_WWTightToHLT->SetLineWidth(2);
efficiencyGraph_WWTightToHLT->GetXaxis()->SetRangeUser(0,100);
file->WriteTObject(efficiencyGraph_WWTightToHLT, efficiencyGraph_WWTightToHLT->GetName(), "WriteDelete");
} //end for loop over eta bins
} //end for loop over charge bins
file->Close();
Int_t errorType = 2; //Clopper Pearson intervals
Double_t ratio;
Double_t errLow;
Double_t errHigh;
Double_t n1;
Double_t n2;
n1 = TMath::Nint(EventCount_TagPlusRecoPassWWTightIdIso);
n2 = TMath::Nint(EventCount_TagPlusRecoPassWWTightIdIso + EventCount_TagPlusRecoFailWWTightIdIso);
if (n1 > n2) n1 = n2;
mithep::MathUtils::CalcRatio(n1 , n2, ratio, errLow, errHigh, errorType);
cout << "Reco -> WWTight Efficiency (MC) : " << n1 << " / " << n2 << " = " << ratio << " + " << errHigh << " - " << errLow << endl;
cout << "\n";
n1 = TMath::Nint(EventCount_TagPlusWWTightIdIsoPassHLT);
n2 = TMath::Nint(EventCount_TagPlusWWTightIdIsoPassHLT + EventCount_TagPlusWWTightIdIsoFailHLT);
if (n1 > n2) n1 = n2;
mithep::MathUtils::CalcRatio(n1 , n2, ratio, errLow, errHigh, errorType);
cout << "WWTight -> HLT : " << n1 << " / " << n2 << " = " << ratio << " + " << errHigh << " - " << errLow << endl;
cout << "\n";
cout << "**********************************************************************\n";
gBenchmark->Show("ElectronTagAndProbe");
}
void kees_gen() {
gROOT->SetStyle("HALLA");
TCanvas *cn = new TCanvas("cn");
cn->Draw();
cn->UseCurrentStyle();
TH1F *frm = new TH1F("frm","",100,0.,10.);
frm->GetXaxis()->SetTitle("Q^{2} [GeV^{2}]");
frm->GetYaxis()->SetTitle("G_{E}^{n}");
frm->SetMinimum(-.02);
frm->SetMaximum(0.1);
frm->UseCurrentStyle();
frm->Draw();
frm->SetAxisRange(0.,5.,"X");
TF1 *genf = new TF1("genf",genff,1.,10.,1);
genf->SetLineColor(2);
genf->SetLineStyle(2);
genf->SetParameter(0,1.);
genf->SetParameter(1,.3);
genf->SetParameter(0,-0.632);
// match to Madey point just below 1.5
// genf->SetParameter(0,.0411/genf->Eval(1.45));
TMultiGraph* mgrDta = new TMultiGraph("Data","G_{E}^{n}");
TLegend *legDta = new TLegend(.54,.6,.875,.90,"","brNDC");
TMultiGraph* wgr = mgrDta;
TLegend *wlg = legDta;
// the data
legDta->SetBorderSize(0); // turn off border
legDta->SetFillStyle(0);
datafile_t *f = datafiles;
TGraph* gr=0;
while ( f && f->filename ) {
gr=OneGraph(f);
if (gr) {
if (f->lnpt) {
mgrDta->Add(gr,f->lnpt);
legDta->AddEntry(gr,f->label,f->lnpt);
}
else if (gr->GetMarkerStyle()>=20) {
mgrDta->Add(gr,"p");
legDta->AddEntry(gr,f->label,"p");
}
else {
mgrDta->Add(gr,"l");
legDta->AddEntry(gr,f->label,"l");
}
}
f++;
}
mgrDta->Draw("p");
// legDta->Draw(); don't draw the data legend
TMultiGraph* mgrThry = new TMultiGraph("Theory","G_{E}^{n}");
TLegend *legThry = new TLegend(.54,.6,.875,.9,"","brNDC");
wgr = mgrThry;
wlg = legThry;
// the theory
wlg->SetBorderSize(0); // turn off border
wlg->SetFillStyle(0);
f = theoryfiles1;
gr=0;
while ( f && f->filename ) {
gr=OneGraph(f);
if (gr) {
TGraphAsymmErrors *egr = dynamic_cast<TGraphAsymmErrors*>(gr);
if (egr && egr->GetN()>1 && egr->GetEYhigh() && egr->GetEYhigh()[1]>0) {
gr = toerror_band(egr);
gr->SetFillStyle(3000+f->style);
}
if (f->lnpt) {
wgr->Add(gr,f->lnpt);
wlg->AddEntry(gr,f->label,f->lnpt);
}
else if (gr->GetMarkerStyle()>=20) {
wgr->Add(gr,"p");
wlg->AddEntry(gr,f->label,"p");
}
else {
wgr->Add(gr,"l");
wlg->AddEntry(gr,f->label,"l");
}
}
f++;
}
genf->Draw("same");
mgrThry->Draw("c");
legThry->AddEntry(genf,"F_{2}/F_{1} #propto ln^{2}(Q^{2}/#Lambda^{2})/Q^{2}","l");
legThry->Draw();
// draw a line at 1
cn->Modified();
cn->Update();
cn->SaveAs(Form("%s.eps",psfile));
cn->SaveAs(Form("%s.root",psfile));
gSystem->Exec(Form("./replace_symbols.pl %s.eps",psfile));
// now an overlay, hopefully matching dimensions
// remove everything but the graph
cn->Update();
TList *clist = cn->GetListOfPrimitives();
TFrame* frame = cn->GetFrame();
for (int i=0; i<clist->GetSize(); ) {
if (clist->At(i) != frame) {
clist->RemoveAt(i);
} else i++;
}
// draw markers in the corners
TMarker *mkr = new TMarker(frame->GetX1(),frame->GetY1(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX2(),frame->GetY1(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX1(),frame->GetY2(),2);
mkr->Draw();
mkr = new TMarker(frame->GetX2(),frame->GetY2(),2);
mkr->Draw();
frame->SetLineColor(10);
cn->Update();
datafile_t miller = { "figure_input/Miller/lattice.GEn.rtf","Miller",
"[0]","[1]","[1]-[3]","[2]-[1]",0,0,1,3,"F" };
gr = OneGraph(&miller);
TGraphAsymmErrors* egr = dynamic_cast<TGraphAsymmErrors*>(gr);
if (egr && egr->GetEYhigh() && egr->GetEYhigh()[egr->GetN()/2]>0) {
gr = toerror_band(egr);
gr->SetLineStyle(1);
gr->SetFillColor(gr->GetLineColor());
gr->SetFillStyle(3000+miller.style);
}
gr->Draw("F");
cn->Update();
cn->SaveAs("gen_Miller_Overlay.eps");
cn->SaveAs("gen_Miller_Overlay.root");
}
TCanvas* NAtRatio(){
TGraphErrors *NatSig = new TGraphErrors(6);
TGraphErrors *NatCtrl = new TGraphErrors(6);
TH1D *Sig0 = ((TH1D*)Sig->Get("kinplot/AlphaT_0"))->Clone();
TH1D *Ctrl0= ((TH1D*)Bkgd->Get("kinplot/AlphaT_0"))->Clone();
TH1D *Sig50 = ((TH1D*)Sig->Get("kinplot_afterHT_50/AlphaT_0"))->Clone();
TH1D *Ctrl50= ((TH1D*)Bkgd->Get("kinplot_afterHT_50/AlphaT_0"))->Clone();
TH1D *Sig100 = ((TH1D*)Sig->Get("kinplot_afterHT_100/AlphaT_0"))->Clone();
TH1D *Ctrl100= ((TH1D*)Bkgd->Get("kinplot_afterHT_100/AlphaT_0"))->Clone();
TH1D *Sig150 = ((TH1D*)Sig->Get("kinplot_afterHT_150/AlphaT_0"))->Clone();
TH1D *Ctrl150= ((TH1D*)Bkgd->Get("kinplot_afterHT_150/AlphaT_0"))->Clone();
TH1D *Sig200 = ((TH1D*)Sig->Get("kinplot_afterHT_200/AlphaT_0"))->Clone();
TH1D *Ctrl200= ((TH1D*)Bkgd->Get("kinplot_afterHT_200/AlphaT_0"))->Clone();
TH1D *Sig250 = ((TH1D*)Sig->Get("kinplot_afterHT_250/AlphaT_0"))->Clone();
TH1D *Ctrl250= ((TH1D*)Bkgd->Get("kinplot_afterHT_250/AlphaT_0"))->Clone();
NatSig->SetPoint(0,0.,(Sig0->Integral(55,300)/Sig0->Integral(0,54)));
NatSig->SetPoint(1,50.,(Sig50->Integral(55,300)/Sig50->Integral(0,54)));
NatSig->SetPoint(2,100.,(Sig100->Integral(55,300)/Sig100->Integral(0,54)));
NatSig->SetPoint(3,150.,(Sig150->Integral(55,300)/Sig150->Integral(0,54)));
NatSig->SetPoint(4,200.,(Sig200->Integral(55,300)/Sig200->Integral(0,54)));
NatSig->SetPoint(5,250.,(Sig250->Integral(55,300)/Sig250->Integral(0,54)));
NatSig->SetPointError(0,1.,sqrt(Sig0->Integral(55,300)/Sig0->Integral(0,54)));
NatSig->SetPointError(1,1.,sqrt(Sig50->Integral(55,300)/Sig50->Integral(0,54)));
NatSig->SetPointError(2,1.,sqrt(Sig100->Integral(55,300)/Sig100->Integral(0,54)));
NatSig->SetPointError(3,1.,sqrt(Sig150->Integral(55,300)/Sig150->Integral(0,54)));
NatSig->SetPointError(4,1.,sqrt(Sig200->Integral(55,300)/Sig200->Integral(0,54)));
NatSig->SetPointError(5,1.,sqrt(Sig250->Integral(55,300)/Sig250->Integral(0,54)));
NatCtrl->SetPoint(0,0.,(Ctrl0->Integral(55,300)/Ctrl0->Integral(0,54)));
NatCtrl->SetPoint(1,50.,(Ctrl50->Integral(55,300)/Ctrl50->Integral(0,54)));
NatCtrl->SetPoint(2,100.,(Ctrl100->Integral(55,300)/Ctrl100->Integral(0,54)));
NatCtrl->SetPoint(3,150.,(Ctrl150->Integral(55,300)/Ctrl150->Integral(0,54)));
NatCtrl->SetPoint(4,200.,(Ctrl200->Integral(55,300)/Ctrl200->Integral(0,54)));
NatCtrl->SetPoint(5,250.,(Ctrl250->Integral(55,300)/Ctrl250->Integral(0,54)));
NatCtrl->SetPointError(0,1.,sqrt(Ctrl0->Integral(55,300)/Ctrl0->Integral(0,54)));
NatCtrl->SetPointError(1,1.,sqrt(Ctrl50->Integral(55,300)/Ctrl50->Integral(0,54)));
NatCtrl->SetPointError(2,1.,sqrt(Ctrl100->Integral(55,300)/Ctrl100->Integral(0,54)));
NatCtrl->SetPointError(3,1.,sqrt(Ctrl150->Integral(55,300)/Ctrl150->Integral(0,54)));
NatCtrl->SetPointError(4,1.,sqrt(Ctrl200->Integral(55,300)/Ctrl200->Integral(0,54)));
NatCtrl->SetPointError(5,1.,sqrt(Ctrl250->Integral(55,300)/Ctrl250->Integral(0,54)));
gROOT->SetStyle("Plain");
TCanvas* c = new TCanvas("NalphaT_Ratio","NAlphaT_Ratio");
c->SetLogy();
TLegend *leg = new TLegend(0.5,0.8,0.99,0.99);
leg->SetFillColor(0);
leg->AddEntry(NatSig,"Selected Events","P");
leg->AddEntry(NatCtrl,"Anti-selected events","P");
NatSig->SetMarkerColor(kRed);
NatSig->SetMarkerStyle(kFullCircle);
NatSig->SetLineColor(kRed);
NatSig->SetLineWidth(2);
NatCtrl->SetMarkerColor(kBlue);
NatCtrl->SetMarkerStyle(kFullCircle);
NatCtrl->SetLineColor(kBlue);
NatCtrl->SetLineWidth(2);
NatCtrl->Draw("APX");
NatSig->Draw("PX");
//NatSig->Fit("pol1");
NatCtrl->GetXaxis()->SetTitle("HT Cut [GeV]");
NatCtrl->GetYaxis()->SetTitle("#frac{N(#alpha_{T}>0.55)}{N(#alpha_{T}<0.55)}");
NatCtrl->GetXaxis()->SetTitle("HT Cut [GeV]");
NatCtrl->GetYaxis()->SetRangeUser(0.0005,0.5);
NatCtrl->SetTitle();
leg->Draw("SAME");
c->Update();
c->SaveAs(saving+"NAlphaTRatio_plot.png");
return c;
}
void PlotPedestalsvsTime(Int_t year=2011, Int_t firstRun=141820,
Int_t lastRun=146900, Int_t ipedGainChain=0)
{
TGrid::Connect("alien:",0,0,"t");
gSystem->Exec(Form("gbbox find \"/alice/data/%d/OCDB/ZDC/Calib/Pedestals/\" \"Run*.root\" > calibAlienFiles.txt",year));
FILE* listruns=fopen("calibAlienFiles.txt","r");
const int kNchannels=24;
TGraphErrors* graph[24];
for(Int_t i=0; i<kNchannels; i++){
graph[i] = new TGraphErrors(0);
char name[50], title[50];
sprintf(name,"graph%d",i); sprintf(title,"Pedestal ch.%d vs. run#",i);
graph[i]->SetName("graph"); graph[i]->SetTitle("title");
}
Char_t filnam[200], filnamalien[200];
Int_t iPoint=0;
Int_t nrun, nrun2, nv, ns;
while(!feof(listruns)){
int st = fscanf(listruns,"%s\n",filnam);
Char_t directory[100];
sprintf(directory,"/alice/data/%d",year);
if(!strstr(filnam,directory)) continue;
sscanf(filnam,"/alice/data/%d/OCDB/ZDC/Calib/Pedestals/Run%d_%d_v%d_s%d.root",&year,&nrun,&nrun2,&nv,&ns);
if(nrun<firstRun) continue;
if(nrun>lastRun) continue;
sprintf(filnamalien,"alien://%s",filnam);
printf("Opening file: %s\n",filnam);
TFile *f = TFile::Open(filnamalien);
AliCDBEntry *entry = (AliCDBEntry*)f->Get("AliCDBEntry");
AliZDCPedestals *calibdata = dynamic_cast<AliZDCPedestals*> (entry->GetObject());
for(int i=0; i<kNchannels; i++){
if(ipedGainChain==0){
graph[i]->SetPoint(iPoint, (Double_t)nrun, calibdata->GetMeanPed(i));
graph[i]->SetPointError(iPoint, 0., calibdata->GetMeanPedWidth(i));
}
else{
graph[i]->SetPoint(iPoint, (Double_t)nrun, calibdata->GetMeanPed(i+kNchannels));
graph[i]->SetPointError(iPoint, 0., calibdata->GetMeanPedWidth(i+kNchannels));
}
}
iPoint++;
f->Close();
}
TFile *outfile=new TFile(Form("PedCalib%dVsTime.root",year),"recreate");
outfile->cd();
for(int i=0; i<kNchannels; i++) graph[i]->Write();
outfile->Close();
//***********************************************************
// #### ROOT initialization
gROOT->Reset();
gStyle->SetCanvasColor(10);
gStyle->SetFrameFillColor(10);
gStyle->SetOptTitle(0);
gStyle->SetOptStat(1111);
gStyle->SetOptFit(0);
gStyle->SetTitleTextColor(4);
gStyle->SetStatTextColor(4);
gStyle->SetStatX(0.92);
gStyle->SetStatY(0.92);
gStyle->SetLineColor(1);
gStyle->SetPalette(1);
gStyle->SetPadTopMargin(0.05);
gStyle->SetPadRightMargin(0.05);
gStyle->SetPadBottomMargin(0.09);
gStyle->SetPadLeftMargin(0.09);
gStyle->SetTitleOffset(1.1,"Y");
// *************************************************************
TCanvas *cHadPeds = new TCanvas("cHadPeds","Hadronic ZDC pedestals",0,0,1000,800);
cHadPeds->Divide(5,4);
for(int ic=0; ic<5; ic++){
// *** ZNC pedestals
cHadPeds->cd(ic+1);
//
TH1F *haxis1=0;
if(ipedGainChain==0){
if(ic==0) haxis1 = gPad->DrawFrame(firstRun-100, 80, lastRun+100, 100);
else haxis1 = gPad->DrawFrame(firstRun-100, 50, lastRun+100, 70);
}
else{
if(ic==0) haxis1 = gPad->DrawFrame(firstRun-100, 500, lastRun+100, 800);
else haxis1 = gPad->DrawFrame(firstRun-100, 300, lastRun+100, 600);
}
haxis1->GetXaxis()->SetNoExponent();
haxis1->SetXTitle("RUN no.");
haxis1->SetYTitle("ZNC pedestals");
//
graph[ic]->SetMarkerStyle(20);
graph[ic]->SetMarkerColor(kBlue);
graph[ic]->Draw("P, SAME");
// *** ZPC pedestals
cHadPeds->cd(ic+6);
//
TH1F *haxis2=0;
if(ipedGainChain==0) haxis2= gPad->DrawFrame(firstRun-100, 55, lastRun+100, 85);
else haxis2 = gPad->DrawFrame(firstRun-100, 400, lastRun+100, 700);
haxis2->GetXaxis()->SetNoExponent();
haxis2->SetXTitle("RUN no.");
haxis2->SetYTitle("ZPC pedestals");
//
graph[ic+5]->SetMarkerStyle(21);
graph[ic+5]->SetMarkerColor(kBlue+3);
graph[ic+5]->Draw("P, SAME");
// *** ZNA pedestals
cHadPeds->cd(ic+11);
//
TH1F *haxis3=0;
if(ipedGainChain==0) haxis3 = gPad->DrawFrame(firstRun-100, 35, lastRun+100, 85);
else haxis3 = gPad->DrawFrame(firstRun-100, 300, lastRun+100, 700);
haxis3->GetXaxis()->SetNoExponent();
haxis3->SetXTitle("RUN no.");
haxis3->SetYTitle("ZNA pedestals");
//
graph[ic+12]->SetMarkerStyle(20);
graph[ic+12]->SetMarkerColor(kRed);
graph[ic+12]->Draw("P, SAME");
// *** ZPA pedestals
cHadPeds->cd(ic+16);
//
TH1F *haxis4=0;
if(ipedGainChain==0) haxis4 = gPad->DrawFrame(firstRun-100, 40, lastRun+100, 80);
else haxis4 = gPad->DrawFrame(firstRun-100, 300, lastRun+100, 600);
haxis4->GetXaxis()->SetNoExponent();
haxis4->SetXTitle("RUN no.");
haxis4->SetYTitle("ZPA pedestals");
//
graph[ic+17]->SetMarkerStyle(21);
graph[ic+17]->SetMarkerColor(kRed+1);
graph[ic+17]->Draw("P, SAME");
}
cHadPeds->SaveAs("ZDCPedvsTime1.gif");
cHadPeds->SaveAs("ZDCPedvsTime1.C");
TCanvas *cothPeds = new TCanvas("cothPeds","ZEM + Ref. pedestals",800,0,600,600);
cothPeds->Divide(2,2);
for(int ic=0; ic<2; ic++){
// *** ZEM pedestals
cothPeds->cd(ic+1);
//
TH1F *haxis5=0;
if(ipedGainChain==0) haxis5 = gPad->DrawFrame(firstRun-100, 30, lastRun+20, 70);
else haxis5 = gPad->DrawFrame(firstRun-100, 250, lastRun+100, 550);
haxis5->GetXaxis()->SetNoExponent();
haxis5->SetXTitle("RUN no.");
haxis5->SetYTitle("ZEM pedestals");
//
graph[ic+10]->SetMarkerStyle(22);
graph[ic+10]->SetMarkerColor(kGreen+1);
graph[ic+10]->Draw("P, SAME");
// *** Ref. pedestals
cothPeds->cd(ic+3);
//
TH1F *haxis6=0;
if(ipedGainChain==0) haxis6 = gPad->DrawFrame(firstRun-100, 50, lastRun+100, 90);
else haxis6 = gPad->DrawFrame(firstRun-100, 400, lastRun+100, 700);
haxis6->GetXaxis()->SetNoExponent();
haxis6->SetXTitle("RUN no.");
haxis6->SetYTitle("PMRef. pedestals");
//
graph[ic+22]->SetMarkerStyle(23);
graph[ic+22]->SetMarkerColor(kGreen+4);
graph[ic+22]->Draw("P, SAME");
}
cothPeds->SaveAs("ZDCPedvsTime2.gif");
cothPeds->SaveAs("ZDCPedvsTime2.C");
}
fitResult getPurity(TString fname, sampleType collision, TCut evtSeltCut, TCut sbEvtCut, TString canvasName, float photonPtThr, float photonPtThrUp) {
double purity(0);
multiTreeUtil* tgj = new multiTreeUtil();
multiTreeUtil* tgjMC = new multiTreeUtil();
cout << " Calculating Purity....." << endl;
tgj->addFile(fname, "tgj", "", 1); // tgj->AddFriend("yTrk");
if (collision==kPPDATA) {
tgjMC->addFile(fnamePPMC_AllQcdPho30to50, "tgj", "", wPPMC_AllQcdPho30to50 );
tgjMC->addFile(fnamePPMC_AllQcdPho50to80, "tgj", "", wPPMC_AllQcdPho50to80 );
tgjMC->addFile(fnamePPMC_AllQcdPho80to120, "tgj", "", wPPMC_AllQcdPho80to120);
tgjMC->addFile(fnamePPMC_AllQcdPho120to9999, "tgj", "", wPPMC_AllQcdPho120to9999);
}
else if (collision==kPADATA) {
tgjMC->addFile(fnamePAMC_AllQcdPho30to50, "tgj","", wPAMC_AllQcdPho30to50);
tgjMC->addFile(fnamePAMC_AllQcdPho50to80, "tgj","", wPAMC_AllQcdPho50to80);
tgjMC->addFile(fnamePAMC_AllQcdPho80to120, "tgj","", wPAMC_AllQcdPho80to120);
tgjMC->addFile(fnamePAMC_AllQcdPho120to9999, "tgj","", wPAMC_AllQcdPho120to9999);
}
else if (collision==kHIDATA) {
/* tgjMC->addFile(fnameHIMC_AllQcdPho30to50, "tgj", "",wHIMC_AllQcdPho30to50);
tgjMC->addFile(fnameHIMC_AllQcdPho50to80, "tgj", "",wHIMC_AllQcdPho50to80);
tgjMC->addFile(fnameHIMC_AllQcdPho80to9999, "tgj", "",wHIMC_AllQcdPho80to9999); */
tgjMC->addFile(fnameHIMC_AllQcdPho30to9999, "tgj", "",wHIMC_AllQcdPho80to9999);
}
else {
cout << " Error: getPurity. check the type of the collision! " << endl;
fitResult fitr0;
return fitr0;
}
TH1D* hCand = new TH1D("cand","",25,0,0.025);
TH1D* hBkg = (TH1D*)hCand->Clone("bkg"); TH1D* hSig = (TH1D*)hCand->Clone("sig");
tgj->Draw2( hCand, "sigmaIetaIeta", evtSeltCut , "");
tgj->Draw2( hBkg, "sigmaIetaIeta", sbEvtCut , "");
tgjMC->Draw2( hSig, "sigmaIetaIeta", evtSeltCut && "genIso<5 && abs(genMomId)<=22", "");
handsomeTH1(hCand,1);
handsomeTH1(hSig,2);
handsomeTH1(hBkg,4);
hCand->Draw();
hSig->Draw("same");
hBkg->Draw("same hist");
TCanvas* cPurity = new TCanvas("cpurity","",500,500);
fitResult fitr = doFit ( hSig, hBkg, hCand, 0.005, 0.025);
drawText(Form("Purity : %.2f", (float)fitr.purity010), 0.5680963,0.429118);
drawText(Form("p_{T}^{#gamma}: %d-%d GeV", (int)photonPtThr, (int)photonPtThrUp), 0.568,0.529118);
cPurity->SaveAs( Form("%s.pdf",canvasName.Data() ) );
// gPad->SetLogy(); cPurity->SaveAs( Form("%s_logScale.pdf",canvasName.Data() ) );
TCanvas* c1 = new TCanvas("c1","",100,100);
delete tgj;
delete tgjMC;
delete hSig;
delete hBkg;
delete hCand;
return fitr;
}
TCanvas *plotmean(TString selecter)
{
TCanvas *cWork = NULL;
if( selecter == "L" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,500);
cWork->Divide(2,2);
plotmean(cWork, 1, "JP", selecter);
plotmean(cWork, 2, "JBP", selecter);
plotmean(cWork, 3, "CSV", selecter);
plotmean(cWork, 4, "TCHE", selecter);
}
else if( selecter == "M" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,750);
cWork->Divide(2,3);
plotmean(cWork, 1, "JP", selecter);
plotmean(cWork, 2, "JBP", selecter);
plotmean(cWork, 3, "CSV", selecter);
plotmean(cWork, 4, "TCHE", selecter);
plotmean(cWork, 5, "TCHP", selecter);
plotmean(cWork, 6, "SSVHE", selecter);
}
else if( selecter == "T" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,750);
cWork->Divide(2,3);
plotmean(cWork, 1, "JP", selecter);
plotmean(cWork, 2, "JBP", selecter);
plotmean(cWork, 3, "CSV", selecter);
//plotmean(cWork, 4, "TCHE", selecter);
plotmean(cWork, 5, "TCHP", selecter);
plotmean(cWork, 6, "SSVHP", selecter);
}
else if( selecter == "TCHE" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,500);
cWork->Divide(1,2);
plotmean(cWork, 1, selecter, "L");
plotmean(cWork, 2, selecter, "M");
}
else if( selecter == "TCHP" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,500);
cWork->Divide(1,2);
plotmean(cWork, 1, selecter, "M");
plotmean(cWork, 2, selecter, "T");
}
else if( selecter == "SSVHE" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,250);
plotmean(cWork, 0, selecter, "M");
}
else if( selecter == "SSVHP" )
{
cWork = new TCanvas("cWork", "plots",200,10,700,250);
plotmean(cWork, 0, selecter, "T");
}
else
{
cWork = new TCanvas("cWork", "plots",200,10,700,750);
cWork->Divide(1,3);
plotmean(cWork, 1, selecter, "L");
plotmean(cWork, 2, selecter, "M");
plotmean(cWork, 3, selecter, "T");
}
cWork->WaitPrimitive();
cWork->SaveAs("MistagFunc_"+selecter+".pdf");
return cWork;
}
void PlotGluonFusionHiggsShapeSystematics() {
TFile *file = new TFile("/data/blue/sixie/Thesis/Limits/MVAIDIsoCombinedDetIsoSameSigWP/130/hww130_of_0j.input.root","READ");
TH1F *DefaultShape;
TH1F *UpShape;
TH1F *DownShape;
TCanvas *cv ;
TLegend *legend;
//*************************
//ggH signal - DF 0Jet
//*************************
DefaultShape = (TH1F*)file->Get("histo_ggH");
UpShape = (TH1F*)file->Get("histo_ggH_CMS_MVAggHBoundingUp");
DownShape = (TH1F*)file->Get("histo_ggH_CMS_MVAggHBoundingDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
//Make relative histograms
UpShapeRelative = MakeRelative(UpShape,DefaultShape);
DownShapeRelative = MakeRelative(DownShape,DefaultShape);
cv = new TCanvas("cv","cv",800,600);
pad1 = new TPad("pad1","pad1", 0,0.2,1,1);
pad1->SetBottomMargin(0.125);
pad1->Draw();
pad1->cd();
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Systematics Shape (Up)", "L");
legend->AddEntry(DownShape, "Systematics Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Number of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.1);
DefaultShape->GetXaxis()->SetTitleOffset(1.05);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,13);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->cd();
pad2 = new TPad("pad2","pad2", 0,0,1,0.2);
pad1->SetTopMargin(0.01);
pad2->Draw();
pad2->cd();
UpShapeRelative->GetYaxis()->SetTitle("% Difference");
UpShapeRelative->GetYaxis()->SetTitleSize(0.15);
UpShapeRelative->GetYaxis()->SetTitleOffset(0.3);
UpShapeRelative->GetYaxis()->SetRangeUser(-3,3);
UpShapeRelative->GetYaxis()->SetLabelSize(0.15);
UpShapeRelative->GetXaxis()->SetLabelSize(0.0);
UpShapeRelative->SetLineColor(kBlue);
UpShapeRelative->SetMarkerColor(kBlue);
UpShapeRelative->Draw("hist");
DownShapeRelative->SetLineColor(kRed);
DownShapeRelative->SetMarkerColor(kRed);
DownShapeRelative->Draw("hist,same");
cv->SaveAs("ggHShapeVariation_ggH_0Jet_DF.png");
cv->SaveAs("ggHShapeVariation_ggH_0Jet_DF.eps");
//*************************
//ggH signal - SF 0Jet
//*************************
file = new TFile("/data/blue/sixie/Thesis/Limits/MVAIDIsoCombinedDetIsoSameSigWP/130/hww130_sf_0j.input.root","READ");
DefaultShape = (TH1F*)file->Get("histo_ggH");
UpShape = (TH1F*)file->Get("histo_ggH_CMS_MVAggHBoundingUp");
DownShape = (TH1F*)file->Get("histo_ggH_CMS_MVAggHBoundingDown");
assert(DefaultShape);
assert(UpShape);
assert(DownShape);
//Make relative histograms
UpShapeRelative = MakeRelative(UpShape,DefaultShape);
DownShapeRelative = MakeRelative(DownShape,DefaultShape);
cv = new TCanvas("cv","cv",800,600);
pad1 = new TPad("pad1","pad1", 0,0.2,1,1);
pad1->SetBottomMargin(0.125);
pad1->Draw();
pad1->cd();
legend = new TLegend(0.2, 0.6, 0.5, 0.9);
legend->SetTextSize(0.04);
legend->SetBorderSize(0);
legend->SetFillColor(kWhite);
legend->AddEntry(DefaultShape, "Default Shape", "L");
legend->AddEntry(UpShape, "Systematics Shape (Up)", "L");
legend->AddEntry(DownShape, "Systematics Shape (Down)", "L");
DefaultShape->SetLineColor(kBlack);
UpShape->SetLineColor(kBlue);
DownShape->SetLineColor(kRed);
DefaultShape->SetLineWidth(2);
UpShape->SetLineWidth(2);
DownShape->SetLineWidth(2);
DefaultShape->SetTitle("");
DefaultShape->GetXaxis()->SetTitle("MVA discriminator");
DefaultShape->GetYaxis()->SetTitle("Number of Events");
DefaultShape->GetYaxis()->SetTitleOffset(1.1);
DefaultShape->GetXaxis()->SetTitleOffset(1.05);
DefaultShape->GetXaxis()->SetRangeUser(-1.0,1.0);
DefaultShape->GetYaxis()->SetRangeUser(0.0,5.5);
DefaultShape->Draw("hist");
UpShape->Draw("same,hist");
DownShape->Draw("same,hist");
legend->Draw();
cv->cd();
pad2 = new TPad("pad2","pad2", 0,0,1,0.2);
pad1->SetTopMargin(0.01);
pad2->Draw();
pad2->cd();
UpShapeRelative->GetYaxis()->SetTitle("% Difference");
UpShapeRelative->GetYaxis()->SetTitleSize(0.15);
UpShapeRelative->GetYaxis()->SetTitleOffset(0.3);
UpShapeRelative->GetYaxis()->SetRangeUser(-3,3);
UpShapeRelative->GetYaxis()->SetLabelSize(0.15);
UpShapeRelative->GetXaxis()->SetLabelSize(0.0);
UpShapeRelative->SetLineColor(kBlue);
UpShapeRelative->SetMarkerColor(kBlue);
UpShapeRelative->Draw("hist");
DownShapeRelative->SetLineColor(kRed);
DownShapeRelative->SetMarkerColor(kRed);
DownShapeRelative->Draw("hist,same");
cv->SaveAs("ggHShapeVariation_ggH_0Jet_SF.png");
cv->SaveAs("ggHShapeVariation_ggH_0Jet_SF.eps");
}
TF1* fit(Double_t ptmin, Double_t ptmax)
{
TCanvas* c = new TCanvas(Form("c_%.0f_%.0f",ptmin,ptmax),"",600,600);
TFile* infile = new TFile(Form("%s_%s_%.0f_%.0f.root",infname.Data(),collisionsystem.Data(),ptmin,ptmax));
TH1D* h = (TH1D*)infile->Get("h"); h->SetName(Form("h_%.0f_%.0f",ptmin,ptmax));
TH1D* hMCSignal = (TH1D*)infile->Get("hMCSignal"); hMCSignal->SetName(Form("hMCSignal_%.0f_%.0f",ptmin,ptmax));
TH1D* hMCSwapped = (TH1D*)infile->Get("hMCSwapped"); hMCSwapped->SetName(Form("hMCSwapped_%.0f_%.0f",ptmin,ptmax));
TF1* f = new TF1(Form("f_%.0f_%.0f",ptmin,ptmax),"[0]*([7]*([9]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[9])*Gaus(x,[1],[10])/(sqrt(2*3.14159)*[10]))+(1-[7])*Gaus(x,[1],[8])/(sqrt(2*3.14159)*[8]))+[3]*exp([4]*x)", 1.7, 2.0);
f->SetParLimits(10,0.001,0.05);
f->SetParLimits(2,0.01,0.1);
f->SetParLimits(8,0.02,0.2);
f->SetParLimits(7,0,1);
f->SetParLimits(9,0,1);
f->SetParameter(0,setparam0);
f->SetParameter(1,setparam1);
f->SetParameter(2,setparam2);
f->SetParameter(10,setparam10);
f->SetParameter(9,setparam9);
f->FixParameter(8,setparam8);
f->FixParameter(7,1);
f->FixParameter(1,fixparam1);
f->FixParameter(3,0);
f->FixParameter(4,0);
h->GetEntries();
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
f->ReleaseParameter(1);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSignal->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
f->FixParameter(1,f->GetParameter(1));
f->FixParameter(2,f->GetParameter(2));
f->FixParameter(10,f->GetParameter(10));
f->FixParameter(9,f->GetParameter(9));
f->FixParameter(7,0);
f->ReleaseParameter(8);
f->SetParameter(8,setparam8);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
hMCSwapped->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
f->SetParLimits(0,0,1.e+6);
f->FixParameter(7,hMCSignal->Integral(0,1000)/(hMCSwapped->Integral(0,1000)+hMCSignal->Integral(0,1000)));
f->FixParameter(8,f->GetParameter(8));
f->ReleaseParameter(3);
f->ReleaseParameter(4);
f->SetParLimits(3,0,1.e+10);
f->SetParameter(3,1.e+3);
f->SetLineColor(kRed);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"q","",minhisto,maxhisto);
f->ReleaseParameter(1);
f->SetParLimits(1,1.85,1.90);
//f->ReleaseParameter(2); // you need to release these two parameters if you want to perform studies on the sigma shape
//f->ReleaseParameter(10); // you need to release these two parameters if you want to perform studies on the sigma shape
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L q","",minhisto,maxhisto);
h->Fit(Form("f_%.0f_%.0f",ptmin,ptmax),"L m","",minhisto,maxhisto);
TF1* background = new TF1(Form("background_%.0f_%.0f",ptmin,ptmax),"[0]*exp([1]*x)");
background->SetParameter(0,f->GetParameter(3));
background->SetParameter(1,f->GetParameter(4));
background->SetLineColor(4);
background->SetRange(minhisto,maxhisto);
background->SetLineStyle(2);
TF1* mass = new TF1(Form("fmass_%.0f_%.0f",ptmin,ptmax),"[0]*([3]*([4]*Gaus(x,[1],[2])/(sqrt(2*3.14159)*[2])+(1-[4])*Gaus(x,[1],[5])/(sqrt(2*3.14159)*[5])))");
mass->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(2),f->GetParameter(7),f->GetParameter(9),f->GetParameter(10));
mass->SetParError(0,f->GetParError(0));
mass->SetParError(1,f->GetParError(1));
mass->SetParError(2,f->GetParError(2));
mass->SetParError(3,f->GetParError(7));
mass->SetParError(4,f->GetParError(9));
mass->SetParError(5,f->GetParError(10));
mass->SetFillColor(kOrange-3);
mass->SetFillStyle(3002);
mass->SetLineColor(kOrange-3);
mass->SetLineWidth(3);
mass->SetLineStyle(2);
TF1* massSwap = new TF1(Form("fmassSwap_%.0f_%.0f",ptmin,ptmax),"[0]*(1-[2])*Gaus(x,[1],[3])/(sqrt(2*3.14159)*[3])");
massSwap->SetParameters(f->GetParameter(0),f->GetParameter(1),f->GetParameter(7),f->GetParameter(8));
massSwap->SetParError(0,f->GetParError(0));
massSwap->SetParError(1,f->GetParError(1));
massSwap->SetParError(2,f->GetParError(7));
massSwap->SetParError(3,f->GetParError(8));
massSwap->SetFillColor(kGreen+4);
massSwap->SetFillStyle(3005);
massSwap->SetLineColor(kGreen+4);
massSwap->SetLineWidth(3);
massSwap->SetLineStyle(1);
h->SetXTitle("m_{#piK} (GeV/c^{2})");
h->SetYTitle("Entries / (5 MeV/c^{2})");
h->GetXaxis()->CenterTitle();
h->GetYaxis()->CenterTitle();
h->SetAxisRange(0,h->GetMaximum()*1.4*1.2,"Y");
h->GetXaxis()->SetTitleOffset(1.3);
h->GetYaxis()->SetTitleOffset(1.8);
h->GetXaxis()->SetLabelOffset(0.007);
h->GetYaxis()->SetLabelOffset(0.007);
h->GetXaxis()->SetTitleSize(0.045);
h->GetYaxis()->SetTitleSize(0.045);
h->GetXaxis()->SetTitleFont(42);
h->GetYaxis()->SetTitleFont(42);
h->GetXaxis()->SetLabelFont(42);
h->GetYaxis()->SetLabelFont(42);
h->GetXaxis()->SetLabelSize(0.04);
h->GetYaxis()->SetLabelSize(0.04);
h->SetMarkerSize(0.8);
h->SetMarkerStyle(20);
h->SetStats(0);
h->Draw("e");
background->Draw("same");
mass->SetRange(minhisto,maxhisto);
mass->Draw("same");
massSwap->SetRange(minhisto,maxhisto);
massSwap->Draw("same");
f->Draw("same");
Double_t yield = mass->Integral(minhisto,maxhisto)/binwidthmass;
Double_t yieldErr = mass->Integral(minhisto,maxhisto)/binwidthmass*mass->GetParError(0)/mass->GetParameter(0);
std::cout<<"YIELD="<<yield<<std::endl;
TLegend* leg = new TLegend(0.65,0.58,0.82,0.88,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.04);
leg->SetTextFont(42);
leg->SetFillStyle(0);
leg->AddEntry(h,"Data","pl");
leg->AddEntry(f,"Fit","l");
leg->AddEntry(mass,"D^{0}+#bar{D^{#lower[0.2]{0}}} Signal","f");
leg->AddEntry(massSwap,"K-#pi swapped","f");
leg->AddEntry(background,"Combinatorial","l");
leg->Draw("same");
TLatex* texCms = new TLatex(0.18,0.93, "#scale[1.25]{CMS} Preliminary");
texCms->SetNDC();
texCms->SetTextAlign(12);
texCms->SetTextSize(0.04);
texCms->SetTextFont(42);
texCms->Draw();
TLatex* texCol = new TLatex(0.96,0.93, Form("%s #sqrt{s_{NN}} = 5.02 TeV",collisionsystem.Data()));
texCol->SetNDC();
texCol->SetTextAlign(32);
texCol->SetTextSize(0.04);
texCol->SetTextFont(42);
texCol->Draw();
TLatex* texPt = new TLatex(0.22,0.78,Form("%.1f < p_{T} < %.1f GeV/c",ptmin,ptmax));
texPt->SetNDC();
texPt->SetTextFont(42);
texPt->SetTextSize(0.04);
texPt->SetLineWidth(2);
texPt->Draw();
TLatex* texY = new TLatex(0.22,0.83,"|y| < 1.0");
texY->SetNDC();
texY->SetTextFont(42);
texY->SetTextSize(0.04);
texY->SetLineWidth(2);
texY->Draw();
TLatex* texYield = new TLatex(0.22,0.73,Form("N_{D} = %.0f #pm %.0f",yield,yieldErr));
texYield->SetNDC();
texYield->SetTextFont(42);
texYield->SetTextSize(0.04);
texYield->SetLineWidth(2);
texYield->Draw();
c->SaveAs(Form("plotFits/DMass_expo_%s_%.0f_%.0f.pdf",collisionsystem.Data(),ptmin,ptmax));
TCanvas* cPull = new TCanvas(Form("cPull_%.0f_%.0f",ptmin,ptmax),"",600,700);
TH1D* hPull = (TH1D*)h->Clone("hPull");
for(int i=0;i<h->GetNbinsX();i++)
{
Double_t nfit = f->Integral(h->GetBinLowEdge(i+1),h->GetBinLowEdge(i+1)+h->GetBinWidth(i+1))/h->GetBinWidth(i+1);
hPull->SetBinContent(i+1,(h->GetBinContent(i+1)-nfit)/h->GetBinError(i+1));
hPull->SetBinError(i+1,0);
}
hPull->SetMinimum(-4.);
hPull->SetMaximum(4.);
hPull->SetYTitle("Pull");
hPull->GetXaxis()->SetTitleOffset(1.);
hPull->GetYaxis()->SetTitleOffset(0.65);
hPull->GetXaxis()->SetLabelOffset(0.007);
hPull->GetYaxis()->SetLabelOffset(0.007);
hPull->GetXaxis()->SetTitleSize(0.12);
hPull->GetYaxis()->SetTitleSize(0.12);
hPull->GetXaxis()->SetLabelSize(0.1);
hPull->GetYaxis()->SetLabelSize(0.1);
hPull->GetYaxis()->SetNdivisions(504);
TLine* lPull = new TLine(1.7, 0, 2., 0);
lPull->SetLineWidth(1);
lPull->SetLineStyle(7);
lPull->SetLineColor(1);
TPad* pFit = new TPad("pFit","",0,0.3,1,1);
pFit->SetBottomMargin(0);
pFit->Draw();
pFit->cd();
h->Draw("e");
background->Draw("same");
mass->Draw("same");
massSwap->Draw("same");
f->Draw("same");
leg->Draw("same");
texCms->Draw();
texCol->Draw();
texPt->Draw();
texY->Draw();
texYield->Draw();
cPull->cd();
TPad* pPull = new TPad("pPull","",0,0,1,0.3);
pPull->SetTopMargin(0);
pPull->SetBottomMargin(0.3);
pPull->Draw();
pPull->cd();
hPull->Draw("p");
lPull->Draw();
cPull->cd();
cPull->SaveAs(Form("plotFits/DMass_expo_%s_%.0f_%.0f_Pull.pdf",collisionsystem.Data(),ptmin,ptmax));
return mass;
}
void drawingEff_TnPToyStudy::loadHisto(vector<string> *outname) {
if (!finput) cout << "Cannot open input file!\n" << endl;
TFile *foutput = new TFile(Form("%s_toySFToy.root",outname->at(1).c_str()),"recreate");
setTDRStyle();
gStyle->SetEndErrorSize(3);
TLatex *lat = new TLatex(); lat->SetNDC(); lat->SetTextSize(0.035);
TCanvas *can = new TCanvas("can","can",600,600);
TLegend *leg = new TLegend(0.55,0.60,0.94,0.88);
SetLegendStyle(leg);
cout << "\n\t" << outname->at(0) << " " << outname->at(1) << endl;
// Load denominator, numerators
///// Eff vs centrality in 4+1 |y| regions (6.5-50 GeV/c), forward & low pT region
TObjArray *hnum = (TObjArray*)finput->Get("hnum_cent_rap0024");
TObjArray *hden = (TObjArray*)finput->Get("hden_cent_rap0024");
bool dofixcent = true; // True: Only if it is centrality drawing (no matter if it's pp or pbpb)
TProfile *tp_cent_rap[5];
tp_cent_rap[0] = simpleEff(hnum, hden, dofixcent);
tp_cent_rap[0]->SetName("tnpSFToy_cent_rap0024");
TH1F *haxes = new TH1F("haxes",";;Efficiency",1,0,100);
haxes->GetXaxis()->SetTitle("Centrality [%]");
haxes->Draw();
tp_cent_rap[0]->Draw("same");
leg->AddEntry(tp_cent_rap[0],"|y|: 0-2.4, 6.5-50 GeV/c","p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_cent_rap_0.png",outname->at(1).c_str()));
can->SaveAs(Form("%s_cent_rap_0.pdf",outname->at(1).c_str()));
vector<TH1*> tps;
vector<string> yname;
yname.push_back("$|y|<2.4$");
tps.push_back(tp_cent_rap[0]);
TString texname = outname->at(1) + "_cent.tex";
inittex(texname.Data(), "Centrality [\\%]", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
delete can;
delete leg;
for (int i=0; i<nbins_4rap; i++) {
TObjArray *hnum1 = (TObjArray*)finput->Get( Form("hnum_cent_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
TObjArray *hden1 = (TObjArray*)finput->Get( Form("hden_cent_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
tp_cent_rap[i+1] = simpleEff(hnum1, hden1, dofixcent);
tp_cent_rap[i+1]->SetName( Form("tnpSFToy_cent_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.55,0.60,0.94,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_cent_rap[i+1]->Draw("same");
leg->AddEntry(tp_cent_rap[i+1],Form("|y|: %.1f-%.1f, 6.5-50 GeV/c",bins_4rap[i],bins_4rap[i+1]),"p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_cent_rap_%d.png",outname->at(1).c_str(),i+1));
can->SaveAs(Form("%s_cent_rap_%d.pdf",outname->at(1).c_str(),i+1));
yname.push_back(Form("$%0.1f<|y|<%0.1f$",bins_4rap[i],bins_4rap[i+1]));
tps.push_back(tp_cent_rap[i+1]);
delete can;
delete leg;
}
texname = outname->at(1) + "_cent_pt65500.tex";
inittex(texname.Data(), "Centrality [\\%]", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
hnum = (TObjArray*)finput->Get("hnum_cent_rap1824_pt3065");
hden = (TObjArray*)finput->Get("hden_cent_rap1824_pt3065");
tp_cent_rap[4] = simpleEff(hnum, hden, dofixcent);
tp_cent_rap[4]->SetName("tnpSFToy_cent_rap1824_pt3065");
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.55,0.60,0.94,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_cent_rap[4]->Draw("same");
leg->AddEntry(tp_cent_rap[4],Form("|y|: %.1f-%.1f, 3-6.5 GeV/c",bins_4rap[nbins_4rap-1],bins_4rap[nbins_4rap]),"p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_cent_rap_%d.png",outname->at(1).c_str(),nbins_4rap));
can->SaveAs(Form("%s_cent_rap_%d.pdf",outname->at(1).c_str(),nbins_4rap));
yname.push_back(Form("$%0.1f<|y|<%0.1f$, $3<p_{T}<6.5$ GeV/c",bins_4rap[nbins_4rap-1],bins_4rap[nbins_4rap]));
tps.push_back(tp_cent_rap[4]);
texname = outname->at(1) + "_cent_pt30500.tex";
inittex(texname.Data(), "Centrality [\\%]", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
delete can;
delete leg;
///// Eff vs pT in 4+1 |y| regions
hnum = (TObjArray*)finput->Get("hnum_pt_rap0024");
hden = (TObjArray*)finput->Get("hden_pt_rap0024");
dofixcent = false;
TProfile *tp_pt_rap[5];
tp_pt_rap[0] = simpleEff(hnum, hden, dofixcent);
tp_pt_rap[0]->SetName("tnpSFToy_pt_rap0024");
haxes->GetXaxis()->SetTitle("p_{T} [GeV/c]");
haxes->SetBins(1,0,50);
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.6,0.68,0.9,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_pt_rap[0]->Draw("same");
if (ispbpb) leg->AddEntry(tp_pt_rap[0],"|y|: 0-2.4, 0-100%","p");
else leg->AddEntry(tp_pt_rap[0],"|y|: 0-2.4","p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_pt_rap_0.png",outname->at(1).c_str()));
can->SaveAs(Form("%s_pt_rap_0.pdf",outname->at(1).c_str()));
yname.push_back("$|y|<2.4$");
tps.push_back(tp_pt_rap[0]);
// |y| ranges have different number of pT bins -> create separate tex files
texname = outname->at(1) + "_pt_rap__rap0024.tex";
inittex(texname.Data(), "$p_{T}$ $\\mathrm{[GeV/c]}$", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
delete can;
delete leg;
for (int i=0; i<nbins_4rap-1; i++) {
TObjArray *hnum1 = (TObjArray*)finput->Get( Form("hnum_pt_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
TObjArray *hden1 = (TObjArray*)finput->Get( Form("hden_pt_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
tp_pt_rap[i+1] = simpleEff(hnum1, hden1, dofixcent);
tp_pt_rap[i+1]->SetName( Form("tnpSFToy_pt_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.6,0.68,0.9,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_pt_rap[i+1]->Draw("same");
if (ispbpb) leg->AddEntry(tp_pt_rap[i+1],Form("|y|: %.1f-%.1f, 0-100%%",bins_4rap[i],bins_4rap[i+1]),"p");
else leg->AddEntry(tp_pt_rap[i+1],Form("|y|: %.1f-%.1f",bins_4rap[i],bins_4rap[i+1]),"p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_pt_rap_%d.png",outname->at(1).c_str(),i+1));
can->SaveAs(Form("%s_pt_rap_%d.pdf",outname->at(1).c_str(),i+1));
yname.push_back(Form("$%0.1f<|y|<%0.1f$",bins_4rap[i],bins_4rap[i+1]));
tps.push_back(tp_pt_rap[i+1]);
delete can;
delete leg;
}
texname = outname->at(1) + "_pt_rap__pt65500.tex";
inittex(texname.Data(), "$p_{T}$ $\\mathrm{[GeV/c]}$", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
for (int i=nbins_4rap-1; i<nbins_4rap; i++) {
TObjArray *hnum1 = (TObjArray*)finput->Get( Form("hnum_pt_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
TObjArray *hden1 = (TObjArray*)finput->Get( Form("hden_pt_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
tp_pt_rap[i+1] = simpleEff(hnum1, hden1, dofixcent);
tp_pt_rap[i+1]->SetName( Form("tnpSFToy_cent_rap%02.0f%02.0f",bins_4rap[i]*10,bins_4rap[i+1]*10) );
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.6,0.68,0.9,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_pt_rap[i+1]->Draw("same");
if (ispbpb) leg->AddEntry(tp_pt_rap[i+1],Form("|y|: %.1f-%.1f, 0-100%%",bins_4rap[i],bins_4rap[i+1]),"p");
else leg->AddEntry(tp_pt_rap[i+1],Form("|y|: %.1f-%.1f",bins_4rap[i],bins_4rap[i+1]),"p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
can->SaveAs(Form("%s_pt_rap_%d.png",outname->at(1).c_str(),i+1));
can->SaveAs(Form("%s_pt_rap_%d.pdf",outname->at(1).c_str(),i+1));
yname.push_back(Form("$%0.1f<|y|<%0.1f$",bins_4rap[i],bins_4rap[i+1]));
tps.push_back(tp_pt_rap[i+1]);
delete can;
delete leg;
}
texname = outname->at(1) + "_pt_rap__pt30500.tex";
inittex(texname.Data(), "$p_{T}$ $\\mathrm{[GeV/c]}$", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
///// Eff vs pT in 3 centrality regions
TProfile *tp_pt_cent[nbins_3cent];
for (int i=0; i<(ispbpb?nbins_3cent-1:1); i++) { // for pp, only the 1st bin is necessary
TObjArray *hnum1 = (TObjArray*)finput->Get( Form("hnum_pt_cent%02.0f%02.0f",bins_3cent[i],bins_3cent[i+1]) );
TObjArray *hden1 = (TObjArray*)finput->Get( Form("hden_pt_cent%02.0f%02.0f",bins_3cent[i],bins_3cent[i+1]) );
tp_pt_cent[i] = simpleEff(hnum1, hden1, dofixcent);
tp_pt_cent[i]->SetName( Form("tnpSFToy_pt_cent%02.0f%02.0f",bins_3cent[i],bins_3cent[i+1]) );
haxes->GetXaxis()->SetTitle("p_{T} [GeV/c]");
haxes->SetBins(1,0,50);
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.67,0.68,0.9,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_pt_cent[i]->Draw("same");
if (ispbpb) {
leg->AddEntry(tp_pt_cent[i],Form("%.0f-%.0f%%",bins_3cent[i],bins_3cent[i+1]),"p");
leg->Draw();
}
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
lat->DrawLatex(0.2,0.80,"|y| < 2.4");
can->SaveAs(Form("%s_pt_cent_%d.png",outname->at(1).c_str(),i));
can->SaveAs(Form("%s_pt_cent_%d.pdf",outname->at(1).c_str(),i));
yname.push_back(Form("$%0.1f-%0.1f$\\%%",bins_3cent[i],bins_3cent[i+1]));
tps.push_back(tp_pt_cent[i]);
delete can;
delete leg;
}
if (ispbpb) {
hnum = (TObjArray*)finput->Get( Form("hnum_pt_cent%02.0f%03.0f",bins_3cent[nbins_3cent-1],bins_3cent[nbins_3cent]) );
hden = (TObjArray*)finput->Get( Form("hden_pt_cent%02.0f%03.0f",bins_3cent[nbins_3cent-1],bins_3cent[nbins_3cent]) );
tp_pt_cent[nbins_3cent-1] = simpleEff(hnum, hden, dofixcent);
tp_pt_cent[nbins_3cent-1]->SetName( Form("tnpSFToy_pt_cent%02.0f%03.0f",bins_3cent[nbins_3cent-1],bins_3cent[nbins_3cent]) );
haxes->GetXaxis()->SetTitle("p_{T} [GeV/c]");
haxes->SetBins(1,0,50);
can = new TCanvas("can","can",600,600);
leg = new TLegend(0.67,0.68,0.9,0.88);
SetLegendStyle(leg);
haxes->Draw();
tp_pt_cent[nbins_3cent-1]->Draw("same");
leg->AddEntry(tp_pt_cent[nbins_3cent-1],Form("%.0f-%.0f%%",bins_3cent[nbins_3cent-1],bins_3cent[nbins_3cent]),"p");
leg->Draw();
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
lat->DrawLatex(0.2,0.80,"|y| < 2.4");
can->SaveAs(Form("%s_pt_cent_%d.png",outname->at(1).c_str(),nbins_3cent));
can->SaveAs(Form("%s_pt_cent_%d.pdf",outname->at(1).c_str(),nbins_3cent));
yname.push_back(Form("$%0.1f-%0.1f$\\%%",bins_3cent[nbins_3cent-1],bins_3cent[nbins_3cent]));
tps.push_back(tp_pt_cent[nbins_3cent-1]);
delete can;
delete leg;
}
texname = outname->at(1) + "_pt_cent.tex";
inittex(texname.Data(), "$p_{T}$ $\\mathrm{[GeV/c]}$", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
///// Eff vs rap integrated
hnum = (TObjArray*)finput->Get("hnum_rap");
hden = (TObjArray*)finput->Get("hden_rap");
TProfile *tp_rap = simpleEff(hnum, hden, dofixcent);
tp_rap->SetName("tnpSFToy_rap");
haxes->GetXaxis()->SetTitle("|y|");
haxes->SetBins(1,0,2.4);
can = new TCanvas("can","can",600,600);
haxes->Draw();
tp_rap->Draw("same");
lat->DrawLatex(0.2,0.85,outname->at(0).c_str());
lat->DrawLatex(0.2,0.80,"6.5-50 GeV/c");
if (ispbpb) lat->DrawLatex(0.2,0.75,"0-100%");
can->SaveAs(Form("%s_rap.png",outname->at(1).c_str()));
can->SaveAs(Form("%s_rap.pdf",outname->at(1).c_str()));
yname.push_back("$6.5<p_{T}<50$ GeV/c, 0-100%");
tps.push_back(tp_rap);
texname = outname->at(1) + "_rap.tex";
inittex(texname.Data(), "|y|", yname);
printHist(tps, texname.Data());
closetex(texname.Data());
tps.clear();
yname.clear();
delete can;
delete lat;
///// Write TProfiles into .root file
foutput->cd();
for (int i=0; i<5; i++)
tp_cent_rap[i]->Write();
for (int i=0; i<nbins_4rap+1; i++)
tp_pt_rap[i]->Write();
for (int i=0; i<(ispbpb?nbins_3cent:1); i++)
tp_pt_cent[i]->Write();
tp_rap->Write();
// Clean up memory
for (int i=0; i<5; i++)
delete tp_cent_rap[i];
for (int i=0; i<nbins_4rap+1; i++)
delete tp_pt_rap[i];
for (int i=0; i<(ispbpb?nbins_3cent:1); i++)
delete tp_pt_cent[i];
delete tp_rap;
}
void plotLimit(string outputDir="./", TString inputs="", TString inputs_blinded="", TString inputXSec="", bool strengthLimit=true, bool blind=false, double energy=7, double luminosity=5.035, TString legendName="ee and #mu#mu channels")
{
setTDRStyle();
gStyle->SetPadTopMargin (0.05);
gStyle->SetPadBottomMargin(0.12);
gStyle->SetPadRightMargin (0.16);
gStyle->SetPadLeftMargin (0.14);
gStyle->SetTitleSize(0.04, "XYZ");
gStyle->SetTitleXOffset(1.1);
gStyle->SetTitleYOffset(1.45);
gStyle->SetPalette(1);
gStyle->SetNdivisions(505);
//get the limits from the tree
TFile* file = TFile::Open(inputs);
printf("Looping on %s\n",inputs.Data());
if(!file) return;
if(file->IsZombie()) return;
TFile* file_blinded = TFile::Open(inputs_blinded);
printf("Looping on %s\n",inputs_blinded.Data());
if(!file_blinded) return;
if(file_blinded->IsZombie()) return;
TTree* tree_blinded = (TTree*)file_blinded->Get("limit");
tree_blinded->GetBranch("mh" )->SetAddress(&Tmh );
tree_blinded->GetBranch("limit" )->SetAddress(&Tlimit );
tree_blinded->GetBranch("limitErr" )->SetAddress(&TlimitErr);
tree_blinded->GetBranch("quantileExpected")->SetAddress(&TquantExp);
TGraph* ExpLimitm2 = getLimitGraph(tree_blinded,0.025);
TGraph* ExpLimitm1 = getLimitGraph(tree_blinded,0.160);
TGraph* ExpLimit = getLimitGraph(tree_blinded,0.500);
TGraph* ExpLimitp1 = getLimitGraph(tree_blinded,0.840);
TGraph* ExpLimitp2 = getLimitGraph(tree_blinded,0.975);
file_blinded->Close();
TTree* tree = (TTree*)file->Get("limit");
tree->GetBranch("mh" )->SetAddress(&Tmh );
tree->GetBranch("limit" )->SetAddress(&Tlimit );
tree->GetBranch("limitErr" )->SetAddress(&TlimitErr);
tree->GetBranch("quantileExpected")->SetAddress(&TquantExp);
TGraph* ObsLimit = getLimitGraph(tree,-1 );
file->Close();
FILE* pFileSStrenght = fopen((outputDir+"SignalStrenght").c_str(),"w");
std::cout << "Printing Signal Strenght" << std::endl;
for(int i=0;i<ExpLimit->GetN();i++){
double M = ExpLimit->GetX()[i];
std::cout << "Mass: " << M << "; ExpLimit: " << ExpLimit->Eval(M) << std::endl;
printf("$%8.6E$ & $%8.6E$ & $[%8.6E,%8.6E]$ & $[%8.6E,%8.6E]$ \\\\\\hline\n",M, ExpLimit->Eval(M), ExpLimitm1->Eval(M), ExpLimitp1->Eval(M), ExpLimitm2->Eval(M), ExpLimitp2->Eval(M));
fprintf(pFileSStrenght, "$%8.6E$ & $%8.6E$ & $[%8.6E,%8.6E]$ & $[%8.6E,%8.6E]$ & $%8.6E$ \\\\\\hline\n",M, ExpLimit->Eval(M), ExpLimitm1->Eval(M), ExpLimitp1->Eval(M), ExpLimitm2->Eval(M), ExpLimitp2->Eval(M), ObsLimit->Eval(M));
if(int(ExpLimit->GetX()[i])%50!=0)continue; //printf("%f ",ObsLimit->Eval(M));
}printf("\n");
fclose(pFileSStrenght);
//get the pValue
inputs = inputs.ReplaceAll("/LimitTree", "/PValueTree");
file = TFile::Open(inputs);
printf("Looping on %s\n",inputs.Data());
if(!file) return;
if(file->IsZombie()) return;
tree = (TTree*)file->Get("limit");
tree->GetBranch("limit" )->SetAddress(&Tlimit );
TGraph* pValue = getLimitGraph(tree,-1);
file->Close();
//make TH Cross-sections
string suffix = outputDir;
TGraph* THXSec = Hxswg::utils::getXSec(outputDir);
scaleGraph(THXSec, 1000); //convert cross-section to fb
double cprime=1.0; double brnew=0.0;
double XSecScaleFactor = 1.0;
if(suffix.find("_cp")!=string::npos){
sscanf(suffix.c_str()+suffix.find("_cp"), "_cp%lf_brn%lf", &cprime, &brnew);
XSecScaleFactor = pow(cprime,2) * (1-brnew);
}
//XSecScaleFactor = 0.001; //pb to fb
scaleGraph(THXSec, XSecScaleFactor);
string prod = "pp_SM";
if(outputDir.find("ggH")!=std::string::npos)prod="gg";
if(outputDir.find("qqH")!=std::string::npos)prod="qq";
if(outputDir.find("ppH")!=std::string::npos)prod="pp";
strengthLimit = false;
if(prod=="pp_SM")strengthLimit=true;
//TGraph *XSecMELA = Hxswg::utils::getXSecMELA(cprime);
//Hxswg::utils::multiplyGraph( ObsLimit, XSecMELA);
//Hxswg::utils::multiplyGraph( ExpLimitm2, XSecMELA);
//Hxswg::utils::multiplyGraph( ExpLimitm1, XSecMELA);
//Hxswg::utils::multiplyGraph( ExpLimit, XSecMELA);
//Hxswg::utils::multiplyGraph( ExpLimitp1, XSecMELA);
//Hxswg::utils::multiplyGraph( ExpLimitp2, XSecMELA);
//Scale exclusion XSec in fb
scaleGraph(ObsLimit , 0.001); //pb to fb
scaleGraph(ExpLimitm2, 0.001); //pb to fb
scaleGraph(ExpLimitm1, 0.001); //pb to fb
scaleGraph(ExpLimit , 0.001); //pb to fb
scaleGraph(ExpLimitp1, 0.001); //pb to fb
scaleGraph(ExpLimitp2, 0.001); //pb to fb
//scal eTH cross-section and limits according to scale factor
//this only apply to NarrowResonnance case
if(strengthLimit){
Hxswg::utils::divideGraph(ObsLimit , THXSec);
Hxswg::utils::divideGraph(ExpLimitm2 , THXSec);
Hxswg::utils::divideGraph(ExpLimitm1 , THXSec);
Hxswg::utils::divideGraph(ExpLimit , THXSec);
Hxswg::utils::divideGraph(ExpLimitp1 , THXSec);
Hxswg::utils::divideGraph(ExpLimitp2 , THXSec);
Hxswg::utils::divideGraph(THXSec , THXSec);
}
//limits in terms of signal strength
TCanvas* c = new TCanvas("c", "c",800,800);
c->SetGridx();
c->SetGridy();
TH1F* framework = new TH1F("Graph","Graph",1,strengthLimit?199:199,2500); //3000);
framework->SetStats(false);
framework->SetTitle("");
framework->GetXaxis()->SetTitle("M_{H} [GeV]");
framework->GetYaxis()->SetTitleOffset(1.70);
if(strengthLimit){
framework->GetYaxis()->SetTitle("#mu = #sigma_{95%} / #sigma_{th}");
framework->GetYaxis()->SetRangeUser(1E-4,1E3);
c->SetLogy(true);
}else{
framework->GetYaxis()->SetTitle((string("#sigma_{95%} (") + prod +" #rightarrow H #rightarrow ZZ) (pb)").c_str());
framework->GetYaxis()->SetRangeUser(1E-3,1E3);
c->SetLogy(true);
}
framework->GetXaxis()->SetLabelOffset(0.007);
framework->GetXaxis()->SetLabelSize(0.03);
framework->GetXaxis()->SetTitleOffset(1.0);
framework->GetXaxis()->SetTitleFont(42);
framework->GetXaxis()->SetTitleSize(0.035);
framework->GetYaxis()->SetLabelFont(42);
framework->GetYaxis()->SetLabelOffset(0.007);
framework->GetYaxis()->SetLabelSize(0.03);
framework->GetYaxis()->SetTitleOffset(1.3);
framework->GetYaxis()->SetTitleFont(42);
framework->GetYaxis()->SetTitleSize(0.035);
framework->Draw();
TGraph* TGObsLimit = ObsLimit; TGObsLimit->SetLineWidth(2);
TGraph* TGExpLimit = ExpLimit; TGExpLimit->SetLineWidth(2); TGExpLimit->SetLineStyle(2);
TCutG* TGExpLimit1S = GetErrorBand("1S", ExpLimitm1, ExpLimitp1);
TCutG* TGExpLimit2S = GetErrorBand("2S", ExpLimitm2, ExpLimitp2); TGExpLimit2S->SetFillColor(5);
THXSec->SetLineWidth(2); THXSec->SetLineStyle(1); THXSec->SetLineColor(4);
TGExpLimit->SetLineColor(1); TGExpLimit->SetLineStyle(2);
TGObsLimit->SetLineWidth(2); TGObsLimit->SetMarkerStyle(20);
TGExpLimit2S->Draw("fc same");
TGExpLimit1S->Draw("fc same");
if(!blind) TGObsLimit->Draw("same P");
TGExpLimit->Draw("same c");
/*if(strengthLimit){
TLine* SMLine = new TLine(framework->GetXaxis()->GetXmin(),1.0,framework->GetXaxis()->GetXmax(),1.0);
SMLine->SetLineWidth(2); SMLine->SetLineStyle(1); SMLine->SetLineColor(4);
SMLine->Draw("same C");
}else{
THXSec->Draw("same C");
}*/
utils::root::DrawPreliminary(luminosity, energy, c);
TLegend* LEG = new TLegend(0.55,0.75,0.85,0.95);
LEG->SetHeader("");
LEG->SetFillColor(0);
LEG->SetFillStyle(0);
LEG->SetTextFont(42);
LEG->SetBorderSize(0);
//LEG->AddEntry(THXSec , "Th prediction" ,"L");
LEG->AddEntry(TGExpLimit , "median expected" ,"L");
LEG->AddEntry(TGExpLimit1S , "expected #pm 1#sigma" ,"F");
LEG->AddEntry(TGExpLimit2S , "expected #pm 2#sigma" ,"F");
if(!blind) LEG->AddEntry(TGObsLimit , "observed" ,"LP");
LEG->Draw();
c->RedrawAxis();
c->SaveAs((outputDir+"Limit.png").c_str());
c->SaveAs((outputDir+"Limit.C").c_str());
c->SaveAs((outputDir+"Limit.pdf").c_str());
//save a summary of the limits
FILE* pFileSum = fopen((outputDir+"LimitSummary").c_str(),"w");
for(int i=0;i<TGExpLimit->GetN();i++){
double M = ExpLimit->GetX()[i];
fprintf(pFileSum, "$%8.6E$ & $%8.6E$ & $[%8.6E,%8.6E]$ & $[%8.6E,%8.6E]$ & $%8.6E$ & Th=$%8.6E$ & pValue=$%8.6E$\\\\\\hline\n",M, ExpLimit->Eval(M), ExpLimitm1->Eval(M), ExpLimitp1->Eval(M), ExpLimitm2->Eval(M), ExpLimitp2->Eval(M), ObsLimit->Eval(M), (THXSec!=NULL)?THXSec->Eval(M):-1, pValue->Eval(M));
if(int(ExpLimit->GetX()[i])%50!=0)continue; printf("%f ",ObsLimit->Eval(M));
}printf("\n");
fclose(pFileSum);
pFileSum = fopen((outputDir+"LimitRange").c_str(),"w");
fprintf(pFileSum, "EXPECTED LIMIT --> "); printLimits(pFileSum,TGExpLimit, TGExpLimit->GetX()[0], TGExpLimit->GetX()[TGExpLimit->GetN()-1]);
if(!blind) fprintf(pFileSum, "OBSERVED LIMIT --> "); printLimits(pFileSum,TGObsLimit, TGObsLimit->GetX()[0], TGObsLimit->GetX()[TGObsLimit->GetN()-1]);
fprintf(pFileSum, "Exp Limits for Model are: "); for(int i=0;i<TGExpLimit->GetN();i++){if(int(TGExpLimit->GetX()[i])%50==0) fprintf(pFileSum, "%f+-%f ",TGExpLimit->GetY()[i], (ExpLimitp1->GetY()[i]-ExpLimitm1->GetY()[i])/2.0);}fprintf(pFileSum,"\n");
if(!blind) { fprintf(pFileSum, "Obs Limits for Model are: "); for(int i=0;i<TGObsLimit->GetN();i++){if(int(TGObsLimit->GetX()[i])%50==0) fprintf(pFileSum, "%f ",TGObsLimit->GetY()[i]);}fprintf(pFileSum,"\n"); }
fclose(pFileSum);
}
//------------------------------------------------------------------------------
// DrawHistogram
//------------------------------------------------------------------------------
void DrawHistogram(TString hname,
TString xtitle,
Int_t ngroup = -1,
Int_t precision = 1,
TString units = "NULL",
Double_t xmin = -999,
Double_t xmax = 999,
Bool_t moveOverflow = true)
{
//TCanvas* canvas = new TCanvas(hname, hname, 550, 720);
TCanvas* canvas = new TCanvas(hname, hname, 800, 800);
TPad* pad1 = new TPad("pad1", "pad1", 0, 0.3, 1, 1.0);
TPad* pad2 = new TPad("pad2", "pad2", 0, 0.0, 1, 0.3);
pad1->SetTopMargin (0.08);
pad1->SetBottomMargin(0.02);
pad1->Draw();
pad2->SetTopMargin (0.08);
pad2->SetBottomMargin(0.35);
pad2->Draw();
//----------------------------------------------------------------------------
// pad1
//----------------------------------------------------------------------------
pad1->cd();
pad1->SetLogy(_setLogy);
THStack* hstack = new THStack(hname, hname);
TH1F* hist[nProcesses];
//Save histograms to root file
TFile* outfile;
//TString fname = Form("files/%s_%djet.root", hname.Data(),_njet);
TString fname = "files/0jet_"+hname+".root";
if(_njet==1) fname = "files/1jet_"+hname+".root";
outfile = new TFile(fname, "create");
TH1F* data;
TH1F* top;
TH1F* tW;
TH1F* WW;
TH1F* WZ;
TH1F* ZZ;
TH1F* Wg;
TH1F* WgSMu;
TH1F* WgSEl;
TH1F* Wjets;
TH1F* Zjets;
TH1F* DYtau;
TH1F* Zgamma;
TH1F* ggH;
for (UInt_t ip=0; ip<nProcesses; ip++) {
hist[ip] = (TH1F*)input[ip]->Get(hname);
hist[ip]->SetName(hname + process[ip]);
hist[ip]->SetTitle("");
if(ip == iData) data = (TH1F*)hist[iData]->Clone("Data"); //data -> Sumw2();
if(ip == itt) top = (TH1F*)hist[itt]->Clone("top"); //top -> Sumw2();
if(ip == itW) tW = (TH1F*)hist[itW]->Clone("tW"); //tW -> Sumw2();
if(ip == iWW) WW = (TH1F*)hist[iWW]->Clone("WW"); //WW -> Sumw2();
if(ip == iWZ) WZ = (TH1F*)hist[iWZ]->Clone("WZ"); //VV -> Sumw2();
if(ip == iZZ) ZZ = (TH1F*)hist[iZZ]->Clone("ZZ"); //ZZ -> Sumw2();
if(ip == iWg) Wg = (TH1F*)hist[iWg]->Clone("Wg"); //Wg -> Sumw2();
if(ip == iWgSMu){
WgSMu = (TH1F*)hist[iWgSMu]->Clone("WgSMu"); //WgSMu -> Sumw2();
hist[iWgSMu]->Scale(1.5);
}
if(ip == iWgSEl){
WgSEl = (TH1F*)hist[iWgSEl]->Clone("WgSEl"); //WgSel -> Sumw2();
hist[iWgSEl]->Scale(1.5); //WgSel -> Sumw2();
}
if(ip == iWj) Wjets = (TH1F*)hist[iWj]->Clone("W+jets"); //Wjets -> Sumw2();
if(ip == iDY) Zjets = (TH1F*)hist[iDY]->Clone("Z+jets"); //Zjets -> Sumw2();
if(ip == iDYtau) DYtau = (TH1F*)hist[iDYtau]->Clone("DYtau"); //DYtau -> Sumw2();
if(ip == iZgamma) Zgamma = (TH1F*)hist[iZgamma]->Clone("Zgamma"); //Zgamma -> Sumw2();
if(ip == iH125) ggH = (TH1F*)hist[iH125]->Clone("ggH"); //ggH -> Sumw2();
if (moveOverflow) MoveOverflowBins (hist[ip], xmin, xmax);
else ZeroOutOfRangeBins(hist[ip], xmin, xmax);
if (ngroup > 0) hist[ip]->Rebin(ngroup);
if (ip == iWg) {
//hist[ip]->Scale(0.01);
}
if (ip == iData) {
hist[ip]->SetMarkerStyle(kFullCircle);
}
else {
hist[ip]->SetFillColor(color[ip]);
hist[ip]->SetFillStyle(1001);
hist[ip]->SetLineColor(color[ip]);
if (_dataDriven && ip == itt) hist[ip]->Scale(ttScale[_njet]);
if (_dataDriven && ip == itW) hist[ip]->Scale(tWScale[_njet]);
if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]);
if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]);
if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]);
if( ip != iZZ ) hstack->Add(hist[ip]);//TODO something wrong with ZZ
}
}
if (_dataDriven)
{
top->Scale(ttScale[_njet]);
tW->Scale(tWScale[_njet]);
WW->Scale(WWScale[_njet]);
Zjets->Scale(ZjScale[_njet]);
DYtau->Scale(ZjScale[_njet]);
}
top ->Add(tW);
//VV ->Add(ZZ);
//VV ->Add(Wg);
//Zjets->Add(DYtau);
//Zjets->Add(Zgamma);
data -> Write();
top -> Write();
WW -> Write();
//VV -> Write();
//Wjets -> Write();
//Zjets -> Write();
ggH -> Write();
outfile->Close();
// All MC
//----------------------------------------------------------------------------
TH1F* allmc = (TH1F*)hist[iData]->Clone("allmc");
allmc->SetFillColor (kGray+2);
allmc->SetFillStyle ( 3345);
allmc->SetLineColor (kGray+2);
allmc->SetMarkerColor(kGray+2);
allmc->SetMarkerSize ( 0);
for (UInt_t ibin=1; ibin<=allmc->GetNbinsX(); ibin++) {
Double_t binValue = 0;
Double_t binError = 0;
for (UInt_t ip=0; ip<nProcesses; ip++) {
if (ip == iData) continue;
if (ip == iZZ) continue;
Double_t binContent = hist[ip]->GetBinContent(ibin);
binValue += binContent;
binError += (hist[ip]->GetBinError(ibin) * hist[ip]->GetBinError(ibin));
//We need to calculate systematic uncertainty for ggH case
// if (_dataDriven)
// binError += (systError[ip]*binContent * systError[ip]*binContent);
}
binError = sqrt(binError);
allmc->SetBinContent(ibin, binValue);
allmc->SetBinError (ibin, binError);
}
// Axis labels
//------------------------------------------------------------------
TAxis* xaxis = hist[iData]->GetXaxis();
TAxis* yaxis = hist[iData]->GetYaxis();
TString ytitle = Form("entries / %s.%df", "%", precision);
xaxis->SetTitle(xtitle);
yaxis->SetTitle(Form(ytitle.Data(), hist[iData]->GetBinWidth(0)));
yaxis->SetTitleOffset(1.6);
if (!units.Contains("NULL")) {
xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data()));
yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data()));
}
// Draw
//--------------------------------------------------------------------
xaxis->SetRangeUser(xmin, xmax);
hist[iData]->Draw("ep");
hstack ->Draw("hist,same");
allmc ->Draw("e2,same");
hist[iData]->Draw("ep,same");
// Adjust scale
//----------------------------------------------------------------------------
Float_t theMax = GetMaximumIncludingErrors(hist[iData], xmin, xmax);
Float_t theMaxMC = GetMaximumIncludingErrors(allmc, xmin, xmax);
if (theMaxMC > theMax) theMax = theMaxMC;
if (pad1->GetLogy()) {
theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7);
hist[iData]->SetMinimum(0.05);
}
else theMax *= 1.55;
hist[iData]->SetMaximum(theMax);
// Legend
//----------------------------------------------------------------------
Double_t x0 = 0.720;
Double_t y0 = 0.834;
Double_t yoffset = 0.048;
Double_t delta = yoffset + 0.001;
Double_t ndelta = 0;
Double_t YieldTop = Yield(hist[itt]) + Yield(hist[itW]);
Double_t YieldWZ = Yield(hist[iWZ]);
Double_t YieldVV = Yield(hist[iWZ]) + Yield(hist[iZZ]) + Yield(hist[iWg]);
//Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]);
Double_t YieldZJets = Yield(hist[iDY]) + Yield(hist[iDYtau]) + Yield(hist[iZgamma]);
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iData], Form(" data (%.0f)", Yield(hist[iData])), "lp", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.49, y0 - ndelta, allmc, Form(" all (%.0f)", Yield(allmc)), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWW], Form(" WW (%.0f)", Yield(hist[iWW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWZ], Form(" WZ (%.0f)", Yield(hist[iWZ])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWg], Form(" Wg (%.0f)", Yield(hist[iWg])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSMu], Form(" Wg*Mu (%.0f)", Yield(hist[iWgSMu])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWgSEl], Form(" Wg*El (%.0f)", Yield(hist[iWgSEl])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iWj], Form(" W+jets (%.0f)",Yield(hist[iWj])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, hist[iZZ], Form(" ZZ (%.0f)", Yield(hist[iZZ])), "f", 0.03, 0.2, yoffset); ndelta += delta;
ndelta = 0;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" DY (%.0f)", Yield(hist[iDY])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDYtau], Form(" DYtau (%.0f)", Yield(hist[iDYtau])),"f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iZgamma],Form(" Zg (%.0f)", Yield(hist[iZgamma])),"f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[iDY], Form(" Z+jets (%.0f)", YieldZJets), "f", 0.03, 0.2, yoffset); ndelta += delta;
//DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" Higgs (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[iH125], Form(" ggH (%.0f)", Yield(hist[iH125])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[itt], Form(" tt (%.0f)", Yield(hist[itt])), "f", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.23, y0 - ndelta, hist[itW], Form(" tW (%.0f)", Yield(hist[itW])), "f", 0.03, 0.2, yoffset); ndelta += delta;
// Additional titles
//----------------------------------------------------------------------------
//TString channelLabel = "ee/#mu#mu/e#mu/#mue";
TString channelLabel = "";
//if (_channel == "EE") channelLabel = "ee";
//if (_channel == "MuMu") channelLabel = "#mu#mu";
//if (_channel == "EMu") channelLabel = "e#mu";
//if (_channel == "MuE") channelLabel = "#mue";
//if (_channel == "SF") channelLabel = "ee/#mu#mu";
//if (_channel == "OF") channelLabel = "e#mu/#mue";
channelLabel += Form(" %d", _njet);
if (_njet == 0) channelLabel += "-jets";
if (_njet == 1) channelLabel += "-jet";
if (_njet >= 2) channelLabel += "-jets";
double nBin;
double binWidth;
nBin = allmc->GetSize();
nBin -=2;
binWidth = allmc->GetBinWidth(2);
int Z1bin=70/binWidth;
int Z2bin=110/binWidth;
cout<<"number of bin: "<<nBin<<endl;
cout<<"Z bin1: "<<Z1bin<<" Z bin2: "<<Z2bin<<endl;
double nMcZ, nDataZ;
nMcZ = allmc->Integral(Z1bin,Z2bin);
nDataZ = hist[iData]->Integral(Z1bin,Z2bin);
double effiCorr;
effiCorr=nDataZ/nMcZ;
cout<<"efficiency correction factor: "<<effiCorr<<endl;
double nMcGstar, nDataGstar, nMcGamma;
nMcGstar = hist[iWgSMu]->Integral(1,2);
nMcGamma = hist[iWg]->Integral(1,2);
//nMcGstar = allmc->Integral(1,2);
nMcGstar *= effiCorr;
nMcGamma *= effiCorr;
nDataGstar = hist[iData]->Integral(1,2);
double Kfactor;
double KfactorErr;
nDataGstar -= nMcGamma;
Kfactor = nDataGstar/nMcGstar;
KfactorErr =Kfactor* TMath::Sqrt(nDataGstar/nDataGstar/nDataGstar + nMcGstar/nMcGstar/nMcGstar);
KfactorErr += 0.1;
cout<<"Kfactor: "<<Kfactor<<"+"<<KfactorErr<<endl;
//DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data(),"");
DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3),"");
DrawTLatex(0.45, 0.48, 0.04, 13, Form("K factor (Data/Wg*) = %.2f #pm %.2f", Kfactor, KfactorErr ),"");
DrawTLatex(0.45, 0.43, 0.04, 13, Form("0< InvM(#mu^{+}#mu^{-}) <4 GeV"),"");
//----------------------------------------------------------------------------
// pad2
//----------------------------------------------------------------------------
pad2->cd();
TH1F* ratio = (TH1F*)hist[iData]->Clone("ratio");
TH1F* uncertainty = (TH1F*)allmc->Clone("uncertainty");
for (UInt_t ibin=1; ibin<=ratio->GetNbinsX(); ibin++) {
Double_t mcValue = allmc->GetBinContent(ibin);
Double_t mcError = allmc->GetBinError (ibin);
Double_t dtValue = ratio->GetBinContent(ibin);
Double_t dtError = ratio->GetBinError (ibin);
Double_t ratioValue = (mcValue > 0) ? dtValue/mcValue : 0.0;
Double_t ratioError = (mcValue > 0) ? dtError/mcValue : 0.0;
Double_t uncertaintyError = (mcValue > 0) ? mcError/mcValue : 0.0;
ratio->SetBinContent(ibin, ratioValue);
ratio->SetBinError (ibin, ratioError);
uncertainty->SetBinContent(ibin, 1.0);
uncertainty->SetBinError (ibin, uncertaintyError);
}
TAxis* uaxis = (TAxis*)uncertainty->GetXaxis();
uaxis->SetRangeUser(xmin, xmax);
uncertainty->Draw("e2");
ratio ->Draw("ep,same");
uncertainty->GetYaxis()->SetRangeUser(0, 2.5);
// Save
//----------------------------------------------------------------------
pad2->cd(); SetAxis(uncertainty, hist[iData]->GetXaxis()->GetTitle(), "data / prediction", 0.10, 0.8);
pad1->cd(); SetAxis(hist[iData], "", hist[iData]->GetYaxis()->GetTitle(), 0.05, 1.6);
canvas->cd();
TString suffixLogy = (_setLogy) ? "_Log" : "_Lin";
canvas->SaveAs(Form("%s/%s%s.%s",
_output.Data(),
hname.Data(),
suffixLogy.Data(),
_format.Data()));
}
void embeddedToysWithBackgDetEffects_1DKD(int nEvts=600, int nToys=3000,
sample mySample = kScalar_fa3p5,
bool bkg, bool sigFloating, int counter){
RooRealVar* kd = new RooRealVar("psMELA","psMELA",0,1);
kd->setBins(1000);
RooPlot* kdframe1 = kd->frame();
// 0- template
TFile f1("KDdistribution_ps_analytical_detEff.root", "READ");
TH1F *h_KD_ps = (TH1F*)f1.Get("h_KD");
h_KD_ps->SetName("h_KD_ps");
RooDataHist rdh_KD_ps("rdh_KD_ps","rdh_KD_ps",RooArgList(*kd),h_KD_ps);
RooHistPdf pdf_KD_ps("pdf_KD_ps","pdf_KD_ps",RooArgList(*kd),rdh_KD_ps);
// 0+ template
TFile f2("KDdistribution_sm_analytical_detEff.root", "READ");
TH1F *h_KD_sm = (TH1F*)f2.Get("h_KD");
h_KD_sm->SetName("h_KD_sm");
RooDataHist rdh_KD_sm("rdh_KD_sm","rdh_KD_sm",RooArgList(*kd),h_KD_sm);
RooHistPdf pdf_KD_sm("pdf_KD_sm","pdf_KD_sm",RooArgList(*kd),rdh_KD_sm);
// backg template
TFile f3("KDdistribution_bkg_analytical_detEff.root", "READ");
TH1F *h_KD_bkg = (TH1F*)f3.Get("h_KD");
h_KD_bkg->SetName("h_KD_bkg");
RooDataHist rdh_KD_bkg("rdh_KD_bkg","rdh_KD_bkg",RooArgList(*kd),h_KD_bkg);
RooHistPdf pdf_KD_bkg("pdf_KD_bkg","pdf_KD_bkg",RooArgList(*kd),rdh_KD_bkg);
//Define signal model with 0+, 0- mixture
RooRealVar rrv_fa3("fa3","fa3",0.5,0.,1.); //free parameter of the model
RooFormulaVar rfv_fa3Obs("fa3obs","1/ (1 + (1/@0 - 1)*0.99433)",RooArgList(rrv_fa3));
RooAddPdf modelSignal("modelSignal","ps+sm",pdf_KD_ps,pdf_KD_sm,rfv_fa3Obs);
rrv_fa3.setConstant(kFALSE);
//Define signal+bakground model
RooRealVar rrv_BoverTOT("BoverTOT","BoverTOT",1/(3.75+1),0.,10.);
RooAddPdf model("model","background+modelSignal",pdf_KD_bkg,modelSignal,rrv_BoverTOT);
if(sigFloating)
rrv_BoverTOT.setConstant(kFALSE);
else
rrv_BoverTOT.setConstant(kTRUE);
//Set the values of free parameters to compute pulls
double fa3Val=-99;
if (mySample == kScalar_fa3p0)
fa3Val=0.;
else if (mySample == kScalar_fa3p1)
fa3Val=0.1;
else if (mySample == kScalar_fa3p5 || mySample == kScalar_fa3p5phia390)
fa3Val=0.5;
else if (mySample == kScalar_fa3p25)
fa3Val=0.25;
else{
cout<<"fa3Val not correct!"<<endl;
return 0;
}
double sigFracVal=1 - 1/(3.75+1);
//Plot the models
TCanvas* c = new TCanvas("modelPlot_detBkg","modelPlot_detBkg",400,400);
rdh_KD_ps.plotOn(kdframe1,LineColor(kBlack),MarkerColor(kBlack));
pdf_KD_ps.plotOn(kdframe1,LineColor(kBlack),RooFit::Name("pseudo"));
//rdh_KD_sm.plotOn(kdframe1,LineColor(kBlue),MarkColor(kBlue));
pdf_KD_sm.plotOn(kdframe1,LineColor(kBlue),RooFit::Name("SM"));
//rdh_KD_bkg.plotOn(kdframe1,LineColor(kGreen),LineColor(kGreen));
pdf_KD_bkg.plotOn(kdframe1,LineColor(kGreen),RooFit::Name("bkg"));
modelSignal.plotOn(kdframe1,LineColor(kRed),RooFit::Name("signal_fa3p5"));
model.plotOn(kdframe1,LineColor(kOrange),RooFit::Name("signal+background"));
TLegend *leg = new TLegend (0.7,0.6,0.95,0.8);
leg->AddEntry(kdframe1->findObject("pseudo"),"0-","L");
leg->AddEntry(kdframe1->findObject("SM"),"0+","L");
leg->AddEntry(kdframe1->findObject("bkg"),"bkg","L");
leg->AddEntry(kdframe1->findObject("signal_fa3p5"),"signal fa3=0.5","L");
leg->AddEntry(kdframe1->findObject("signal+background"),"signal + bkg","L");
kdframe1->Draw();
leg->SetFillColor(kWhite);
leg->Draw("same");
c->SaveAs("modelPlot_detBkg.eps");
c->SaveAs("modelPlot_detBkg.png");
//Load the trees into the datasets
TChain* myChain = new TChain("SelectedTree");
myChain->Add(inputFileNames[mySample]);
if(!myChain || myChain->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data = new RooDataSet("data","data",myChain,RooArgSet(*kd),"");
TChain* myChain_bkg = new TChain("SelectedTree");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut10_smeared_withDiscriminants_2e2mu_cutDetector.root");
myChain_bkg->Add("samples/analyticalpsMELA/withResolution/pwgevents_mllCut4_wResolution_withDiscriminants_cutDetector.root");
if(!myChain_bkg || myChain_bkg->GetEntries()<=0) {
cout<<"error in the tree"<<endl;
return 0;
}
RooDataSet* data_bkg = new RooDataSet("data_bkg","data_bkg",myChain_bkg,RooArgSet(*kd),"");
cout << "Number of events in data sig: " << data->numEntries() << endl;
cout << "Number of events in data bkg: " << data_bkg->numEntries() << endl;
// Initialize tree to save toys to
TTree* results = new TTree("results","toy results");
double fa3,fa3Error, fa3Pull;
double sigFrac,sigFracError, sigFracPull;
double significance;
results->Branch("fa3",&fa3,"fa3/D");
results->Branch("fa3Error",&fa3Error,"fa3Error/D");
results->Branch("fa3Pull",&fa3Pull,"fa3Pull/D");
results->Branch("sigFrac",&sigFrac,"sigFrac/D");
results->Branch("sigFracError",&sigFracError,"sigFracError/D");
results->Branch("sigFracPull",&sigFracPull,"sigFracPull/D");
results->Branch("significance",&significance,"significance/D");
//---------------------------------
RooDataSet* toyData;
RooDataSet* toyData_bkgOnly;
int embedTracker=nEvts*counter;
int embedTracker_bkg=TMath::Ceil(nEvts/3.75*counter);
RooArgSet *tempEvent;
RooFitResult *toyfitresults;
RooFitResult *toyfitresults_sigBkg;
RooFitResult *toyfitresults_bkgOnly;
RooRealVar *r_fa3;
RooRealVar *r_sigFrac;
for(int i = 0 ; i<nToys ; i++){
cout <<i<<"<-----------------------------"<<endl;
//if(toyData) delete toyData;
toyData = new RooDataSet("toyData","toyData",RooArgSet(*kd));
toyData_bkgOnly = new RooDataSet("toyData_bkgOnly","toyData_bkgOnly",RooArgSet(*kd));
if(nEvts+embedTracker > data->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
if(nEvts+embedTracker_bkg > data_bkg->sumEntries()){
cout << "Playground::generate() - ERROR!!! Playground::data does not have enough events to fill toy!!!! bye :) " << endl;
toyData = NULL;
abort();
return 0;
}
for(int iEvent=0; iEvent<nEvts; iEvent++){
if(iEvent==1)
cout << "generating event: " << iEvent << " embedTracker: " << embedTracker << endl;
tempEvent = (RooArgSet*) data->get(embedTracker);
toyData->add(*tempEvent);
embedTracker++;
}
if(bkg){
for(int iEvent=0; iEvent<nEvts/3.75; iEvent++){
if(iEvent==1)
cout << "generating bkg event: " << iEvent << " embedTracker bkg: " << embedTracker_bkg << endl;
tempEvent = (RooArgSet*) data_bkg->get(embedTracker_bkg);
toyData->add(*tempEvent);
toyData_bkgOnly->add(*tempEvent);
embedTracker_bkg++;
}
}
if(bkg)
toyfitresults =model.fitTo(*toyData,Save());
else
toyfitresults =modelSignal.fitTo(*toyData,Save());
//cout<<toyfitresults<<endl;
r_fa3 = (RooRealVar *) toyfitresults->floatParsFinal().find("fa3");
fa3 = r_fa3->getVal();
fa3Error = r_fa3->getError();
fa3Pull = (r_fa3->getVal() - fa3Val) / r_fa3->getError();
if(sigFloating){
r_sigFrac = (RooRealVar *) toyfitresults->floatParsFinal().find("BoverTOT");
sigFrac = 1-r_sigFrac->getVal();
sigFracError = r_sigFrac->getError();
sigFracPull = (1-r_sigFrac->getVal() - sigFracVal) / r_sigFrac->getError();
}
// fill TTree
results->Fill();
}
char nEvtsString[100];
sprintf(nEvtsString,"_%iEvts_%iiter",nEvts, counter);
// write tree to output file (ouputFileName set at top)
TFile *outputFile = new TFile("embeddedToys1DKD_fa3Corr_WithBackgDetEffects_"+sampleName[mySample]+nEvtsString+".root","RECREATE");
results->Write();
outputFile->Close();
}
//------------------------------------------------------------------------------
//Subtraction
//------------------------------------------------------------------------------
void Subtraction(TString hname,
TString xtitle,
Int_t ngroup = -1,
Int_t precision = 1,
TString units = "NULL",
Double_t xmin = -999,
Double_t xmax = 999,
Bool_t moveOverflow = true)
{
TCanvas* canvas = new TCanvas(hname, hname, 800, 800);
TPad* pad1 = new TPad("pad1", "pad1", 0, 0.0, 1, 1.0);
pad1->SetTopMargin (0.08);
//pad1->SetBottomMargin(0.02);
pad1->Draw();
//----------------------------------------------------------------------------
// pad1
//----------------------------------------------------------------------------
pad1->cd();
pad1->SetLogy(_setLogy);
TH1F* hist[nProcesses];
for (UInt_t ip=0; ip<nProcesses; ip++) {
hist[ip] = (TH1F*)input[ip]->Get(hname);
hist[ip]->SetName(hname + process[ip]);
if (moveOverflow) MoveOverflowBins (hist[ip], xmin, xmax);
else ZeroOutOfRangeBins(hist[ip], xmin, xmax);
if (ngroup > 0) hist[ip]->Rebin(ngroup);
if (_dataDriven && ip == iWW) hist[ip]->Scale(WWScale[_njet]);
if (_dataDriven && ip == iDY) hist[ip]->Scale(ZjScale[_njet]);
if (_dataDriven && ip == iDYtau) hist[ip]->Scale(ZjScale[_njet]);
}
// Data subtraction for Top background estimation
//----------------------------------------------------------------------------
TH1F* subData = (TH1F*)hist[iData]->Clone("subData");
for (UInt_t ip=0; ip<nProcesses; ip++) {
if (ip == itt) continue;
if (ip == itW) continue;
if (ip == iData ) continue;
subData->Add(hist[ip],-1);
}
subData->SetLineColor(kRed+1);
Double_t subData_Yield = subData->Integral();
//subData->SetLineColor();
// Top background
//----------------------------------------------------------------------------
TH1F* Top = (TH1F*)hist[itt]->Clone("Top");
Top->Add(hist[itW]);
Top->SetLineColor(kBlue+1);
Double_t Top_Yield = Top->Integral();
// Axis labels
//----------------------------------------------------------------------------
TAxis* xaxis = subData->GetXaxis();
TAxis* yaxis = subData->GetYaxis();
TString ytitle = Form("entries / %s.%df", "%", precision);
xaxis->SetTitle(xtitle);
yaxis->SetTitle(Form(ytitle.Data(), subData->GetBinWidth(0)));
yaxis->SetTitleOffset(1.6);
if (!units.Contains("NULL")) {
xaxis->SetTitle(Form("%s [%s]", xaxis->GetTitle(), units.Data()));
yaxis->SetTitle(Form("%s %s", yaxis->GetTitle(), units.Data()));
}
// Draw
//----------------------------------------------------------------------------
xaxis->SetRangeUser(xmin, xmax);
subData->Draw("hist");
Top->Draw("hist same");
// Adjust scale
//----------------------------------------------------------------------------
subData->SetMinimum(0.0);
Float_t theMax = GetMaximumIncludingErrors(subData, xmin, xmax);
Float_t theMaxMC = GetMaximumIncludingErrors(Top, xmin, xmax);
if (theMaxMC > theMax) theMax = theMaxMC;
if (pad1->GetLogy()) {
theMax = TMath::Power(10, TMath::Log10(theMax) + 2.7);
subData->SetMinimum(0.05);
}
else theMax *= 1.55;
subData->SetMaximum(theMax);
// Legend
//----------------------------------------------------------------------------
Double_t x0 = 0.720;
Double_t y0 = 0.834;
Double_t yoffset = 0.048;
Double_t delta = yoffset + 0.001;
Double_t ndelta = 0;
DrawLegend(x0 - 0.49, y0 - ndelta, subData, Form(" Data Subtraction (MC without Top) (%.0f)", Yield(subData)), "l", 0.03, 0.2, yoffset); ndelta += delta;
DrawLegend(x0 - 0.49, y0 - ndelta, Top, Form(" Top (%.0f)", Yield(Top)), "l", 0.03, 0.2, yoffset); ndelta += delta;
// Additional titles
//----------------------------------------------------------------------------
//TString channelLabel = "ee/#mu#mu/e#mu/#mue";
TString channelLabel = "";
//if (_channel == "EE") channelLabel = "ee";
//if (_channel == "MuMu") channelLabel = "#mu#mu";
//if (_channel == "EMu") channelLabel = "e#mu";
//if (_channel == "MuE") channelLabel = "#mue";
//if (_channel == "SF") channelLabel = "ee/#mu#mu";
//if (_channel == "OF") channelLabel = "e#mu/#mue";
channelLabel += Form(" %d", _njet);
if (_njet == 0) channelLabel += "-jets";
if (_njet == 1) channelLabel += "-jet";
if (_njet >= 2) channelLabel += "-jets";
DrawTLatex(0.185, 0.975, 0.05, 13, channelLabel.Data(),"");
DrawTLatex(0.940, 0.983, 0.05, 33, Form("L = %.1f fb^{-1}", _luminosity/1e3),"");
if (Top_Yield!=0){
cout << "subData_Yield = "<<subData_Yield<<", Top_Yield = "<<Top_Yield<<", Ratio = "<< subData_Yield/Top_Yield <<endl;
TLatex *tex3 = new TLatex(0.250, 0.75, "Scale Factor");
tex3->SetNDC();
tex3->SetTextSize(0.035);
tex3->Draw();
TLatex *tex4 = new TLatex(0.250, 0.7, Form("%.0f / %.0f = %3.3f",subData_Yield ,Top_Yield ,subData_Yield/Top_Yield));
tex4->SetNDC();
tex4->SetTextSize(0.035);
tex4->Draw();
}
// Save
//----------------------------------------------------------------------------
pad1->cd();
//SetAxis(subData, "", subData->GetYaxis()->GetTitle(), 0.05, 1.6);
canvas->cd();
TString suffixLogy = (_setLogy) ? "_Log" : "_Lin";
canvas->SaveAs(Form("%s/%s%s_sub.%s",
_output.Data(),
hname.Data(),
suffixLogy.Data(),
_format.Data()));
}
void makejpsifit(string inputFilename, string outFilename,
Int_t ptBin, Int_t etaBin,
double minMass, double maxMass,
double mean_bw, double gamma_bw, double cutoff_cb, double power_cb,
const char* plotOpt, const int nbins, Int_t isMC) {
TStyle *mystyle = RooHZZStyle("ZZ");
mystyle->cd();
//Create Data Set
RooRealVar mass("zmass","m(e^{+}e^{-})",minMass,maxMass,"GeV/c^{2}");
// Reading everything from root tree instead
TFile *tfile = TFile::Open(inputFilename.c_str());
TTree *ttree = (TTree*)tfile->Get("zeetree/probe_tree");
hzztree *zeeTree = new hzztree(ttree);
RooArgSet zMassArgSet(mass);
RooDataSet* data = new RooDataSet("data", "ntuple parameters", zMassArgSet);
for (int i = 0; i < zeeTree->fChain->GetEntries(); i++) {
if(i%100000==0) cout << "Processing Event " << i << endl;
zeeTree->fChain->GetEntry(i);
//*************************************************************************
//Electron Selection
//*************************************************************************
// already passed for this tree
//*************************************************************************
//Compute electron four vector;
//*************************************************************************
double ele1pt = zeeTree->l1pt;
double ele2pt = zeeTree->l2pt;
double ELECTRONMASS = 0.51e-3;
TLorentzVector ele1FourVector;
ele1FourVector.SetPtEtaPhiM(zeeTree->l1pt, zeeTree->l1eta, zeeTree->l1phi, ELECTRONMASS);
TLorentzVector ele2FourVector;
ele2FourVector.SetPtEtaPhiM(zeeTree->l2pt, zeeTree->l2eta, zeeTree->l2phi, ELECTRONMASS);
//*************************************************************************
//pt and eta cuts on electron
//*************************************************************************
if (! (ele1pt > 7 && ele2pt > 7
&& fabs( zeeTree->l1eta) < 2.5
&& fabs( zeeTree->l2eta) < 2.5 )) continue;
//*************************************************************************
//pt bins and eta bins
//*************************************************************************
Int_t Ele1PtBin = -1;
Int_t Ele1EtaBin = -1;
Int_t Ele2PtBin = -1;
Int_t Ele2EtaBin = -1;
if (ele1pt > 7 && ele1pt < 10) Ele1PtBin = 0;
else if (ele1pt < 20) Ele1PtBin = 1;
else Ele1PtBin = 2;
if (ele2pt > 7 && ele2pt < 10) Ele2PtBin = 0;
else if (ele2pt < 20) Ele2PtBin = 1;
else Ele2PtBin = 2;
if (fabs(zeeTree->l1sceta) < 1.479) Ele1EtaBin = 0;
else Ele1EtaBin = 1;
if (fabs(zeeTree->l2sceta) < 1.479) Ele2EtaBin = 0;
else Ele2EtaBin = 1;
if (!(Ele1PtBin == ptBin || Ele2PtBin == ptBin)) continue;
if (!(Ele1EtaBin == etaBin && Ele2EtaBin == etaBin)) continue;
//*************************************************************************
// restrict range of mass
//*************************************************************************
double zMass = (ele1FourVector+ele2FourVector).M();
if (zMass < minMass || zMass > maxMass) continue;
//*************************************************************************
//set mass variable
//*************************************************************************
zMassArgSet.setRealValue("zmass", zMass);
data->add(zMassArgSet);
}
// do binned fit to gain time...
mass.setBins(nbins);
RooDataHist *bdata = new RooDataHist("data_binned","data_binned", zMassArgSet, *data);
cout << "dataset size: " << data->numEntries() << endl;
// // Closing file
// treeFile->Close();
//====================== Parameters===========================
//Crystal Ball parameters
// RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
// RooRealVar cbSigma("sigma_{CB}", "CB Width", 1.7, 0.8, 5.0, "GeV/c^{2}");
// RooRealVar cbCut ("a_{CB}","CB Cut", 1.05, 1.0, 3.0);
// RooRealVar cbPower("n_{CB}","CB Order", 2.45, 0.1, 20.0);
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", -.01, -10, 10, "GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}", "CB Width", 1.5, 0.01, 5.0, "GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.0, 1.0, 3.0);
RooRealVar cbPower("n_{CB}","CB Order", 2.5, 0.1, 20.0);
cbCut.setVal(cutoff_cb);
cbPower.setVal(power_cb);
// Just checking
//cbCut.Print();
//cbPower.Print();
//Breit_Wigner parameters
RooRealVar bwMean("m_{JPsi}","BW Mean", 3.096916, "GeV/c^{2}");
bwMean.setVal(mean_bw);
RooRealVar bwWidth("#Gamma_{JPsi}", "BW Width", 92.9e-6, "GeV/c^{2}");
bwWidth.setVal(gamma_bw);
// Fix the Breit-Wigner parameters to PDG values
bwMean.setConstant(kTRUE);
bwWidth.setConstant(kTRUE);
// Exponential Background parameters
RooRealVar expRate("#lambda_{exp}", "Exponential Rate", -0.064, -1, 1);
RooRealVar c0("c_{0}", "c0", 1., 0., 50.);
//Number of Signal and Background events
RooRealVar nsig("N_{S}", "# signal events", 524, 0.1, 10000000000.);
RooRealVar nbkg("N_{B}", "# background events", 43, 1., 10000000.);
//============================ P.D.F.s=============================
// Mass signal for two decay electrons p.d.f.
RooBreitWigner bw("bw", "bw", mass, bwMean, bwWidth);
RooCBShape cball("cball", "Crystal Ball", mass, cbBias, cbSigma, cbCut, cbPower);
RooFFTConvPdf BWxCB("BWxCB", "bw X crystal ball", mass, bw, cball);
// Mass background p.d.f.
RooExponential bg("bg", "exp. background", mass, expRate);
// Mass model for signal electrons p.d.f.
RooAddPdf model("model", "signal", RooArgList(BWxCB), RooArgList(nsig));
TStopwatch t ;
t.Start() ;
double fitmin, fitmax;
if(isMC) {
fitmin = (etaBin==0) ? 3.00 : 2.7;
fitmax = (etaBin==0) ? 3.20 : 3.4;
} else {
fitmin = (etaBin==0) ? ( (ptBin>=2) ? 3.01 : 3.02 ) : 2.7;
fitmax = (etaBin==0) ? ( (ptBin==3) ? 3.23 : 3.22 ) : 3.4;
}
RooFitResult *fitres = model.fitTo(*bdata,Range(fitmin,fitmax),Hesse(1),Minos(1),Timer(1),Save(1));
fitres->SetName("fitres");
t.Print() ;
TCanvas* c = new TCanvas("c","Unbinned Invariant Mass Fit", 0,0,800,600);
//========================== Plotting ============================
//Create a frame
RooPlot* plot = mass.frame(Range(minMass,maxMass),Bins(nbins));
// Add data and model to canvas
int col = (isMC ? kAzure+4 : kGreen+1);
data->plotOn(plot);
model.plotOn(plot,LineColor(col));
data->plotOn(plot);
model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(cbBias, cbSigma, cbCut, cbPower, bwMean, bwWidth, expRate, nsig, nbkg)), Layout(0.15,0.45,0.80));
plot->getAttText()->SetTextSize(.03);
plot->SetTitle("");
plot->Draw();
// Print Fit Values
TLatex *tex = new TLatex();
tex->SetNDC();
tex->SetTextSize(.1);
tex->SetTextFont(132);
// tex->Draw();
tex->SetTextSize(0.057);
if(isMC) tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} MC");
else tex->DrawLatex(0.65, 0.75, "J/#psi #rightarrow e^{+}e^{-} data");
tex->SetTextSize(0.030);
tex->DrawLatex(0.645, 0.65, Form("BW Mean = %.2f GeV/c^{2}", bwMean.getVal()));
tex->DrawLatex(0.645, 0.60, Form("BW #sigma = %.2f GeV/c^{2}", bwWidth.getVal()));
c->Update();
c->SaveAs((outFilename + ".pdf").c_str());
c->SaveAs((outFilename + ".png").c_str());
// tablefile << Form(Outfile + "& $ %f $ & $ %f $ & $ %f $\\ \hline",cbBias.getVal(), cbSigma.getVal(), cbCut.getVal());
// Output workspace with model and data
RooWorkspace *w = new RooWorkspace("JPsieeMassScaleAndResolutionFit");
w->import(model);
w->import(*bdata);
w->writeToFile((outFilename + ".root").c_str());
TFile *tfileo = TFile::Open((outFilename + ".root").c_str(),"update");
fitres->Write();
tfileo->Close();
}
// -----------------------------------------------------------------------------
//
TCanvas* createPlot( TDirectory* output_file,
std::string output_canvas,
std::vector<std::string> input_files,
std::vector<std::string> input_histos,
std::vector<std::string> input_legend,
std::vector<int> marker_style,
std::vector<int> marker_colour,
std::vector<float> marker_size,
std::vector<float> lumis,
double lumi,
int rebin,
bool norm,
bool log,
double min = -1.,
double max = -1. )
{
// SetSomeStyles();
// Create legend
TLegend* legend = new TLegend( 0.6, 0.5, 0.9, 0.7, NULL, "brNDC" );
legend->SetFillColor(0);
legend->SetLineColor(0);
// Create canvas
TCanvas* aCanvas = createCanvas( output_canvas, output_file, log );
TPaveText* stats = new TPaveText( 0.6, 0.3, 0.9, 0.45, "brNDC" );
stats->SetFillColor(0);
stats->SetLineColor(0);
TLatex* prelim = new TLatex( 0.55, 0.8, "#scale[0.8]{CMS preliminary 2011}" );
prelim->SetTextSize(0.04);
prelim->SetNDC();
std::stringstream ssl; ssl << "#scale[0.8]{#int L dt = " << lumi << "pb^{-1}, #sqrt{s} = 7 TeV}";
TLatex* lumistxt = new TLatex( 0.51, 0.87, ssl.str().c_str() );
lumistxt->SetTextSize(0.04);
lumistxt->SetNDC();
// First histo be drawn
bool first = true;
// Loop through histogram names
std::vector<TH1D*> his;
for ( uint ihis = 0; ihis < input_histos.size(); ++ihis ) {
his.push_back( (TH1D*)getHisto( input_files[ihis], input_histos[ihis], "QcdBkgdEst", rebin ) );
}
// For Ted
bool print_ted = true;
std::stringstream ted;
if ( print_ted ) { ted << "self._htMeans = ("; }
// Loop through histograms
double aMax = 0.;
double aMin = 1.e12;
for ( uint ihis = 0; ihis < his.size(); ++ihis ) {
if ( !his[ihis] ) { continue; }
// Line colour and fill
his[ihis]->Scale(lumis[ihis]/100.);
his[ihis]->SetMarkerStyle(marker_style[ihis]);
his[ihis]->SetMarkerColor(marker_colour[ihis]);
his[ihis]->SetMarkerSize(marker_size[ihis]);
his[ihis]->SetLineColor(marker_colour[ihis]);
his[ihis]->SetLineStyle(0);
his[ihis]->SetLineWidth(0);
// Populate legend
if ( input_legend.size() > ihis ) { legend->AddEntry( his[ihis], input_legend[ihis].c_str(), "EPL" ); }
else { legend->AddEntry( his[ihis], input_histos[ihis].c_str(), "EPL" ); }
// Populate stats box
std::stringstream ss;
ss << "Mean=" << int(his[ihis]->GetMean()*100.)/100. << ", RMS=" << int(his[ihis]->GetRMS()*100.)/100.;
TText* text = stats->AddText(ss.str().c_str());
text->SetTextAlign(11);
text->SetTextSize(0.03);
text->SetTextColor(marker_colour[ihis]);
// For Ted
if ( print_ted ) ted << std::setw(9) << std::scientific << std::setprecision(3) << his[ihis]->GetMean() << ", ";
// Calc min/max number of entries
if ( his[ihis]->GetMaximum() > aMax ) { aMax = his[ihis]->GetMaximum(); }
if ( his[ihis]->GetMinimum(1.e-12) < aMin ) { aMin = his[ihis]->GetMinimum(1.e-12); }
}
// For Ted
if ( print_ted ) {
ted << ")" << std::endl;
std::cout << ted.str() << std::endl;
}
if ( !his.empty() ) {
if ( his[0] ) his[0]->GetYaxis()->SetTitleOffset(1.43);
if ( his[0] ) his[0]->GetYaxis()->SetTitleSize(0.06);
if ( his[0] ) his[0]->GetXaxis()->SetTitleSize(0.06);
if ( his[0] ) his[0]->GetXaxis()->SetTitleOffset(0.9);
}
for ( uint ihis = 0; ihis < his.size(); ++ihis ) {
if ( !his[ihis] ) { continue; }
//his[ihis]->GetYaxis()->SetTitle("a.u.");
if ( log ) {
his[ihis]->SetMaximum( aMax * 10. );
his[ihis]->SetMinimum( aMin * 0.1 );
} else {
his[ihis]->SetMaximum( aMax * 1.1 );
his[ihis]->SetMinimum( aMin * 0.9 );
}
if ( min > 0. ) his[ihis]->SetMinimum( min );
if ( max > 0. ) his[ihis]->SetMaximum( max );
if ( norm ) {
std::string options = "";
if ( first ) { options = "Ehist"; first = false; }
else { options = "hsame"; }
if ( his[ihis]->GetEntries() > 0. ) { his[ihis]->DrawNormalized(options.c_str()); }
} else {
std::string options = "";
if ( first ) { options = "h"; first = false; }
else { options = "hsame"; }
his[ihis]->Draw(options.c_str());
}
} // Loop through histos
output_file->cd();
legend->Draw("same");
stats->Draw("same");
prelim->Draw("same");
lumistxt->Draw("same");
aCanvas->Modified();
//aCanvas->SaveAs( std::string(output_canvas+".png").c_str() );
aCanvas->SaveAs( std::string(output_canvas+".pdf").c_str() );
aCanvas->SaveAs( std::string(output_canvas+".C").c_str() );
aCanvas->Write();
return aCanvas;
}
void plot_CL_chi2_roofit(char * filename, double min, double max, double initial, double ndof_min, double ndof_max, char * plot, char * var = "chi2")
{
//gStyle->SetOptStat(0);
//gStyle->SetOptFit(1);
//gStyle->SetStatFontSize(0.02);
TFile * _file0 = TFile::Open(filename);
TTree * t = (TTree*)_file0->Get("tuple");
RooRealVar * chi2 = new RooRealVar(var, "#chi^{2}", min, max);
RooRealVar * ndof = new RooRealVar("ndof", "ndof", initial, ndof_min, ndof_max);
RooChiSquarePdf * pdf = new RooChiSquarePdf("pdf", "pdf", *chi2, *ndof);
RooDataSet * data = new RooDataSet("data", "data", RooArgSet(*chi2), RooFit::Import(*t));
pdf->fitTo(*data);
char formula[30];
sprintf(formula, "TMath::Prob(%s,ndof)", var);
RooFormulaVar * CL_ndof_eff_formula = new RooFormulaVar("CL","CL(#chi^{2})",formula, RooArgList(*chi2, *ndof));
RooRealVar * CL_ndof_eff = (RooRealVar*) data->addColumn(*CL_ndof_eff_formula);
CL_ndof_eff->setRange(0, 1);
RooUniform * uniform = new RooUniform("uniform", "uniform", *CL_ndof_eff);
uniform->fitTo(*data);
//RooFormulaVar * CL_ndof_min_formula = new RooFormulaVar("CL","CL(#chi^{2})","TMath::Prob(chi2,39)", RooArgList(*chi2));
//RooRealVar * CL_ndof_min = (RooRealVar*) data->addColumn(*CL_ndof_min_formula);
//CL_ndof_min->setRange(0, 1);
RooPlot * frame0 = chi2->frame(RooFit::Bins(25));
data->plotOn(frame0);
pdf->plotOn(frame0);
pdf->paramOn(frame0, RooFit::Format("NELU", RooFit::AutoPrecision(2)), RooFit::Layout(0.6,0.95,0.75));
data->statOn(frame0, RooFit::Format("NELU", RooFit::AutoPrecision(2)), RooFit::Layout(0.6,0.95,0.95));
RooPlot * frame1 = CL_ndof_eff->frame(RooFit::Bins(10));
data->plotOn(frame1);
uniform->plotOn(frame1);
TCanvas * c = new TCanvas("c","c",1200, 600);
c->Divide(2,1);
c->cd(1);
frame0->Draw();
c->cd(2);
frame1->Draw();
/*
char buf[30];
sprintf(buf, "TMath::Prob(chi2,%f)>>h1", f1->GetParameter(0));
cout << buf << endl;
c->Modified();
c->Update();
c->cd(2);
t->Draw("TMath::Prob(chi2,ndof-8)>>h0");
t->Draw(buf);
h1->Draw();
h1->Fit("pol0");
h0->Draw("same");
h1->GetXaxis()->SetTitle("CL(#chi^{2})");
h1->GetYaxis()->SetTitle("Number of toys / 0.1");
h1->SetMinimum(0);
h1->SetMaximum(2*t->GetEntries()/nbins);
*/
c->SaveAs(plot);
}
void MakeSpinPlots::DrawBlindFit(TString tag, TString mcName,TString cosThetaBin){
TString fitTag="FULLFIT";
TString cat = "evtcat";
if(cosThetaBin!=""){
tag+="_"+cosThetaBin;
fitTag="FULLCOSTFIT";
cat = "evtcat_cosT";
}
TString dataTag = "_Combined";
if(cosThetaBin!="") dataTag+="_CosTBin";
TCanvas *cv = new TCanvas(Form("%s_%s",mcName.Data(),tag.Data()));
RooRealVar* mass = ws->var("mass");
mass->setBins( (mass->getMax() - mass->getMin())/1.5 ); //enfore 1.5GeV bin width
RooPlot* frame = mass->frame();
double Nb = ws->var(Form("Data_BKGFIT_%s_Nbkg",tag.Data()))->getVal();
cout << Nb << endl;
RooDataSet *blind = (RooDataSet*)ws->data("Data"+dataTag)->reduce(TString("((mass<119) || (mass>135.5)) && ")+cat+"=="+cat+"::"+tag);
blind->plotOn(frame);
tPair lbl(mcName,tag);
double nBkg = ws->data("Data"+dataTag)->sumEntries(cat+"=="+cat+"::"+tag);
ws->pdf( Form("Data_BKGFIT_%s_bkgModel",tag.Data()) )->plotOn(frame,RooFit::Range("all"),RooFit::Normalization(nBkg/blind->sumEntries()),
RooFit::LineColor(kRed));
//TLatex *prelim = new TLatex(250,x->GetXmax()-40.,"CMS Preliminary");
TLatex *prelim = new TLatex(0.12,0.96,"CMS Preliminary");
TLatex *lum = new TLatex(0.7,0.96,Form("#sqrt{s}=8 TeV L = %0.1f fb^{-1}",lumi));
prelim->SetNDC();
lum->SetNDC();
prelim->SetTextSize(0.045);
prelim->SetTextColor(kBlack);
lum->SetTextSize(0.045);
lum->SetTextColor(kBlack);
TLatex *owner = new TLatex(0.6,0.88,"Caltech-CMS Preliminary");
owner->SetNDC();
owner->SetTextSize(0.045);
owner->SetTextColor(kBlack);
TLatex *Nbkg = new TLatex(0.7,0.8,Form("N_{bkg}= %0.1f #pm %0.1f",nBackground[lbl].first,nBackground[lbl].second));
Nbkg->SetNDC();
Nbkg->SetTextSize(0.045);
TLatex *sig = new TLatex(0.7,0.72,Form("#sigma_{eff} = %0.1f #pm %0.2f",fitSigEff[lbl].first,fitSigEff[lbl].second));
sig->SetNDC();
sig->SetTextSize(0.045);
TLatex *expBkg = new TLatex(0.7,0.64,Form("B @ 125 = %0.1f",fitBkg1Sigma[lbl].first));
expBkg->SetNDC();
expBkg->SetTextSize(0.045);
frame->addObject(prelim);
frame->addObject(lum);
//frame->addObject(owner);
frame->addObject(Nbkg);
frame->addObject(sig);
frame->addObject(expBkg);
frame->Draw();
cv->SaveAs( basePath+Form("/mgg-%s-%s-%s_BLIND.png",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/C/mgg-%s-%s-%s_BLIND.C",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/mgg-%s-%s-%s_BLIND.pdf",outputTag.Data(),mcName.Data(),tag.Data()) );
delete cv;
}
