void chi2(int xmin = 0, int xmax = 200, TString filename="../DsubMC/met2j0bIso2ewkScale_0_200.root", int nparam = 2){
RooAbsData::ErrorType errorType = RooAbsData::SumW2;
file = new TFile(filename);
RooRealVar* h = new RooRealVar("h","h",xmin,xmax);
//Get Data
TH1D* hData = file->Get("dataih");
hData->SetName("hData");
//hData->Draw();
RooDataHist* data = new RooDataHist("data","data",*h,hData);
//Get Summed MC
TH1D* hMC = file->Get("hh");
hMC->SetName("hMC");
hMC->Draw();
RooDataHist rdhMC("MC","MC",*h,hMC);
RooHistPdf pdfMC("MCpdf","MCpdf",*h,rdhMC);
//make (plot) the curves
RooPlot* hFrame = h->frame(Name("hFrame"));
data->plotOn(hFrame,RooFit::DataError(errorType));
pdfMC.plotOn(hFrame,ProjWData(*data),Components(pdfMC),Name("h_total"));
//Determine Chi^2
double chi2fit = hFrame->chiSquare("h_total", "h_data", nparam);
cout<<"Chi 2 / dof: "<<chi2fit<<endl;
//Determine K-S
double ks = hMC->KolmogorovTest(hData);
cout<<"Kolmogorov-Smirnov: "<<ks<<endl;
}
void MCStudy()
{
string fileName = "h4l_Template_2012_lowmass_unconstrained_new_v00.root";
const char * wsName = "combined"; //"w";
const char * modelSBName = "ModelConfig"; //"modelConfig";
const char * dataName = dataname.c_str();
TFile* file = TFile::Open(fileName);
// get the workspace out of file
RooWorkspace* w = (RooWorkspace*) file->Get(wsName);
if (!wsName) {
cout << "workspace not found" << endl;
return -1.0;
}
// get the modelConfig out of the file
ModelConfig* sbModel = (ModelConfig*) w->obj(modelSBName);
// get the data out of file
//RooAbsData* data = w->data(dataName);
// get toy MC data
TFile *fhist = new TFile("../ToyMC/toyMC_ggF125.root");
TH1F *hsum = (TH1F*) fhist->Get("sumtoy1");
RooRealVar m4l("m4l","m4l",120,130);
RooDataHist* data = new RooDataHist("data","data",x,hsum);
// get pdf
RooAbsPdf* model = sbModel->GetPdf();
RooPlot* xframe = m4l.frame();
data->plotOn(xframe);
model->fitTo(*data);
model->plotOn(xframe,LineColor(kRed));
TCanvas *c = new TCanvas("c","c");
xframe->Draw();
}
void simul(){
TFile* in = new TFile( "../bin/Kdata.root", "READ" );
TH1D* h = in->Get("tof_8");
RooRealVar * x = new RooRealVar( "x", "x", -10, 10 );
RooDataHist * rdh = new RooDataHist( "data", "data", RooArgSet( *x ), h);
RooRealVar m( "mean", "mean", 0, -1, 1 );
RooRealVar s( "sigma", "sigma", .5, 0, 1 );
RooGaussian g( "gauss", "gauss", )
RooPlot * frame = x->frame();
rdh->plotOn( frame );
frame->Draw();
}
void MakeSpinPlots::DrawSpinSubTotBackground(TString mcName,bool signal){
bool drawSM = (smName!="" && smName!=mcName);
TCanvas cv;
double thisN = ws->data(mcName+"_Combined")->sumEntries();
float norm = thisN;
if(signal) norm = ws->var(Form("Data_%s_FULLFIT_Nsig",mcName.Data()))->getVal();
RooPlot *frame = ws->var("cosT")->frame(0,1,10);
RooDataSet* tmp = (RooDataSet*)ws->data(Form("Data_Combined"))->reduce("(mass>115 && mass<120) || (mass>130 && mass<135)");
tmp->plotOn(frame,RooFit::Rescale(norm/tmp->sumEntries()));
ws->pdf(Form("%s_FIT_cosTpdf",mcName.Data()))->plotOn(frame,RooFit::LineColor(kGreen),RooFit::Normalization(norm/tmp->sumEntries()));
if(drawSM) ws->pdf(Form("%s_FIT_cosTpdf",smName.Data()))->plotOn(frame,RooFit::LineColor(kRed),RooFit::Normalization(norm/tmp->sumEntries()));
if(signal){
RooDataHist *h = (RooDataHist*)ws->data( Form("Data_%s_Combined_bkgSub_cosT",mcName.Data()) );
h->plotOn(frame,RooFit::MarkerStyle(4));
std::cout << "Nsig: " << h->sumEntries() << std::endl;
}
frame->SetMaximum(frame->GetMaximum()*(signal?2.:1.2)*norm/tmp->sumEntries());
frame->SetMinimum(-1*frame->GetMaximum());
TLegend l(0.6,0.2,0.95,0.45);
l.SetFillColor(0);
l.SetBorderSize(0);
l.SetHeader("Combined");
l.AddEntry(frame->getObject(0),"Data m#in [115,120]#cup[130,135]","p");
l.AddEntry(frame->getObject(1),mcName,"l");
if(drawSM) l.AddEntry(frame->getObject(2),"SM Higgs","l");
if(signal) l.AddEntry(frame->getObject(2+drawSM),"bkg-subtracted Data","p");
frame->Draw();
l.Draw("SAME");
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_SimpleSub_%s%s_%s.png",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/C/CosThetaDist_SimpleSub_%s%s_%s.C",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
cv.SaveAs( basePath+Form("/cosThetaPlots/CosThetaDist_SimpleSub_%s%s_%s.pdf",outputTag.Data(),(signal ? "":"_BLIND"),mcName.Data()) );
}
RooFitResult* fitter_Zee(TH1D *hist){
RooRealVar Zmassvar("Zmassvar","Zmassvar", 82, 100);
RooDataHist *datahist = new RooDataHist("data","Z Mass",Zmassvar,hist);
RooPlot *Zmassvarframe = Zmassvar.frame(Name("Zmassvarframe"),Title(hist->GetTitle())) ;
datahist->plotOn(Zmassvarframe);
RooRealVar alpha ("alpha" , "alpha" , 0.005,0.001,0.1);
RooRealVar n ("n" , "n" , 1,0.001,10);
RooRealVar cbmean ("cbmean" , "cbmean" , 1, 0.8, 1.2);
RooRealVar cbsigma("cbsigma", "cbsigma" , 0.01, 0.001, 0.2);
RooRealVar bwmean("bwmean","bwmean",91,85,95);
RooRealVar bwsigma("bwsigma","bwsigma",3,2,4);
RooRealVar expoconst("expoconst","expoconst",-0.1,-0.5,0);
RooCBShape cball ("cball" , "crystal ball" , Zmassvar, cbmean, cbsigma, alpha, n);
RooBreitWigner bw("bw","breit wigner",Zmassvar,bwmean,bwsigma);
RooFFTConvPdf cballXbw("cballXbw","cball (X) bw",Zmassvar,bw,cball);
RooExponential expo("expo", "exponential", Zmassvar, expoconst);
RooRealVar frac("frac","frac",0.1,0.001,0.2);
RooAddPdf Zshapemodel("Zshapemodel","expo + cball (X) bw",RooArgList(expo,cballXbw),frac);
RooFitResult *fitres =Zshapemodel.fitTo(*datahist,Range(82,100),Save());
Zshapemodel.plotOn(Zmassvarframe,LineColor(kBlue));
Zmassvarframe->Draw();
fitres->Print();
return fitres;
};
void DrawMass(int iSEL)
{
gROOT->ForceStyle();
TString SET[2] = {"A","B"};
RooMsgService::instance().setSilentMode(kTRUE);
for(int i=0;i<2;i++) {
RooMsgService::instance().setStreamStatus(i,kFALSE);
}
TString SELECTION[2] = {"NOM","VBF"};
TString MASS_RAW[2] = {"mbb[1]","mbb[2]"};
TString MASS_REG[2] = {"mbbReg[1]","mbbReg[2]"};
// TFile *inf = TFile::Open("Fit_VBFPowheg125_sel"+SELECTION[iSEL]+".root");
TFile *inf = TFile::Open("/usb/data2/UAData/2015/flatTree_VBFPowheg125.root");
TTree *tr = (TTree*)inf->Get("Hbb/events");
TH1F *hRaw = new TH1F("hRawMass","hRawMass",150,0,300);
TH1F *hReg = new TH1F("hRegMass","hRegMass",150,0,300);
RooRealVar x("mbb","mbb",60,170);
TCanvas *can = new TCanvas("Mbb_sel"+SELECTION[iSEL],"Mbb_sel"+SELECTION[iSEL],900,750);
TCut ct1 = TCut("triggerResult[0]==1||triggerResult[1]==1");
TCut cs1 = TCut("jetBtag[b1[1]]>0.244 && jetBtag[b2[1]]>0.244 && jetPt[3]>40. && jetPt[2]>50. && jetPt[1]>70. && jetPt[0]>80. && dEtaqq[1]>2.5 && mqq[1]>250 && dPhibb[1]<2.0 && nLeptons==0");
tr->Draw(MASS_RAW[iSEL]+">>hRawMass",ct1&&cs1);
tr->Draw(MASS_REG[iSEL]+">>hRegMass",ct1&&cs1);
hRaw->Sumw2();
hReg->Sumw2();
hRaw->Scale(1./(hRaw->Integral()*hRaw->GetBinWidth(1)));
hReg->Scale(1./(hReg->Integral()*hReg->GetBinWidth(1)));
RooDataHist *rRaw = new RooDataHist("rRaw","rRaw",x,hRaw);
RooDataHist *rReg = new RooDataHist("rReg","rReg",x,hReg);
RooRealVar m1("m1","m1",125,110,140);
RooRealVar m2("m2","m2",125,110,140);
RooRealVar sL1("sL1","sL1",12,3,30);
RooRealVar sL2("sL2","sL2",12,3,30);
RooRealVar sR1("sR1","sR1",12,3,30);
RooRealVar sR2("sR2","sR2",12,3,30);
RooRealVar a1("a1","a1",1,-10,10);
RooRealVar a2("a2","a2",1,-10,10);
RooRealVar n1("n1","n1",1,0,100);
RooRealVar n2("n2","n2",1,0,100);
RooRealVar b10("b10","b10",0.5,0.,1.);
RooRealVar b11("b11","b11",0.5,0.,1.);
RooRealVar b12("b12","b12",0.5,0.,1.);
RooRealVar b13("b13","b13",0.5,0.,1.);
RooRealVar b20("b20","b20",0.5,0.,1.);
RooRealVar b21("b21","b21",0.5,0.,1.);
RooRealVar b22("b22","b22",0.5,0.,1.);
RooRealVar b23("b23","b23",0.5,0.,1.);
RooBernstein bkg1("bkg1","bkg1",x,RooArgSet(b10,b11,b12,b13));
RooBernstein bkg2("bkg2","bkg2",x,RooArgSet(b20,b21,b22,b23));
RooRealVar fsig1("fsig1","fsig1",0.7,0.,1.);
RooRealVar fsig2("fsig2","fsig2",0.7,0.,1.);
RooBifurGauss sig1("sig1","sig1",x,m1,sL1,sR1);
RooBifurGauss sig2("sig2","sig2",x,m2,sL2,sR2);
//RooCBShape sig1("sig1","sig1",x,m1,s1,a1,n1);
//RooCBShape sig2("sig2","sig2",x,m2,s2,a2,n2);
RooAddPdf *model1 = new RooAddPdf("model1","model1",RooArgList(sig1,bkg1),fsig1);
RooAddPdf *model2 = new RooAddPdf("model2","model2",RooArgList(sig2,bkg2),fsig2);
model1->fitTo(*rRaw,SumW2Error(kFALSE),"q");
model2->fitTo(*rReg,SumW2Error(kFALSE),"q");
hRaw->SetLineWidth(2);
hReg->SetLineWidth(2);
hRaw->SetLineColor(kBlack);
hReg->SetLineColor(kRed+1);
hReg->SetFillColor(kRed-10);
hRaw->SetMarkerStyle(21);
hReg->SetMarkerStyle(20);
hRaw->SetMarkerSize(1.5);
hReg->SetMarkerSize(1.5);
hRaw->SetMarkerColor(kBlack);
hReg->SetMarkerColor(kRed+1);
RooPlot* frame = x.frame();
rRaw->plotOn(frame,LineColor(kBlack),LineWidth(1),MarkerColor(kBlack),MarkerStyle(21));
model1->plotOn(frame,LineColor(kBlack),LineWidth(2));
rReg->plotOn(frame,LineColor(kRed+1),LineWidth(1),MarkerColor(kRed+1),MarkerStyle(20));
model2->plotOn(frame,LineColor(kRed+1),LineWidth(2));
TF1 *tmp_func1 = model1->asTF(x,fsig1,x);
TF1 *tmp_func2 = model2->asTF(x,fsig2,x);
double y01 = tmp_func1->GetMaximum();
double x01 = tmp_func1->GetMaximumX();
double x11 = tmp_func1->GetX(y01/2,60,x01);
double x21 = tmp_func1->GetX(y01/2,x01,200);
double FWHM1 = x21-x11;
double y02 = tmp_func2->GetMaximum();
double x02 = tmp_func2->GetMaximumX();
double x12 = tmp_func2->GetX(y02/2,60,x02);
double x22 = tmp_func2->GetX(y02/2,x02,200);
double FWHM2 = x22-x12;
hReg->GetXaxis()->SetRangeUser(60,170);
hReg->GetXaxis()->SetTitle("m_{bb} (GeV)");
hReg->GetYaxis()->SetTitle("1/N #times dN/dm_{bb} (GeV^{-1})");
hReg->GetYaxis()->SetNdivisions(505);
hReg->SetMaximum(0.035);
hReg->Draw("HIST");
hRaw->Draw("HIST SAME");
frame->Draw("same");
TLegend *leg = new TLegend(0.18,0.7,0.43,0.91);
leg->SetTextFont(42);
leg->SetTextSize(0.05);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetHeader("m_{H} = 125 GeV (set "+SET[iSEL]+")");
leg->AddEntry(hReg,"Regressed","LP");
leg->AddEntry(hRaw,"Raw","LP");
leg->Draw();
TPaveText *pave1 = new TPaveText(0.18,0.56,0.43,0.7,"NDC");
pave1->AddText(TString::Format("PEAK = %1.1f GeV",x02));
pave1->AddText(TString::Format("FWHM = %1.1f GeV",FWHM2));
pave1->SetTextFont(42);
pave1->SetTextSize(0.04);
pave1->SetTextColor(kRed+1);
pave1->SetBorderSize(0);
pave1->SetFillColor(0);
pave1->Draw();
TPaveText *pave2 = new TPaveText(0.18,0.42,0.43,0.56,"NDC");
pave2->AddText(TString::Format("PEAK = %1.1f GeV",x01));
pave2->AddText(TString::Format("FWHM = %1.1f GeV",FWHM1));
pave2->SetTextFont(42);
pave2->SetTextSize(0.04);
pave2->SetTextColor(kBlack);
pave2->SetBorderSize(0);
pave2->SetFillColor(0);
pave2->Draw();
can->SaveAs("regressionKost.pdf");
// CMS_lumi(can,0,0);
}
int scaleSmearFit(TString RDFile, TString MCFile, char BaseName[30])
{
cout<<"Processing "<<BaseName<<endl;
gStyle->SetPalette(1);
//Data and histograms
TFile *f_RD = new TFile(RDFile);
TFile *f_MC = new TFile(MCFile);
TH1D *h1_ZmassDaughEtaRD = (TH1D*)f_RD->Get("h1_ZmassDaughEtaRD")->Clone();
TH1D *h1_ZmassDaughEtaMC[ScaleBins][ScaleBins];
//Variables
char histName[30];
RooRealVar zMass("zMass","zMass",60,120);
RooRealVar *nMC;
RooRealVar nBRD("nBRD","nBRD",5,2000);
RooRealVar nSRD("nSRD","nSRD",1000,0,20000);
RooRealVar nBMC("nBMC","nBMC",5,2000);
RooRealVar nSMC("nSMC","nSMC",1000,0,20000);
RooPlot *zmassframe;
RooPlot *zmassframeMC;
CPlot *plotFit;
CPlot *plotFitMC;
//zMass.setBins(50);
RooFitResult* fitRes;
RooFitResult* fitResMC;
TCanvas *myCan = MakeCanvas("myCan","myCan",800,600);
RooDataHist *ZmassMC;
//RooHistPdf *pdfMC;
RooAddPdf *pdfMC;
RooAddPdf* pdfRD;
//RD fitting
RooDataHist *ZmassRD =
new RooDataHist("ZmassRD","ZmassRD", RooArgSet(zMass),h1_ZmassDaughEtaRD);
//CBreitWignerConvCrystalBall ZsignalPdf("ZsigPdf",zMass);
//pdfRD=new RooAddPdf("pdfRD","pdfRD",RooArgList(*(ZsignalPdf.model)),RooArgList(nRD));
CVoigtian ZsigRD("ZsigRD",zMass);
CErfExpo ZbgRD("ZbgRD",zMass);
//CQuadraticExp ZbgRD("ZbgRD",zMass);
pdfRD=new RooAddPdf("pdfRD","pdfRD",RooArgList(*(ZsigRD.model),*(ZbgRD.model)),RooArgList(nSRD,nBRD));
pdfRD=new RooAddPdf("pdfRD","pdfRD",RooArgList(*(ZsigRD.model),*(ZbgRD.model)),RooArgList(nSRD,nBRD));
fitRes=pdfRD->fitTo(*ZmassRD,Extended(),Minos(kTRUE),Save(kTRUE));
//fitRes=ZsignalPdf.model->fitTo(*ZmassRD,Minos(kTRUE),Save(kTRUE));
zmassframe=zMass.frame(Bins(60));
ZmassRD->plotOn(zmassframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("zp"));
//ZsignalPdf.model->plotOn(zmassframe,LineColor(kBlue),DrawOption("l"));
pdfRD->plotOn(zmassframe,LineColor(kBlack),DrawOption("l"));
pdfRD->plotOn(zmassframe,Components(RooArgSet(*(ZsigRD.model))),LineColor(kBlue),DrawOption("l"));
pdfRD->plotOn(zmassframe,Components(RooArgSet(*(ZbgRD.model))),LineColor(kRed),DrawOption("l"));
sprintf(histName,"ZmassRD_%s",BaseName);
plotFit = new CPlot(histName,zmassframe,"","","Z mass");
plotFit->setOutDir("Plot");
plotFit->Draw(myCan,kTRUE,"png");
//CErfExpo *pdfZbg;
//double nLL[41][41];
// 90 0.004
double ScaleWidth = (ScaleH-ScaleL)/(ScaleBins-1);
double SmearWidth = (SmearH-SmearL)/(ScaleBins-1);
sprintf(histName,"h2_NLL_%s",BaseName);
TH2D *h2_NLL = new TH2D(histName,histName,
ScaleBins,ScaleL-ScaleWidth/2,ScaleH+ScaleWidth/2,
ScaleBins,SmearL-SmearWidth/2,SmearH+SmearWidth/2);
//TH2D *h2_NLL = new TH2D("h2_NLL","NLL",41,0.97,1.05,41,0.5,1.5);
double x,prob;
//RooAbsReal *nll;
double nll;
double binContent;
//***
CVoigtian ZsigMC("ZsigMC",zMass);
RooArgSet allArgset(zMass);
RooArgSet anaVar;
//for(int i(0);i<=0;i++)for(int j(0);j<=0;j++)
for(int i(0);i<=ScaleBins-1;i++)for(int j(0);j<=ScaleBins-1;j++)
{
sprintf(histName,"h1_ZmassDaughEta_%d_%d",i,j);
h1_ZmassDaughEtaMC[i][j] = (TH1D*)f_MC->Get(histName)->Clone(histName);
ZmassMC =
new RooDataHist("ZmassMC","ZmassMC",RooArgSet(zMass),h1_ZmassDaughEtaMC[i][j]);
// interpolation order
//pdfMC =new RooHistPdf ("pdfMC", "pdfMC", zMass,*ZmassMC, 1);
//Using fitting MC
nSMC.setVal(285);
ZsigMC.mass->setVal(91.37);
ZsigMC.sigma->setVal(0.42);
ZsigMC.width->setVal(4.4);
pdfMC = new RooAddPdf("pdfMC","pdfMC",RooArgList(*(ZsigMC.model)),RooArgList(nSMC));
fitResMC = pdfMC->fitTo(*ZmassMC,Extended(),Minos(kTRUE),Save(kTRUE),SumW2Error(kTRUE));//SumW2Error(kTRUE) default
nll=0;
//nll= h1_ZmassDaughEtaMC[i][j]->Chi2Test(h1_ZmassDaughEtaRD,"CHI2/NDF");
// code 1000 dataHist sum
int intCode = pdfMC->getAnalyticalIntegral(allArgset,anaVar);
double norm = pdfMC->analyticalIntegral(intCode);
cout<<"norm: code "<<norm<<" : "<<intCode<<"======================"<<endl;
//double totalProb(0);
//****
for(int k(1);k<=60;k++)
{
x=h1_ZmassDaughEtaMC[i][j]->GetBinCenter(k);
// binContent = h1_ZmassDaughEtaRD->GetBinContent(k);
//binContent = h1_ZmassDaughEtaMC[i][j]->GetBinContent(k);
zMass=x;
//prob = ZsignalPdf.model->evaluate();
binContent = ZsigRD.model->evaluate()*(120-60)/60.*nSRD.getVal();
prob = pdfMC->evaluate()*(120-60)/60.;
//cout<<"binCont, prob "<<binContent<<" "<<prob<<endl;
//totalProb +=prob;
nll+=-binContent*log(prob);
//cout<<" x: prob "<<x<<" "<<prob<<endl;
}
h2_NLL->SetBinContent(i+1,j+1,nll);
/***/
//
//
if( j==0 || j==int(ScaleBins/2)|| j==(ScaleBins-1) )
{
//RD MCpdf RDpdf Plot
zmassframe =zMass.frame(Bins(60));
ZmassRD->plotOn(zmassframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("zp"));
pdfRD->plotOn(zmassframe,LineColor(kBlack));
pdfMC->plotOn(zmassframe,LineColor(kBlue));
//pdfRD->plotOn(zmassframe,Components(RooArgSet(*(pdfZbg->model))),LineColor(kRed));
sprintf(histName,"Zmass_%s_%d_%d",BaseName,i,j);
plotFit = new CPlot(histName,zmassframe,"","","Z mass");
plotFit->SetLegend(0.68,0.57,0.93,0.8);
plotFit->GetLegend()->AddEntry(pdfRD,"RD","f");
plotFit->GetLegend()->AddEntry(pdfMC,"MC","f");
plotFit->setOutDir("Plot");
plotFit->Draw(myCan,kTRUE,"png");
//MC MCPdf Plot
zmassframeMC = zMass.frame(Bins(60));
ZmassMC->plotOn(zmassframeMC,LineColor(kBlue),DrawOption("p"));
pdfMC->plotOn(zmassframeMC,LineColor(kBlue),DrawOption("l"));
sprintf(histName,"ZmassMC_%s_%d_%d",BaseName,i,j);
plotFitMC = new CPlot(histName,zmassframeMC,"","","Z mass MC");
plotFitMC->setOutDir("Plot");
plotFitMC->Draw(myCan,kTRUE,"png");
}
}
//====
//Plot
//====
//Zmass----------
//CPlot *plotZmassRD=new CPlot("plotZmassRD","","zMass","Event");
//plotZmassRD->setOutDir("Plot");
//plotZmassRD->AddHist1D(h1_ZmassDaughEtaRD,"",kBlack);
//plotZmassRD->SetLegend(0.68,0.57,0.93,0.8);
//plotZmassRD->GetLegend()->AddEntry(h1_ZmassDaughEtaRD,"RD Ele","l");
//plotZmassRD->AddTextBox("both lepton at the |Eta|<0.4",0.65,0.80,0.99,0.86,0);
//plotZmassRD->Draw(myCan,kTRUE,"png");
//NLL------------
sprintf(histName,"plotNLL_%s",BaseName);
CPlot *plotNll=new CPlot(histName,"","Scale","Smear");
plotNll->setOutDir("Plot");
//plotNll->AddHist2D(h2_NLL,"COLZ",kWhite,kBlack);
plotNll->AddHist2D(h2_NLL,"SURF3",kWhite,kBlack);
plotNll->Draw(myCan,kTRUE,"png");
//****/
return 0;
}
void fitTopMass(const char * inFileName)
{
gROOT->SetBatch(true);
gSystem->Load("libRooFit");
TFile* inFile = TFile::Open(inFileName);
RooRealVar x("mass","M_{top}",100,200);
using namespace std;
vector<TH1F*> hists;
vector<int> nTotal;
std::vector<std::pair<float, float> > range;
const char* types[] = { "top1","top2","top"};
for( auto type : types ) {
hists.push_back ( (TH1F*)inFile->Get(TString::Format("%s_mass_GenJet",type)) ) ;
hists.push_back ( (TH1F*)inFile->Get(TString::Format("%s_mass_Jet",type)) ) ;
hists.push_back ( (TH1F*)inFile->Get(TString::Format("%s_mass_btagged_Jet",type)) ) ;
hists.push_back ( (TH1F*)inFile->Get(TString::Format("%s_mass_charged_Jet",type)) ) ;
hists.push_back ( (TH1F*)inFile->Get(TString::Format("%s_mass_btagged_charged_Jet",type)) ) ;
}
for( int i= 0 ; i<hists.size() ; i++) {
if ( hists[i] == nullptr) std::cout<<"Error! Hist is nullptr."<<std::endl;
}
for( int i = 0 ; i < hists.size() ; i++) {
nTotal.push_back(hists[i]->Integral());
}
// For top1,
for(int i= 0 ; i < 5 ; i++) {
range.push_back( make_pair(150,180) );
}
// For top2,
for(int i= 0 ; i < 5 ; i++) {
range.push_back( make_pair(150,180) );
}
// For all top,
for(int i= 0 ; i < 5 ; i++) {
range.push_back( make_pair(150,180) );
}
for( int i= 0 ; i< hists.size() ; i++) {
std::cout<<"hist["<<i<<"]"<<std::endl;
RooDataHist* dh = new RooDataHist("dh","data histogram",x,hists[i]);
auto gaus_mean = RooRealVar("gaus_mean","gaus_mean",172.5, 100,200);
auto gaus_sigma = RooRealVar("gaus_sigma","gaus_sigma",1, 0,100);
auto nGaus = RooRealVar("nGaus","nGaus",nTotal[i]*0.2, 0., nTotal[i]);
auto gaus_pdf = RooGaussian("gaus_pdf","Gaussian p.d.f",x,gaus_mean, gaus_sigma);
auto expo_tau = RooRealVar("exp_const","exp_const",0,-10000,10000);
auto nExp = RooRealVar("nExp","nExp",1,0,nTotal[i]);
auto expo_pdf = RooExponential("bkg","bkg p.d.f",x,expo_tau);
auto CB_mean = RooRealVar("CB_mean","CB_mean",172.5,100,200);
auto CB_sigma = RooRealVar("CB_sigma","CB_sigma",5,0,100);
auto CB_alpha = RooRealVar("CB_alpha","CB_alpha",1,0,100);
auto CB_n = RooRealVar("CB_n","CB_n",1,0,100);
auto nCB = RooRealVar("nCB","nCB",nTotal[i]*0.8,0.,nTotal[i]);
auto CB_pdf = RooCBShape("sig","signal p.d.f",x,CB_mean, CB_sigma, CB_alpha, CB_n );
auto BW_mean = RooRealVar("BW_mean","BW_mean",172.5,100,200);
auto BW_sigma = RooRealVar("BW_sigma","BW_sigma",10,0,100);
auto nBW = RooRealVar("nBW","nBW",nTotal[i]*0.7, 0, nTotal[i]);
auto BW_pdf = RooBreitWigner("sig","signal p.d.f",x,BW_mean, BW_sigma );
RooFormulaVar mirrorX("neg_x","-mass", RooArgSet(x));
//RooRealVar landau_mean("lan_mean","Landau_mean",150.5,100,200);
RooRealVar landau_mean("lan_mean","Landau_mean",-160,-200,-100);
RooRealVar landau_sigma("lan_sigma","Landau_sigma",2.5, 0,100);
RooRealVar nLandau("nLan","nlan",nTotal[i]*0.3, 0, nTotal[i]);
RooLandau landau_pdf("lx","lx",mirrorX,landau_mean, landau_sigma);
//TF1* f1 = new TF1("landau","nLan*ROOT::Math::landau_pdf(-x,lan_sigma,-lan_mean)",100,300);
//RooAbsPdf* invlandau_pdf = RooFit::bindPdf(f1,x,nLandau, landau_mean,landau_sigma);
//RooGenericPdf invlandau_pdf("invLandau","ROOT::Math::landau_pdf(-x,lan_sigma,-lan_mean)",RooArgSet(x,landau_sigma,landau_mean));
//sig_pdf = cb_pdf;
//bkg_pdf = bw_pdf;
//nsig = nCB;
//nbkg = nBW;
//RooFFTConvPdf model("lxg","CB (x) gauss",x,CB_pdf,gaus_pdf);
//RooFFTConvPdf model("lxg","CB (x) BW",x,CB_pdf,BW_pdf);
//auto model = RooAddPdf("model","model",RooArgList(landau),RooArgList(nlandau));
//auto model = RooAddPdf("model","model",RooArgList(sig_pdf, bkg_pdf),RooArgList(nsig, nbkg));
//auto model = RooAddPdf("model","model",RooArgList(CB_pdf, gaus_pdf),RooArgList(nCB, nGaus));
RooAddPdf* model;
RooFitResult * fitResult;
TPaveText* t1 = new TPaveText(0.15,0.5,0.45,0.8,"brNDC");
//auto model = RooAddPdf("model","model",RooArgList(CB_pdf, expo_pdf),RooArgList(nCB, nExp));
//auto model = RooAddPdf("model","model",RooArgList(CB_pdf, BW_pdf),RooArgList(nCB, nBW));
//auto model = RooAddPdf("model","model",RooArgList(CB_pdf),RooArgList(nCB));
//auto model = RooAddPdf("model","model",RooArgList(cb_pdf, gaus_pdf),RooArgList(nCB, nGaus));
//auto model = sig_pdf;
std::cout<<"Hello"<<std::endl;
if ( i< 5 ) {
/*
model = new RooAddPdf("model","model",RooArgList(BW_pdf),RooArgList(nBW));
fitResult = model->fitTo(*dh, RooFit::Extended(true), RooFit::Save(), RooFit::Range( range[i].first, range[i].second ));
t1->AddText(TString::Format("Breit-Wigner ) Mean : %3.3f(+-%3.3f)", BW_mean.getVal(), BW_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", BW_sigma.getVal(), BW_sigma.getError()));
*/
model = new RooAddPdf("model","model",RooArgList(BW_pdf, landau_pdf),RooArgList(nBW, nLandau));
fitResult = model->fitTo(*dh, RooFit::Extended(true), RooFit::Save(), RooFit::Range( range[i].first, range[i].second ));
t1->AddText(TString::Format("Breit-Wigner ) Mean : %3.3f(+-%3.3f)", BW_mean.getVal(), BW_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", BW_sigma.getVal(), BW_sigma.getError()));
t1->AddText(TString::Format("Landau ) Mean : %3.3f(+-%3.3f)", landau_mean.getVal(), landau_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", landau_sigma.getVal(), landau_sigma.getError()));
}
if ( i>=5 && i<10 ) {
model = new RooAddPdf("model","model",RooArgList(BW_pdf, landau_pdf),RooArgList(nBW, nLandau));
fitResult = model->fitTo(*dh, RooFit::Extended(true), RooFit::Save(), RooFit::Range( range[i].first, range[i].second ));
t1->AddText(TString::Format("Breit-Wigner ) Mean : %3.3f(+-%3.3f)", BW_mean.getVal(), BW_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", BW_sigma.getVal(), BW_sigma.getError()));
t1->AddText(TString::Format("Landau ) Mean : %3.3f(+-%3.3f)", landau_mean.getVal(), landau_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", landau_sigma.getVal(), landau_sigma.getError()));
}
if ( i>=10 ) {
model = new RooAddPdf("model","model",RooArgList(BW_pdf, landau_pdf),RooArgList(nBW, nLandau));
fitResult = model->fitTo(*dh, RooFit::Extended(true), RooFit::Save(), RooFit::Range( range[i].first, range[i].second ));
t1->AddText(TString::Format("Breit-Wigner ) Mean : %3.3f(+-%3.3f)", BW_mean.getVal(), BW_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", BW_sigma.getVal(), BW_sigma.getError()));
t1->AddText(TString::Format("Landau ) Mean : %3.3f(+-%3.3f)", landau_mean.getVal(), landau_mean.getError()));
t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", landau_sigma.getVal(), landau_sigma.getError()));
}
//t1->AddText(TString::Format("Breit-Wigner ) Mean : %3.3f(+-%3.3f)", BW_mean.getVal(), BW_mean.getError()));
//t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f)", BW_sigma.getVal(), BW_sigma.getError()));
//t1->AddText(TString::Format("CrystalBall ) Mean : %3.3f(+-%3.3f)", CB_mean.getVal(), CB_mean.getError()));
//t1->AddText(TString::Format("#sigma : %0.3f(+-%0.3f) #alpha : %0.2f ", CB_sigma.getVal(), CB_sigma.getError(), CB_alpha.getVal()));
t1->Draw();
RooPlot* top_mass_frame = x.frame();
dh->plotOn(top_mass_frame);
model->plotOn(top_mass_frame);
model->plotOn(top_mass_frame, RooFit::Components(BW_pdf),RooFit::LineStyle(kDashed));
//model.plotOn(top_mass_frame, RooFit::Components(CB_pdf),RooFit::LineStyle(kDashed));
//model.plotOn(top_mass_frame, RooFit::Components(gaus_pdf),RooFit::LineColor(kRed), RooFit::LineStyle(kDashed));
model->plotOn(top_mass_frame, RooFit::Components(landau_pdf),RooFit::LineColor(kRed), RooFit::LineStyle(kDashed));
TString canvas_name = TString::Format("FitResult_%s",hists[i]->GetName());
TCanvas* c1 = new TCanvas(canvas_name.Data(),canvas_name.Data(),800,600);
top_mass_frame->addObject(t1);
top_mass_frame->Draw();
top_mass_frame->SetTitle(canvas_name.Data());
c1->SaveAs( (TString(c1->GetName())+".png").Data());
c1->SaveAs( (TString("plotCode/")+TString(c1->GetName()).Strip()+".C").Data());
delete c1;
delete dh;
}
}
double* fitHist(TCanvas *iC, bool iDoMu,int iPlot, std::string iName,TH1D *iData,TH1D *iW,TH1D *iEWK,TH1D *iAntiData,TH1D *iAntiW,TH1D *iAntiEWK,const Double_t METMAX,const Int_t NBINS,const Double_t lumi,const Int_t Ecm,int iAltQCD) {
//
// Declare fit parameters for signal and background yields
// Note: W signal and EWK+top PDFs are constrained to the ratio described in MC
//
RooRealVar nSig(("nSig"+iName).c_str(),("nSig"+iName).c_str(),0.7*(iData->Integral()),0,iData->Integral());
RooRealVar nQCD(("nQCD"+iName).c_str(),("nQCD"+iName).c_str(),0.3*(iData->Integral()),0,iData->Integral());
RooRealVar cewk(("cewk"+iName).c_str(),("cewk"+iName).c_str(),0.1,0,5) ;
cewk.setVal(iEWK->Integral()/iW->Integral());
cewk.setConstant(kTRUE);
RooFormulaVar nEWK(("nEWK"+iName).c_str(),("nEWK"+iName).c_str(),("cewk"+iName+"*nSig"+iName).c_str(),RooArgList(nSig,cewk));
RooRealVar nAntiSig(("nAntiSig"+iName).c_str(),("nAntiSig"+iName).c_str(),0.05*(iAntiData->Integral()),0,iAntiData->Integral());
RooRealVar nAntiQCD(("nAntiQCD"+iName).c_str(),("nAntiQCD"+iName).c_str(),0.9 *(iAntiData->Integral()),0,iAntiData->Integral());
RooRealVar dewk (("dewk" +iName).c_str(),("dewk" +iName).c_str(),0.1,0,5) ;
dewk.setVal(iAntiEWK->Integral()/iAntiW->Integral());
dewk.setConstant(kTRUE);
RooFormulaVar nAntiEWK(("nAntiEWK"+iName).c_str(),("nAntiEWK"+iName).c_str(),("dewk"+iName+"*nAntiSig"+iName).c_str(),RooArgList(nAntiSig,dewk));
//
// Construct PDFs for fitting
//
RooRealVar pfmet(("pfmet"+iName).c_str(),("pfmet"+iName).c_str(),0,METMAX);
pfmet.setBins(NBINS);
// Signal PDFs
RooDataHist wMet (("wMET" +iName).c_str(), ("wMET" +iName).c_str(), RooArgSet(pfmet),iW);
RooHistPdf pdfW(( "w"+iName).c_str(), ( "w"+iName).c_str(), pfmet, wMet, 1);
RooDataHist awMet (("awMET"+iName).c_str(), ("awMET"+iName).c_str(), RooArgSet(pfmet),iAntiW);
RooHistPdf apdfW(("aw"+iName).c_str(), ("aw"+iName).c_str(), pfmet,awMet, 1);
// EWK+top PDFs
RooDataHist ewkMet (("ewkMET" +iName).c_str(),( "ewkMET"+iName).c_str(), RooArgSet(pfmet),iEWK);
RooHistPdf pdfEWK (( "ewk"+iName).c_str(),( "ewk"+iName).c_str(), pfmet,ewkMet, 1);
RooDataHist aewkMet(("aewkMET"+iName).c_str(),("aewkMET"+iName).c_str(), RooArgSet(pfmet),iAntiEWK);
RooHistPdf apdfEWK (("aewk"+iName).c_str(),("aewk"+iName).c_str(), pfmet,aewkMet, 1);
// QCD Pdfs
CPepeModel0 qcd0 (("qcd0" +iName).c_str(),pfmet);
CPepeModel1 qcd1 (("qcd1" +iName).c_str(),pfmet);
CPepeModel2 qcd2 (("qcd2" +iName).c_str(),pfmet);
CPepeModel0 aqcd0(("aqcd0"+iName).c_str(),pfmet);
CPepeModel1 aqcd1(("aqcd1"+iName).c_str(),pfmet,qcd1.sigma);
CPepeModel2 aqcd2(("aqcd2"+iName).c_str(),pfmet);
RooGenericPdf *lQCD = qcd0.model;
RooGenericPdf *lAQCD = aqcd0.model;
if(iDoMu) lQCD = qcd1.model;
if(iDoMu) lAQCD = aqcd1.model;
if(iAltQCD == 0) lQCD = qcd0.model;
if(iAltQCD == 1) lQCD = qcd1.model;
if(iAltQCD == 2) lQCD = qcd2.model;
if(iAltQCD == 0) lAQCD = aqcd0.model;
if(iAltQCD == 1) lAQCD = aqcd1.model;
if(iAltQCD == 2) lAQCD = aqcd2.model;
// Signal + Background PDFs
RooAddPdf pdfMet (("pdfMet"+iName).c_str(), ("pdfMet" +iName).c_str(), RooArgList(pdfW ,pdfEWK ,*lQCD), RooArgList(nSig,nEWK,nQCD));
RooAddPdf apdfMet(("apdfMet"+iName).c_str(),("apdfMet"+iName).c_str(), RooArgList(apdfW,apdfEWK,*lAQCD), RooArgList(nAntiSig,nAntiEWK,nAntiQCD));
// PDF for simultaneous fit
RooCategory rooCat("rooCat","rooCat");
rooCat.defineType("Select");
rooCat.defineType("Anti");
RooSimultaneous pdfTotal("pdfTotal","pdfTotal",rooCat);
pdfTotal.addPdf(pdfMet, "Select");
if(iDoMu) pdfTotal.addPdf(apdfMet,"Anti");
// Perform fits
RooDataHist dataMet (("dataMet"+iName).c_str(),("dataMet"+iName).c_str(), RooArgSet(pfmet),iData);
RooDataHist antiMet (("antiMet"+iName).c_str(),("antiMet"+iName).c_str(), RooArgSet(pfmet),iAntiData);
RooDataHist dataTotal(("data" +iName).c_str(),("data" +iName).c_str(), RooArgList(pfmet), Index(rooCat),
Import("Select", dataMet),
Import("Anti", antiMet));
RooFitResult *fitRes = 0;
bool runMinos = kTRUE;
if(iPlot == 0 || iPlot == 3) runMinos = kFALSE; //Remove Minos when running toys (too damn slow)
if(!iDoMu) fitRes = pdfMet .fitTo(dataMet ,Extended(),Minos(runMinos),Save(kTRUE));
if( iDoMu) fitRes = pdfTotal.fitTo(dataTotal,Extended(),Minos(runMinos),Save(kTRUE));
double *lResults = new double[16];
lResults[0] = nSig.getVal();
lResults[1] = nEWK.getVal();
lResults[2] = nQCD.getVal();
lResults[3] = nAntiSig.getVal();
lResults[4] = nAntiEWK.getVal();
lResults[5] = nAntiQCD.getVal();
if(!iDoMu) lResults[6] = double(qcd0.sigma->getVal());
if( iDoMu) lResults[6] = double(qcd1.sigma->getVal());
lResults[7] = 0.;
if(!iDoMu) lResults[7] = qcd1.a1->getVal();
lResults[8] = nSig .getPropagatedError(*fitRes);
lResults[9] = nEWK .getPropagatedError(*fitRes);
lResults[10] = nQCD .getPropagatedError(*fitRes);
lResults[11] = nAntiSig.getPropagatedError(*fitRes);
lResults[12] = nAntiEWK.getPropagatedError(*fitRes);
lResults[13] = nAntiQCD.getPropagatedError(*fitRes);
if( iDoMu) lResults[14] = qcd0.sigma->getError();
if(!iDoMu) lResults[14] = qcd1.sigma->getError();
if( iDoMu) lResults[15] = 0;
if(!iDoMu) lResults[15] = qcd1.a1 ->getError();
if(iPlot == 0 ) return lResults;
//
// Use histogram version of fitted PDFs to make ratio plots
// (Will also use PDF histograms later for Chi^2 and KS tests)
//
TH1D *hPdfMet = (TH1D*)(pdfMet.createHistogram(("hPdfMet"+iName).c_str(), pfmet));
hPdfMet->Scale((nSig.getVal()+nEWK.getVal()+nQCD.getVal())/hPdfMet->Integral());
TH1D *hMetDiff = makeDiffHist(iData,hPdfMet,"hMetDiff"+iName);
hMetDiff->SetMarkerStyle(kFullCircle);
hMetDiff->SetMarkerSize(0.9);
TH1D *hPdfAntiMet = (TH1D*)(apdfMet.createHistogram(("hPdfAntiMet"+iName).c_str(), pfmet));
hPdfAntiMet->Scale((nAntiSig.getVal()+nAntiEWK.getVal()+nAntiQCD.getVal())/hPdfAntiMet->Integral());
TH1D *hAntiMetDiff = makeDiffHist(iAntiData,hPdfAntiMet,"hAntiMetDiff"+iName);
hAntiMetDiff->SetMarkerStyle(kFullCircle);
hAntiMetDiff->SetMarkerSize(0.9);
if(iPlot == 3 ) {
//Build best fit QCD with default W and EWK Shap
TH1D *hPdfMetQCD = (TH1D*)(lQCD ->createHistogram(("hPdfMetQCD" +iName).c_str(), pfmet));
TH1D *hPdfAMetQCD = (TH1D*)(lAQCD->createHistogram(("hPdfAntiMetQCD"+iName).c_str(), pfmet));
hPdfMetQCD ->Scale(nQCD .getVal()/hPdfMetQCD ->Integral());
hPdfAMetQCD->Scale(nAntiQCD.getVal()/hPdfAMetQCD->Integral());
TH1D *pW = (TH1D*) iW ->Clone("WForToys");
pW ->Scale(nSig .getVal()/pW ->Integral());
TH1D *pEWK = (TH1D*) iEWK ->Clone("EWKForToys");
pEWK ->Scale(nEWK .getVal()/pEWK ->Integral());
TH1D *pAW = (TH1D*) iAntiW ->Clone("AWForToys");
pAW ->Scale(nAntiSig.getVal()/pAW ->Integral());
TH1D *pAEWK = (TH1D*) iAntiEWK->Clone("AEWKForToys");
pAEWK->Scale(nAntiEWK.getVal()/pAEWK->Integral());
hPdfMetQCD ->Add(pW);
hPdfMetQCD ->Add(pEWK);
hPdfAMetQCD->Add(pAW);
hPdfAMetQCD->Add(pAEWK);
fBestFit = hPdfMetQCD;
fAntiBestFit = hPdfAMetQCD;
return lResults;
}
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
char ylabel[100]; // string buffer for y-axis label
// file format for output plots
const TString format("png");
// label for lumi
char lumitext[100];
if(lumi<0.1) sprintf(lumitext,"%.1f pb^{-1} at #sqrt{s} = %i TeV",lumi*1000.,Ecm);
else sprintf(lumitext,"%.2f fb^{-1} at #sqrt{s} = %i TeV",lumi ,Ecm);
// plot colors
Int_t linecolorW = kOrange-3;
Int_t fillcolorW = kOrange-2;
Int_t linecolorEWK = kOrange+10;
Int_t fillcolorEWK = kOrange+7;
Int_t linecolorQCD = kViolet+2;
Int_t fillcolorQCD = kViolet-5;
Int_t ratioColor = kGray+2;
//
// Dummy histograms for TLegend
// (Nobody can figure out how to properly pass RooFit objects...)
//
TH1D *hDummyData = new TH1D("hDummyData","",0,0,10);
hDummyData->SetMarkerStyle(kFullCircle);
hDummyData->SetMarkerSize(0.9);
TH1D *hDummyW = new TH1D("hDummyW","",0,0,10);
hDummyW->SetLineColor(linecolorW);
hDummyW->SetFillColor(fillcolorW);
hDummyW->SetFillStyle(1001);
TH1D *hDummyEWK = new TH1D("hDummyEWK","",0,0,10);
hDummyEWK->SetLineColor(linecolorEWK);
hDummyEWK->SetFillColor(fillcolorEWK);
hDummyEWK->SetFillStyle(1001);
TH1D *hDummyQCD = new TH1D("hDummyQCD","",0,0,10);
hDummyQCD->SetLineColor(linecolorQCD);
hDummyQCD->SetFillColor(fillcolorQCD);
hDummyQCD->SetFillStyle(1001);
//
// W MET plot
//
RooPlot *wmframe = pfmet.frame(Bins(NBINS));
dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
pdfMet.plotOn(wmframe,FillColor(fillcolorW),DrawOption("F"));
pdfMet.plotOn(wmframe,LineColor(linecolorW));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*lQCD)),LineColor(linecolorEWK));
pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfW)),LineColor(linecolorW),LineStyle(2));
dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",iData->GetBinWidth(1));
CPlot plotMet(("fitmet"+iName).c_str(),wmframe,"","",ylabel);
plotMet.SetLegend(0.68,0.57,0.93,0.77);
plotMet.GetLegend()->AddEntry(hDummyData,"data","PL");
plotMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
plotMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
plotMet.SetYRange(0.1,1.1*(iData->GetMaximum()));
plotMet.Draw(iC,kFALSE,format,1);
CPlot plotMetDiff(("fitmet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
plotMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
plotMetDiff.SetYRange(-8,8);
plotMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotMetDiff.Draw(iC,kTRUE,format,2);
plotMet.Draw(iC,kTRUE,format,1);
plotMet.SetName(("fitmetlog"+iName).c_str());
plotMet.SetLogy();
plotMet.SetYRange(1e-3*(iData->GetMaximum()),10*(iData->GetMaximum()));
plotMet.Draw(iC,kTRUE,format,1);
if(iDoMu) {
RooPlot *awmframe = pfmet.frame(Bins(NBINS));
antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
apdfMet.plotOn(awmframe,FillColor(fillcolorW),DrawOption("F"));
apdfMet.plotOn(awmframe,LineColor(linecolorW));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),FillColor(fillcolorEWK),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*lQCD)),LineColor(linecolorEWK));
apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),FillColor(fillcolorQCD),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(*lQCD)),LineColor(linecolorQCD));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfW)),LineColor(linecolorW),LineStyle(2));
antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",iAntiData->GetBinWidth(1));
CPlot plotAntiMet(("fitantimet"+iName).c_str(),awmframe,"","",ylabel);
plotAntiMet.SetLegend(0.68,0.57,0.93,0.77);
plotAntiMet.GetLegend()->AddEntry(hDummyData,"data","PL");
plotAntiMet.GetLegend()->AddEntry(hDummyW,"W#rightarrow#mu#nu","F");
plotAntiMet.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotAntiMet.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotAntiMet.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotAntiMet.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
plotAntiMet.SetYRange(0.1,1.1*(iAntiData->GetMaximum()));
plotAntiMet.Draw(iC,kFALSE,format,1);
CPlot plotAntiMetDiff(("fitantimet"+iName).c_str(),"","#slash{E}_{T} [GeV]","#chi");
plotAntiMetDiff.AddHist1D(hMetDiff,"EX0",ratioColor);
plotAntiMetDiff.SetYRange(-8,8);
plotAntiMetDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotAntiMetDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotAntiMetDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotAntiMetDiff.Draw(iC,kTRUE,format,2);
plotAntiMet.SetName(("fitantimetlog"+iName).c_str());
plotAntiMet.SetLogy();
plotAntiMet.SetYRange(1e-3*(iAntiData->GetMaximum()),10*(iAntiData->GetMaximum()));
plotAntiMet.Draw(iC,kTRUE,format,1);
}
if(iPlot == 1) return lResults;
ofstream txtfile;
std::string txtfName = "fitres"+iName;
if( iDoMu) txtfName + "Mu.txt";
if(!iDoMu) txtfName + "Mu.txt";
ios_base::fmtflags flags;
cout << " --- test " << iData->Integral() << " -- " << hPdfMet->Integral() << endl;
Double_t chi2prob = iData->Chi2Test(hPdfMet,"PUW");
Double_t chi2ndf = iData->Chi2Test(hPdfMet,"CHI2/NDFUW");
Double_t ksprob = iData->KolmogorovTest(hPdfMet);
Double_t ksprobpe = 1;//iData->KolmogorovTest(hPdfMet,"DX");
txtfile.open(txtfName.c_str());
assert(txtfile.is_open());
flags = txtfile.flags();
txtfile << setprecision(10);
txtfile << " *** Yields *** " << endl;
txtfile << "Selected: " << iData->Integral() << endl;
txtfile << " Signal: " << nSig.getVal() << " +/- " << nSig.getPropagatedError(*fitRes) << endl;
txtfile << " QCD: " << nQCD.getVal() << " +/- " << nQCD.getPropagatedError(*fitRes) << endl;
txtfile << " Other: " << nEWK.getVal() << " +/- " << nEWK.getPropagatedError(*fitRes) << endl;
txtfile << endl;
txtfile.flags(flags);
fitRes->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose);
txtfile << endl;
printCorrelations(txtfile, fitRes);
txtfile << endl;
printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe);
txtfile.close();
return lResults;
}
void templatefit1() {
std::vector<string> samples_;
float scales[] = {0.0961,0.0978,1.491,0.0253,0.0224,0.0145,0.0125,0.0160,0.0158,0.0341,0.0341,0.0341,0.020,0.0017,0.0055,0.0032,0.00084,0.02};
samples_.push_back("WPHJET.root");
samples_.push_back("ZJET.root");
samples_.push_back("PHJET200400.root");
//samples_.push_back("WJET.root");
samples_.push_back("T-W-CH.root");
samples_.push_back("TBAR-W-CH.root");
samples_.push_back("T-S-CH.root");
samples_.push_back("TBAR-S-CH.root");
samples_.push_back("T-T-CH.root");
samples_.push_back("TBAR-T-CH.root");
samples_.push_back("TTBAR1.root");
samples_.push_back("TTBAR2.root");
samples_.push_back("TTBAR3.root");
samples_.push_back("TTG.root");
samples_.push_back("WWG.root");
samples_.push_back("WW.root");
samples_.push_back("WZ.root");
samples_.push_back("ZZ.root");
samples_.push_back("ZGAMMA.root");
//samples_.push_back("SIGNAL.root");
//samples_.push_back("REALDATA.root");
std::vector<string> samplesreverse_;
samplesreverse_.push_back("etarev/WPHJET.root");
samplesreverse_.push_back("etarev/ZJET.root");
samplesreverse_.push_back("etarev/PHJET200400.root");
samplesreverse_.push_back("etarev/T-W-CH.root");
samplesreverse_.push_back("etarev/TBAR-W-CH.root");
samplesreverse_.push_back("etarev/T-S-CH.root");
samplesreverse_.push_back("etarev/TBAR-S-CH.root");
samplesreverse_.push_back("etarev/T-T-CH.root");
samplesreverse_.push_back("etarev/TBAR-T-CH.root");
samplesreverse_.push_back("etarev/TTBAR1.root");
samplesreverse_.push_back("etarev/TTBAR2.root");
samplesreverse_.push_back("etarev/TTBAR3.root");
samplesreverse_.push_back("etarev/TTG.root");
samplesreverse_.push_back("etarev/WWG.root");
samplesreverse_.push_back("etarev/WW.root");
samplesreverse_.push_back("etarev/WZ.root");
samplesreverse_.push_back("etarev/ZZ.root");
samplesreverse_.push_back("etarev/ZGAMMA.root");
//open files
std::vector<TFile*> files;
for(unsigned int idx=0; idx<samples_.size(); ++idx){
files.push_back(new TFile(samples_[idx].c_str()));
}
std::vector<TFile*> reversefiles;
for(unsigned int idx=0; idx<samplesreverse_.size(); ++idx){
reversefiles.push_back(new TFile(samplesreverse_[idx].c_str()));
}
TFile* data = new TFile("REALDATA.root");
TFile* datarev=new TFile("etarev/REALDATA.root");
/////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////
std::vector<string> variables2_;
variables2_.push_back("photon_Pt");
// variables2_.push_back("photon_Eta");
// variables2_.push_back("muon_Pt");
// variables2_.push_back("muon_Eta");
// variables2_.push_back("Jet_Pt");
// variables2_.push_back("Jet_Eta");
// variables2_.push_back("Jet_Multiplicity");
// variables2_.push_back("topmass");
// variables2_.push_back("WTmass");
// variables2_.push_back("Cosmuonjet");
// variables2_.push_back("Cosmuonphoton");
// variables2_.push_back("Cosphotonjet");
// variables2_.push_back("Deltaphiphotonjet");
// variables2_.push_back("Deltaphiphotonmuon");
// variables2_.push_back("Deltaphimuonjet");
// variables2_.push_back("DeltaRphotonmuon");
// variables2_.push_back("DeltaRphotonjet");
// variables2_.push_back("DeltaRmuonjet");
// variables2_.push_back("HT");
// variables2_.push_back("Photonmuonmass");
// variables2_.push_back("Costopphoton");
// variables2_.push_back("sigmaetaetaendcap");
// variables2_.push_back("sigmaetaetabarrel");
// load histograms
std::vector<TH1F*> BGhists;
for(unsigned int idx=0; idx<files.size(); ++idx){
BGhists.push_back((TH1F*)files[idx]->Get((std::string("analyzestep2/").append(variables2_[0]).c_str())));
}
std::vector<TH1F*> revBGhists;
for(unsigned int idx=0; idx<reversefiles.size(); ++idx){
revBGhists.push_back((TH1F*)reversefiles[idx]->Get((std::string("analyzestep2/").append(variables2_[0]).c_str())));
}
TH1F* DATAhists;
DATAhists = (TH1F*)data->Get((std::string("analyzestep2/").append(variables2_[0]).c_str()));
TH1F* SIGhists;
TH1F* revDATAhists;
revDATAhists = (TH1F*)datarev->Get((std::string("analyzestep2/").append(variables2_[0]).c_str()));
float lumi = 5.319;
for(unsigned int idx=0; idx<samples_.size(); ++idx){
BGhists[idx]->Scale(lumi*scales[idx]);
}
for(unsigned int idx=0; idx<samplesreverse_.size(); ++idx){
revBGhists[idx]->Scale(lumi*scales[idx]);
}
for(unsigned int idx=1; idx<samples_.size(); ++idx){
BGhists[idx]->Add(BGhists[idx-1]);
}
for(unsigned int idx=1; idx<samplesreverse_.size(); ++idx){
revBGhists[idx]->Add(revBGhists[idx-1]);
}
SIGhists=revDATAhists;
SIGhists->Add(revBGhists[samples_.size()-1],-1);
//TCanvas* conv = new TCanvas("BGBG", "BG" , 600, 600);
//conv->cd(0);
//DATAhists->Draw();
//revBGhists[samples_.size()-1]->Draw("same");
//TCanvas* nv = new TCanvas("data", "data" , 600, 600);
//nv->cd(0);
//SIGhists->Draw();
int norm=1;
double scalesig =norm/SIGhists->Integral();
SIGhists->Scale(scalesig);
//double scaledata =norm/DATAhists->Integral();
//DATAhists->Scale(scaledata);
double scalebg =norm/BGhists[samples_.size()-1]->Integral();
BGhists[samples_.size()-1]->Scale(scalebg);
//TCanvas* conv = new TCanvas("signal", "signal" , 600, 600);
//conv->cd(0);
//SIGhists->Draw();
//TCanvas* nv = new TCanvas("data", "data" , 600, 600);
//nv->cd(0);
//DATAhists->Draw();
//TCanvas* con = new TCanvas("BG", "BG" , 600, 600);
//con->cd(0);
//BGhists[samples_.size()-1]->Draw();
//conv->cd(0);
////Ghists->Draw();
RooRealVar x("x", "x", 50.,500.);
// RooRealVar x("x", "x", -3,3);
// RooRealVar x("x", "x", 26.,500.);
// RooRealVar x("x", "x", 25.,150.);
// RooRealVar x("x", "x", 0.,400.);
RooDataHist* template1 = new RooDataHist("template1", "template1", RooArgList(x), SIGhists);
RooHistPdf modelTemplate1("modelTemplate1", "modelTemplate1", RooArgSet(x), *template1);
RooDataHist* template2 = new RooDataHist("template2", "template2", RooArgList(x), BGhists[samples_.size()-1]);
RooHistPdf modelTemplate2("modelTemplate2", "modelTemplate2", RooArgSet(x), *template2);
RooDataHist* sumData = new RooDataHist("sumData", "sumData", RooArgList(x), DATAhists);
std::cout << " executing fit..." << std::endl;
RooRealVar coeffTemplate1("coeffTemplate1", "coeffTemplate1", 0, 2000);
RooRealVar coeffTemplate2("coeffTemplate2", "coeffTemplate2", 0, 2000);
RooAddPdf sumTemplate("sumTemplate", "coeff*modelTemplate1 + (1 - coeff)*modelTemplate2",RooArgList(modelTemplate1, modelTemplate2),RooArgList(coeffTemplate1,coeffTemplate2));
sumTemplate.fitTo(*sumData);
std::cout << "--> coeffTemplate1 = " << coeffTemplate1.getVal() << std::endl;
std::cout << "--> coeffTemplate2 = " << coeffTemplate2.getVal() << std::endl;
RooPlot* frame = x.frame() ;
sumData->plotOn(frame,LineStyle(kDashed)) ;
sumTemplate.plotOn(frame) ;
//modelTemplate2.plotOn(frame) ;
frame->Draw() ;
}
void fitWWa_el() {
TFile* fin = new TFile("../RunII_WVA_ControlPlots.root");
TH1D* data_obs = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/data_obs");
TH1D* th1fkdata = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1FakePhotons");
TH1D* th1wwa = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wwa");
TH1D* th1wza = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wza");
TH1D* th1wajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1wajets");
TH1D* th1zajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1zajets");
TH1D* th1Top = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1ttajets");
TH1D* th1tajets = (TH1D*) fin->Get("Electron/vbf_maxpt_jj_m/th1tajets");
int NbinsX = data_obs->GetNbinsX();
double xmin = data_obs->GetXaxis()->GetBinLowEdge(1);
double xmax = data_obs->GetXaxis()->GetBinLowEdge(NbinsX+1);
data_obs->GetXaxis()->SetRangeUser(xmin, xmax);
th1fkdata->GetXaxis()->SetRangeUser(xmin, xmax);
th1wwa->GetXaxis()->SetRangeUser(xmin, xmax);
th1wza->GetXaxis()->SetRangeUser(xmin, xmax);
th1wajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1zajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1Top->GetXaxis()->SetRangeUser(xmin, xmax);
th1tajets->GetXaxis()->SetRangeUser(xmin, xmax);
th1wwa->Add(th1wza);
th1Top->Add(th1tajets);
mjj_ = new RooRealVar( "Mjj", "m_{jj}", xmin, xmax, "GeV");
RooRealVar Mass = *mjj_;
RooDataHist* data = new RooDataHist("data","data", *mjj_, data_obs);
RooHistPdf* pdffk = makePdf(th1fkdata, "pdffk");
RooHistPdf* pdfwwa = makePdf(th1wwa, "pdfwwa");
RooHistPdf* pdfwajets = makePdf(th1wajets, "pdfwajets");
RooHistPdf* pdfzajets = makePdf(th1zajets, "pdfzajets");
RooHistPdf* pdfTop = makePdf(th1Top, "pdfTop");
double fkNorm = th1fkdata->Integral();
double wwaNorm = th1wwa->Integral();
double wajetsNorm = th1wajets->Integral();
double zajetsNorm = th1zajets->Integral();
double TopNorm = th1Top->Integral();
RooRealVar nfk("nfk","nfk", fkNorm, 0.0, 1000.);
RooRealVar nwwa("nwwa","nwwa", wwaNorm);
RooRealVar nwajets("nwajets","nwajets", 400.0, 0.0, 10000.);
RooRealVar nzajets("nzajets","nzajets", zajetsNorm);
RooRealVar nTop("nTop","nTop", TopNorm);
RooArgList* components
= new RooArgList(*pdffk, *pdfwwa, *pdfwajets, *pdfzajets, *pdfTop);
RooArgList* yields = new RooArgList(nfk, nwwa, nwajets, nzajets, nTop);
RooAddPdf totalPdf("totalPdf","extended sum pdf", *components, *yields);
RooGaussian consNfk("consNfk","", nfk, RooConst(fkNorm),RooConst(0.146*fkNorm)) ;
RooGaussian consNwwa("consNwwa","", nwwa, RooConst(wwaNorm),RooConst(0.28*wwaNorm)) ;
RooGaussian consNzajets("consNzajets","", nzajets, RooConst(zajetsNorm),RooConst(0.22*zajetsNorm)) ;
RooGaussian consNTop("consNTop","", nTop, RooConst(TopNorm),RooConst(0.21*TopNorm)) ;
RooFitResult *fitResult
= totalPdf.fitTo(*data, Save(true),
ExternalConstraints(consNfk),
//ExternalConstraints(consNwwa),
//ExternalConstraints(consNzajets),
//ExternalConstraints(consNTop),
RooFit::Extended(true),
//RooFit::Minos(true),
//RooFit::Hesse(false),
//PrintEvalErrors(-1),
// RooFit::Range(rangeString),
Warnings(false)
);
fitResult->Print("v");
std::cout << "===================== Wa+jets k-factor = " <<
nwajets.getVal() / wajetsNorm << " +- " << nwajets.getError() / wajetsNorm << std::endl;
// ********** Make and save Canvas for the plots ********** //
gROOT->ProcessLine(".L ~kalanand/tdrstyle.C");
setTDRStyle();
tdrStyle->SetErrorX(0.5);
tdrStyle->SetPadLeftMargin(0.19);
tdrStyle->SetPadRightMargin(0.10);
tdrStyle->SetPadBottomMargin(0.15);
tdrStyle->SetLegendBorderSize(0);
tdrStyle->SetTitleYOffset(1.5);
RooAbsData::ErrorType errorType = RooAbsData::SumW2;
TCanvas* c = new TCanvas("fit","",500,500);
RooPlot* frame1 = Mass.frame();
data->plotOn(frame1,RooFit::DataError(errorType), Name("h_data"));
totalPdf.plotOn(frame1,ProjWData(*data), Name("h_total"));
totalPdf.plotOn(frame1,ProjWData(*data),Components("pdfwajets"),
LineColor(kRed), LineStyle(2), Name("h_wajets"));
totalPdf.plotOn(frame1,ProjWData(*data),Components("pdffk,pdfwwa,pdfzajets,pdfTop"),
LineColor(kBlack), LineStyle(2), Name("h_others"));
totalPdf.plotOn(frame1,ProjWData(*data));
frame1->SetMinimum(0);
frame1->SetMaximum(1.35* frame1->GetMaximum());
frame1->Draw("e0");
std::cout << "===================== chi2/ dof = " << frame1->chiSquare() << std::endl;
TPaveText *plotlabel4 = new TPaveText(0.25,0.66,0.5,0.81,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.04);
char temp[50];
sprintf(temp, "#chi^{2} / dof = %.2f", frame1->chiSquare());
plotlabel4->AddText(temp);
plotlabel4->Draw();
cmsPrelim2();
TLegend* legend = new TLegend(0.55,0.72,0.88,0.91);
RooHist* datahist = frame1->getHist("h_data");
RooCurve* totalhist = frame1->getCurve("h_total");
RooCurve* wjetshist = frame1->getCurve("h_wajets");
RooCurve* otherhist = frame1->getCurve("h_others");
legend->AddEntry( datahist, "Data", "PE");
legend->AddEntry( totalhist, "Fit", "L");
legend->AddEntry( wjetshist, "W#gamma+jets", "L");
legend->AddEntry( otherhist, "Other processes", "L");
legend->SetFillColor(0);
legend->Draw();
c->SaveAs( "el_WVa_WjetsKfactorFit.png");
c->SaveAs( "el_WVa_WjetsKfactorFit.pdf");
}
//---------------------------------------------------------------
double *binnedFit(TString fiName, vector<double> xlim, double mtop, TLatex *channel_tex, TString outdir, double lumi)
//---------------------------------------------------------------
{
using namespace RooFit;
// reduce RooFit's verbosity on the INFO level
RooMsgService::instance().getStream(1).removeTopic(Minimization);
RooMsgService::instance().getStream(1).removeTopic(Plotting);
RooMsgService::instance().getStream(1).removeTopic(ObjectHandling);
RooMsgService::instance().getStream(1).removeTopic(Eval);
RooMsgService::instance().getStream(1).removeTopic(Fitting);
RooMsgService::instance().setSilentMode(true);
RooMsgService::instance().setGlobalKillBelow(RooFit::FATAL);
TFile *res = TFile::Open(fiName);
RooRealVar mtl("mass", "M_{J/#psi+l}", 0., 250., "GeV");
//RooRealVar mean("mean", "mass", (xlim[1]+xlim[0])/2., (xlim[1]+3.*xlim[0])/4., (3.*xlim[1]+xlim[0])/4.);
RooRealVar mean("mean", "mass", 70., 60., 80.);
RooRealVar width("width", "width", 25., 15., 40.);
TH1F *histo = (TH1F*)res->Get("MTriLept-allPair");
h_myStyle(histo,38,38,3002,histo->GetMinimum(),1.2*histo->GetMaximum(),510,510,20,38,1.,0.);
RooDataHist *datahist = new RooDataHist("datahist", "datahist", RooArgList(mtl), histo, 1.);
RooGaussian pdf("gaus", "gaus", mtl, mean, width);
pdf.fitTo(*datahist, Range(xlim[0], xlim[1]), SumW2Error(kTRUE), PrintLevel(-1), PrintEvalErrors(-1));
TCanvas *cn = new TCanvas("cn", "cn", 800, 800);
cn->cd();
RooPlot *massframe = mtl.frame();
datahist->plotOn(massframe, MarkerColor(38), LineColor(38), DataError(RooAbsData::SumW2));
pdf.plotOn(massframe, LineColor(38), Range(xlim[0], xlim[1]));
massframe->Draw();
histo->Draw("samehist");
TLegend *leg = new TLegend(0.58,0.82,0.93,0.92,NULL,"brNDC");
if (mtop < 1e-6)
leg->SetHeader(TString::Format("#tilde{M}_{J/#psi+l} = (%3.1f #pm %3.1f) GeV", mean.getVal(), mean.getError()));
else
leg->SetHeader(TString::Format("#splitline{M_{t}^{gen} = %3.1f GeV}{#tilde{M}_{J/#psi+l} = (%3.1f #pm %3.1f) GeV}", mtop+0.5, mean.getVal(), mean.getError()));
leg_myStyle(leg);
leg->Draw("same");
channel_tex->Draw("same");
if (mtop < 1e-6)
cms_myStyle(lumi, true);
else
cms_myStyle(lumi, false);
TString outFile = outdir;
if (mtop < 1e-6)
outFile += "GausianBinnedFit_Data";
else
outFile += TString::Format("GaussianBinnedFit_%d_5", (int)mtop);
cn->SaveAs(outFile+".pdf");
cn->SaveAs(outFile+".C");
cn->SaveAs(outFile+".jpg");
cn->SaveAs(outFile+".eps");
res->Close();
double *mean_err = new double[2];
mean_err[0] = mean.getVal();
mean_err[1] = mean.getError();
return mean_err;
}
void fit_fractions_hist_syst(const Int_t n_loop = 1, const Int_t flag=2, const TString channel="ee",
const Bool_t debug=false, const int rebin=4)
{
int generated_events = 23513 - 1266;
if ( channel == "mm" )
generated_events = 32719 - 1715;
// ========================================================================================
// Define the fit observable
// ========================================================================================
RooRealVar x("x","SVX mass",0.,10.);
// ========================================================================================
// Define the fit parameters
// ========================================================================================
double f_c_0 = 0.242451;
double f_l_0 = 0.494342;
if ( channel=="mm" ){
f_c_0 = 0.272683;
f_l_0 = 0.493308;
}
RooRealVar f_c("f_c","c-jet fraction", f_c_0,0.,1.);
RooRealVar f_l("f_l","dusg-jet fraction", f_l_0,0.,1.);
// ========================================================================================
// Build the Likelihood
// ========================================================================================
#if HISTPDF>0
TString dir = ( channel=="ee" ? "anaEle/" : ("anaMuo/") );
TFile * f_pdf = new TFile(path + "DYJetsToLL.root");
TH1F * h_b = (TH1F*) f_pdf->Get(dir + hname + "_b")->Clone("h_b");
TH1F * h_c = (TH1F*) f_pdf->Get(dir + hname + "_c")->Clone("h_c");
TH1F * h_l = (TH1F*) f_pdf->Get(dir + hname + "_l")->Clone("h_l");
if ( rebin>0 ) {
h_b->Rebin(rebin);
h_c->Rebin(rebin);
h_l->Rebin(rebin);
}
const int nSmooth = 0;
// --- b-jet pdf:
RooHistPdf * Pdf_b = new RooHistPdf("Pdf_b","b pdf", x,
RooDataHist("h_b","",RooArgSet(x),h_b),
nSmooth);
// --- c-jet pdf:
RooHistPdf * Pdf_c = new RooHistPdf("Pdf_c","c pdf",x,
RooDataHist("h_c","",RooArgSet(x),h_c),
nSmooth);
// --- dusg-jet pdf:
RooHistPdf * Pdf_l = new RooHistPdf("Pdf_l","l pdf",x,
RooDataHist("h_l","",RooArgSet(x),h_l),
nSmooth);
#else
// --- b-jet pdf:
RooRealVar b0("b0","b0", 3.68511e+02);
RooRealVar b1("b1","b1", 4.18671e+00);
RooRealVar b2("b2","b2", -5.43157e+00);
RooRealVar b3("b3","b3", -5.37153e+00);
RooRealVar b4("b4","b4", 1.68118e+00);
RooRealVar b5("b5","b5", 4.74296e-01);
if (channel=="mm"){
b0.setVal( 2.15313e+03);
b1.setVal( 4.95404e+00);
b2.setVal(-6.02701e+00);
b3.setVal(-6.03382e+00);
b4.setVal( 1.85650e+00);
b5.setVal( 4.98217e-01);
}
RooArgList b_pdf_par(b0,b1,b2,b3,b4,b5,x);
RooGenericPdf * Pdf_b = new RooGenericPdf("Pdf_b","b pdf",
"@0*(TMath::Power(@6+@1,@2)+TMath::Exp(@3*@6))*(1.+TMath::Erf((@6-@4)/@5))",
b_pdf_par);
RooRealVar b0_0("b0_0","b0_0", 3.68511e+02);
RooRealVar b1_0("b1_0","b1_0", 4.18671e+00);
RooRealVar b2_0("b2_0","b2_0", -5.43157e+00);
RooRealVar b3_0("b3_0","b3_0", -5.37153e+00);
RooRealVar b4_0("b4_0","b4_0", 1.68118e+00);
RooRealVar b5_0("b5_0","b5_0", 4.74296e-01);
if (channel=="mm"){
b0_0.setVal( 2.15313e+03);
b1_0.setVal( 4.95404e+00);
b2_0.setVal(-6.02701e+00);
b3_0.setVal(-6.03382e+00);
b4_0.setVal( 1.85650e+00);
b5_0.setVal( 4.98217e-01);
}
RooArgList b_pdf_par_0(b0_0,b1_0,b2_0,b3_0,b4_0,b5_0,x);
RooGenericPdf * Pdf_b_0 = new RooGenericPdf("Pdf_b","b pdf",
"@0*(TMath::Power(@6+@1,@2)+TMath::Exp(@3*@6))*(1.+TMath::Erf((@6-@4)/@5))",
b_pdf_par_0);
// --- c-jet pdf:
RooRealVar c0("c0","c0", 2.82240e+00);
RooRealVar c1("c1","c1", 2.55373e+00);
RooRealVar c2("c2","c2", -4.04638e+00);
RooRealVar c3("c3","c3", -2.60516e+00);
RooRealVar c4("c4","c4", 1.23763e+00);
RooRealVar c5("c5","c5", 4.27637e-01);
if (channel=="mm"){
c0.setVal( 2.40900e+01);
c1.setVal( 3.45622e+00);
c2.setVal(-4.75556e+00);
c3.setVal(-3.84626e+00);
c4.setVal( 1.40510e+00);
c5.setVal( 4.41045e-01);
}
RooArgList c_pdf_par(c0,c1,c2,c3,c4,c5,x);
RooGenericPdf * Pdf_c = new RooGenericPdf("Pdf_c","c pdf",
"@0*(TMath::Power(@6+@1,@2)+TMath::Exp(@3*@6))*(1.+TMath::Erf((@6-@4)/@5))",
c_pdf_par);
RooRealVar c0_0("c0_0","c0_0", 2.82240e+00);
RooRealVar c1_0("c1_0","c1_0", 2.55373e+00);
RooRealVar c2_0("c2_0","c2_0", -4.04638e+00);
RooRealVar c3_0("c3_0","c3_0", -2.60516e+00);
RooRealVar c4_0("c4_0","c4_0", 1.23763e+00);
RooRealVar c5_0("c5_0","c5_0", 4.27637e-01);
if (channel=="mm"){
c0_0.setVal( 2.40900e+01);
c1_0.setVal( 3.45622e+00);
c2_0.setVal(-4.75556e+00);
c3_0.setVal(-3.84626e+00);
c4_0.setVal( 1.40510e+00);
c5_0.setVal( 4.41045e-01);
}
RooArgList c_pdf_par_0(c0_0,c1_0,c2_0,c3_0,c4_0,c5_0,x);
RooGenericPdf * Pdf_c_0 = new RooGenericPdf("Pdf_c_0","c pdf",
"@0*(TMath::Power(@6+@1,@2)+TMath::Exp(@3*@6))*(1.+TMath::Erf((@6-@4)/@5))",
c_pdf_par_0);
// --- dusg-jet pdf:
RooRealVar l0("l0","l0", 6.31062e+00);
RooRealVar l1("l1","l1", 6.12407e-01);
RooRealVar l2("l2","l2", 2.67040e-01);
RooRealVar l3("l3","l3", 1.13059e+00);
RooRealVar l4("l4","l4", 1.80036e-01);
RooRealVar l5("l5","l5", 2.22999e+00);
RooRealVar l6("l6","l6", -4.48947e+00);
if (channel=="mm"){
l0.setVal( 3.65986e+01);
l1.setVal( 5.83322e-01);
l2.setVal( 2.51782e-01);
l3.setVal( 1.10027e+00);
l4.setVal( 2.16042e-01);
l5.setVal( 3.00909e+00);
l6.setVal(-5.10485e+00);
}
RooArgList l_pdf_par(l0,l1,l2,l3,l4,l5,l6,x);
RooGenericPdf * Pdf_l = new RooGenericPdf("Pdf_l","l pdf",
"@0*(2.+TMath::Erf((@7-@1)/@2)+TMath::Erf((@7-@3)/@4))*TMath::Power(@7+@5,@6)",
l_pdf_par);
RooRealVar l0_0("l0_0","l0_0", 6.31062e+00);
RooRealVar l1_0("l1_0","l1_0", 6.12407e-01);
RooRealVar l2_0("l2_0","l2_0", 2.67040e-01);
RooRealVar l3_0("l3_0","l3_0", 1.13059e+00);
RooRealVar l4_0("l4_0","l4_0", 1.80036e-01);
RooRealVar l5_0("l5_0","l5_0", 2.22999e+00);
RooRealVar l6_0("l6_0","l6_0", -4.48947e+00);
if (channel=="mm"){
l0_0.setVal( 3.65986e+01);
l1_0.setVal( 5.83322e-01);
l2_0.setVal( 2.51782e-01);
l3_0.setVal( 1.10027e+00);
l4_0.setVal( 2.16042e-01);
l5_0.setVal( 3.00909e+00);
l6_0.setVal(-5.10485e+00);
}
RooArgList l_pdf_par_0(l0_0,l1_0,l2_0,l3_0,l4_0,l5_0,l6_0,x);
RooGenericPdf * Pdf_l_0 = new RooGenericPdf("Pdf_l_0","l pdf",
"@0*(2.+TMath::Erf((@7-@1)/@2)+TMath::Erf((@7-@3)/@4))*TMath::Power(@7+@5,@6)",
l_pdf_par_0);
if ( debug ){
frame = x.frame();
Pdf_b->plotOn(frame);
frame->Draw();
//return;
}
#endif
// --- build the likelihood:
RooAddPdf model("model","Likelihood",RooArgList(*Pdf_c,*Pdf_l,*Pdf_b),RooArgList(f_c,f_l));
RooAddPdf model_0("model_0","Likelihood",RooArgList(*Pdf_c_0,*Pdf_l_0,*Pdf_b_0),RooArgList(f_c,f_l));
// ========================================================================================
// Read the data
// ========================================================================================
RooDataHist *dataHist = NULL;
if ( flag==0 || flag==1 || flag==2 ){
// --- Fit the data
if ( flag==0 ){
if ( channel == "ee" ){
//f = new TFile(path + "DoubleElectron_2012_merge.root");
//h = (TH1F*) f->Get("anaEle/"+hname)->Clone("h");
f = new TFile("data_noBkg.root");
h = (TH1F*) f->Get("hc_ee")->Clone("h");
}
else if ( channel == "mm" ){
//f = new TFile(path + "DoubleMu_2012_merge.root");
//h = (TH1F*) f->Get("anaMuo/"+hname)->Clone("h");
f = new TFile("data_noBkg.root");
h = (TH1F*) f->Get("hc_mm")->Clone("h");
}
else {
std::cout << "\n*** ERROR: wrong channel name\n" << std::endl;
return;
}
if ( rebin>0 )
h->Rebin(rebin);
dataHist = new RooDataHist("dataHist","x",RooArgSet(x),h);
}
// --- Fit the DY sample
else if ( flag==1 ){
f = new TFile(path + "DYJetsToLL.root");
if ( channel == "ee" ){
h = (TH1F*) f->Get("anaEle/"+hname)->Clone("h");
}
else if ( channel == "mm" ){
h = (TH1F*) f->Get("anaMuo/"+hname)->Clone("h");
}
else {
std::cout << "\n*** ERROR: wrong channel name\n" << std::endl;
return;
}
if ( rebin>0 )
h->Rebin(rebin);
dataHist = new RooDataHist("dataHist","x",RooArgSet(x),h);
}
// --- Generate a toy MC
else if ( flag==2 ){
x.setBins(50);
dataHist = model_0.generateBinned(RooArgSet(x), generated_events);
}
if ( debug ){
RooFitResult * fitRes = model_0.fitTo(*dataHist,Save(),SumW2Error(kFALSE),Minimizer("Minuit2"));
frame = x.frame();
dataHist->plotOn(frame);
model_0.plotOn(frame);
model_0.plotOn(frame, Components(*Pdf_b_0),LineStyle(kDashed),LineColor(kRed)) ;
model_0.plotOn(frame, Components(*Pdf_c_0),LineStyle(kDashed),LineColor(kBlue)) ;
model_0.plotOn(frame, Components(*Pdf_l_0),LineStyle(kDashed),LineColor(kBlack)) ;
canvas = new TCanvas("canvas","canvas");
frame->Draw();
//return;
}
// --- Set the parameters of MultiGaus
// b flavour
int nDim_h = 5;
int nDim_l = 6;
TVectorD parMeans_b(nDim_h);
parMeans_b(0) = b1.getVal();
parMeans_b(1) = b2.getVal();
parMeans_b(2) = b3.getVal();
parMeans_b(3) = b4.getVal();
parMeans_b(4) = b5.getVal();
TMatrixDSym covMatrix_b(nDim_h);
covMatrix_b(0,0) = 1.671e+00; covMatrix_b(0,1) = -1.254e+00; covMatrix_b(0,2) = -1.296e+00; covMatrix_b(0,3) = 4.291e-01; covMatrix_b(0,4) = 6.217e-02;
covMatrix_b(1,0) = covMatrix_b(0,1); covMatrix_b(1,1) = 1.011e+00; covMatrix_b(1,2) = 1.045e+00; covMatrix_b(1,3) = -3.317e-01; covMatrix_b(1,4) = -4.667e-02;
covMatrix_b(2,0) = covMatrix_b(0,2); covMatrix_b(2,1) = covMatrix_b(1,2); covMatrix_b(2,2) = 1.104e+00; covMatrix_b(2,3) = -3.351e-01; covMatrix_b(2,4) = -4.523e-02;
covMatrix_b(3,0) = covMatrix_b(0,3); covMatrix_b(3,1) = covMatrix_b(1,3); covMatrix_b(3,2) = covMatrix_b(2,3); covMatrix_b(3,3) = 1.143e-01; covMatrix_b(3,4) = 1.704e-02;
covMatrix_b(4,0) = covMatrix_b(0,4); covMatrix_b(4,1) = covMatrix_b(1,4); covMatrix_b(4,2) = covMatrix_b(2,4); covMatrix_b(4,3) = covMatrix_b(3,4); covMatrix_b(4,4) = 2.746e-03;
covMatrix_b.Print();
TVectorD genPars_b(nDim_l);
// c flavour
TVectorD parMeans_c(nDim_h);
parMeans_c(0) = c1.getVal();
parMeans_c(1) = c2.getVal();
parMeans_c(2) = c3.getVal();
parMeans_c(3) = c4.getVal();
parMeans_c(4) = c5.getVal();
TMatrixDSym covMatrix_c(nDim_h);
covMatrix_c(0,0) = 2.401e-01; covMatrix_c(0,1) = 1.875e-01; covMatrix_c(0,2) = 1.673e-01; covMatrix_c(0,3) = -1.856e-02; covMatrix_c(0,4) = -1.120e-03;
covMatrix_c(1,0) = covMatrix_c(0,1); covMatrix_c(1,1) = 3.539e-01; covMatrix_c(1,2) = 3.859e-01; covMatrix_c(1,3) = -5.883e-02; covMatrix_c(1,4) = -8.237e-03;
covMatrix_c(2,0) = covMatrix_c(0,2); covMatrix_c(2,1) = covMatrix_c(1,2); covMatrix_c(2,2) = 4.353e-01; covMatrix_c(2,3) = -6.739e-02; covMatrix_c(2,4) = -9.588e-03;
covMatrix_c(3,0) = covMatrix_c(0,3); covMatrix_c(3,1) = covMatrix_c(1,3); covMatrix_c(3,2) = covMatrix_c(2,3); covMatrix_c(3,3) = 1.112e-02; covMatrix_c(3,4) = 1.785e-03;
covMatrix_c(4,0) = covMatrix_c(0,4); covMatrix_c(4,1) = covMatrix_c(1,4); covMatrix_c(4,2) = covMatrix_c(2,4); covMatrix_c(4,3) = covMatrix_c(3,4); covMatrix_c(4,4) = 3.735e-04;
covMatrix_c.Print();
TVectorD genPars_c(nDim_l);
// light flavour
TVectorD parMeans_l(nDim_l);
parMeans_l(0) = l1.getVal();
parMeans_l(1) = l2.getVal();
parMeans_l(2) = l3.getVal();
parMeans_l(3) = l4.getVal();
parMeans_l(4) = l5.getVal();
parMeans_l(5) = l6.getVal();
TMatrixDSym covMatrix_l(nDim_l);
covMatrix_l(0,0) = 7.090e-04; covMatrix_l(0,1) = 3.629e-04; covMatrix_l(0,2) = 6.320e-04; covMatrix_l(0,3) = -7.600e-05; covMatrix_l(0,4) = -1.336e-02; covMatrix_l(0,5) = 1.077e-02;
covMatrix_l(1,0) = covMatrix_l(0,1); covMatrix_l(1,1) = 2.661e-04; covMatrix_l(1,2) = 2.863e-04; covMatrix_l(1,3) = 1.026e-05; covMatrix_l(1,4) = -5.617e-03; covMatrix_l(1,5) = 4.414e-03;
covMatrix_l(2,0) = covMatrix_l(0,2); covMatrix_l(2,1) = covMatrix_l(1,2); covMatrix_l(2,2) = 1.198e-03; covMatrix_l(2,3) = -2.218e-05; covMatrix_l(2,4) = -1.200e-02; covMatrix_l(2,5) = 9.095e-03;
covMatrix_l(3,0) = covMatrix_l(0,3); covMatrix_l(3,1) = covMatrix_l(1,3); covMatrix_l(3,2) = covMatrix_l(2,3); covMatrix_l(3,3) = 1.214e-03; covMatrix_l(3,4) = 3.792e-03; covMatrix_l(3,5) = -3.238e-03;
covMatrix_l(4,0) = covMatrix_l(0,4); covMatrix_l(4,1) = covMatrix_l(1,4); covMatrix_l(4,2) = covMatrix_l(2,4); covMatrix_l(4,3) = covMatrix_l(3,4); covMatrix_l(4,4) = 3.927e-01; covMatrix_l(4,5) = -3.457e-01;
covMatrix_l(5,0) = covMatrix_l(0,5); covMatrix_l(5,1) = covMatrix_l(1,5); covMatrix_l(5,2) = covMatrix_l(2,5); covMatrix_l(5,3) = covMatrix_l(3,5); covMatrix_l(5,4) = covMatrix_l(4,5); covMatrix_l(5,5) = 3.127e-01;
covMatrix_l.Print();
TVectorD genPars_l(nDim_l);
b_frame = x.frame();
c_frame = x.frame();
l_frame = x.frame();
TH1* h0_b = Pdf_b_0->createHistogram("h0_b",x);
h0_b->SetEntries((int) (1.-f_c_0-f_l_0)*generated_events);
h0_b->Scale((1.-f_c_0-f_l_0)*generated_events/h0_b->Integral());
TH1* h0_c = Pdf_c_0->createHistogram("h0_c",x);
h0_c->SetEntries((int) f_c_0*generated_events);
h0_c->Scale(f_c_0*generated_events/h0_c->Integral());
TH1* h0_l = Pdf_l_0->createHistogram("h0_l",x);
h0_l->SetEntries((int) f_l_0*generated_events);
h0_l->Scale(f_l_0*generated_events/h0_l->Integral());
for (int iloop=0; iloop<n_loop; ++iloop ){
if ( iloop % 100 == 0 )
cout << " >>>>>>>>>>>> Iteration # " << iloop << endl;
f_l.setVal(f_l_0);
f_c.setVal(f_c_0);
double chi2 = 99999.;
double prob = -999.;
double chi2_b = 9999.;
double chi2_c = 9999.;
double chi2_l = 9999.;
double ks_b = -999.;
double ks_c = -999.;
double ks_l = -999.;
//while ( chi2_b>0.5 || std::isnan(chi2_b) ){
while ( ks_b<0.1 ){
MultiGaus(parMeans_b, covMatrix_b, genPars_b);
//genPars_b.Print();
b1.setVal(genPars_b[0]);
b2.setVal(genPars_b[1]);
b3.setVal(genPars_b[2]);
b4.setVal(genPars_b[3]);
b5.setVal(genPars_b[4]);
TH1* h1_b = Pdf_b->createHistogram("h1_b",x);
h1_b->SetEntries((int) (1.-f_c_0-f_l_0)*generated_events);
h1_b->Scale((1.-f_c_0-f_l_0)*generated_events/h1_b->Integral());
//h1_b->Draw("SAME");
chi2_b = h1_b->Chi2Test(h0_b,"WW CHI2/NDF");
h_chi2_b.Fill(chi2_b);
ks_b = h1_b->KolmogorovTest(h0_b);
h_ks_b.Fill(ks_b);
delete h1_b;
}
//while ( chi2_c>0.5 || std::isnan(chi2_c) ){
while ( ks_c<0.1 ){
MultiGaus(parMeans_c, covMatrix_c, genPars_c);
//genPars_c.Print();
c1.setVal(genPars_c[0]);
c2.setVal(genPars_c[1]);
c3.setVal(genPars_c[2]);
c4.setVal(genPars_c[3]);
c5.setVal(genPars_c[4]);
TH1* h1_c = Pdf_c->createHistogram("h1_c",x);
h1_c->SetEntries((int) f_c_0*generated_events);
h1_c->Scale(f_c_0*generated_events/h1_c->Integral());
//h1_c->Draw("SAME");
chi2_c = h1_c->Chi2Test(h0_c,"WW CHI2/NDF");
h_chi2_c.Fill(chi2_c);
ks_c = h1_c->KolmogorovTest(h0_c);
h_ks_c.Fill(ks_c);
delete h1_c;
}
//while ( chi2_l>0.5 || std::isnan(chi2_l) ){
while ( ks_l<0.1 ){
MultiGaus(parMeans_l, covMatrix_l, genPars_l);
//genPars_l.Print();
l1.setVal(genPars_l[0]);
l2.setVal(genPars_l[1]);
l3.setVal(genPars_l[2]);
l4.setVal(genPars_l[3]);
l5.setVal(genPars_l[4]);
l6.setVal(genPars_l[5]);
TH1* h1_l = Pdf_l->createHistogram("h1_l",x);
h1_l->SetEntries((int) f_l_0*generated_events);
h1_l->Scale(f_l_0*generated_events/h1_l->Integral());
//h1_l->Draw("SAME");
chi2_l = h1_l->Chi2Test(h0_l,"WW CHI2/NDF");
h_chi2_l.Fill(chi2_l);
ks_l = h1_l->KolmogorovTest(h0_l);
h_ks_l.Fill(ks_l);
delete h1_l;
}
RooFitResult * fitRes = model.fitTo(*dataHist,Save(),SumW2Error(kFALSE),Minimizer("Minuit2"),PrintLevel(1),Verbose(0));
if (fitRes->status() != 0 ) continue;
frame = x.frame();
dataHist->plotOn(frame);
model.plotOn(frame);
//chi2 = frame->chiSquare("model_Norm[x]","h_dataHist",2);
chi2 = frame->chiSquare(2);
prob = TMath::Prob(chi2,2);
h_chi2.Fill(chi2);
h_prob.Fill(prob);
//if ( prob < 0.6 ) continue;
if ( chi2 > 5. ) continue;
if ( f_c.getVal()<0.01 ||
f_l.getVal()<0.01 ||
(1.-f_c.getVal()-f_l.getVal())<0.01 ) continue;
if ( f_c.getVal()>0.99 ||
f_l.getVal()>0.99 ||
(1.-f_c.getVal()-f_l.getVal())>0.99 ) continue;
Pdf_b->plotOn(b_frame);
Pdf_c->plotOn(c_frame);
Pdf_l->plotOn(l_frame);
h_b1.Fill(genPars_b[0]);
h_b2.Fill(genPars_b[1]);
h_b3.Fill(genPars_b[2]);
h_b4.Fill(genPars_b[3]);
h_b5.Fill(genPars_b[4]);
h_c1.Fill(genPars_c[0]);
h_c2.Fill(genPars_c[1]);
h_c3.Fill(genPars_c[2]);
h_c4.Fill(genPars_c[3]);
h_c5.Fill(genPars_c[4]);
h_l1.Fill(genPars_l[0]);
h_l2.Fill(genPars_l[1]);
h_l3.Fill(genPars_l[2]);
h_l4.Fill(genPars_l[3]);
h_l5.Fill(genPars_l[4]);
h_l6.Fill(genPars_l[5]);
if ( debug ) {
model.plotOn(frame, Components(*Pdf_b),LineStyle(kDashed),LineColor(kRed)) ;
model.plotOn(frame, Components(*Pdf_c),LineStyle(kDashed),LineColor(kBlue)) ;
model.plotOn(frame, Components(*Pdf_l),LineStyle(kDashed),LineColor(kBlack)) ;
canvas = new TCanvas("canvas","canvas");
frame->Draw();
}
h_fc.Fill(f_c.getVal());
}
Pdf_b_0->plotOn(b_frame,LineColor(kRed),LineWidth(1));
Pdf_c_0->plotOn(c_frame,LineColor(kRed),LineWidth(1));
Pdf_l_0->plotOn(l_frame,LineColor(kRed),LineWidth(1));
c_chi2 = new TCanvas();
h_chi2.Draw();
c_prob = new TCanvas();
h_prob.Draw();
c_chi2_pdf = new TCanvas("c_chi2_pdf", "Pdf's chi2", 1024, 768);
c_chi2_pdf->Divide(3,2);
c_chi2_pdf->cd(1);
h_chi2_b.Draw();
c_chi2_pdf->cd(2);
h_chi2_c.Draw();
c_chi2_pdf->cd(3);
h_chi2_l.Draw();
c_chi2_pdf->cd(4);
h_ks_b.Draw();
c_chi2_pdf->cd(5);
h_ks_c.Draw();
c_chi2_pdf->cd(6);
h_ks_l.Draw();
c_bpars = new TCanvas("c_bpars", "generated b parameters: distributions", 1024, 768);
c_bpars->Divide(3,2);
c_bpars->cd(1);
h_b1.Draw();
c_bpars->cd(2);
h_b2.Draw();
c_bpars->cd(3);
h_b3.Draw();
c_bpars->cd(4);
h_b4.Draw();
c_bpars->cd(5);
h_b5.Draw();
c_cpars = new TCanvas("c_cpars", "generated c parameters: distributions", 1024, 768);
c_cpars->Divide(3,2);
c_cpars->cd(1);
h_c1.Draw();
c_cpars->cd(2);
h_c2.Draw();
c_cpars->cd(3);
h_c3.Draw();
c_cpars->cd(4);
h_c4.Draw();
c_cpars->cd(5);
h_c5.Draw();
c_lpars = new TCanvas("l_lpars", "generated dusg parameters: distributions", 1024, 768);
c_lpars->Divide(3,2);
c_lpars->cd(1);
h_l1.Draw();
c_lpars->cd(2);
h_l2.Draw();
c_lpars->cd(3);
h_l3.Draw();
c_lpars->cd(4);
h_l4.Draw();
c_lpars->cd(5);
h_l5.Draw();
c_lpars->cd(6);
h_l6.Draw();
c_bpdf = new TCanvas();
b_frame->Draw();
c_cpdf = new TCanvas();
c_frame->Draw();
c_lpdf = new TCanvas();
l_frame->Draw();
c_fc = new TCanvas();
h_fc.Draw();
c_bpdf ->SaveAs("figs/c_bpdf.png");
c_cpdf ->SaveAs("figs/c_cpdf.png");
c_lpdf ->SaveAs("figs/c_lpdf.png");
c_fc ->SaveAs("figs/c_fc.png");
c_chi2 ->SaveAs("figs/c_chi2.png");
c_prob ->SaveAs("figs/c_prob.png");
c_bpars->SaveAs("figs/c_bpars.png");
c_cpars->SaveAs("figs/c_cpars.png");
c_lpars->SaveAs("figs/c_lpars.png");
c_chi2_pdf->SaveAs("figs/c_chi2_pdf.png");
c_bpdf ->SaveAs("figs/c_bpdf.root");
c_cpdf ->SaveAs("figs/c_cpdf.root");
c_lpdf ->SaveAs("figs/c_lpdf.root");
c_fc ->SaveAs("figs/c_fc.root");
c_chi2 ->SaveAs("figs/c_chi2.root");
c_prob ->SaveAs("figs/c_prob.root");
c_bpars->SaveAs("figs/c_bpars.root");
c_cpars->SaveAs("figs/c_cpars.root");
c_lpars->SaveAs("figs/c_lpars.root");
c_chi2_pdf->SaveAs("figs/c_chi2_pdf.root");
}
}
void fitTF1(TCanvas *canvas, TH1F h, double XMIN_, double XMAX_, double dX_, double params[], Color_t LC_=kBlack) { //double& FWHM_, double& x0_, double& x1_, double& x2_, double& y0_, double& y1_, double& INT_, double& YIELD_) {
//TCanvas* fitTF1(TH1F h, double HSCALE_, double XMIN_, double XMAX_) {
//TF1* fitTF1(TH1F h, double HSCALE_, double XMIN_, double XMAX_) {
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
for(int i=0;i<2;i++) RooMsgService::instance().setStreamStatus(i,kFALSE);
//TCanvas *canvas = new TCanvas(TString::Format("canvas_%s",h.GetName()),TString::Format("canvas_%s",h.GetName()),1800,1200);
RooDataHist *RooHistFit = 0;
RooAddPdf *model = 0;
RooWorkspace w = RooWorkspace("w","workspace");
RooRealVar x("mbbReg","mbbReg",XMIN_,XMAX_);
RooRealVar kJES("CMS_scale_j","CMS_scale_j",1,0.9,1.1);
RooRealVar kJER("CMS_res_j","CMS_res_j",1,0.8,1.2);
kJES.setConstant(kTRUE);
kJER.setConstant(kTRUE);
TString hname = h.GetName();
RooHistFit = new RooDataHist("fit_"+hname,"fit_"+hname,x,&h);
RooRealVar YieldVBF = RooRealVar("yield_"+hname,"yield_"+hname,h.Integral());
RooRealVar m("mean_"+hname,"mean_"+hname,125,100,150);
RooRealVar s("sigma_"+hname,"sigma_"+hname,12,3,30);
RooFormulaVar mShift("mShift_"+hname,"@0*@1",RooArgList(m,kJES));
RooFormulaVar sShift("sShift_"+hname,"@0*@1",RooArgList(m,kJER));
RooRealVar a("alpha_"+hname,"alpha_"+hname,1,-10,10);
RooRealVar n("exp_"+hname,"exp_"+hname,1,0,100);
RooRealVar b0("b0_"+hname,"b0_"+hname,0.5,0.,1.);
RooRealVar b1("b1_"+hname,"b1_"+hname,0.5,0.,1.);
RooRealVar b2("b2_"+hname,"b2_"+hname,0.5,0.,1.);
RooRealVar b3("b3_"+hname,"b3_"+hname,0.5,0.,1.);
RooBernstein bkg("signal_bkg_"+hname,"signal_bkg_"+hname,x,RooArgSet(b0,b1,b2));
RooRealVar fsig("fsig_"+hname,"fsig_"+hname,0.7,0.0,1.0);
RooCBShape sig("signal_gauss_"+hname,"signal_gauss_"+hname,x,mShift,sShift,a,n);
model = new RooAddPdf("signal_model_"+hname,"signal_model_"+hname,RooArgList(sig,bkg),fsig);
//RooFitResult *res = model->fitTo(*RooHistFit,RooFit::Save(),RooFit::SumW2Error(kFALSE),"q");
model->fitTo(*RooHistFit,RooFit::Save(),RooFit::SumW2Error(kFALSE),"q");
//res->Print();
//model->Print();
canvas->cd();
canvas->SetTopMargin(0.1);
RooPlot *frame = x.frame();
// no scale
RooHistFit->plotOn(frame);
model->plotOn(frame,RooFit::LineColor(LC_),RooFit::LineWidth(2));//,RooFit::LineStyle(kDotted));
model->plotOn(frame,RooFit::Components(bkg),RooFit::LineColor(LC_),RooFit::LineWidth(2),RooFit::LineStyle(kDashed));
// with scale
// RooHistFit->plotOn(frame,RooFit::Normalization(HSCALE_,RooAbsReal::NumEvent));
// model->plotOn(frame,RooFit::Normalization(HSCALE_,RooAbsReal::NumEvent),RooFit::LineWidth(1));
// model->plotOn(frame,RooFit::Components(bkg),RooFit::LineColor(kBlue),RooFit::LineWidth(1),RooFit::LineStyle(kDashed),RooFit::Normalization(HSCALE_,RooAbsReal::NumEvent));
frame->GetXaxis()->SetLimits(50,200);
frame->GetXaxis()->SetNdivisions(505);
frame->GetXaxis()->SetTitle("M_{b#bar{b}} (GeV)");
frame->GetYaxis()->SetTitle("Events");
frame->Draw();
h.SetFillColor(kGray);
h.Draw("hist,same");
frame->Draw("same");
gPad->RedrawAxis();
TF1 *tmp = model->asTF(x,fsig,x);
//tmp->Print();
double y0_ = tmp->GetMaximum();
double x0_ = tmp->GetMaximumX();
double x1_ = tmp->GetX(y0_/2.,XMIN_,x0_);
double x2_ = tmp->GetX(y0_/2.,x0_,XMAX_);
double FWHM_ = x2_-x1_;
double INT_ = tmp->Integral(XMIN_,XMAX_);
double YIELD_= YieldVBF.getVal();
double y1_ = dX_*0.5*y0_*(YieldVBF.getVal()/tmp->Integral(XMIN_,XMAX_));
params[0] = x0_;
params[1] = x1_;
params[2] = x2_;
params[3] = y0_;
params[4] = y1_;
params[5] = FWHM_;
params[6] = INT_;
params[7] = YIELD_;
//cout<<"Int = "<<tmp->Integral(XMIN_,XMAX_)<<", Yield = "<<YieldVBF.getVal()<<", y0 = "<<y0_<<", y1 = "<<y1_ <<", x0 = "<< x0_ << ", x1 = "<<x1_<<", x2 = "<<x2_<<", FWHM = "<<FWHM_<<endl;
TLine ln = TLine(x1_,y1_,x2_,y1_);
ln.SetLineColor(kMagenta+3);
ln.SetLineStyle(7);
ln.SetLineWidth(2);
ln.Draw();
canvas->Update();
canvas->SaveAs("testC.png");
// tmp->Delete();
// frame->Delete();
// res->Delete();
// TF1 *f1 = model->asTF(x,fsig,x);
// return f1;
////tmp->Delete();
////ln->Delete();
////model->Delete();
////RooHistFit->Delete();
////w->Delete();
////YieldVBF->Delete();
////frame->Delete();
////res->Delete();
//delete tmp;
//delete ln;
//delete model;
//delete RooHistFit;
//delete w;
//delete YieldVBF;
//delete frame;
//delete res;
// return canvas;
}
int main(){
BaBarStyle p;
p.SetBaBarStyle();
//gROOT->SetStyle("Plain");
Bool_t doNorm = kTRUE;
Bool_t doComparison = kFALSE;
Bool_t doFract = kFALSE;
Bool_t doFit = kFALSE;
Bool_t doPlots = kFALSE;
//define DalitzSpace for generation
EvtPDL pdl;
pdl.readPDT("evt.pdl");
EvtDecayMode mode("D0 -> K- pi+ pi0");
EvtDalitzPlot dalitzSpace(mode);
RooRealVar m2Kpi_d0mass("m2Kpi_d0mass","m2Kpi_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AB),dalitzSpace.qAbsMax(EvtCyclic3::AB));
RooRealVar m2Kpi0_d0mass("m2Kpi0_d0mass","m2Kpi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::AC),dalitzSpace.qAbsMax(EvtCyclic3::AC));
RooRealVar m2pipi0_d0mass("m2pipi0_d0mass","m2pipi0_d0mass",1.,dalitzSpace.qAbsMin(EvtCyclic3::BC),dalitzSpace.qAbsMax(EvtCyclic3::BC));
RooCategory D0flav("D0flav","D0flav");
D0flav.defineType("D0",-1);
D0flav.defineType("antiD0",1);
//this is just to plot the m23 pdf
Float_t total = pow(dalitzSpace.bigM(),2) + pow(dalitzSpace.mA(),2) + pow(dalitzSpace.mB(),2) + pow(dalitzSpace.mC(),2);
RooRealVar totalm("totalm","totalm",total);
RooFormulaVar mass13a("mass13a","@0-@1-@2",RooArgSet(totalm,m2Kpi_d0mass,m2pipi0_d0mass));
cout << "read the dataset" << endl;
TFile hello("DataSet_out_tmp.root");
gROOT->cd();
RooDataSet *data = (RooDataSet*)hello.Get("fulldata");
RooDataSet *data_1 = (RooDataSet*)data->reduce("D0flav == 1 && isWS == 0 && d0LifetimeErr < 0.5 && d0Lifetime > -2. && d0Lifetime < 4.");
RooDataSet *finaldata = (RooDataSet*)data_1->reduce("deltaMass > 0.1449 && deltaMass < 0.1459 && d0Mass > 1.8495 && d0Mass < 1.8795");
RooDataSet *leftdata = (RooDataSet*)(RooDataSet*)data_1->reduce("d0Mass > 1.74 && d0Mass < 1.79");
RooDataSet *rightdata = (RooDataSet*)data_1->reduce("d0Mass > 1.94 && d0Mass < 1.99");
//here we set the weights for the dataset
finaldata->setWeightVar(0);
leftdata->setWeightVar(0);
rightdata->setWeightVar(0);
//if you want to have a little dataset to test, uncomment next line and rename finaldata above
//RooDataSet *finaldata = finaldata_1->reduce(EventRange(1,1000));
cout << "*************************************************************" << endl;
cout << "The final data entry " << finaldata->numEntries() << endl;
cout << "*************************************************************" << endl;
//Construct signal pdf
string dirname = "configmaps/effmapping_RS_CP/";
RooKpipi0pdf *D0pdf = new RooKpipi0pdf("D0pdf","D0pdf",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace,dirname,1);
RooKpipi0pdf *D0pdf23 = new RooKpipi0pdf("D0pdf23","D0pdf23",m2Kpi_d0mass,mass13a,&dalitzSpace,dirname,1);
if(doNorm) D0pdf->getManager()->calNorm();
//When we plot the 1D projection, need to calculate the 1D integral
//set the precision here
//cout << "config integrator " << endl;
RooNumIntConfig *cfg = RooAbsReal::defaultIntegratorConfig();
cfg->setEpsAbs(1E-3);
cfg->setEpsRel(1E-3);
cfg->method1D().setLabel("RooSegmentedIntegrator1D");
//cfg.getConfigSection("RooSegmentedIntegrator1D").setRealValue("numSeg",3);
//cfg->method1D()->Print("v");
D0pdf->setIntegratorConfig(*cfg);
D0pdf23->setIntegratorConfig(*cfg);
cout << "about to init" << endl;
m2Kpi_d0mass.setBins(150);
m2Kpi0_d0mass.setBins(150);
m2pipi0_d0mass.setBins(150);
//background description
//RooBkg combdalitz("combdalitz","combdalitz",m2Kpi_d0mass,m2Kpi0_d0mass,&dalitzSpace);
//RooBkg combdalitz23("combdalitz23","combdalitz23",m2Kpi_d0mass,mass13a,&dalitzSpace);
RooRealVar Nsig("Nsig","Nsig", 653962. + 2218.);
RooRealVar Nbkg("Nbkg","Nbkg", 2255. + 551.);
RooDataHist* dbdalitz = new RooDataHist("dbdalitz","dbdalitz",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*finaldata);
RooDataHist* dbdalitz23 = new RooDataHist("dbdalitz23","dbdalitz23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*finaldata);
////////////////////////////////////////
//background parametrization using sidebands histograms
////////////////////////////////////////
TH2F *lefth = m2Kpi_d0mass.createHistogram("lefth",m2Kpi0_d0mass);
leftdata->fillHistogram(lefth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *righth = m2Kpi_d0mass.createHistogram("righth",m2Kpi0_d0mass);
rightdata->fillHistogram(righth,RooArgList(m2Kpi_d0mass,m2Kpi0_d0mass));
TH2F *lefth23 = m2Kpi_d0mass.createHistogram("lefth23",m2pipi0_d0mass);
leftdata->fillHistogram(lefth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
TH2F *righth23 = m2Kpi_d0mass.createHistogram("righth23",m2pipi0_d0mass);
rightdata->fillHistogram(righth23,RooArgList(m2Kpi_d0mass,m2pipi0_d0mass));
righth->Scale(lefth->Integral()/righth->Integral());
lefth->Sumw2();
righth->Sumw2();
righth23->Scale(lefth23->Integral()/righth23->Integral());
lefth23->Sumw2();
righth23->Sumw2();
RooDataHist *lefthist = new RooDataHist("lefthist","lefthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),lefth);
RooDataHist *righthist = new RooDataHist("righthist","righthist",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),righth);
RooDataHist *lefthist23 = new RooDataHist("lefthist23","lefthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),lefth23);
RooDataHist *righthist23 = new RooDataHist("righthist23","righthist23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),righth23);
RooHistPdf leftpdf("leftpdf","leftpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*lefthist,4);
RooHistPdf rightpdf("rightpdf","rightpdf",RooArgSet(m2Kpi_d0mass,m2Kpi0_d0mass),*righthist,4);
RooHistPdf leftpdf23("leftpdf23","leftpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*lefthist23,4);
RooHistPdf rightpdf23("rightpdf23","rightpdf23",RooArgSet(m2Kpi_d0mass,m2pipi0_d0mass),*righthist23,4);
RooRealVar fcomb("fcomb","fcomb",0.738);
RooAddPdf combdalitz("combdalitz","combdalitz",RooArgList(leftpdf,rightpdf),RooArgList(fcomb));
RooAddPdf combdalitz23("combdalitz23","combdalitz23",RooArgList(leftpdf23,rightpdf23),RooArgList(fcomb));
///////////////////////////////////////
RooAddPdf totpdf("totpdf","totpdf",RooArgList(*D0pdf,combdalitz),RooArgList(Nsig,Nbkg));
RooAddPdf totpdf23("totpdf23","totpdf23",RooArgList(*D0pdf23,combdalitz23),RooArgList(Nsig,Nbkg));
if(doFit){
// Start Minuit session on Chi2
RooChi2Var chi2("chi2","chi2",totpdf,*dbdalitz);
RooMinuit m2(chi2);
m2.migrad();
m2.hesse();
RooFitResult* fitRes = m2.save();
fitRes->Print("v");
RooArgSet results(fitRes->floatParsFinal());
RooArgSet conresults(fitRes->constPars());
results.add(conresults);
results.writeToFile("fit_isobar_RS.txt");
//save the stupid result
TFile f("fit_RSDalitz_result.root","RECREATE");
fitRes->Write();
f.Close();
}
if(doFract) {
cout << "Calculating fit fractions" << endl;
TFile f("fit_RSDalitz_result.root");
RooFitResult* fitRes = (RooFitResult*)f.Get("chi2");
//now calculate the fit fractions
const Int_t nRes = D0pdf->getManager()->getnRes();
//recalculate the normalization if necessary
D0pdf->getManager()->calNorm();
EvtComplex normarray[nRes][nRes];
const Int_t myRes = 12;
TH1F fitty[myRes];
//read the integral value from the cache file.
//In this way we don't need to compute the normalization everytime during MIGRAD
char int_name[50];
D0pdf->getManager()->getFileName(int_name);
ifstream f1;
f1.open(int_name);
if (!f1){
cout << "Error opening file " << endl;
assert(0);
}
Double_t re=0.,im=0.;
//Read in the cache file and store back to array
for(Int_t j=0;j<nRes;j++) {
char thname[100];
sprintf(thname,"thname_%d",j);
if(j < myRes) fitty[j] = TH1F(thname,thname,30,0.,1.);
for(Int_t k=0;k<nRes;k++){
f1 >> re >> im;
normarray[j][k] = EvtComplex(re,im);
}
}
EvtComplex mynorm[myRes][myRes];
Int_t m = 0, l = 0;
for(Int_t i=0;i<myRes;i++){
for(Int_t j=0;j<myRes;j++){
if(i==0) l = 7;
else if(i==1) l = 6;
else if(i==2) l = 11;
else if(i==3) l = 4;
else if(i==4) l = 5;
else if(i==5) l = 3;
else if(i==6) l = 9;
else if(i==7) l = 10;
else if(i==8) l = 12;
else if(i==9) l = 8;
else if(i==10) l = 2;
else if(i==11) l = 0;
if(j==0) m = 7;
else if(j==1) m = 6;
else if(j==2) m = 11;
else if(j==3) m = 4;
else if(j==4) m = 5;
else if(j==5) m = 3;
else if(j==6) m = 9;
else if(j==7) m = 10;
else if(j==8) m = 12;
else if(j==9) m = 8;
else if(j==10) m = 2;
else if(j==11) m = 0;
mynorm[i][j] = normarray[l][m];
}
}
//do 100 experiments and extract parameters using covariance matrix
for(Int_t l=0;l<300;l++){
RooArgList listpar = fitRes->randomizePars();
if(l==0) listpar.Print();
Double_t mynormD0 = 0.;
EvtComplex coeff_i(0.,0.), coeff_j(0.,0.);
for(Int_t i=0;i<2*myRes;i++){
for(Int_t j=0;j<2*myRes;j++){
if(i==(2*myRes - 2)) coeff_i = EvtComplex(1.,0.);
else coeff_i = EvtComplex(((RooAbsReal*)listpar.at(i))->getVal()*cos(((RooAbsReal*)listpar.at(i+1))->getVal()),
((RooAbsReal*)listpar.at(i))->getVal()*sin(((RooAbsReal*)listpar.at(i+1))->getVal()));
if(j==(2*myRes - 2)) coeff_j = EvtComplex(1.,0.);
else coeff_j = EvtComplex(((RooAbsReal*)listpar.at(j))->getVal()*cos(((RooAbsReal*)listpar.at(j+1))->getVal()),
((RooAbsReal*)listpar.at(j))->getVal()*sin(((RooAbsReal*)listpar.at(j+1))->getVal()));
mynormD0 += real(coeff_i*conj(coeff_j)*(mynorm[i/2][j/2]));
j++;
}
i++;
}
//now calculate the fit fractions
for(Int_t i=0;i<2*myRes;i++){
Double_t fitfrac = 0.;
if(i==(2*myRes - 2)) fitfrac = abs(mynorm[i/2][i/2])/mynormD0;
else fitfrac = abs2( ((RooAbsReal*)listpar.at(i))->getVal())*abs(mynorm[i/2][i/2])/mynormD0;
fitty[i/2].Fill(fitfrac);
i++;
}
}// nexperiments
Double_t tot_frac = 0.;
for(Int_t i=0;i<myRes;i++){
tot_frac += fitty[i].GetMean();
cout << "Resonance " << i << ": fit fraction = " << fitty[i].GetMean() << " +/- " << fitty[i].GetRMS() << endl;
}
cout << "Total fit fraction = " << tot_frac << endl;
cout << "///////////////////////////" << endl;
}
if(doPlots){
//Make the plots
// REMEBER: if you want roofit to consider the reweighted errors, you must put DataError(RooAbsData::SumW2))
//******************************************************
RooPlot* xframe = m2Kpi_d0mass.frame();
dbdalitz->plotOn(xframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(xframe);
xframe->getAttLine()->SetLineWidth(1);
xframe->getAttLine()->SetLineStyle(1);
xframe->SetTitle("");
xframe->GetXaxis()->SetTitle("s_{12} [GeV^{2}/c^{4}]");
xframe->GetYaxis()->SetTitle("Events/4 MeV^{2}/c^{4}");
Double_t chi2Kpi = xframe->chiSquare();
RooPlot* yframe = m2Kpi0_d0mass.frame();
dbdalitz->plotOn(yframe,MarkerSize(0.1),DrawOption("z"));
totpdf.plotOn(yframe);
yframe->getAttLine()->SetLineWidth(1);
yframe->getAttLine()->SetLineStyle(1);
yframe->SetTitle("");
yframe->GetXaxis()->SetTitle("s_{13} [GeV^{2}/c^{4}]");
yframe->GetYaxis()->SetTitle("Events/5 MeV^{2}/c^{4}");
Double_t chi2Kpi0 = yframe->chiSquare();
/*
RooPlot* zframe = m2pipi0_d0mass.frame(0.,2.3);
dbdalitz23->plotOn(zframe,MarkerSize(0.1),DrawOption("z"));
totpdf23.plotOn(zframe);
zframe->getAttLine()->SetLineWidth(1);
zframe->getAttLine()->SetLineStyle(1);
zframe->SetTitle("");
zframe->GetXaxis()->SetTitle("m^{2}_{#pi^{+}#pi^{0}}");
Double_t chi2pipi0 = zframe->chiSquare();
cout << "Chi2 for Kpi = " << chi2Kpi << endl;
cout << "Chi2 for Kpi0 = " << chi2Kpi0 << endl;
cout << "Chi2 for pipi0 = " << chi2pipi0 << endl;
RooPlot* pullFramem12 = m2Kpi_d0mass.frame() ;
pullFramem12->SetTitle("");
pullFramem12->GetXaxis()->SetTitle("");
pullFramem12->addPlotable(xframe->pullHist()) ;
pullFramem12->SetMaximum(5.);
pullFramem12->SetMinimum(-5.);
RooPlot* pullFramem13 = m2Kpi0_d0mass.frame() ;
pullFramem13->SetTitle("");
pullFramem13->GetXaxis()->SetTitle("");
pullFramem13->addPlotable(yframe->pullHist()) ;
pullFramem13->SetMaximum(5.);
pullFramem13->SetMinimum(-5.);
RooPlot* pullFramem23 = m2pipi0_d0mass.frame() ;
pullFramem23->SetTitle("");
pullFramem23->GetXaxis()->SetTitle("");
pullFramem23->addPlotable(zframe->pullHist()) ;
pullFramem23->SetMaximum(5.);
pullFramem23->SetMinimum(-5.);
TCanvas *c2 = new TCanvas("c2","residuals",1200,200);
c2->Divide(3,1);
c2->cd(1);pullFramem12->Draw();
c2->cd(2);pullFramem13->Draw();
c2->cd(3);pullFramem23->Draw();
c2->SaveAs("RSresiduals.eps");
*/
totpdf.plotOn(xframe,Project(m2Kpi0_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
totpdf.plotOn(yframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz)),DrawOption("F"),FillColor(kRed));
//totpdf23.plotOn(zframe,Project(m2Kpi_d0mass),Components(RooArgSet(combdalitz23)),DrawOption("F"),FillColor(kRed));
TPaveText *box_m12 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m12->AddText("(b)");
box_m12->SetFillColor(10);
TPaveText *box_m13 = new TPaveText(2.5,2.5,2.7,2.7,"");
box_m13->AddText("(c)");
box_m13->SetFillColor(10);
TCanvas c1("c1","c1",600,600);
c1.cd();
xframe->Draw();box_m12->Draw("SAME");
c1.SaveAs("RSfit_m2Kpi.eps");
TCanvas c2("c2","c2",600,600);
c2.cd();
yframe->Draw();box_m13->Draw("SAME");
c2.SaveAs("RSfit_m2Kpi0.eps");
/*
TCanvas *c1 = new TCanvas("c1","allevents",1200,400);
c1->Divide(3,1);
c1->cd(1);xframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(2);yframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->cd(3);zframe->Draw();
//p.SetBaBarLabel(-1,-1,-1,"preliminary");
c1->SaveAs("RSsigfit.eps");
*/
}
if(doComparison){
RooDataSet *littledata = (RooDataSet*)finaldata->reduce(EventRange(1,70000));
RooArgSet VarList1(m2Kpi_d0mass,m2Kpi0_d0mass);
Int_t num_entries = littledata->numEntries();
RooDataSet* genpdf = D0pdf->generate(VarList1,num_entries);
Int_t nbinx = 20;
Int_t nbiny = 20;
m2Kpi_d0mass.setBins(nbinx);
m2Kpi0_d0mass.setBins(nbiny);
TH2F* pdfhist = new TH2F("pdfhist","pdfhist",nbinx,0.39,3.,nbiny,0.39,3.);
TH2F* datahist = new TH2F("datahist","datahist",nbinx,0.39,3.,nbiny,0.39,3.);
pdfhist = genpdf->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
datahist = finaldata->createHistogram(m2Kpi_d0mass,m2Kpi0_d0mass);
pdfhist->GetXaxis()->SetTitle("m_{K#pi}^{2}");
pdfhist->GetYaxis()->SetTitle("m_{K#pi^{0}}^{2}");
pdfhist->Scale(datahist->Integral()/pdfhist->Integral());
pdfhist->Add(datahist,-1.);
TCanvas c2;
c2.cd();pdfhist->Draw("LEGO2Z");
c2.SaveAs("RSsigdiff.eps");
TFile ftmp("prova.root","RECREATE");
ftmp.cd();pdfhist->Write();
ftmp.Close();
}
return 0;
}//end of the macro
int fitHisto(int siteNum,string dataVer)
{
//===>initialize variable
bool anaLiHe=true;//He8/Li9 bg
int ADNumOfSite[3]={0};
int daqHistNum=5;
if( dataVer.find("13")!=-1 || dataVer.find("14")!=-1 || dataVer.find("15")!=-1 || dataVer.find("16")!=-1)
{
ADNumOfSite[0]=2;
ADNumOfSite[1]=2;
ADNumOfSite[2]=4;
daqHistNum=5;
} else
{
if( dataVer.find("11")!=-1 || dataVer.find("12")!=-1 )
{
ADNumOfSite[0]=2;
ADNumOfSite[1]=1;
ADNumOfSite[2]=3;
daqHistNum=4;
}
}
string site;
if( siteNum==1 )
{
site="EH1";
} else if(siteNum==2)
{
site="EH2";
}else if (siteNum==3)
{
site="EH3";
}else
{
site="EH1";
}
//===>initialize histograms
//livetime
string runnum;
TH1F* h[daqHistNum];//the fifth is for daqtime
Double_t totalTime[5]={0.};
//Li9 He8
double n98total=0.;
//double in98total=0.;
double ifitn98total=0.;
double n98Rate=0.;
double in98Rate=0.;
double tlivetime=0.;
TH1F* showermuonNum[6];
TH1F* time2lastshowermuon[6];
TH1F* hh[6];
//===>get histograms from .root file for analyse
string filename;
filename=site;
filename+="mergedHist_";
filename+=dataVer;
filename+=".root";
TFile* f=new TFile(filename.c_str());
//livetime
for( int i=0 ; i<daqHistNum ; i++ )
{
stringstream hname;
if( i==daqHistNum-1 )
{
hname<<"LiveTime/DaqTime";
} else
{
hname<<"LiveTime/AD";
hname<<i+1;
hname<<"LiveTime";
}
h[i] = (TH1F*)f->Get(hname.str().c_str());
if( !(h[i]) )
{
cout<<"Can not get Hist : "<<hname.str()<<" from "<<site<<"/"<<runnum<<" ."<<endl;
//return true;
continue;
}
}
//Li9 He8
if(anaLiHe)
{
for( int i=0 ; i<6 ; i++ )
{
TString hnameLi;
hnameLi="lidj/showermuonNum";
hnameLi+=i+1;
showermuonNum[i]=(TH1F*)f->Get(hnameLi);
hnameLi="lidj/time2lastshowermuon";
hnameLi+=i+1;
hnameLi+="4Li";
time2lastshowermuon[i]=(TH1F*)f->Get(hnameLi);
}
}
//===>analyse
TAxis *xaxis = h[0]->GetXaxis();
int binNum = xaxis->GetNbins();
int BinBound=h[0]->FindBin(1346428800);//2012.9.1 0:0:0
//livetime
if( BinBound!=0 )
{
if( site=="EH2" )
{
for(int j=1 ; j<=BinBound ; j++ )
{
h[1]->SetBinContent(j,0);
}
}
if( site=="EH3" )
{
for(int j=1 ; j<=BinBound ; j++ )
{
h[3]->SetBinContent(j,0);
}
}
}
double totalTimeSpecical=0.;
for( int j=BinBound ; j<=binNum ; j++ )
{
totalTimeSpecical+=h[4]->GetBinContent(j);
}
for( int i=0 ; i<5 ; i++ )
{
totalTime[i]=0.;
for( int j=1 ; j<=binNum ; j++ )
{
totalTime[i]+=h[i]->GetBinContent(j);
}
}
double totalDaqtime=0.;
if( site=="EH2" )
{
totalDaqtime=totalTime[4]+totalTimeSpecical;
}else if( site=="EH3" )
{
totalDaqtime=totalTime[4]*3+totalTimeSpecical;
} else
{
totalDaqtime=totalTime[4]*2;
}
//Li He
std::cout<<"begin to analyse Li "<<endl;
if(anaLiHe)
{
int hnum=time2lastshowermuon[0]->FindBin(100);
//std::cout<<"0.001 : "<<time2lastshowermuon[0]->FindBin(0.001)<<endl;
//std::cout<<"100 : "<<time2lastshowermuon[0]->FindBin(100)<<endl;
//std::cout<<"hnum : "<<hnum<<endl;
for( int k=0 ; k<6 ; k++ )
{
TString hhname="slice";
hhname+=k+1;
hh[k]=new TH1F(hhname,"hh",hnum-2,0.001,100);
for( int i=1 ; i<hnum-2 ; i++ )
{
hh[k]->SetBinContent(i,time2lastshowermuon[k]->GetBinContent(i+1));
}
hh[k]->SetOption("E1");
}
double showerTh[7] = {0.02, 0.5, 1.5, 2.5, 3.5, 4.5, 5.0};
TH1F* LiResult[5];
LiResult[0]= new TH1F("LiResult", "All", 6, showerTh);
LiResult[1]= new TH1F("LiResult", "AD1", 6, showerTh);
LiResult[2]= new TH1F("LiResult", "AD2", 6, showerTh);
LiResult[3]= new TH1F("LiResult", "AD3", 6, showerTh);
LiResult[4]= new TH1F("LiResult", "AD4", 6, showerTh);
double NumMuon[6]={0.};
double RateMuon[6]={0.};
double NumIbd[6]={0.};
RooRealVar x("x","x",0.001,40., "s");
RooRealVar tauLi9("tauLi9", "tauLi9", -0.257, "s");
RooRealVar tauHe8("tauHe8", "tauHe8", -0.172, "s");
RooRealVar rateMu("rateMu","rate of showermuon",-0.1,-10., 0.,"Hz");
RooRealVar Li9Frac("Li9Frac","Li9's Frac", 0.0);//R
RooRealVar N98("N98","total number of Li9 and He8",500.,0.,1.e5);
//RooRealVar N98("N98","total number of Li9 and He8",3e2, 1e1, 2.e5);
RooFormulaVar lambdaLi9("lambdaLi9","lambdaLi9","1/@0 + @1",RooArgList(tauLi9, rateMu));
RooFormulaVar lambdaHe8("lambdaHe8","lambdaHe8","1/@0 + @1",RooArgList(tauHe8, rateMu));
RooFormulaVar coeLi9("coeLi9","coeLi9","@0 * @1 ",RooArgList(N98,Li9Frac));
RooFormulaVar coeHe8("coeHe8","coeHe8","@0 * ( 1 - @1 )",RooArgList(N98,Li9Frac));
RooRealVar NIbd("NIbd","number of background",3e2, 1e1, 2.e6);
RooExponential expLi9("expLi9", "Li9 distribution", x, lambdaLi9);
RooExponential expHe8("expHe8", "He8 distribution", x, lambdaHe8);
double Ibdrate[3]={0.0076,0.0067,0.00082};
RooRealVar rateIbd("rateIbd","rateIbd",-Ibdrate[siteNum-1],-10,0.,"Hz");
RooFormulaVar lambdaIbd("lambdaIbd","lambdaIbd","@0 + @1",RooArgList(rateIbd, rateMu));
RooExponential expIbd("expIbd","Ibd distribution",x,rateMu);
//RooExponential expIbd("expIbd","Ibd distribution",x,lambdaIbd);
RooFitResult* fitres;
RooAddPdf* sum;
RooDataHist* data;
RooPlot* mesframe[6];
double n98[41]={0.};
double in98[41]={0.};
double nIbd[41]={0.};
double inIbd[41]={0.};
double minNLL[41]={0.};
double rateMuValue[41]={0.};
double rateMuErr[41]={0.};
//double minNl[6]={0.};
int minindex[6]={0};
double n98fit[6]={0.};
double in98fit[6]={0.};
double rateMufit[6]={0.};
double binwidth=0.;
TH1F* lh[5][6];
TString lname[5]={"","AD1","AD2","AD3","AD4"};
int lcolor[5]={4,3,2,6,5};
bool draw6slice=false;
TCanvas* c;
TString xTitle[6]={"slice 1 : 0.02~0.5GeV","slice 2 : 0.5~1.5GeV","slice 3 : 1.5~2.5GeV","slice 4 : 2.5~3.5GeV","slice 5 : 3.5~4.5GeV","slice 6 : >4.5GeV"};
if( draw6slice )
{
c = new TCanvas("c","c",2000,800) ;
c->Divide(3,2);
gStyle->SetEndErrorSize(5.0);
gStyle->SetMarkerSize(0.1);
//gStyle->SetHistLineWidth(1);
if( 0 )
{
// it's strange ,if you can't draw following six figs in the big 3*2 pad,you can fist use these code,run once,don't exit the ROOT,then you can draw six figs!!!
data = new RooDataHist("data", "data", x, time2lastshowermuon[0]);
sum = new RooAddPdf("sum","sum",RooArgList(expLi9, expHe8, expIbd),RooArgList(coeLi9, coeHe8, NIbd));
RooPlot* mesframe = x.frame() ;
data->plotOn(mesframe) ;
c->cd(1);
mesframe->Draw();
return true;
}
}
for( int ihist=0 ; ihist<1 ; ihist++ )
{
double minNl[6]={0.};
for( int j=0 ; j<6 ; j++ )
{
std::cout<<"now is "<< j+1<<endl;
NumIbd[j]=hh[j]->Integral(1,hh[j]->FindBin(40));
hh[j]->Rebin(100);
data = new RooDataHist("data", "data", x, hh[j]);
sum = new RooAddPdf("sum","sum",RooArgList(expLi9, expHe8, expIbd),RooArgList(coeLi9, coeHe8, NIbd));
for( int i=0 ; i<41 ; i++ )
{
Li9Frac.setVal(i*0.025);
fitres = sum->fitTo((*data),Save(),PrintLevel(-1),Extended(kTRUE));
//fitres->Print();
n98[i]=N98.getVal(0);
in98[i]=N98.getError();
nIbd[i]=NIbd.getVal(0);
inIbd[i]=NIbd.getError();
rateMuValue[i]=rateMu.getVal(0);
rateMuErr[i]=rateMu.getError();
minNLL[i] = fitres->minNll();
if( minNLL[i]<minNl[j] )
{
minNl[j]=minNLL[i];
minindex[j]=i;
}
}
n98fit[j]=n98[minindex[j]];
in98fit[j]=in98[minindex[j]];
rateMufit[j]=rateMuValue[minindex[j]];
if( draw6slice )
{
//for drawing fit figure
Li9Frac.setVal(minindex[j]*0.025);
fitres = sum->fitTo((*data),Save(),PrintLevel(-1),Extended(kTRUE));
//fitres->Print();
mesframe[j] = x.frame() ;
data->plotOn(mesframe[j]) ;
sum->plotOn(mesframe[j]);
sum->plotOn(mesframe[j],Components(expIbd),LineStyle(kDashed),LineColor(kGreen)) ;
sum->plotOn(mesframe[j],Components(RooArgSet(expLi9,expHe8)),LineStyle(kDashed),LineColor(kRed)) ;
xTitle[j]+=" time since last muon (s)";
mesframe[j]->GetXaxis()->SetTitle(xTitle[j]);
mesframe[j]->GetYaxis()->SetTitle("Entries");
c->cd(j+1);
mesframe[j]->Draw();
//gPad->SetLogy();
}
}
n98total=(n98fit[0]+n98fit[1]+n98fit[2]+(n98fit[3]+n98fit[4]+n98fit[5])*exp(-1/0.257))/0.678;
ifitn98total=sqrt(in98fit[0]*in98fit[0]+in98fit[1]*in98fit[1]+in98fit[2]*in98fit[2]+((in98fit[3]+in98fit[4]+in98fit[5])*exp(-1/0.257)*(in98fit[3]+in98fit[4]+in98fit[5])*exp(-1/0.257)))/0.678;
if( ihist==0 )
{
for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
{
tlivetime+=totalTime[i];
}
}else
{
tlivetime=totalTime[ihist-1];
}
n98Rate=n98total/(tlivetime/(24*3600));
in98Rate=sqrt((ifitn98total/(tlivetime/(24*3600)))*(ifitn98total/(tlivetime/(24*3600)))+(n98total/(tlivetime/(24*3600))/2)*(n98total/(tlivetime/(24*3600))/2));
for( int j=0 ; j<6 ; j++ )
{
LiResult[ihist]->SetBinContent(j+1,n98fit[j]);
LiResult[ihist]->SetBinError(j+1,in98fit[j]);
for( int jbin=0 ; jbin<binNum ; jbin++ )
{
NumMuon[j]+=showermuonNum[j]->GetBinContent(jbin);
}
RateMuon[j]=NumMuon[j]/totalDaqtime;
//std::cout<<"RateMuon[j] : "<<RateMuon[j]<<endl;
//std::cout<<"RateMuon0[j] : "<<RateMuon0[j]<<endl;
std::cout<<" R "<<minindex[j]*0.025<<" n98["<<minindex[j]<<"] "<<n98fit[j]<<" in98["<<minindex[j]<<"] "<< in98fit[j]<<" fitRateMu["<<minindex[j]<<"] "<<rateMufit[j]<<" realRateMu "<<RateMuon[j]<<" NumTol "<<NumIbd[j]<<endl;
}
std::cout<<"n98Num : "<<n98total<<" +- "<<ifitn98total<<" Rate : "<<n98Rate<<" +- "<< in98Rate<<endl;
}
/*
//TCanvas* c4 = new TCanvas("c4", "c4", 600, 400);
//gStyle->SetEndErrorSize(0.0);
LiResult[0]->SetMarkerStyle(20);
LiResult[0]->SetMarkerColor(lcolor[0]);
LiResult[0]->SetLineColor(lcolor[0]);
LiResult[0]->SetMarkerSize(1.0);
LiResult[0]->SetMinimum(0);
LiResult[0]->SetMaximum(LiResult[0]->GetMaximum()*1.5);
LiResult[0]->GetXaxis()->SetTitle("Muon visible energy (GeV)");
LiResult[0]->GetYaxis()->SetTitle("Fitted ^{9}Li events");
LiResult[0]->SetTitle("");
LiResult[0]->SetStats(kFALSE);
LiResult[0]->Draw("EP");
TLegend *legend=new TLegend(.6,.65,.79,.89);
TString legendLabel=dataVer+" "+site+" "+"All";
legend->AddEntry(LiResult[0],legendLabel,"lp");
for( int ihist=1 ; ihist<ADNumOfSite[siteNum-1]+1; ihist++ )
{
LiResult[ihist]->SetMarkerStyle(20);
LiResult[ihist]->SetMarkerColor(lcolor[ihist]);
LiResult[ihist]->SetLineColor(lcolor[ihist]);
LiResult[ihist]->SetMarkerSize(1.0);
LiResult[ihist]->SetStats(kFALSE);
LiResult[ihist]->Draw("EPsame");
legend->AddEntry(LiResult[ihist],lname[ihist],"lp");
}
legend->SetFillColor(0);
legend->Draw();
*/
}
//f->Close();
//===>print result
std::cout<<""<<endl;
std::cout<<site <<"'s infomation : "<<endl;
std::cout<<""<<endl;
for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
{
std::cout<<"Total AD"<<i+1<<"LiveTime : "<<totalTime[i]/(24*3600)<<endl;
}
std::cout<<"Total DaqTime : "<<totalTime[daqHistNum-1]/(24*3600)<<" day" <<endl;
std::cout<<""<<endl;
if(anaLiHe)
{
std::cout<<" "<<endl;
/*
std::cout<<"Li9/He8 "<<endl;
std::cout<<"n98total : "<<n98total <<" +- "<<in98total <<" Rate:"<<n98total/totalTime[0]*24*3600 <<" +- "<<in98total/totalTime[0]*24*3600 <<endl;
std::cout<<"n98total0(without rpc) : "<<n98total0 <<" +- "<<in98total0 <<" Rate:"<<n98total0/totalTime0[0]*24*3600 <<" +- "<<in98total0/totalTime0[0]*24*3600 <<endl;
*/
}
//===>write into .root file
string rootname=site;
rootname+="FitResult_"+dataVer+".root";
TFile* file = new TFile(rootname.c_str(),"RECREATE");
file->cd();
for( int i=0 ; i<daqHistNum ; i++ )
{
h[i]->Write();
}
if( anaLiHe )
{
//for( int i=0 ; i<ADNumOfSite[siteNum-1] ; i++ )
for( int i=0 ; i<6 ; i++ )
{
hh[i]->Write();
}
}
file->Close();
f->Close();
return 0;
}
void fitPtOverMCJLST(int mass = 125, int LHCsqrts = 7, int whichtype = 1,
bool correctErrors = false, /* string changeParName = "", */
bool showErrorPDFs = false, string systString = "Default")
// whichtype
// 0 - gg Signal
// 1 - VBF Signal
// 2 - ZZ
// 3 - ZX
// 4 - ggZZ
// 5 - WH
// 6 - ZH
// 7 - ttH
{
string changeParName = "";
if (systString == "Default") changeParName = "up";
string nameSample[8] = {"gg","vbf","zz","zx","ggzz","wh","zh","tth"};
float maxType[8] = {2.4,3.2,1.6,1.6,1.6,3.2,3.2,3.2};
float rebinType[8] = {1,2,1,1,4,10,10,40};
for (int t = 0; t < 8; t++) {
if (mass > 150) maxType[t] = int(117.90*maxType[t]/sqrt(mass-10.91))/10.;
}
char fileToOpen[200];
sprintf(fileToOpen,"selRootFiles/PToverM_%s%d_SEL_%dTeV.root",nameSample[whichtype].c_str(),mass,LHCsqrts);
// if (whichtype == 3) sprintf(fileToOpen,"PTOVERM_%s_SEL_allTeV.root",nameSample[whichtype].c_str());
RooRealVar* ptoverm = new RooRealVar("ptoverm","p_{T}/M^{4l}",0.,maxType[whichtype],"GeV/c");
TFile input(fileToOpen);
// if (systString == "Mass" || systString == "Mela") {
// sprintf(fileToOpen,"ptovermH_%sUp",systString.c_str());
// } else {
sprintf(fileToOpen,"ptovermH_%s",systString.c_str());
//}
TH1F* ptovermH = (TH1F*)input.Get(fileToOpen);
if (rebinType[whichtype] > 1) ptovermH->Rebin(rebinType[whichtype]);
if (maxType[whichtype] < ptovermH->GetBinLowEdge(ptovermH->GetNbinsX() + 1) - ptovermH->GetBinWidth(1)) {
int theBin = ptovermH->FindBin(maxType[whichtype]);
ptovermH->GetXaxis()->SetRange(1,theBin-1);
}
gROOT->ProcessLine(".L mytdrstyle.C");
gROOT->ProcessLine("setTDRStyle()");
// cout << endl << "Signal " << endl;
ptoverm->setBins(ptovermH->GetNbinsX());
RooDataHist* rdh = new RooDataHist("rdh","Some dataset",RooArgList(*ptoverm),Import(*ptovermH,kFALSE));
// fit definitions
// RooWorkspace *ws = new RooWorkspace("ws");
RooRealVar m("m","emme", 1.,0.01, 40.);
RooRealVar n("n","enne", 0.93, 0.05, 15.);
RooRealVar n2("n2","enne2", 0.75, 0.5, 15.);
RooRealVar bb("bb","bibi",0.02, 0.000005, 20.0);
RooRealVar T("T","tti",0.2,0.00000005,1.);
RooRealVar bb2("bb2","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexp("fexp","f_exp",0.02, 0.0, 1.0);
if (whichtype == 0) {
if (LHCsqrts == 8) {
m.setVal(3.319); // m.setConstant(kTRUE);
n.setVal(0.7606); if (systString != "Default" || mass != 125) n.setConstant(kTRUE);
n2.setVal(0.8061); n2.setConstant(kTRUE);
bb.setVal(3.728); // bb.setConstant(kTRUE);
T.setVal(0.00333); // T.setConstant(kTRUE);
bb2.setVal(1.7172); // bb2.setConstant(kTRUE);
fexp.setVal(0.002144); if (systString != "Default" || mass != 125) fexp.setConstant(kTRUE);
} else {
m.setVal(0.061); // m.setConstant(kTRUE);
n.setVal(1.6141); if (systString == "Resummation" || systString == "TopMass") n.setConstant(kTRUE);
n2.setVal(1.3294); n2.setConstant(kTRUE);
bb.setVal(4.2761); // bb.setConstant(kTRUE);
T.setVal(0.0361); // T.setConstant(kTRUE);
bb2.setVal(1.6643); bb2.setConstant(kTRUE);
fexp.setVal(0.0004); // fexp.setConstant(kTRUE);
}
} else if (whichtype == 1) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.02048); bb.setConstant(kTRUE);
T.setVal(0.16115); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE); // T.setConstant(kTRUE);
bb2.setVal(1.0024); bb2.setConstant(kTRUE);
fexp.setVal(0.005); fexp.setConstant(kTRUE);
if (mass > 300) {
fexp.setVal(0.0); fexp.setConstant(kFALSE);
}
if (mass > 500) {
bb2.setVal(5.0); // bb2.setConstant(kFALSE);
}
if (mass > 500) {
bb.setVal(15.0); // bb.setConstant(kFALSE);
}
} else if (whichtype == 2) {
if (LHCsqrts == 8) {
m.setVal(1.0476); // m.setConstant(kTRUE);
bb.setVal(3.3088); // if (mass != 140) bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.0021889); if (systString.find("Mela") != string::npos || mass != 140) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else {
m.setVal(1.028); // m.setConstant(kTRUE);
bb.setVal(2.91); // bb.setConstant(kTRUE);
n2.setVal(0.7146); n2.setConstant(kTRUE);
n.setVal(0.9518); n.setConstant(kTRUE);
bb2.setVal(100000.); bb2.setConstant(kTRUE);
T.setVal(0.002248); if (systString.find("Mela") != string::npos) T.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
}
} else if (whichtype == 3) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(3.4523); n.setConstant(kTRUE);
n2.setVal(0.6910); n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 4) {
m.setVal(1.411); // m.setConstant(kTRUE);
n.setVal(5.756); // n.setConstant(kTRUE);
n2.setVal(0.8738); // n2.setConstant(kTRUE);
bb.setVal(0.00039); // bb.setConstant(kTRUE);
T.setVal(0.118); // T.setConstant(kTRUE);
bb2.setVal(0.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.0); fexp.setConstant(kTRUE);
} else if (whichtype == 5 && LHCsqrts == 8) {
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(3.897); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
} else {
// cout << "Entro qui" << endl;
m.setVal(1.006); // m.setConstant(kTRUE);
n.setVal(10.939); n.setConstant(kTRUE);
n2.setVal(1.1448); n2.setConstant(kTRUE);
bb.setVal(0.0129); bb.setConstant(kTRUE);
T.setVal(0.1009); // T.setConstant(kTRUE);
bb2.setVal(1.0224); bb2.setConstant(kTRUE);
fexp.setVal(0.01); fexp.setConstant(kTRUE);
}
RooModifTsallis* rt3 = new RooModifTsallis("rt3","rt3",*ptoverm,m,n,n2,bb,bb2,T,fexp);
// ws->import(*rt3);
// fit
RooFitResult* fit = rt3->fitTo(*rdh,Minos(0),Save(1),SumW2Error(kTRUE),NumCPU(1));
float mVal = m.getVal();
float nVal = n.getVal();
float n2Val = n2.getVal();
float bbVal = bb.getVal();
float bb2Val = bb2.getVal();
float fexpVal = fexp.getVal();
float TVal = T.getVal();
if (correctErrors) {
// Tsallis errors not reliable, use toy MC
TH1F* mHist = new TH1F("mHist","m",21,-0.5*mVal,0.5*mVal);
TH1F* nHist = new TH1F("nHist","n",21,-0.2*nVal,0.2*nVal);
TH1F* n2Hist = new TH1F("n2Hist","n2",21,-0.2*n2Val,0.2*n2Val);
TH1F* bbHist = new TH1F("bbHist","bb",21,-0.2*bbVal,0.2*bbVal);
TH1F* bb2Hist = new TH1F("bb2Hist","bb2",21,-0.2*bb2Val,0.2*bb2Val);
TH1F* fexpHist = new TH1F("fexpHist","fexp",21,-0.2*fexpVal-0.000001,0.2*fexpVal+0.000001);
TH1F* THist = new TH1F("THist","T",21,-0.5*TVal,0.5*TVal);
mHist->GetXaxis()->SetTitle("m-m_{gen}");
nHist->GetXaxis()->SetTitle("n-n_{gen}");
n2Hist->GetXaxis()->SetTitle("n2-n2_{gen}");
bbHist->GetXaxis()->SetTitle("bb-bb_{gen}");
bb2Hist->GetXaxis()->SetTitle("bb2-bb2_{gen}");
THist->GetXaxis()->SetTitle("T-T_{gen}");
fexpHist->GetXaxis()->SetTitle("fexp-fexp_{gen}");
for (unsigned int iToy = 0; iToy < 200; iToy++) {
cout << endl << "####" << endl;
cout << "Generating toy experiment n. " << iToy+1 << endl;
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
TDatime *now = new TDatime();
Int_t seed = now->GetDate() + now->GetTime();
cout << "RooFit Generation Seed = " << seed+iToy << endl;
RooRandom::randomGenerator()->SetSeed(seed+iToy);
cout << "####" << endl << endl;
RooDataSet *dataToy = rt3->generate(RooArgSet(*ptoverm),ptovermH->GetEntries());
RooDataHist *dataToyH = new RooDataHist("dataToyH","toy",RooArgSet(*ptoverm),*dataToy);
rt3->fitTo(*dataToyH,Minos(0),SumW2Error(kTRUE),NumCPU(1));
if (fit->floatParsFinal().find("m")) mHist->Fill(m.getVal()-mVal);
if (fit->floatParsFinal().find("n")) nHist->Fill(n.getVal()-nVal);
if (fit->floatParsFinal().find("n2")) n2Hist->Fill(n2.getVal()-n2Val);
if (fit->floatParsFinal().find("bb")) bbHist->Fill(bb.getVal()-bbVal);
if (fit->floatParsFinal().find("bb2")) bb2Hist->Fill(bb2.getVal()-bb2Val);
if (fit->floatParsFinal().find("fexp")) fexpHist->Fill(fexp.getVal()-fexpVal);
if (fit->floatParsFinal().find("T")) THist->Fill(T.getVal()-TVal);
}
TCanvas cant("cant","Test canvas",5.,5.,900.,500.);
cant.Divide(4,2);
cant.cd(1); mHist->Draw();
cant.cd(2); nHist->Draw();
cant.cd(3); n2Hist->Draw();
cant.cd(4); bbHist->Draw();
cant.cd(5); bb2Hist->Draw();
cant.cd(6); fexpHist->Draw();
cant.cd(7); THist->Draw();
// cant.SaveAs("figs/testToys.pdf");
cant.SaveAs("newfigs/testToys.pdf");
if (fit->floatParsFinal().find("m")) m.setError(mHist->GetRMS());
if (fit->floatParsFinal().find("n")) n.setError(nHist->GetRMS());
if (fit->floatParsFinal().find("n2")) n2.setError(n2Hist->GetRMS());
if (fit->floatParsFinal().find("bb")) bb.setError(bbHist->GetRMS());
if (fit->floatParsFinal().find("bb2")) bb2.setError(bb2Hist->GetRMS());
if (fit->floatParsFinal().find("fexp")) fexp.setError(fexpHist->GetRMS());
if (fit->floatParsFinal().find("T")) T.setError(THist->GetRMS());
}
m.setVal(mVal);
n.setVal(nVal);
n2.setVal(n2Val);
bb.setVal(bbVal);
bb2.setVal(bb2Val);
fexp.setVal(fexpVal);
T.setVal(TVal);
char fileToSave[200];
// if (changeParName != "")
// sprintf(fileToSave,"text/paramsPTOverMCJLST_%s_%dTeV_%s_%s.txt",nameSample[whichtype].c_str(),LHCsqrts,systString.c_str(),changeParName.c_str());
// else
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_%s.txt",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
ofstream os1(fileToSave);
if (changeParName != "") {
sprintf(fileToSave,"m%s",changeParName.c_str()); m.SetName(fileToSave);
sprintf(fileToSave,"n%s",changeParName.c_str()); n.SetName(fileToSave);
sprintf(fileToSave,"n2%s",changeParName.c_str()); n2.SetName(fileToSave);
sprintf(fileToSave,"bb%s",changeParName.c_str()); bb.SetName(fileToSave);
sprintf(fileToSave,"bb2%s",changeParName.c_str()); bb2.SetName(fileToSave);
sprintf(fileToSave,"fexp%s",changeParName.c_str()); fexp.SetName(fileToSave);
sprintf(fileToSave,"T%s",changeParName.c_str()); T.SetName(fileToSave);
}
(RooArgSet(m,n,n2,bb,bb2,fexp,T)).writeToStream(os1,false);
os1.close();
RooRealVar mup("mup","emme", 1.,0.01, 30.);
RooRealVar nup("nup","enne", 0.93, 0.5, 15.);
RooRealVar n2up("n2up","enne2", 0.75, 0.5, 15.);
RooRealVar bbup("bbup","bibi",0.02, 0.00005, 20.0);
RooRealVar Tup("Tup","tti",0.2,0.00000005,1.);
RooRealVar bb2up("bb2up","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpup("fexpup","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3up = new RooModifTsallis("rt3up","rt3up",*ptoverm,mup,nup,n2up,bbup,bb2up,Tup,fexpup);
// ws->import(*rt3up);
RooRealVar mdown("mdown","emme", 1.,0.01, 30.);
RooRealVar ndown("ndown","enne", 0.93, 0.5, 15.);
RooRealVar n2down("n2down","enne2", 0.75, 0.5, 15.);
RooRealVar bbdown("bbdown","bibi",0.02, 0.00005, 20.0);
RooRealVar Tdown("Tdown","tti",0.2,0.00000005,1.);
RooRealVar bb2down("bb2down","bibi2",0.02, 0.0005, 10.0);
RooRealVar fexpdown("fexpdown","f_exp",0.02, 0.0, 1.0);
RooModifTsallis* rt3down = new RooModifTsallis("rt3down","rt3down",*ptoverm,mdown,ndown,n2down,bbdown,bb2down,Tdown,fexpdown);
// ws->import(*rt3down);
RooPlot *frame = ptoverm->frame();
char reducestr[300];
sprintf(reducestr,"ptoverm > %f && ptoverm < %f",ptoverm->getMin(),ptoverm->getMax());
rdh->plotOn(frame,DataError(RooAbsData::SumW2),Cut(reducestr));
static RooHist *hpull;
float chi2 = 0.;
if (changeParName == "") {
sprintf(fileToSave,"text/paramsPTOverMCJLST_%s%d_%dTeV_Default.txt",nameSample[whichtype].c_str(),mass,LHCsqrts);
ifstream is1(fileToSave);
(RooArgSet(mup,nup,n2up,bbup,bb2up,fexpup,Tup)).readFromStream(is1,false);
mdown.setVal(fabs(3*mup.getVal() - 2*m.getVal()));
ndown.setVal(fabs(3*nup.getVal() - 2*n.getVal()));
n2down.setVal(fabs(3*n2up.getVal() - 2*n2.getVal()));
bbdown.setVal(fabs(3*bbup.getVal() - 2*bb.getVal()));
Tdown.setVal(fabs(3*Tup.getVal() - 2*T.getVal()));
bb2down.setVal(fabs(3*bb2up.getVal() - 2*bb2.getVal()));
fexpdown.setVal(fabs(3*fexpup.getVal() - 2*fexp.getVal()));
if (showErrorPDFs) {
rt3->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
rt3up->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
if (systString.find("Mela") == string::npos) rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
} else {
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
}
} else {
mup.setVal(m.getVal() + m.getError()); cout << "mup = " << mup.getVal() << endl;
nup.setVal(n.getVal() + n.getError());
n2up.setVal(n2.getVal() + n2.getError());
bbup.setVal(bb.getVal() + bb.getError());
Tup.setVal(T.getVal() + T.getError());
bb2up.setVal(bb2.getVal() + bb2.getError());
fexpup.setVal(fexp.getVal() + fexp.getError());
mdown.setVal(m.getVal() - m.getError()); cout << "mdown = " << mdown.getVal() << endl;
ndown.setVal(n.getVal() - n.getError());
n2down.setVal(n2.getVal() - n2.getError());
bbdown.setVal(bb.getVal() - bb.getError());
Tdown.setVal(T.getVal() - T.getError());
bb2down.setVal(bb2.getVal() - bb2.getError());
fexpdown.setVal(fexp.getVal() - fexp.getError());
rt3->plotOn(frame,LineColor(kBlue),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
hpull = frame->pullHist();
if (showErrorPDFs) {
rt3up->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
rt3down->plotOn(frame,LineColor(kRed),LineStyle(kDashed),Normalization(rdh->sumEntries(),RooAbsReal::NumEvent));
}
}
double *ypulls = hpull->GetY();
unsigned int nBins = rdh->numEntries();
unsigned int nFullBins = 0;
for (unsigned int i = 0; i < nBins; i++) {
cout << "Pull of bin " << i << " = " << ypulls[i] << endl;
if (fabs(ypulls[i]) < 5.0) chi2 += ypulls[i]*ypulls[i];
cout << "Partial chi2 = " << chi2 << endl;
if (fabs(ypulls[i]) > 0.0001 && fabs(ypulls[i]) < 5.0) nFullBins++;
}
for (unsigned int i = 0; i < nBins; i++) {
if (fabs(ypulls[i]) < 0.0001) ypulls[i] = 999.;
hpull->SetPointError(i,0.,0.,0.,0.);
}
int nFitPar = fit->floatParsFinal().getSize() - 1;
TCanvas can("can","The canvas",5.,5.,500.,900.);
can.Divide(1,3);
TLatex *t = new TLatex();
t->SetNDC();
t->SetTextAlign(22);
t->SetTextSize(0.06);
can.cd(1);
gPad->SetBottomMargin(0.0);
frame->Draw();
// gPad->SetLogy();
// Htest->Draw();
sprintf(fileToSave,"%s %d GeV at %d TeV",nameSample[whichtype].c_str(),mass,LHCsqrts);
t->DrawLatex(0.6,0.8,fileToSave);
can.cd(2);
gPad->SetLogy();
gPad->SetTopMargin(0.0);
frame->Draw();
RooPlot* pull = ptoverm->frame(Title("Pull Distribution")) ;
pull->GetYaxis()->SetTitle("Pull");
/* pull->SetLabelSize(0.08,"XYZ");
pull->SetTitleSize(0.08,"XYZ");
pull->SetTitleOffset(0.6,"Y");
pull->SetTitleOffset(1.0,"X"); */
pull->addPlotable(hpull,"P") ;
pull->SetMinimum(-6.);
pull->SetMaximum(6.);
can.cd(3);
gPad->SetGridy();
pull->Draw();
sprintf(fileToSave,"#chi^{2}/n_{DoF} = %4.1f/%d",chi2,nFullBins - nFitPar);
if (chi2 < 1000.) t->DrawLatex(0.80,0.86,fileToSave);
// sprintf(fileToSave,"figs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
sprintf(fileToSave,"newfigs/fitPTOverMCJLST_%s%d_%dTeV_%s.pdf",nameSample[whichtype].c_str(),mass,LHCsqrts,systString.c_str());
can.SaveAs(fileToSave);
}
void FitBias(TString CAT,TString CUT,float SIG,float BKG,int NTOYS)
{
gROOT->ForceStyle();
RooMsgService::instance().setSilentMode(kTRUE);
RooMsgService::instance().setStreamStatus(0,kFALSE);
RooMsgService::instance().setStreamStatus(1,kFALSE);
// -----------------------------------------
TFile *fTemplates = TFile::Open("templates_"+CUT+"_"+CAT+"_workspace.root");
RooWorkspace *wTemplates = (RooWorkspace*)fTemplates->Get("w");
RooRealVar *x = (RooRealVar*)wTemplates->var("mTop");
RooAbsPdf *pdf_signal = (RooAbsPdf*)wTemplates->pdf("ttbar_pdf_Nominal");
RooAbsPdf *pdf_bkg = (RooAbsPdf*)wTemplates->pdf("qcdCor_pdf");
TRandom *rnd = new TRandom();
rnd->SetSeed(0);
x->setBins(250);
RooPlot *frame;
TFile *outf;
if (NTOYS > 1) {
outf = TFile::Open("FitBiasToys_"+CUT+"_"+CAT+".root","RECREATE");
}
float nSigInj,nBkgInj,nSigFit,nBkgFit,eSigFit,eBkgFit,nll;
TTree *tr = new TTree("toys","toys");
tr->Branch("nSigInj",&nSigInj,"nSigInj/F");
tr->Branch("nSigFit",&nSigFit,"nSigFit/F");
tr->Branch("nBkgInj",&nBkgInj,"nBkgInj/F");
tr->Branch("nBkgFit",&nBkgFit,"nBkgFit/F");
tr->Branch("eSigFit",&eSigFit,"eSigFit/F");
tr->Branch("eBkgFit",&eBkgFit,"eBkgFit/F");
tr->Branch("nll" ,&nll ,"nll/F");
for(int itoy=0;itoy<NTOYS;itoy++) {
// generate pseudodataset
nSigInj = rnd->Poisson(SIG);
nBkgInj = rnd->Poisson(BKG);
RooRealVar *nSig = new RooRealVar("nSig","nSig",nSigInj);
RooRealVar *nBkg = new RooRealVar("nBkg","nBkg",nBkgInj);
RooAddPdf *model = new RooAddPdf("model","model",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nSig,*nBkg));
RooDataSet *data = model->generate(*x,nSigInj+nBkgInj);
RooDataHist *roohist = new RooDataHist("roohist","roohist",RooArgList(*x),*data);
// build fit model
RooRealVar *nFitSig = new RooRealVar("nFitSig","nFitSig",SIG,0,10*SIG);
RooRealVar *nFitBkg = new RooRealVar("nFitBkg","nFitBkg",BKG,0,10*BKG);
RooAddPdf *modelFit = new RooAddPdf("modelFit","modelFit",RooArgList(*pdf_signal,*pdf_bkg),RooArgList(*nFitSig,*nFitBkg));
// fit the pseudo dataset
RooFitResult *res = modelFit->fitTo(*roohist,RooFit::Save(),RooFit::Extended(kTRUE));
//res->Print();
nSigFit = nFitSig->getVal();
nBkgFit = nFitBkg->getVal();
eSigFit = nFitSig->getError();
eBkgFit = nFitBkg->getError();
nll = res->minNll();
tr->Fill();
if (itoy % 100 == 0) {
cout<<"Toy #"<<itoy<<": injected = "<<nSigInj<<", fitted = "<<nSigFit<<", error = "<<eSigFit<<endl;
}
if (NTOYS == 1) {
frame = x->frame();
roohist->plotOn(frame);
model->plotOn(frame);
}
}
if (NTOYS == 1) {
TCanvas *can = new TCanvas("Toy","Toy",900,600);
frame->Draw();
}
else {
outf->cd();
tr->Write();
outf->Close();
fTemplates->Close();
}
}
RooAddPdf fitScaledMuMuGammaMass(
const char *histoname = "scaledMmgMass_00",
const char *filename = "scaledMmgHistos.root",
const char* plotOpt = "NEU",
const int nbins = 20)
{
gROOT->ProcessLine(".L tdrstyle.C");
setTDRStyle();
gStyle->SetPadRightMargin(0.05);
double minMass = 60;
double maxMass = 120;
RooRealVar mass("mass","m(#mu#mu#gamma)", minMass, maxMass,"GeV/c^{2}");
// Read data set
TFile * file = new TFile(filename);
TH1F * hh = (TH1F*) file->Get(histoname);
if (!hh) {
cout << "Didn't find " << histoname << " in " << filename << endl;
return;
}
RooDataHist *data = new RooDataHist("data", "data", RooArgSet(mass), hh);
// RooDataSet *data = RooDataSet::read(filename,RooArgSet(mass));
// RooDataSet *dataB = RooDataSet::read(filenameB,RooArgSet(mass));
// Build p.d.f.
////////////////////////////////////////////////
// Parameters //
////////////////////////////////////////////////
// Signal p.d.f. parameters
// Parameters for a Gaussian and a Crystal Ball Lineshape
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", 0.05, -10, 10,"GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}","CB Width", 1.6, 0.001, 10.0,"GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.5, 0.1, 2.0);
RooRealVar cbPower("n_{CB}","CB Power", 1.3, 0.1, 20.0);
// cbSigma.setConstant(kTRUE);
// cbCut.setConstant(kTRUE);
// cbPower.setConstant(kTRUE);
// Parameters for Breit-Wigner
RooRealVar bwMean("m_{Z}","BW Mean", 91.1876, "GeV/c^{2}");
RooRealVar bwWidth("#Gamma_{Z}", "BW Width", 2.4952, "GeV/c^{2}");
// Keep Breit-Wigner parameters fixed to the PDG values
// bwMean.setConstant(kTRUE);
// bwWidth.setConstant(kTRUE);
// Background p.d.f. parameters
// Parameters for exponential
RooRealVar expRate("#lambda_{exp}", "Exponential Rate", -0.119, -10, 1);
// expRate.setConstant(kTRUE);
// fraction of signal
// RooRealVar frac("frac", "Signal Fraction", 0.1,0.,0.3.);
/* RooRealVar nsig("N_{S}", "#signal events", 9000, 0.,10000.);
RooRealVar nbkg("N_{B}", "#background events", 1000,2,10000.);*/
RooRealVar nsig("N_{S}", "#signal events", 29300, 0.1, 100000.);
RooRealVar nbkg("N_{B}", "#background events", 0, 0., 10000.);
// nbkg.setConstant(kTRUE);
////////////////////////////////////////////////
// P.D.F.s //
////////////////////////////////////////////////
// Di-photon mass signal p.d.f.
RooBreitWigner bw("bw", "bw", mass, bwMean, bwWidth);
// RooGaussian signal("signal", "A Gaussian Lineshape", mass, m0, sigma);
RooCBShape cball("cball", "A Crystal Ball Lineshape", mass, cbBias, cbSigma, cbCut, cbPower);
mass.setBins(100000, "fft");
RooFFTConvPdf BWxCB("BWxCB","bw (X) crystall ball", mass, bw, cball);
// Di-photon mass background p.d.f.
RooExponential bg("bg","bkgd exp", mass, expRate);
// Di-photon mass model p.d.f.
RooAddPdf model("model", "signal + background mass model", RooArgList(BWxCB, bg), RooArgList(nsig, nbkg));
TStopwatch t ;
t.Start() ;
model.fitTo(*data,FitOptions("mh"),Optimize(0),Timer(1));
// signal->fitTo(*data,FitOptions("mh"),Optimize(0),Timer(1));
t.Print() ;
TCanvas *c = new TCanvas("c","Unbinned Invariant Mass Fit", 0,0,800,600);
// Plot the fit results
RooPlot* plot = mass.frame(Range(minMass,maxMass)/*,Bins(nbins)*/);
// Plot 1
// dataB->plotOn(plot, MarkerColor(kRed), LineColor(kRed));
data->plotOn(plot);
// model.plotOn(plot);
model.plotOn(plot);
//model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(nsig, nbkg, m0, sigma)));
model.paramOn(plot, Format(plotOpt, AutoPrecision(1)), Parameters(RooArgSet(cbBias, cbSigma, cbCut, cbPower, bwMean, bwWidth, expRate, nsig, nbkg)));
// model.plotOn(plot, Components("signal"), LineStyle(kDashed), LineColor(kRed));
model.plotOn(plot, Components("bg"), LineStyle(kDashed), LineColor(kRed));
plot->Draw();
// TLatex * tex = new TLatex(0.2,0.8,"CMS preliminary");
// tex->SetNDC();
// tex->SetTextFont(42);
// tex->SetLineWidth(2);
// tex->Draw();
// tex->DrawLatex(0.2, 0.725, "7 TeV Data, L = 258 pb^{-1}");
//
// float fsig_peak = NormalizedIntegral(model,
// mass,
// cbBias.getVal() - 2.5*cbSigma.getVal(),
// cbBias.getVal() + 2.5*cbSigma.getVal()
// );
// float fbkg_peak = NormalizedIntegral(bg,
// mass,
// m0.getVal() - 2.5*sigma.getVal(),
// m0.getVal() + 2.5*sigma.getVal()
// );
/* double nsigVal = fsig_peak * nsig.getVal();
double nsigErr = fsig_peak * nsig.getError();
double nsigErrRel = nsigErr / nsigVal;*/
// double nbkgVal = fbkg_peak * nbkg.getVal();
// double nbkgErr = fbkg_peak * nbkg.getError();
// double nbkgErrRel = nbkgErr / nbkgVal;
// cout << "nsig " << nsigVal << " +/- " << nsigErr << endl;
// cout << "S/B_{#pm2.5#sigma} " << nsigVal/nbkgVal << " +/- "
// << (nsigVal/nbkgVal)*sqrt(nsigErrRel*nsigErrRel + nbkgErrRel*nbkgErrRel)
// << endl;
// tex->DrawLatex(0.2, 0.6, Form("N_{S} = %.0f#pm%.0f", nsigVal, nsigErr) );
// tex->DrawLatex(0.2, 0.525, Form("S/B_{#pm2.5#sigma} = %.1f", nsigVal/nbkgVal) );
// tex->DrawLatex(0.2, 0.45, Form("#frac{S}{#sqrt{B}}_{#pm2.5#sigma} = %.1f", nsigVal/sqrt(nbkgVal)));
// leg = new TLegend(0.65,0.6,0.9,0.75);
// leg->SetFillColor(kWhite);
// leg->SetLineColor(kWhite);
// leg->SetShadowColor(kWhite);
// leg->SetTextFont(42);
// TLegendEntry * ldata = leg->AddEntry(data, "Opposite Sign");
// TLegendEntry * ldataB = leg->AddEntry(dataB, "Same Sign");
// ldata->SetMarkerStyle(20);
// ldataB->SetMarkerStyle(20);
// ldataB->SetMarkerColor(kRed);
// leg->Draw();
cout << "histogram name, cbMean, cbMeanErr, cbWidth, cbWidthErr\n"
<< histoname << "\t"
<< cbBias.getVal() << "\t"
<< cbBias.getError() << "\t"
<< cbSigma.getVal() << "\t"
<< cbSigma.getError() << "\t"
<< std::endl << std::flush;
return model;
}
