RooPlot* mycontour(RooRealVar& var1, RooRealVar& var2, Double_t n1, Double_t n2, Double_t n3, Double_t n4, Double_t n5, Double_t n6)
{
// Create and draw a TH2 with the error contours in parameters var1 and v2 at up to 6 'sigma' settings
// where 'sigma' is calculated as n*n*errorLevel
_theFitter->SetObjectFit(this) ;
// Verify that both variables are floating parameters of PDF
Int_t index1= _floatParamList->index(&var1);
if(index1 < 0) {
coutE(Minimization) << "RooMinuit::contour(" << GetName()
<< ") ERROR: " << var1.GetName() << " is not a floating parameter of " << _func->GetName() << endl ;
return 0;
}
Int_t index2= _floatParamList->index(&var2);
if(index2 < 0) {
coutE(Minimization) << "RooMinuit::contour(" << GetName()
<< ") ERROR: " << var2.GetName() << " is not a floating parameter of PDF " << _func->GetName() << endl ;
return 0;
}
// create and draw a frame
RooPlot* frame = new RooPlot(var1,var2) ;
// draw a point at the current parameter values
double val2=(1-var1.getVal())*var2.getVal();
TMarker *point= new TMarker(var1.getVal(), val2 , 8);
frame->addObject(point) ;
// remember our original value of ERRDEF
Double_t errdef= gMinuit->fUp;
Double_t n[6] ;
n[0] = n1 ; n[1] = n2 ; n[2] = n3 ; n[3] = n4 ; n[4] = n5 ; n[5] = n6 ;
for (Int_t ic = 0 ; ic<6 ; ic++) {
if(n[ic] > 0) {
// set the value corresponding to an n1-sigma contour
gMinuit->SetErrorDef(n[ic]*n[ic]*errdef);
// calculate and draw the contour
TGraph* graph= (TGraph*)gMinuit->Contour(50, index1, index2);
if (!graph) {
coutE(Minimization) << "RooMinuit::contour(" << GetName() << ") ERROR: MINUIT did not return a contour graph for n=" << n[ic] << endl ;
} else {
graph->SetName(Form("contour_%s_n%f",_func->GetName(),n[ic])) ;
graph->SetLineStyle(ic+1) ;
graph->SetLineWidth(2) ;
graph->SetLineColor(kBlue) ;
frame->addObject(graph,"L") ;
}
}
}
// restore the original ERRDEF
gMinuit->SetErrorDef(errdef);
return frame ;
}
void MakeSpinPlots::PlotSignalFits(TString tag, TString mcName,TString cosThetaBin){
TCanvas cv;
TString cat=tag;
if(cosThetaBin!="") tag = tag+"_"+cosThetaBin;
float mean = ws->var(Form("%s_FIT_%s_mean",mcName.Data(),tag.Data()))->getVal();
RooPlot *frame = ws->var("mass")->frame(105,140,70);//mean-10,mean+10,40);
RooAbsData *d = ws->data(mcName+"_Combined")->reduce(TString("evtcat==evtcat::")+cat);
if(cosThetaBin!=""){
TObjArray *arr = cosThetaBin.Tokenize("_");
float low = atof(arr->At(1)->GetName());
float high = atof(arr->At(2)->GetName());
d = d->reduce( Form("cosT < %0.2f && cosT >= %0.2f",high,low) );
delete arr;
}
d->plotOn(frame);
RooFitResult *res = (RooFitResult*)ws->obj(Form("%s_FIT_%s_fitResult",mcName.Data(),tag.Data()));
RooAbsPdf * pdf = ws->pdf(Form("%s_FIT_%s",mcName.Data(),tag.Data())); //signal model
std::cout << pdf << "\t" << res << std::endl;
pdf->plotOn(frame,RooFit::FillColor(kGreen),RooFit::VisualizeError(*res,2.0));
pdf->plotOn(frame,RooFit::FillColor(kYellow),RooFit::VisualizeError(*res,1.0));
pdf->plotOn(frame,RooFit::LineColor(kRed));
d->plotOn(frame); //data
tPair lbl(mcName,tag);
TLatex *prelim = new TLatex(0.18,0.9,"CMS Preliminary Simulation");
TLatex *sigL = new TLatex(0.18,0.6,Form("#sigma_{eff} = %0.2f GeV",fitSigEff[lbl].first,fitSigEff[lbl].second));
prelim->SetNDC();
sigL->SetNDC();
prelim->SetTextSize(0.05);
sigL->SetTextSize(0.05);
frame->addObject(prelim);
frame->addObject(sigL);
frame->Draw();
cv.SaveAs(basePath+Form("/signalModels/sig_%s_%s_%s.png",mcName.Data(),outputTag.Data(),tag.Data()));
cv.SaveAs(basePath+Form("/signalModels/C/sig_%s_%s_%s.C",mcName.Data(),outputTag.Data(),tag.Data()));
cv.SaveAs(basePath+Form("/signalModels/sig_%s_%s_%s.pdf",mcName.Data(),outputTag.Data(),tag.Data()));
}
void draw_data_mgg(TString folderName,bool blind=true,float min=103,float max=160)
{
TFile inputFile(folderName+"/data.root");
const int nCat = 5;
TString cats[5] = {"HighPt","Hbb","Zbb","HighRes","LowRes"};
TCanvas cv;
for(int iCat=0; iCat < nCat; iCat++) {
RooWorkspace *ws = (RooWorkspace*)inputFile.Get(cats[iCat]+"_mgg_workspace");
RooFitResult* res = (RooFitResult*)ws->obj("fitresult_pdf_data");
RooRealVar * mass = ws->var("mgg");
mass->setRange("all",min,max);
mass->setRange("blind",121,130);
mass->setRange("low",106,121);
mass->setRange("high",130,160);
mass->setUnit("GeV");
mass->SetTitle("m_{#gamma#gamma}");
RooAbsPdf * pdf = ws->pdf("pdf");
RooPlot *plot = mass->frame(min,max,max-min);
plot->SetTitle("");
RooAbsData* data = ws->data("data")->reduce(Form("mgg > %f && mgg < %f",min,max));
double nTot = data->sumEntries();
if(blind) data = data->reduce("mgg < 121 || mgg>130");
double nBlind = data->sumEntries();
double norm = nTot/nBlind; //normalization for the plot
data->plotOn(plot);
pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"),RooFit::LineWidth(0.1) );
plot->Print();
//add the fix error band
RooCurve* c = plot->getCurve("pdf_Norm[mgg]_Range[Full]_NormRange[Full]");
const int Nc = c->GetN();
//TGraphErrors errfix(Nc);
//TGraphErrors errfix2(Nc);
TGraphAsymmErrors errfix(Nc);
TGraphAsymmErrors errfix2(Nc);
Double_t *x = c->GetX();
Double_t *y = c->GetY();
double NtotalFit = ws->var("Nbkg1")->getVal()*ws->var("Nbkg1")->getVal() + ws->var("Nbkg2")->getVal()*ws->var("Nbkg2")->getVal();
for( int i = 0; i < Nc; i++ )
{
errfix.SetPoint(i,x[i],y[i]);
errfix2.SetPoint(i,x[i],y[i]);
mass->setVal(x[i]);
double shapeErr = pdf->getPropagatedError(*res)*NtotalFit;
//double totalErr = TMath::Sqrt( shapeErr*shapeErr + y[i] );
//total normalization error
double totalErr = TMath::Sqrt( shapeErr*shapeErr + y[i]*y[i]/NtotalFit );
if ( y[i] - totalErr > .0 )
{
errfix.SetPointError(i, 0, 0, totalErr, totalErr );
}
else
{
errfix.SetPointError(i, 0, 0, y[i] - 0.01, totalErr );
}
//2sigma
if ( y[i] - 2.*totalErr > .0 )
{
errfix2.SetPointError(i, 0, 0, 2.*totalErr, 2.*totalErr );
}
else
{
errfix2.SetPointError(i, 0, 0, y[i] - 0.01, 2.*totalErr );
}
/*
std::cout << x[i] << " " << y[i] << " "
<< " ,pdf get Val: " << pdf->getVal()
<< " ,pdf get Prop Err: " << pdf->getPropagatedError(*res)*NtotalFit
<< " stat uncertainty: " << TMath::Sqrt(y[i]) << " Ntot: " << NtotalFit << std::endl;
*/
}
errfix.SetFillColor(kYellow);
errfix2.SetFillColor(kGreen);
//pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kFALSE));
//pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kFALSE));
//pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kTRUE));
//pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kTRUE));
plot->addObject(&errfix,"4");
plot->addObject(&errfix2,"4");
plot->addObject(&errfix,"4");
data->plotOn(plot);
TBox blindBox(121,plot->GetMinimum()-(plot->GetMaximum()-plot->GetMinimum())*0.015,130,plot->GetMaximum());
blindBox.SetFillColor(kGray);
if(blind) {
plot->addObject(&blindBox);
pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kGreen),RooFit::Range("Full"), RooFit::VisualizeError(*res,2.0,kTRUE));
pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::FillColor(kYellow),RooFit::Range("Full"), RooFit::VisualizeError(*res,1.0,kTRUE));
}
//plot->addObject(&errfix,"4");
//data->plotOn(plot);
//pdf->plotOn(plot,RooFit::Normalization( norm ) );
//pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"),RooFit::LineWidth(1.5) );
pdf->plotOn(plot,RooFit::NormRange( "low,high" ),RooFit::Range("Full"), RooFit::LineWidth(1));
data->plotOn(plot);
/*
pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::Range("all"),RooFit::LineWidth(0.8) );
//pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kGreen),RooFit::Range("all"), RooFit::VisualizeError(*res,2.0,kFALSE));
//pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kYellow),RooFit::Range("all"), RooFit::VisualizeError(*res,1.0,kFALSE));
pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kGreen),RooFit::Range("all"), RooFit::VisualizeError(*res,2.0,kTRUE));
pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::FillColor(kYellow),RooFit::Range("all"), RooFit::VisualizeError(*res,1.0,kTRUE));
data->plotOn(plot);
pdf->plotOn(plot,RooFit::Normalization(norm),RooFit::Range("all"),RooFit::LineWidth(0.8) );
*/
TLatex lbl0(0.1,0.96,"CMS Preliminary");
lbl0.SetNDC();
lbl0.SetTextSize(0.042);
plot->addObject(&lbl0);
TLatex lbl(0.4,0.96,Form("%s Box",cats[iCat].Data()));
lbl.SetNDC();
lbl.SetTextSize(0.042);
plot->addObject(&lbl);
TLatex lbl2(0.6,0.96,"#sqrt{s}=8 TeV L = 19.78 fb^{-1}");
lbl2.SetNDC();
lbl2.SetTextSize(0.042);
plot->addObject(&lbl2);
int iObj=-1;
TNamed *obj;
while( (obj = (TNamed*)plot->getObject(++iObj)) ) {
obj->SetName(Form("Object_%d",iObj));
}
plot->Draw();
TString tag = (blind ? "_BLIND" : "");
cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".png");
cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".pdf");
cv.SaveAs(folderName+"/figs/mgg_data_"+cats[iCat]+tag+TString(Form("_%0.0f_%0.0f",min,max))+".C");
}
}
void fit_mass(TString fileN="") {//suffix added before file extension, e.g., '.pdf'
TString placeholder;//to add strings before using them, e.g., for saving text files
gROOT->SetBatch(kTRUE);
gROOT->ProcessLine(".x /afs/cern.ch/user/m/mwilkins/cmtuser/src/lhcbStyle.C");
// gStyle->SetPadTickX(1);
// gStyle->SetPadTickY(1);
// gStyle->SetPadLeftMargin(0.15);
// gStyle->SetTextSize(0.3);
// //open file and get histogram
// TFile *inHistos = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/histos_data.root", "READ");
// TH1F * h100 = (TH1F*)inHistos->Get("h70");
// cout<<"data histogram gotten"<<endl;
//unbinned
TFile *hastree = new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/data/cutfile_Optimized.root", "READ");
TTree * h100 = (TTree*)hastree->Get("mytree");
cout<<"tree gotten"<<endl;
TFile *SMChistos= new TFile("/afs/cern.ch/work/m/mwilkins/Lb2JpsiLtr/MC/withKScut/histos_SMCfile_fullMC.root", "READ");
cout<<"SMC file opened"<<endl;
TH1F *SMCh = (TH1F*)SMChistos->Get("h00");
cout<<"SMC hist gotten"<<endl;
RooRealVar *mass = new RooRealVar("Bs_LOKI_MASS_JpsiConstr","m(J/#psi #Lambda)",4100,6100,"MeV");
mass->setRange("bkg1",4300,4800);
mass->setRange("bkg2",5700,5950);
mass->setRange("bkg3",4300,5500);
mass->setRange("bkg4",5100,5500);
mass->setRange("L",5350,5950);
mass->setRange("tot",4300,5950);
cout<<"mass declared"<<endl;
// RooDataHist *data = new RooDataHist("data","1D",RooArgList(*mass),h100);
//unbinned
RooDataSet *data = new RooDataSet("data","1D",h100,*mass);
cout<<"data declared"<<endl;
RooDataHist *SMC = new RooDataHist("SMC","1D",RooArgList(*mass),SMCh);
cout<<"SMC hist assigned to RooDataHist"<<endl;
// Construct Pdf Model
// /\0
//gaussian
RooRealVar mean1L("mean1L","/\\ gaus 1: mean",5621.103095,5525,5700);
RooRealVar sig1L("sig1L","/\\ gaus 1: sigma",6.898126,0,100);
RooGaussian gau1L("gau1L","#Lambda signal: gaussian 1",*mass,mean1L,sig1L);
RooFormulaVar mean2L("mean2L","@0",mean1L);
RooRealVar sig2L("sig2L","/\\ gaus 2: sigma",14.693117,0,100);
RooGaussian gau2L("gau2L","#Lambda signal: gaussian 2",*mass,mean2L,sig2L);
RooRealVar f1L("f1L","/\\ signal: fraction gaussian 1",0.748776,0,1);
RooAddPdf sigL("sigL","#Lambda signal",RooArgList(gau1L,gau2L),RooArgList(f1L));
// //CB
// RooRealVar mean3L("mean3L","/\\ CB: mean",5621.001,5525,5700);
// RooRealVar sig3L("sig3L","/\\ CB: sigma",5.161,0,100);
// RooRealVar alphaL3("alphaL3","/\\ CB: alpha",2.077,0,1000);
// RooRealVar nL3("nL1","/\\ CB: n",0.286,0,1000);
// RooCBShape CBL("CBL","#Lambda signal: CB",*mass,mean3L,sig3L,alphaL3,nL3);
// RooRealVar mean4L("mean4L","/\\ gaus: mean",5621.804,5525,5700);
// RooRealVar sig4L("sig4L","/\\ gaus: sigma",10.819,0,100);
// RooGaussian gauL("gauL","#Lambda signal: gaussian",*mass,mean4L,sig4L);
// RooRealVar f1L("f1L","/\\ signal: fraction CB",0.578,0,1);
// RooAddPdf sigL("sigL","#Lambda signal",RooArgList(CBL,gauL),RooArgList(f1L));
// sigma0
//using RooHistPdf from MC--no need to build pdf here
RooHistPdf sigS = makeroohistpdf(SMC,mass,"sigS","#Sigma^{0} signal (RooHistPdf)");
// /\*
cout<<"Lst stuff"<<endl;
RooRealVar meanLst1("meanLst1","/\\*(misc.): mean1",5011.031237,4900,5100);
RooRealVar sigLst1("sigLst1","/\\*(misc.): sigma1",70.522092,0,100);
RooRealVar meanLst2("mean5Lst2","/\\*(1405): mean2",5245.261703,5100,5350);
RooRealVar sigLst2("sigLst2","/\\*(1405): sigma2",64.564763,0,100);
RooRealVar alphaLst2("alphaLst2","/\\*(1405): alpha2",29.150301);
RooRealVar nLst2("nLst2","/\\*(1405): n2",4.615817,0,50);
RooGaussian gauLst1("gauLst1","#Lambda*(misc.), gaus",*mass,meanLst1,sigLst1);
RooCBShape gauLst2("gauLst2","#Lambda*(1405), CB",*mass,meanLst2,sigLst2,alphaLst2,nLst2);
// RooRealVar fLst1("fLst1","/\\* bkg: fraction gaus 1",0.743,0,1);
// RooAddPdf bkgLst("bkgLst","#Lambda* signal",RooArgList(gauLst1,gauLst2),RooArgList(fLst1));
//Poly func BKG mass
// RooRealVar b0("b0","Background: Chebychev b0",-1.071,-10000,10000);
RooRealVar b1("b1","Background: Chebychev b1",-1.323004,-10,-0.00000000000000000000001);
RooRealVar b2("b2","Background: Chebychev b2",0.145494,0,10);
RooRealVar b3("b3","Background: Chebychev b3",-0.316,-10000,10000);
RooRealVar b4("b4","Background: Chebychev b4",0.102,-10000,10000);
RooRealVar b5("b5","Background: Chebychev b5",0.014,-10000,10000);
RooRealVar b6("b6","Background: Chebychev b6",-0.015,-10000,10000);
RooRealVar b7("b7","Background: Chebychev b7",0.012,-10000,10000);
RooArgList bList(b1,b2);
RooChebychev bkg("bkg","Background", *mass, bList);
// TF1 *ep = new TF1("ep","[2]*exp([0]*x+[1]*x*x)",4300,5950);
// ep->SetParameter(0,1);
// ep->SetParameter(1,-1);
// ep->SetParameter(2,2000);
// ep->SetParName(0,"a");
// ep->SetParName(1,"b");
// ep->SetParName(2,"c");
// RooRealVar a("a","Background: Coefficent of x",1,-10000,10000);
// RooRealVar b("b","Background: Coefficent of x*x",-1,-10000,10000);
// RooRealVar c("c","Background: Coefficent of exp()",2000,-10000,10000);
// RooTFnPdfBinding bkg("ep","ep",ep,RooArgList(*mass,a,b));
//number of each shape
RooRealVar nbkg("nbkg","N bkg",2165.490249,0,100000000);
RooRealVar nsigL("nsigL","N /\\",1689.637290,0,1000000000);
RooRealVar nsigS("nsigS","N sigma",0.000002,0,10000000000);
RooRealVar ngauLst1("ngauLst1","N /\\*(misc.)",439.812103,0,10000000000);
RooRealVar ngauLst2("ngauLst2","N /\\*(1405)",152.061617,0,10000000000);
RooRealVar nbkgLst("nbkgLst","N /\\*",591.828,0,1000000000);
//add shapes and their number to a totalPdf
RooArgList shapes;
RooArgList yields;
shapes.add(sigL); yields.add(nsigL);
shapes.add(sigS); yields.add(nsigS);
// shapes.add(bkgLst); yields.add(nbkgLst);
shapes.add(gauLst1); yields.add(ngauLst1);
shapes.add(gauLst2); yields.add(ngauLst2);
shapes.add(bkg); yields.add(nbkg);
RooAddPdf totalPdf("totalPdf","totalPdf",shapes,yields);
//fit the totalPdf
RooAbsReal * nll = totalPdf.createNLL(*data,Extended(kTRUE),Range("tot"));
RooMinuit m(*nll);
m.setVerbose(kFALSE);
m.migrad();
m.minos();
m.minos();
//display and save information
ofstream textfile;//create text file to hold data
placeholder = "plots/fit"+fileN+".txt";
textfile.open(placeholder);
TString outputtext;//for useful text
//plot things
RooPlot *framex = mass->frame();
framex->GetYaxis()->SetTitle("Events/(5 MeV)");
data->plotOn(framex,Name("Hist"),MarkerColor(kBlack),LineColor(kBlack),DataError(RooAbsData::SumW2));
totalPdf.plotOn(framex,Name("curvetot"),LineColor(kBlue));
RooArgSet* totalPdfComponents = totalPdf.getComponents();
TIterator* itertPC = totalPdfComponents->createIterator();
RooAddPdf* vartPC = (RooAddPdf*) itertPC->Next();
vartPC = (RooAddPdf*) itertPC->Next();//skip totalPdf
int i=0;//color index
TLegend *leg = new TLegend(0.2, 0.02, .4, .42);
leg->SetTextSize(0.06);
leg->AddEntry(framex->findObject("curvetot"),"Total PDF","l");
while(vartPC){//loop over compotents of totalPdf
TString vartPCtitle = vartPC->GetTitle();
TIterator* itercompPars;//forward declare so it persists outside the if statement
RooRealVar* varcompPars;
if(!(vartPCtitle.Contains(":")||vartPCtitle.Contains("@"))){//only for non-sub-shapes
while(i==0||i==10||i==4||i==1||i==5||(i>=10&&i<=27))i++;//avoid white and blue and black and yellow and horribleness
RooArgSet* compPars = vartPC->getParameters(data);//set of the parameters of the component the loop is on
itercompPars = compPars->createIterator();
varcompPars = (RooRealVar*) itercompPars->Next();
while(varcompPars){//write and print mean, sig, etc. of sub-shapes
TString vartitle = varcompPars->GetTitle();
double varval = varcompPars->getVal();
TString varvalstring = Form("%f",varval);
double hi = varcompPars->getErrorHi();
TString varerrorstring = "[exact]";
if(hi!=-1){
double lo = varcompPars->getErrorLo();
double varerror = TMath::Max(fabs(lo),hi);
varerrorstring = Form("%E",varerror);
}
outputtext = vartitle+" = "+varvalstring+" +/- "+varerrorstring;
textfile<<outputtext<<endl;
cout<<outputtext<<endl;
varcompPars = (RooRealVar*) itercompPars->Next();
}
totalPdf.plotOn(framex,Name(vartPC->GetName()),LineStyle(kDashed),LineColor(i),Components(vartPC->GetName()));
leg->AddEntry(framex->findObject(vartPC->GetName()),vartPCtitle,"l");
i++;
}
vartPC = (RooAddPdf*) itertPC->Next();
itercompPars->Reset();//make sure it's ready for the next vartPC
}
// Calculate chi2/ndf
RooArgSet *floatpar = totalPdf.getParameters(data);
int floatpars = (floatpar->selectByAttrib("Constant",kFALSE))->getSize();
Double_t chi2 = framex->chiSquare("curvetot","Hist",floatpars);
TString chi2string = Form("%f",chi2);
//create text box to list important parameters on the plot
// TPaveText* txt = new TPaveText(0.1,0.5,0.7,0.9,"NBNDC");
// txt->SetTextSize(0.06);
// txt->SetTextColor(kBlack);
// txt->SetBorderSize(0);
// txt->SetFillColor(0);
// txt->SetFillStyle(0);
outputtext = "#chi^{2}/N_{DoF} = "+chi2string;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
// txt->AddText(outputtext);
// Print stuff
TIterator* iteryields = yields.createIterator();
RooRealVar* varyields = (RooRealVar*) iteryields->Next();//only inherits things from TObject unless class specified
vector<double> Y, E;//holds yields and associated errors
vector<TString> YS, ES;//holds strings of the corresponding yields
int j=0;//count vector position
int jS=0, jL=0;//these hold the position of the S and L results;initialized in case there is no nsigS or nsigL
while(varyields){//loop over yields
TString varname = varyields->GetName();
TString vartitle = varyields->GetTitle();
double varval = varyields->getVal();
Y.push_back(varval);
double lo = varyields->getErrorLo();
double hi = varyields->getErrorHi();
E.push_back(TMath::Max(fabs(lo),hi));
YS.push_back(Form("%f",Y[j]));
ES.push_back(Form("%f",E[j]));
if(varname=="nsigS") jS=j;
if(varname=="nsigL") jL=j;
outputtext = vartitle+" = "+YS[j]+" +/- "+ES[j];
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
varyields = (RooRealVar*) iteryields->Next();
j++;
}
//S/L
double result = Y[jS]/Y[jL];
cout<<"result declared"<<endl;
double E_result = TMath::Abs(result)*sqrt(pow(E[jS]/Y[jS],2)+pow(E[jL]/Y[jL],2));
cout<<"E_result declared"<<endl;
TString resultstring = Form("%E",result);
TString E_resultstring = Form("%E",E_result);
outputtext = "Y_{#Sigma^{0}}/Y_{#Lambda} = "+resultstring+" +/- "+E_resultstring;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
double resultlimit = (Y[jS]+E[jS])/(Y[jL]-E[jL]);
outputtext = Form("%E",resultlimit);
outputtext = "limit = "+outputtext;
cout<<outputtext<<endl;
textfile<<outputtext<<endl;
//txt->AddText(outputtext);
// Create canvas and pads, set style
TCanvas *c1 = new TCanvas("c1","data fits",1200,800);
TPad *pad1 = new TPad("pad1","pad1",0.0,0.3,1.0,1.0);
TPad *pad2 = new TPad("pad2","pad2",0.0,0.0,1.0,0.3);
pad1->SetBottomMargin(0);
pad2->SetTopMargin(0);
pad2->SetBottomMargin(0.5);
pad2->SetBorderMode(0);
pad1->SetBorderMode(0);
c1->SetBorderMode(0);
pad2->Draw();
pad1->Draw();
pad1->cd();
framex->SetMinimum(1);
framex->SetMaximum(3000);
framex->addObject(leg);//add legend to frame
//framex->addObject(txt);//add text to frame
gPad->SetTopMargin(0.06);
pad1->SetLogy();
// pad1->Range(4100,0,6100,0.0005);
pad1->Update();
framex->Draw();
// Pull distribution
RooPlot *framex2 = mass->frame();
RooHist* hpull = framex->pullHist("Hist","curvetot");
framex2->addPlotable(hpull,"P");
hpull->SetLineColor(kBlack);
hpull->SetMarkerColor(kBlack);
framex2->SetTitle(0);
framex2->GetYaxis()->SetTitle("Pull");
framex2->GetYaxis()->SetTitleSize(0.15);
framex2->GetYaxis()->SetLabelSize(0.15);
framex2->GetXaxis()->SetTitleSize(0.2);
framex2->GetXaxis()->SetLabelSize(0.15);
framex2->GetYaxis()->CenterTitle();
framex2->GetYaxis()->SetTitleOffset(0.45);
framex2->GetXaxis()->SetTitleOffset(1.1);
framex2->GetYaxis()->SetNdivisions(505);
framex2->GetYaxis()->SetRangeUser(-8.8,8.8);
pad2->cd();
framex2->Draw();
c1->cd();
placeholder = "plots/fit"+fileN+".eps";
c1->Print(placeholder);
placeholder = "plots/fit"+fileN+".C";
c1->SaveAs(placeholder);
textfile.close();
}
std::pair<double, double> fit_mass(RooDataSet* ds, string oFile, string cut, string massvar = "Z_M"){
RooRealVar m( massvar.c_str(), massvar.c_str(), 60., 120. );
RooPlot* plot = m.frame();
// Breit Wigner - Z Lineshape
RooRealVar m0( "m0", "m0", 0 );
RooRealVar width( "width", "width", 1.5, 0, 5 );
RooBreitWigner bw( "gauss", "gauss", m, m0, width );
// Crystal-Ball - Detector response + FSR
RooRealVar mean( "mean", "mean", 90.3, 70, 110 );
RooRealVar sigma( "sigma", "sigma", 0.5, 0, 5);
RooRealVar alpha( "alpha", "alpha", 2.2, 0.01, 5 );
RooRealVar n( "n", "n", 1, 0.01, 80 );
RooCBShape cb( "cb", "cb", m, mean, sigma, alpha, n );
//exponential - DY component + background
RooRealVar lambda("lambda", "slope", -2e-2, -30., 0.);
RooExponential expo("expo", "exponential PDF", m, lambda);
//Set cache for FFT convolution
m.setBins(10000, "cache");
m.setMin("cache", 50.5);
m.setMax("cache", 129.5);
//convolve PDFs
RooFFTConvPdf pdf( "pdf", "pdf", m, cb, bw );
//Background fraction
RooRealVar b("b", "background", 0.7, 0, 1);
RooAddPdf sum("sum", "crystal ball + gaussian + expo", RooArgList(pdf, expo), RooArgList(b));
//sum.fitTo(*ds, RooFit::Extended());
sum.fitTo(*ds);
//Make mass plot
TCanvas* canv = new TCanvas( "canv", "canv", 800.0, 600.0 );
plot -> GetXaxis() -> SetTitle( "M_{#mu#mu} [GeV]" );
plot -> GetYaxis() -> SetTitleOffset( 1.5 );
ds->plotOn( plot );
sum.plotOn(plot);
//print chi2 on plot and add tpavetext
ostringstream sstream;
sstream<<"#chi^{2}/nDoF = "<<plot->chiSquare();
TPaveText* p = new TPaveText(0.15, 0.7, 0.5, 0.9, "NDC");
p->SetFillStyle(0);
p->SetBorderSize(0.0);
plot->addObject(p);
p->AddText(cut.c_str());
p->AddText(sstream.str().c_str());
plot->Draw();
p->Draw();
canv->SaveAs( ("BWxCB_"+oFile+".pdf").c_str() );
// return as pair with value and error of mean
std::pair<double, double> a(mean.getVal(), mean.getError());
return a;
}
void RegressionPlottingAll(bool doEBEE=true, bool doEB=false, bool doEE=false){
TString name1;
TString name2;
TString name3;
string dir;
if (doEBEE){
name1="results_noPU_new.root";
name2="results_bx50_new.root";
name3="results_bx25_new.root";
dir="plots";
}
if (doEB){
name1="resultsEB_noPU_new.root";
name2="resultsEB_bx50_new.root";
name3="resultsEB_bx25_new.root";
dir="plotsEB";
}
if (doEE){
name1="resultsEE_noPU_new.root";
name2="resultsEE_bx50_new.root";
name3="resultsEE_bx25_new.root";
dir="plotsEE";
}
TFile *fResults1 = TFile::Open(name1);
TFile *fResults2 = TFile::Open(name2);
TFile *fResults3 = TFile::Open(name3);
//Plot eraw/etrue and ecor/etrue to quantify regression performance
//Get Histograms
TH1 *hecor1 = (TH1*)fResults1->Get("hCor_true");
TH1 *heraw1 = (TH1*)fResults1->Get("hRaw_true");
TH1 *hecor2 = (TH1*)fResults2->Get("hCor_true");
TH1 *heraw2 = (TH1*)fResults2->Get("hRaw_true");
TH1 *hecor3 = (TH1*)fResults3->Get("hCor_true");
TH1 *heraw3 = (TH1*)fResults3->Get("hRaw_true");
hecor1->Scale(1./hecor1->Integral());
heraw1->Scale(1./heraw1->Integral());
hecor2->Scale(1./hecor2->Integral());
heraw2->Scale(1./heraw2->Integral());
hecor3->Scale(1./hecor3->Integral());
heraw3->Scale(1./heraw3->Integral());
//Compute peak of the distributions by fitting histograms with double Crystal Ball
double PeakRaw1,PeakRawErr1,PeakCor1,PeakCorErr1;
double PeakRaw2,PeakRawErr2,PeakCor2,PeakCorErr2;
double PeakRaw3,PeakRawErr3,PeakCor3,PeakCorErr3;
RooRealVar *bias=new RooRealVar("Ecor/Etrue","Ecor/Etrue",0.8,1.2);
const RooArgList *var=new RooArgList(*bias,"");
RooPlot *plot = bias->frame(Range(0.9,1.07));
plot->SetTitle("");
plot->GetYaxis()->SetTitle("");
RooDataHist *Hraw1=new RooDataHist("","",*var,heraw1);
RooDoubleCBFast *DoubleCBraw1=FitWithDCB(Hraw1,bias,PeakRaw1,PeakRawErr1);
Hraw1->plotOn(plot,MarkerSize(0.8),MarkerColor(kBlue+2),MarkerStyle(24));
DoubleCBraw1->plotOn(plot,LineColor(kBlue+2),LineStyle(2),LineWidth(2),Name("hraw1"));
RooDataHist *Hcor1=new RooDataHist("","",*var,hecor1);
RooDoubleCBFast *DoubleCBcor1=FitWithDCB(Hcor1,bias,PeakCor1,PeakCorErr1);
Hcor1->plotOn(plot,MarkerSize(0.6),MarkerColor(kBlue+2));
DoubleCBcor1->plotOn(plot,LineColor(kBlue+2),LineWidth(2),Name("hcor1"));
RooDataHist *Hraw2=new RooDataHist("","",*var,heraw2);
RooDoubleCBFast *DoubleCBraw2=FitWithDCB(Hraw2,bias,PeakRaw2,PeakRawErr2);
Hraw2->plotOn(plot,MarkerSize(0.8),MarkerColor(kRed+1),MarkerStyle(24));
DoubleCBraw2->plotOn(plot,LineColor(kRed+1),LineStyle(2),LineWidth(2),Name("hraw2"));
RooDataHist *Hcor2=new RooDataHist("","",*var,hecor2);
RooDoubleCBFast *DoubleCBcor2=FitWithDCB(Hcor2,bias,PeakCor2,PeakCorErr2);
Hcor2->plotOn(plot,MarkerSize(0.6),MarkerColor(kRed+1));
DoubleCBcor2->plotOn(plot,LineColor(kRed+1),LineWidth(2),Name("hcor2"));
RooDataHist *Hraw3=new RooDataHist("","",*var,heraw3);
RooDoubleCBFast *DoubleCBraw3=FitWithDCB(Hraw3,bias,PeakRaw3,PeakRawErr3);
Hraw3->plotOn(plot,MarkerSize(0.8),MarkerColor(kOrange+1),MarkerStyle(24));
DoubleCBraw3->plotOn(plot,LineColor(kOrange+1),LineStyle(2),LineWidth(2),Name("hraw3"));
RooDataHist *Hcor3=new RooDataHist("","",*var,hecor3);
RooDoubleCBFast *DoubleCBcor3=FitWithDCB(Hcor3,bias,PeakCor3,PeakCorErr3);
Hcor3->plotOn(plot,MarkerSize(0.6),MarkerColor(kOrange+1));
DoubleCBcor3->plotOn(plot,LineColor(kOrange+1),LineWidth(2),Name("hcor3"));
//Compute Effective Sigma of the distributions
/*double SigEffRaw1=effSigma(heraw1);
double SigEffCor1=effSigma(hecor1);
double SigEffRaw2=effSigma(heraw2);
double SigEffCor2=effSigma(hecor2);
double SigEffRaw3=effSigma(heraw3);
double SigEffCor3=effSigma(hecor3);
double SigEffErr=0.001;*/
//Legend and StatBox
TLegend *leg = new TLegend(0.11,0.39,0.4,0.89);
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->AddEntry(plot->findObject("hraw1"),"Eraw/Etrue, no PU","l");
leg->AddEntry(plot->findObject("hcor1"),"Ecor/Etrue, no PU","l");
leg->AddEntry(plot->findObject("hraw2"),"Eraw/Etrue, bx 50","l");
leg->AddEntry(plot->findObject("hcor2"),"Ecor/Etrue, bx 50","l");
leg->AddEntry(plot->findObject("hraw3"),"Eraw/Etrue, bx 25","l");
leg->AddEntry(plot->findObject("hcor3"),"Ecor/Etrue, bx 25","l");
//leg->SetTextFont(62);
//leg->SetTextSize(0.06);
plot->addObject(leg);
/*TPaveText *stats = new TPaveText(0.58,0.39,0.89,0.89,"NDC");
stats->SetBorderSize(0);
stats->SetFillColor(0);
stats->AddText(Form("Peak Raw = %.4f +/- %.0e",PeakRaw,PeakRawErr));
stats->AddText(Form("Peak Cor = %.4f +/- %.0e",PeakCor,PeakCorErr));
stats->AddText(Form("Sigma Eff Raw = %.3f +/- %.3f",SigEffRaw,SigEffErr));
stats->AddText(Form("Sigma Eff Cor = %.3f +/- %.3f",SigEffCor,SigEffErr));
stats->SetTextSize(0.035);
plot->addObject(stats);*/
//Plot
TCanvas *cresponse=new TCanvas;
plot->Draw();
cresponse->SaveAs(Form("plotsAll/%s/Performance.pdf",dir.c_str()));
cresponse->SaveAs(Form("plotsAll/%s/Performance.png",dir.c_str()));
//Plot ecor/eraw
/* TH1 *hecor_raw = (TH1*)fResults->Get("hCor_raw");
TCanvas *canCor=new TCanvas;
hecor_raw->Draw("HIST");
hecor_raw->SetLineWidth(2);
hecor_raw->GetXaxis()->SetTitle("Ecor/Eraw");
hecor_raw->SetTitle("Ecor/Eraw");
canCor->SaveAs(Form("plotsAll/%s/Correction.png",dir.c_str()));
*/
//Plot |ecor-etrue|/eraw and |eraw-etrue|/eraw
TH1 *hres1 = (TH1*)fResults1->Get("hRes");
TH1 *hres2 = (TH1*)fResults2->Get("hRes");
TH1 *hres3 = (TH1*)fResults3->Get("hRes");
hres1->Scale(1./hres1->Integral());
hres2->Scale(1./hres2->Integral());
hres3->Scale(1./hres3->Integral());
TCanvas *canR=new TCanvas;
canR->SetLogy();
hres1->Draw("HIST,SAME");
hres1->SetLineWidth(2);
hres1->SetLineColor(kBlue+2);
hres1->GetXaxis()->SetRangeUser(0,0.05);
hres2->Draw("HIST,SAME");
hres2->SetLineWidth(2);
hres2->SetLineColor(kRed+1);
hres2->GetXaxis()->SetRangeUser(0,0.05);
hres3->Draw("HIST,SAME");
hres3->SetLineWidth(2);
hres3->SetLineColor(kOrange+1);
hres3->GetXaxis()->SetRangeUser(0,0.05);
hres1->GetXaxis()->SetTitle("#sigma(E)/E");
hres1->SetTitle("");
hres1->GetYaxis()->SetTitle("");
hres1->SetStats(0);
TLegend *leg2 = new TLegend(0.59,0.11,0.89,0.41);
leg2->SetBorderSize(0);
leg2->SetFillColor(0);
leg2->AddEntry(hres1,"#sigma(E)/E, no PU","l");
leg2->AddEntry(hres2,"#sigma(E)/E, bx 50","l");
leg2->AddEntry(hres3,"#sigma(E)/E, bx 25","l");
leg2->Draw();
canR->SaveAs(Form("plotsAll/%s/Resolution.pdf",dir.c_str()));
canR->SaveAs(Form("plotsAll/%s/Resolution.png",dir.c_str()));
// Plot Correction vs input variables
/*
TCanvas *canCoreta=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorEta=(TProfile*)fResults->Get("profEta");
TProfile *profRawEta=(TProfile*)fResults->Get("profEta0");
profRawEta->Draw();
profCorEta->Draw("same");
profRawEta->GetXaxis()->SetTitle("Eta");
profRawEta->GetYaxis()->SetTitle("E/Eraw");
profRawEta->SetTitle("Profile of E/Eraw vs Eta");
profCorEta->SetMarkerStyle(8);
profCorEta->SetLineColor(kRed);
profCorEta->SetMarkerColor(kRed);
profRawEta->SetMarkerStyle(4);
profRawEta->SetLineColor(kBlue);
profRawEta->SetMarkerColor(kBlue);
TLegend *leg2 = new TLegend(0.68,0.12,0.88,0.27);
leg2->SetBorderSize(0);
leg2->SetFillColor(0);
leg2->AddEntry(profRawEta,"Eraw/Etrue","lp");
leg2->AddEntry(profCorEta,"Ecor/Etrue","lp");
leg2->SetTextFont(62);
//leg2->SetTextSize(0.06);
leg2->Draw();
canCoreta->SaveAs(Form("plotsAll/%s/CorEta.png",dir.c_str()));
TCanvas *canCorPhi=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorPhi=(TProfile*)fResults->Get("profPhi");
TProfile *profRawPhi=(TProfile*)fResults->Get("profPhi0");
profRawPhi->Draw();
profCorPhi->Draw("same");
profRawPhi->GetXaxis()->SetTitle("Phi");
profRawPhi->GetYaxis()->SetTitle("E/Eraw");
profRawPhi->SetTitle("Profile of E/Eraw vs Phi");
profCorPhi->SetMarkerStyle(8);
profCorPhi->SetLineColor(kRed);
profCorPhi->SetMarkerColor(kRed);
profRawPhi->SetMarkerStyle(4);
profRawPhi->SetLineColor(kBlue);
profRawPhi->SetMarkerColor(kBlue);
leg2->Draw();
canCorPhi->SaveAs(Form("plotsAll/%s/CorPhi.png",dir.c_str()));
TCanvas *canCorEtaWidth=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorEtaWidth=(TProfile*)fResults->Get("profEtaWidth");
TProfile *profRawEtaWidth=(TProfile*)fResults->Get("profEtaWidth0");
profRawEtaWidth->Draw();
profCorEtaWidth->Draw("same");
profRawEtaWidth->GetXaxis()->SetTitle("EtaWidth");
profRawEtaWidth->GetYaxis()->SetTitle("E/Eraw");
profRawEtaWidth->SetTitle("Profile of E/Eraw vs EtaWidth");
profCorEtaWidth->SetMarkerStyle(8);
profCorEtaWidth->SetLineColor(kRed);
profCorEtaWidth->SetMarkerColor(kRed);
profRawEtaWidth->SetMarkerStyle(4);
profRawEtaWidth->SetLineColor(kBlue);
profRawEtaWidth->SetMarkerColor(kBlue);
leg2->Draw();
canCorEtaWidth->SaveAs(Form("plotsAll/%s/CorEtaWidth.png",dir.c_str()));
TCanvas *canCorPhiWidth=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorPhiWidth=(TProfile*)fResults->Get("profPhiWidth");
TProfile *profRawPhiWidth=(TProfile*)fResults->Get("profPhiWidth0");
profRawPhiWidth->Draw();
profCorPhiWidth->Draw("same");
profRawPhiWidth->GetXaxis()->SetTitle("PhiWidth");
profRawPhiWidth->GetYaxis()->SetTitle("E/Eraw");
profRawPhiWidth->SetTitle("Profile of E/Eraw vs PhiWidth");
profCorPhiWidth->SetMarkerStyle(8);
profCorPhiWidth->SetLineColor(kRed);
profCorPhiWidth->SetMarkerColor(kRed);
profRawPhiWidth->SetMarkerStyle(4);
profRawPhiWidth->SetLineColor(kBlue);
profRawPhiWidth->SetMarkerColor(kBlue);
leg2->Draw();
canCorPhiWidth->SaveAs(Form("plotsAll/%s/CorPhiWidth.png",dir.c_str()));
TCanvas *canCorR9=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorR9=(TProfile*)fResults->Get("profR9");
TProfile *profRawR9=(TProfile*)fResults->Get("profR90");
profRawR9->Draw();
profCorR9->Draw("same");
profRawR9->GetXaxis()->SetTitle("R9");
profRawR9->GetYaxis()->SetTitle("E/Eraw");
profRawR9->SetTitle("Profile of E/Eraw vs R9");
profCorR9->SetMarkerStyle(8);
profCorR9->SetLineColor(kRed);
profCorR9->SetMarkerColor(kRed);
profRawR9->SetMarkerStyle(4);
profRawR9->SetLineColor(kBlue);
profRawR9->SetMarkerColor(kBlue);
leg2->Draw();
canCorR9->SaveAs(Form("plotsAll/%s/CorR9.png",dir.c_str()));
TCanvas *canCorNvtx=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorNvtx=(TProfile*)fResults->Get("profNvtx");
TProfile *profRawNvtx=(TProfile*)fResults->Get("profNvtx0");
profRawNvtx->Draw();
profCorNvtx->Draw("same");
profRawNvtx->GetXaxis()->SetTitle("Nvtx");
profRawNvtx->GetYaxis()->SetTitle("E/Eraw");
profRawNvtx->SetTitle("Profile of E/Eraw vs Nvtx");
profCorNvtx->SetMarkerStyle(8);
profCorNvtx->SetLineColor(kRed);
profCorNvtx->SetMarkerColor(kRed);
profRawNvtx->SetMarkerStyle(4);
profRawNvtx->SetLineColor(kBlue);
profRawNvtx->SetMarkerColor(kBlue);
leg2->Draw();
canCorNvtx->SaveAs(Form("plotsAll/%s/CorNvtx.png",dir.c_str()));
TCanvas *canCorPt=new TCanvas;
gStyle->SetOptStat(0);
TProfile *profCorPt=(TProfile*)fResults->Get("profPt");
TProfile *profRawPt=(TProfile*)fResults->Get("profPt0");
profRawPt->Draw();
profCorPt->Draw("same");
profRawPt->GetXaxis()->SetTitle("Pt");
profRawPt->GetYaxis()->SetTitle("E/Eraw");
profRawPt->SetTitle("Profile of E/Eraw vs Pt");
profCorPt->SetMarkerStyle(8);
profCorPt->SetLineColor(kRed);
profCorPt->SetMarkerColor(kRed);
profRawPt->SetMarkerStyle(4);
profRawPt->SetLineColor(kBlue);
profRawPt->SetMarkerColor(kBlue);
leg2->Draw();
canCorPt->SaveAs(Form("plotsAll/%s/CorPt.png",dir.c_str()));
*/
//Plot Bias and Resolution vs Pt
/* TCanvas *canResPt=new TCanvas;
TProfile *profResPt=(TProfile*)fResults->Get("profPtRes");
profResPt->Draw();
profResPt->GetXaxis()->SetTitle("Pt");
profResPt->GetYaxis()->SetTitle("|Ecor-Etrue|/Eraw");
profResPt->SetTitle("Profile of SigmaE/E vs Pt");
profResPt->SetMarkerStyle(3);
profResPt->SetLineColor(kRed);
canResPt->SaveAs(Form("plotsAll/%s/ResPt.png",dir.c_str()));
*/
//Plot Bias and resolution in bins of Pt and eta
double errpt[9];
double pt[9];
double sigeff11[9];
double errsigeff11[9];
double sigeff12[9];
double errsigeff12[9];
double sigeff13[9];
double errsigeff13[9];
double sigeff14[9];
double errsigeff14[9];
double mean11[9];
double errmean11[9];
double mean12[9];
double errmean12[9];
double mean13[9];
double errmean13[9];
double mean14[9];
double errmean14[9];
double sigeff21[9];
double errsigeff21[9];
double sigeff22[9];
double errsigeff22[9];
double sigeff23[9];
double errsigeff23[9];
double sigeff24[9];
double errsigeff24[9];
double mean21[9];
double errmean21[9];
double mean22[9];
double errmean22[9];
double mean23[9];
double errmean23[9];
double mean24[9];
double errmean24[9];
double sigeff31[9];
double errsigeff31[9];
double sigeff32[9];
double errsigeff32[9];
double sigeff33[9];
double errsigeff33[9];
double sigeff34[9];
double errsigeff34[9];
double mean31[9];
double errmean31[9];
double mean32[9];
double errmean32[9];
double mean33[9];
double errmean33[9];
double mean34[9];
double errmean34[9];
/* TCanvas *can10 = new TCanvas("can7","can7",1200,700);
can10->Divide(5,4);
TCanvas *can11 = new TCanvas("can8","can8",1200,700);
can11->Divide(5,4);
TCanvas *can12 = new TCanvas("can9","can9",1200,700);
can12->Divide(5,4);
TCanvas *can13 = new TCanvas("can10","can10",1200,700);
can13->Divide(5,4);
*/
for (int i=1;i<10;i++){
pt[i-1]=(i+1)*20.;
errpt[i-1]=20;
TH1 *HistPt11=(TH1*)fResults1->Get(Form("hBias_Pt%i_eta1",(i+1)*20));
//RooDataHist *HistPtclone11=new RooDataHist("","",*var,HistPt11);
//RooDoubleCBFast *CB11=FitWithDCB(HistPtclone11,bias,mean11[i-1],errmean11[i-1]);
sigeff11[i-1]=effSigma(HistPt11);
errsigeff11[i-1]=0.4/199;
TH1 *HistPt12=(TH1*)fResults1->Get(Form("hBias_Pt%i_eta2",(i+1)*20));
//RooDataHist *HistPtclone12=new RooDataHist("","",*var,HistPt12);
//RooDoubleCBFast *CB12=FitWithDCB(HistPtclone12,bias,mean12[i-1],errmean12[i-1]);
sigeff12[i-1]=effSigma(HistPt12);
errsigeff12[i-1]=0.4/99;
TH1 *HistPt13=(TH1*)fResults1->Get(Form("hBias_Pt%i_eta3",(i+1)*20));
//RooDataHist *HistPtclone13=new RooDataHist("","",*var,HistPt13);
//RooDoubleCBFast *CB13=FitWithDCB(HistPtclone13,bias,mean13[i-1],errmean13[i-1]);
sigeff13[i-1]=effSigma(HistPt13);
errsigeff13[i-1]=0.4/99;
TH1 *HistPt14=(TH1*)fResults1->Get(Form("hBias_Pt%i_eta4",(i+1)*20));
//RooDataHist *HistPtclone14=new RooDataHist("","",*var,HistPt14);
//RooDoubleCBFast *CB14=FitWithDCB(HistPtclone14,bias,mean14[i-1],errmean14[i-1]);
sigeff14[i-1]=effSigma(HistPt14);
errsigeff14[i-1]=0.4/99;
TH1 *HistPt21=(TH1*)fResults2->Get(Form("hBias_Pt%i_eta1",(i+1)*20));
//RooDataHist *HistPtclone21=new RooDataHist("","",*var,HistPt21);
//RooDoubleCBFast *CB21=FitWithDCB(HistPtclone21,bias,mean21[i-1],errmean21[i-1]);
sigeff21[i-1]=effSigma(HistPt21);
errsigeff21[i-1]=0.4/199;
TH1 *HistPt22=(TH1*)fResults2->Get(Form("hBias_Pt%i_eta2",(i+1)*20));
//RooDataHist *HistPtclone22=new RooDataHist("","",*var,HistPt22);
//RooDoubleCBFast *CB22=FitWithDCB(HistPtclone22,bias,mean22[i-1],errmean22[i-1]);
sigeff22[i-1]=effSigma(HistPt22);
errsigeff22[i-1]=0.4/99;
TH1 *HistPt23=(TH1*)fResults2->Get(Form("hBias_Pt%i_eta3",(i+1)*20));
//RooDataHist *HistPtclone23=new RooDataHist("","",*var,HistPt23);
//RooDoubleCBFast *CB23=FitWithDCB(HistPtclone23,bias,mean23[i-1],errmean23[i-1]);
sigeff23[i-1]=effSigma(HistPt23);
errsigeff23[i-1]=0.4/99;
TH1 *HistPt24=(TH1*)fResults2->Get(Form("hBias_Pt%i_eta4",(i+1)*20));
//RooDataHist *HistPtclone24=new RooDataHist("","",*var,HistPt24);
//RooDoubleCBFast *CB24=FitWithDCB(HistPtclone24,bias,mean24[i-1],errmean24[i-1]);
sigeff24[i-1]=effSigma(HistPt24);
errsigeff24[i-1]=0.4/99;
TH1 *HistPt31=(TH1*)fResults3->Get(Form("hBias_Pt%i_eta1",(i+1)*20));
//RooDataHist *HistPtclone31=new RooDataHist("","",*var,HistPt31);
//RooDoubleCBFast *CB31=FitWithDCB(HistPtclone31,bias,mean31[i-1],errmean31[i-1]);
sigeff31[i-1]=effSigma(HistPt31);
errsigeff31[i-1]=0.4/199;
TH1 *HistPt32=(TH1*)fResults3->Get(Form("hBias_Pt%i_eta2",(i+1)*20));
//RooDataHist *HistPtclone32=new RooDataHist("","",*var,HistPt32);
//RooDoubleCBFast *CB32=FitWithDCB(HistPtclone32,bias,mean32[i-1],errmean32[i-1]);
sigeff32[i-1]=effSigma(HistPt32);
errsigeff32[i-1]=0.4/99;
TH1 *HistPt33=(TH1*)fResults3->Get(Form("hBias_Pt%i_eta3",(i+1)*20));
//RooDataHist *HistPtclone33=new RooDataHist("","",*var,HistPt33);
//RooDoubleCBFast *CB33=FitWithDCB(HistPtclone33,bias,mean33[i-1],errmean33[i-1]);
sigeff33[i-1]=effSigma(HistPt33);
errsigeff33[i-1]=0.4/99;
TH1 *HistPt34=(TH1*)fResults3->Get(Form("hBias_Pt%i_eta4",(i+1)*20));
//RooDataHist *HistPtclone34=new RooDataHist("","",*var,HistPt34);
//RooDoubleCBFast *CB34=FitWithDCB(HistPtclone34,bias,mean34[i-1],errmean34[i-1]);
sigeff34[i-1]=effSigma(HistPt34);
errsigeff34[i-1]=0.4/99;
}
TCanvas *can15=new TCanvas;
can15->Divide(2,2);
can15->cd(1);
TGraphErrors *graphRes_Pt11 = new TGraphErrors(9,pt,sigeff11,errpt,errsigeff11);
graphRes_Pt11->SetMarkerStyle(8);
graphRes_Pt11->SetMarkerColor(kBlue+2);
graphRes_Pt11->SetLineColor(kBlue+2);
TGraphErrors *graphRes_Pt21 = new TGraphErrors(9,pt,sigeff21,errpt,errsigeff21);
graphRes_Pt21->SetMarkerStyle(8);
graphRes_Pt21->SetMarkerColor(kRed+1);
graphRes_Pt21->SetLineColor(kRed+1);
TGraphErrors *graphRes_Pt31 = new TGraphErrors(9,pt,sigeff31,errpt,errsigeff31);
graphRes_Pt31->SetMarkerStyle(8);
graphRes_Pt31->SetMarkerColor(kOrange+1);
graphRes_Pt31->SetLineColor(kOrange+1);
TMultiGraph *graphRes_Pt1=new TMultiGraph();
graphRes_Pt1->Add(graphRes_Pt11);
graphRes_Pt1->Add(graphRes_Pt21);
graphRes_Pt1->Add(graphRes_Pt31);
graphRes_Pt1->Draw("AP");
//graphRes_Pt1->GetXaxis()->SetTitle("pt");
//graphRes_Pt1->GetYaxis()->SetTitle("Ecor/Etrue effective width");
graphRes_Pt1->SetTitle("Ecor/Etrue effective width vs Pt for |#eta|<1;pt;Ecor/Etrue effective width");
TLegend *leg3 = new TLegend(0.69,0.69,0.89,0.89);
leg3->SetBorderSize(0);
leg3->SetFillColor(0);
leg3->AddEntry(graphRes_Pt11, "no PU","lp");
leg3->AddEntry(graphRes_Pt21, "bx 50","lp");
leg3->AddEntry(graphRes_Pt31, "bx 25","lp");
leg3->Draw();
can15->cd(2);
TGraphErrors *graphRes_Pt12 = new TGraphErrors(9,pt,sigeff12,errpt,errsigeff12);
graphRes_Pt12->SetMarkerStyle(8);
graphRes_Pt12->SetMarkerColor(kBlue+2);
graphRes_Pt12->SetLineColor(kBlue+2);
TGraphErrors *graphRes_Pt22 = new TGraphErrors(9,pt,sigeff22,errpt,errsigeff22);
graphRes_Pt22->SetMarkerStyle(8);
graphRes_Pt22->SetMarkerColor(kRed+1);
graphRes_Pt22->SetLineColor(kRed+1);
TGraphErrors *graphRes_Pt32 = new TGraphErrors(9,pt,sigeff32,errpt,errsigeff32);
graphRes_Pt32->SetMarkerStyle(8);
graphRes_Pt32->SetMarkerColor(kOrange+1);
graphRes_Pt32->SetLineColor(kOrange+1);
TMultiGraph *graphRes_Pt2=new TMultiGraph();
graphRes_Pt2->Add(graphRes_Pt12);
graphRes_Pt2->Add(graphRes_Pt22);
graphRes_Pt2->Add(graphRes_Pt32);
graphRes_Pt2->Draw("AP");
//graphRes_Pt2->GetXaxis()->SetTitle("pt");
//graphRes_Pt2->GetYaxis()->SetTitle("Ecor/Etrue effective width");
graphRes_Pt2->SetTitle("Ecor/Etrue effective width vs Pt for 1<|#eta|<1.5;pt;Ecor/Etrue effective width");
leg3->Draw();
can15->cd(3);
TGraphErrors *graphRes_Pt13 = new TGraphErrors(9,pt,sigeff13,errpt,errsigeff13);
graphRes_Pt13->SetMarkerStyle(8);
graphRes_Pt13->SetMarkerColor(kBlue+2);
graphRes_Pt13->SetLineColor(kBlue+2);
TGraphErrors *graphRes_Pt23 = new TGraphErrors(9,pt,sigeff23,errpt,errsigeff23);
graphRes_Pt23->SetMarkerStyle(8);
graphRes_Pt23->SetMarkerColor(kRed+1);
graphRes_Pt23->SetLineColor(kRed+1);
TGraphErrors *graphRes_Pt33 = new TGraphErrors(9,pt,sigeff33,errpt,errsigeff33);
graphRes_Pt33->SetMarkerStyle(8);
graphRes_Pt33->SetMarkerColor(kOrange+1);
graphRes_Pt33->SetLineColor(kOrange+1);
TMultiGraph *graphRes_Pt3=new TMultiGraph();
graphRes_Pt3->Add(graphRes_Pt13);
graphRes_Pt3->Add(graphRes_Pt23);
graphRes_Pt3->Add(graphRes_Pt33);
graphRes_Pt3->Draw("AP");
//graphRes_Pt3->GetXaxis()->SetTitle("pt");
//graphRes_Pt3->GetYaxis()->SetTitle("Ecor/Etrue effective width");
graphRes_Pt3->SetTitle("Ecor/Etrue effective width vs Pt for 1.5<|#eta|<2;pt;Ecor/Etrue effective width");
leg3->Draw();
can15->cd(4);
TGraphErrors *graphRes_Pt14 = new TGraphErrors(9,pt,sigeff14,errpt,errsigeff14);
graphRes_Pt14->SetMarkerStyle(8);
graphRes_Pt14->SetMarkerColor(kBlue+2);
graphRes_Pt14->SetLineColor(kBlue+2);
TGraphErrors *graphRes_Pt24 = new TGraphErrors(9,pt,sigeff24,errpt,errsigeff24);
graphRes_Pt24->SetMarkerStyle(8);
graphRes_Pt24->SetMarkerColor(kRed+1);
graphRes_Pt24->SetLineColor(kRed+1);
TGraphErrors *graphRes_Pt34 = new TGraphErrors(9,pt,sigeff34,errpt,errsigeff34);
graphRes_Pt34->SetMarkerStyle(8);
graphRes_Pt34->SetMarkerColor(kOrange+1);
graphRes_Pt34->SetLineColor(kOrange+1);
TMultiGraph *graphRes_Pt4=new TMultiGraph();
graphRes_Pt4->Add(graphRes_Pt14);
graphRes_Pt4->Add(graphRes_Pt24);
graphRes_Pt4->Add(graphRes_Pt34);
graphRes_Pt4->Draw("AP");
//graphRes_Pt4->GetXaxis()->SetTitle("pt");
//graphRes_Pt4->GetYaxis()->SetTitle("Ecor/Etrue effective width");
graphRes_Pt4->SetTitle("Ecor/Etrue effective width vs Pt for 1.5<|#eta|;pt;Ecor/Etrue effective width");
leg3->Draw();
can15->SaveAs(Form("plotsAll/%s/Res_Pt_Eta.pdf",dir.c_str()));
can15->SaveAs(Form("plotsAll/%s/Res_Pt_Eta.png",dir.c_str()));
/*
TCanvas *can14=new TCanvas;
can14->Divide(2,2);
can14->cd(1);
TGraphErrors *graphCor_Pt1 = new TGraphErrors(9,pt,mean1,errpt,errmean1);
graphCor_Pt1->Draw("AL*");
graphCor_Pt1->SetMarkerStyle(8);
graphCor_Pt1->GetXaxis()->SetTitle("pt");
graphCor_Pt1->GetYaxis()->SetTitle("Ecor/Etrue mean");
graphCor_Pt1->SetTitle("Ecor/Etrue peak value vs Pt for 0<|eta|<1");
can14->cd(2);
TGraphErrors *graphCor_Pt2 = new TGraphErrors(9,pt,mean2,errpt,errmean2);
graphCor_Pt2->Draw("AL*");
graphCor_Pt2->SetMarkerStyle(8);
graphCor_Pt2->GetXaxis()->SetTitle("pt");
graphCor_Pt2->GetYaxis()->SetTitle("Ecor/Etrue mean");
graphCor_Pt2->SetTitle("Ecor/Etrue peak value vs Pt for 1<|eta|<1.48");
can14->cd(3);
TGraphErrors *graphCor_Pt3 = new TGraphErrors(9,pt,mean3,errpt,errmean3);
graphCor_Pt3->Draw("AL*");
graphCor_Pt3->SetMarkerStyle(8);
graphCor_Pt3->GetXaxis()->SetTitle("pt");
graphCor_Pt3->GetYaxis()->SetTitle("Ecor/Etrue mean");
graphCor_Pt3->SetTitle("Ecor/Etrue peak value vs Pt for 1.48<|eta|<2");
can14->cd(4);
TGraphErrors *graphCor_Pt4 = new TGraphErrors(9,pt,mean4,errpt,errmean4);
graphCor_Pt4->Draw("AL*");
graphCor_Pt4->SetMarkerStyle(8);
graphCor_Pt4->GetXaxis()->SetTitle("pt");
graphCor_Pt4->GetYaxis()->SetTitle("Ecor/Etrue mean");
graphCor_Pt4->SetTitle("Ecor/Etrue peak value vs Pt for 2<|eta|<2.5");
can14->SaveAs(Form("plotsAll/%s/Bias_Pt_Eta.png",dir.c_str()));
*/
}
void Fit_2D(TString type)
{
if(!Configure(type, cfg)) return;
tree=(TTree*) cfg.f->Get("fittree");
RooRealVar mass("mass", "mass [GeV/c^{2}]", cfg.mass_low, cfg.mass_high);
RooRealVar t("t", "lifetime [ps]", -1.0e-12, 15e-12);
RooRealVar tE("tE", "lifetime error", 0, 1e-12);
RooRealVar weight("weight","Event weight", 1, 10);
RooDataSet data("data", "data", tree, RooArgSet(mass, t, tE));
// RooDataSet data("data", "data", tree, RooArgSet(mass, t, weight), "", "weight");
/*********************************************************************************************
* Non-prompt background = 1st order polynomial (mass) x (Decay (x) double Gauss)(lifetime)
* Prompt background = 1st order polynomial (mass) x double Gauss (lifetime)
*********************************************************************************************/
if(cfg.prompt_bk){
RooRealVar reso_mean("reso_mean", "mean of resolution function", 0);
// prompt mass polynomial
RooRealVar prompt_p1("prompt_p1","Linear coefficient of prompt background mass polynomial",0.1, -0.2, 5.0);
RooPolynomial prompt_mass("prompt_mass", "Linear function for prompt background mass", mass, RooArgList(prompt_p1));
// prompt lifetime resolution
RooRealVar prompt_sigma_core("prompt_sigma_core","Gauss sigma core of prompt background", 1e-13, 5e-14, 1.2e-13);
RooRealVar prompt_sigma_tail("prompt_sigma_tail","Gauss sigma tail of prompt background", 2e-13, 1.2e-13, 9e-13);
RooGaussian prompt_core("prompt_core","Gauss core for prompt background", t, reso_mean, prompt_sigma_core);
RooGaussian prompt_tail("prompt_tail","Gauss tail for prompt background", t, reso_mean, prompt_sigma_tail);
RooRealVar core_frac("core_frac","Fraction of core in prompt background",0.8, 0.5, 0.99);
RooAddPdf prompt_lt("prompt_lt","Double Gauss for prompt background lifetime",RooArgList(prompt_core, prompt_tail), core_frac);
RooProdPdf prompt("prompt","Prompt 2D background model", RooArgSet(prompt_mass, prompt_lt));
RooGaussModel reso_core("reso_core", "First Gauss of resolution function", t, reso_mean, prompt_sigma_core);
RooGaussModel reso_tail("reso_tail", "Second Gauss of resolution function", t, reso_mean, prompt_sigma_tail);
RooAddModel tau_reso("tau_reso", "Double Gauss of resolution function", RooArgList(reso_core, reso_tail), core_frac);
} else {
RooRealVar tau_reso_sigma("tau_reso_sigma","Sigma of lifetime resolution function",0.1e-13, 1e-15,9.0e-13) ;
// tau_reso_sigma=6.26e-14;
// tau_reso_sigma.setConstant(kTRUE);
RooGaussModel tau_reso("tau_reso","Gauss of lifetime resolution function", t, RooConst(0), tau_reso_sigma) ;
}
if(cfg.nonprompt_bk){
// non-prompt mass polynomial
if(cfg.constant_prompt_fraction){
cout<<"Constant prompt-to-nonprompt fraction in mass."<<endl;
RooPolynomial nonprompt_mass("nonprompt_mass", "Linear function for nonprompt background mass", mass, RooArgList(prompt_p1));
RooPolynomial nonprompt_mass2("nonprompt_mass2", "Linear function for nonprompt background mass", mass, RooArgList(prompt_p1));
} else {
cout<<"Different mass polynomials for prompt and nonprompt backgrounds."<<endl;
RooRealVar nonprompt_p1("nonprompt_p1","Linear coefficient of nonprompt background mass polynomial", 0.1, -0.2, 0.3);
RooRealVar nonprompt_p2("nonprompt_p2","Linear coefficient of nonprompt background mass polynomial", 0.1, -0.2, 0.3);
RooPolynomial nonprompt_mass("nonprompt_mass", "Linear function for nonprompt background mass", mass, RooArgList(nonprompt_p1));
RooPolynomial nonprompt_mass2("nonprompt_mass", "Linear function for nonprompt background mass", mass, RooArgList(nonprompt_p2));
}
// non-prompt lifetime model
RooRealVar tau_bk("tau_bk","Background lifetime",1.2e-12, 5e-15, 2e-12);
RooDecay nonprompt_lt("nonprompt_lt","decay (x) double Gauss for background lifetime", t, tau_bk, tau_reso, RooDecay::SingleSided) ;
if(cfg.single_lt){
cout<<"Nonprompt background has one lifetime component."<<endl;
RooProdPdf nonprompt("nonprompt", "Non-prompt background PDF", RooArgSet(nonprompt_mass, nonprompt_lt));
} else {
cout<<"Nonprompt background has two lifetime components."<<endl;
RooRealVar tau_bk2("tau_bk2","Second background lifetime",0.6e-12, 5e-15, 2e-12);
RooDecay nonprompt_lt2("nonprompt_lt2","decay (x) double Gauss for second background lifetime", t, tau_bk2, tau_reso, RooDecay::SingleSided) ;
RooProdPdf nonprompt1("nonprompt1", "Non-prompt background PDF", RooArgSet(nonprompt_mass, nonprompt_lt));
RooProdPdf nonprompt2("nonprompt2", "Non-prompt background PDF", RooArgSet(nonprompt_mass, nonprompt_lt2));
RooRealVar lt_frac("lt_frac", "fraction of longer background lifetime", 0.2, 0.01, 0.99);
RooAddPdf nonprompt("nonprompt", "Non-prompt background PDF", RooArgList(nonprompt1, nonprompt2), RooArgList(lt_frac));
}
}
/***************************************************************************************
* Signal = Double Gauss (mass) x (Decay (x) double Gauss)(lifetime)
***************************************************************************************/
// mass peak
RooRealVar mass_peak("mass_peak","Gauss mean of signal mass peak", cfg.masspeak, cfg.masspeak-0.04, cfg.masspeak+0.04);
RooRealVar m_sigma1("m_sigma1","Gauss core sigma for signal mass",0.007,0.001,0.012);
RooRealVar m_sigma2("m_sigma2","Gauss tail sigma for signal mass",0.02, 0.010, 0.035);
RooGaussian m_gauss1("m_gauss1","Core Gauss for signal mass", mass, mass_peak, m_sigma1);
RooGaussian m_gauss2("m_gauss2","Tail Gauss for signal mass", mass, mass_peak, m_sigma2);
RooRealVar frac_m_gauss("frac_m_gauss","Fraction of tail Gauss for signal mass",0.2, 0.1, 0.99);
if (cfg.single_sig)
RooGaussian mgauss("mgauss","Single gauss for signal mass", mass, mass_peak, m_sigma1);
else
RooAddPdf mgauss("mgauss","Double gauss for signal mass",RooArgList(m_gauss1, m_gauss2),RooArgList(frac_m_gauss));
// signal lifetime
RooRealVar tau("tau","Lambda_b lifetime",1.5e-12, 0.1e-12, 2e-12);
RooDecay tau_decay_model("tau_decay_model","decay (x) double Gauss for signal lifetime", t, tau, tau_reso, RooDecay::SingleSided) ;
RooProdPdf signal("signal", "Signal PDF", RooArgSet(mgauss, tau_decay_model));
/*********************************************************************************************
* Function for efficiency
*********************************************************************************************/
double effSlope(0);
if (cfg.type==B0) effSlope = -7.019e9;
if (cfg.type==Lambda_b) effSlope = +1.316e9;
effSlope*=.5;
RooFormulaVar eff("eff",("1.0 + TMath::Abs(t)*"+toString(effSlope)).c_str(),t) ;
//RooRealVar eff0("eff0","eff0",1);
//RooRealVar eff1("eff1","eff1",cfg.type==B0?-7.019e9:+1.316e9);
//RooPolynomial eff("eff","eff",t,RooArgSet(eff0, eff1));
//RooEffProd modelEff("modelEff","model with efficiency", full_model, eff) ;
/*********************************************************************************************
* Complete 2D model
*********************************************************************************************/
RooRealVar n_prompt("n_prompt","Number of prompt background events",1000, 0, 50000);
RooRealVar n_nonprompt("n_nonprompt","Number of non-prompt background events",300, 0, 20000);
RooRealVar n_signal("n_signal","Number of signal events",4000, 10, 20000);
if(cfg.no_bkgd && !cfg.eff) RooAddPdf full_model("full_model", "Full 2D model", RooArgList(signal), RooArgList(n_signal));
else if(cfg.no_bkgd && cfg.eff)
{
RooAddPdf intermed_model("intermed_model", "Full 2D model", RooArgList(signal), RooArgList(n_signal));
RooEffProd full_model("full_model", "Full 2D model", intermed_model, eff);
}
else if(!cfg.nonprompt_bk) RooAddPdf full_model("full_model", "Full 2D model", RooArgList(signal, prompt), RooArgList(n_signal, n_prompt));
else if(!cfg.prompt_bk) RooAddPdf full_model("full_model", "Full 2D model", RooArgList(signal, nonprompt), RooArgList(n_signal, n_nonprompt));
else if(cfg.eff)
{
RooAddPdf intermed_model("intermed_model", "Full 2D model", RooArgList(signal, prompt, nonprompt), RooArgList(n_signal, n_prompt, n_nonprompt));
RooEffProd full_model("full_model", "Full 2D model", intermed_model, eff);
}
else RooAddPdf full_model("full_model", "Full 2D model", RooArgList(signal, prompt, nonprompt), RooArgList(n_signal, n_prompt, n_nonprompt));
/*********************************************************************************************
* Do the fitting
*********************************************************************************************/
t.setRange("all", -1.0e-12, 15e-12);
full_model.fitTo(data, Save(kTRUE), NumCPU(6));
RooAbsReal *cdf=mgauss.createCdf(mass);
two_sigma_upper=cdf->findRoot(mass, cfg.mass_low, cfg.mass_high, 0.97725);
two_sigma_lower=cdf->findRoot(mass, cfg.mass_low, cfg.mass_high, 0.02275);
three_sigma_upper=cdf->findRoot(mass, cfg.mass_low, cfg.mass_high, 0.99865);
three_sigma_lower=cdf->findRoot(mass, cfg.mass_low, cfg.mass_high, 1.0-0.99865);
/*********************************************************************************************
* Plot results
*********************************************************************************************/
TH2* hd = data.createHistogram("hd",t,Binning(60),YVar(mass,Binning(20)));
TH2* hf = full_model.createHistogram("hf",t,Binning(60),YVar(mass,Binning(20))) ;
c1=new TCanvas(name_c1, cfg.title1);
c1->Divide(2) ;
c1->cd(1);
gPad->SetLogz();
hd->Draw("surf") ;
c1->cd(2);
gPad->SetLogz();
hf->Draw("surf") ;
c2=new TCanvas(name_c2, cfg.title2, 1100, 550);
c2->Divide(2) ;
c2->cd(1);
RooPlot* framex = mass.frame(Title("Mass projection")) ;
data.plotOn(framex) ;
full_model.plotOn(framex, Range("all"), LineColor(kBlue));
full_model.plotOn(framex, Components(signal), LineColor(kRed));
if(cfg.prompt_bk) full_model.plotOn(framex, Components(prompt), LineStyle(kDashed), LineColor(kBlack));
if(cfg.nonprompt_bk) full_model.plotOn(framex, Components(nonprompt), LineStyle(kDotted), LineColor(kBlack));
framex->addObject(writeTLatex("mass: " +
roundToString(mass_peak.getVal(), 3) + " #pm " +
roundToString(mass_peak.getError()+0.0004, 3) + " GeV/c^{2}", 0.32, 0.87, 0.05));
framex->Draw();
c2->cd(2);
gPad->SetLogy();
RooPlot* framey = t.frame(Title("Lifetime projection")) ;
data.plotOn(framey) ;
full_model.plotOn(framey, Range("all"), LineColor(kBlue)) ;
full_model.plotOn(framey, Components(signal), LineColor(kRed));
if(cfg.prompt_bk) full_model.plotOn(framey, Components(prompt), LineStyle(kDashed), LineColor(kBlack));
if(cfg.nonprompt_bk) full_model.plotOn(framey, Components(nonprompt), LineStyle(kDotted), LineColor(kBlack));
framey->addObject(writeTLatex("#tau: " +
roundToString(tau.getVal()*1e12, 3) + " #pm " +
roundToString(tau.getError()*1e12, 3) + " ps", 0.5,
0.87, 0.05));
framey->Draw();
c3=new TCanvas(name_c3, cfg.title3, 1100, 550);
c3->cd();
c3->Divide(3);
c3->cd(1);
gPad->SetLogy();
mass.setRange("sbl", cfg.mass_low, three_sigma_lower);
RooPlot* framesbl = t.frame(Title("Lower sideband"), Range("sbl")) ;
data.plotOn(framesbl, CutRange("sbl")) ;
full_model.plotOn(framesbl, ProjectionRange("sbl")) ;
full_model.plotOn(framesbl, Components(signal), LineColor(kRed), ProjectionRange("sbl"));
if(cfg.prompt_bk) full_model.plotOn(framesbl, Components(prompt), LineStyle(kDashed), LineColor(kBlack), ProjectionRange("sbl"));
if(cfg.nonprompt_bk) full_model.plotOn(framesbl, Components(nonprompt), LineStyle(kDotted), LineColor(kBlack), ProjectionRange("sbl"));
framesbl->Draw();
c3->cd(2);
gPad->SetLogy();
mass.setRange("sig", two_sigma_lower, two_sigma_upper);
RooPlot* framesig = t.frame(Title("Signal region"),Range("sig")) ;
data.plotOn(framesig, CutRange("sig")) ;
full_model.plotOn(framesig, ProjectionRange("sig")) ;
full_model.plotOn(framesig, Components(signal), LineColor(kRed), ProjectionRange("sig"));
if(cfg.prompt_bk) full_model.plotOn(framesig, Components(prompt), LineStyle(kDashed), LineColor(kBlack), ProjectionRange("sig"));
if(cfg.nonprompt_bk) full_model.plotOn(framesig, Components(nonprompt), LineStyle(kDotted), LineColor(kBlack), ProjectionRange("sig"));
framesig->Draw();
c3->cd(3);
gPad->SetLogy();
mass.setRange("sb", three_sigma_upper, cfg.mass_high);
RooPlot* framesbh = t.frame(Title("Upper sideband"),Range("sb")) ;
data.plotOn(framesbh, CutRange("sb")) ;
full_model.plotOn(framesbh, ProjectionRange("sb")) ;
full_model.plotOn(framesbh, Components(signal), LineColor(kRed), ProjectionRange("sb"));
if(cfg.prompt_bk) full_model.plotOn(framesbh, Components(prompt), LineStyle(kDashed), LineColor(kBlack), ProjectionRange("sb"));
if(cfg.nonprompt_bk) full_model.plotOn(framesbh, Components(nonprompt), LineStyle(kDotted), LineColor(kBlack), ProjectionRange("sb"));
framesbh->Draw();
//cout << "Fitresults: t: "<< tau.getVal()*1e12 << " +- "<<tau.getError()*1e12<<" ps ";
//cout << " chisq(m): " << framex->chiSquare() << " chisq(t): " << framey->chiSquare();
//cout << " mass: " << mass_peak.getVal() << " m_sigma1: " << m_sigma1.getVal() << " m_sigma2: " << m_sigma2.getVal() << " tau_bk: " << tau_bk.getVal();
//cout << " nsig: " << n_signal.getVal()<<" npr: "<<n_prompt.getVal()<<" nnpr: "<<n_nonprompt.getVal()<<endl;
cfg.f->Close();
cfg.f->Delete();
delete cfg.f;
cout << "FITRESULTS: ";
cout << tau.getVal()*1e12 << " " << tau.getError()*1e12 << " ";
cout << mass_peak.getVal() << " " << mass_peak.getError() << " ";
cout << m_sigma1.getVal() << " " << m_sigma1.getError() << " ";
cout << m_sigma2.getVal() << " " << m_sigma2.getError() << " ";
cout << frac_m_gauss.getVal() << " " << frac_m_gauss.getError() << " ";
cout << core_frac.getVal() << " " << core_frac.getError() << " ";
cout << tau_bk.getVal()*1e12 << " " << tau_bk.getError()*1e12 << " ";
cout << n_nonprompt.getVal() << " " << n_nonprompt.getError() << " ";
cout << n_prompt.getVal() << " " << n_prompt.getError() << " ";
cout << n_signal.getVal() << " " << n_signal.getError() << " ";
cout << prompt_p1.getVal() << " " << prompt_p1.getError() << " ";
cout << prompt_sigma_core.getVal() << " " << prompt_sigma_core.getError() << " ";
cout << prompt_sigma_tail.getVal() << " " << prompt_sigma_tail.getError() << " ";
cout << endl;
}
void MakeSpinPlots::DrawIndFit(TString tag, TString mcName){
TCanvas *cv = new TCanvas(Form("%s_%s",mcName.Data(),tag.Data()));
if(ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) ) == 0) return;
RooRealVar* mass = ws->var("mass");
mass->setBins( (mass->getMax() - mass->getMin())/1.5 ); //enfore 1.5GeV bin width
RooPlot* frame = mass->frame();
tPair lbl(mcName,tag);
double Ns = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getVal();
double Nb = ws->var( Form("Data_%s_INDFIT_%s_Nbkg",mcName.Data(),tag.Data()) )->getVal();
double Nblind = ws->data("Data_Combined")->reduce("(mass>100 && mass<119) || (mass>135.5 && mass<170)")->sumEntries(TString("evtcat==evtcat::")+tag);
double Ntot = ws->data("Data_Combined")->sumEntries(TString("evtcat==evtcat::")+tag);
RooFitResult* fitres = (RooFitResult*)ws->obj(Form("Data_%s_INDFIT_fitResult",mcName.Data()));
std::cout << fitres << std::endl;
ws->data("Data_Combined")->reduce(TString("evtcat==evtcat::")+tag)->plotOn(frame,RooFit::LineColor(kWhite),RooFit::MarkerColor(kWhite));
//Data_Hgg125_INDFIT_EB_0
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::FillColor(kGreen),RooFit::VisualizeError(*fitres,2.0));
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::FillColor(kYellow),RooFit::VisualizeError(*fitres,1.0));
ws->pdf(Form("Data_%s_INDFIT_%s",mcName.Data(),tag.Data()))->plotOn(frame, RooFit::LineColor(kRed));
std::cout << "1" << std::endl;
ws->pdf(Form("Data_BKGFIT_%s_bkgModel",tag.Data()))->plotOn(frame, RooFit::Normalization(Nb/(Nb+Ns)),RooFit::LineColor(kRed),RooFit::LineStyle(kDashed));
std::cout << "2" << std::endl;
ws->data("Data_Combined")->reduce(TString("evtcat==evtcat::")+tag)->plotOn(frame);
frame->Draw();
//TLatex *prelim = new TLatex(250,x->GetXmax()-40.,"CMS Preliminary");
TLatex *prelim = new TLatex(0.12,0.96,"CMS Preliminary");
TLatex *lum = new TLatex(0.7,0.96,Form("#sqrt{s}=8 TeV L = %0.1f fb^{-1}",lumi));
prelim->SetNDC();
lum->SetNDC();
prelim->SetTextSize(0.045);
prelim->SetTextColor(kBlack);
lum->SetTextSize(0.045);
lum->SetTextColor(kBlack);
TLatex *owner = new TLatex(0.6,0.88,"Alex Mott (Nov. 13, 2012)");
owner->SetNDC();
owner->SetTextSize(0.045);
owner->SetTextColor(kBlack);
TLatex *mu = new TLatex(0.7,0.8,Form("#mu = %0.1f #pm %0.2f", fitMean[lbl].first,fitMean[lbl].second));
mu->SetNDC();
mu->SetTextSize(0.045);
TLatex *sig = new TLatex(0.7,0.72,Form("#sigma_{eff} = %0.1f #pm %0.2f", fitSigEff[lbl].first,fitSigEff[lbl].second));
sig->SetNDC();
sig->SetTextSize(0.045);
float nSig = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getVal();
float nSigErr = ws->var( Form("Data_%s_INDFIT_%s_Nsig",mcName.Data(),tag.Data()) )->getError();
TLatex *Nsig = new TLatex(0.7,0.64,Form("N_{sig}= %0.1f #pm %0.1f",nSig,nSigErr));
Nsig->SetNDC();
Nsig->SetTextSize(0.045);
frame->addObject(prelim);
frame->addObject(lum);
//frame->addObject(owner);
frame->addObject(mu);
frame->addObject(sig);
frame->addObject(Nsig);
frame->Draw();
cv->SaveAs( basePath+Form("/mgg-FloatedFraction-%s-%s-%s.png",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/C/mgg-FloatedFraction-%s-%s-%s.C",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/mgg-FloatedFraction-%s-%s-%s.pdf",outputTag.Data(),mcName.Data(),tag.Data()) );
delete cv;
}
void MakeSpinPlots::DrawBlindFit(TString tag, TString mcName,TString cosThetaBin){
TString fitTag="FULLFIT";
TString cat = "evtcat";
if(cosThetaBin!=""){
tag+="_"+cosThetaBin;
fitTag="FULLCOSTFIT";
cat = "evtcat_cosT";
}
TString dataTag = "_Combined";
if(cosThetaBin!="") dataTag+="_CosTBin";
TCanvas *cv = new TCanvas(Form("%s_%s",mcName.Data(),tag.Data()));
RooRealVar* mass = ws->var("mass");
mass->setBins( (mass->getMax() - mass->getMin())/1.5 ); //enfore 1.5GeV bin width
RooPlot* frame = mass->frame();
double Nb = ws->var(Form("Data_BKGFIT_%s_Nbkg",tag.Data()))->getVal();
cout << Nb << endl;
RooDataSet *blind = (RooDataSet*)ws->data("Data"+dataTag)->reduce(TString("((mass<119) || (mass>135.5)) && ")+cat+"=="+cat+"::"+tag);
blind->plotOn(frame);
tPair lbl(mcName,tag);
double nBkg = ws->data("Data"+dataTag)->sumEntries(cat+"=="+cat+"::"+tag);
ws->pdf( Form("Data_BKGFIT_%s_bkgModel",tag.Data()) )->plotOn(frame,RooFit::Range("all"),RooFit::Normalization(nBkg/blind->sumEntries()),
RooFit::LineColor(kRed));
//TLatex *prelim = new TLatex(250,x->GetXmax()-40.,"CMS Preliminary");
TLatex *prelim = new TLatex(0.12,0.96,"CMS Preliminary");
TLatex *lum = new TLatex(0.7,0.96,Form("#sqrt{s}=8 TeV L = %0.1f fb^{-1}",lumi));
prelim->SetNDC();
lum->SetNDC();
prelim->SetTextSize(0.045);
prelim->SetTextColor(kBlack);
lum->SetTextSize(0.045);
lum->SetTextColor(kBlack);
TLatex *owner = new TLatex(0.6,0.88,"Caltech-CMS Preliminary");
owner->SetNDC();
owner->SetTextSize(0.045);
owner->SetTextColor(kBlack);
TLatex *Nbkg = new TLatex(0.7,0.8,Form("N_{bkg}= %0.1f #pm %0.1f",nBackground[lbl].first,nBackground[lbl].second));
Nbkg->SetNDC();
Nbkg->SetTextSize(0.045);
TLatex *sig = new TLatex(0.7,0.72,Form("#sigma_{eff} = %0.1f #pm %0.2f",fitSigEff[lbl].first,fitSigEff[lbl].second));
sig->SetNDC();
sig->SetTextSize(0.045);
TLatex *expBkg = new TLatex(0.7,0.64,Form("B @ 125 = %0.1f",fitBkg1Sigma[lbl].first));
expBkg->SetNDC();
expBkg->SetTextSize(0.045);
frame->addObject(prelim);
frame->addObject(lum);
//frame->addObject(owner);
frame->addObject(Nbkg);
frame->addObject(sig);
frame->addObject(expBkg);
frame->Draw();
cv->SaveAs( basePath+Form("/mgg-%s-%s-%s_BLIND.png",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/C/mgg-%s-%s-%s_BLIND.C",outputTag.Data(),mcName.Data(),tag.Data()) );
cv->SaveAs( basePath+Form("/mgg-%s-%s-%s_BLIND.pdf",outputTag.Data(),mcName.Data(),tag.Data()) );
delete cv;
}
RooPlot *transform(RooPlot *contour, double corx, double cory, bool mode) {
RooPlot *h;
if (mode) {
h = new RooPlot(0.,1.,0.,1.);//contour->Clone(); h->Reset();
} else {
h = new RooPlot(0.,1.,0.,1.2);
}
contour->Print();
TGraph *g1 = (TGraph*)contour->findObject("contour_nll_n1.000000");
TGraph *g2 = (TGraph*)contour->findObject("contour_nll_n2.000000");
TMarker *point= (TMarker*)contour->findObject("TMarker");
Double_t ix1[50], ix2[50];
Double_t iy1prime[50], iy2prime[50];
Double_t idiff1[50], isum1[50];
Double_t idiff2[50], isum2[50];
for (int i=0; i<50; i++) {
ix1[i]=corx*g1->GetX()[i];
ix2[i]=corx*g2->GetX()[i];
iy1prime[i]=cory*(1.-(g1->GetX()[i]))*(g1->GetY()[i]);
iy2prime[i]=cory*(1.-(g2->GetX()[i]))*(g2->GetY()[i]);
idiff1[i]=ix1[i]-iy1prime[i];
isum1[i]=ix1[i]+iy1prime[i];
idiff2[i]=ix2[i]-iy2prime[i];
isum2[i]=ix2[i]+iy2prime[i];
}
Double_t mx=corx*point->GetX();
Double_t my=cory*(1-point->GetX())*point->GetY();
TMarker *dpoint; //= new TMarker(mx, my, 8);
TGraph *c1, *c2;
if (mode) {
c1 = new TGraph(50,ix1,iy1prime);
c2 = new TGraph(50,ix2,iy2prime);
dpoint=new TMarker(mx,my,8);
h->SetTitle(";f_{L};f_{R}");
} else {
c1 = new TGraph(50,idiff1,isum1);
c2 = new TGraph(50,idiff2,isum2);
dpoint=new TMarker((mx-my),(mx+my),8);
h->SetTitle(";f_{L}-f_{R};f_{L}+f_{R}");
}
c1->SetLineStyle(1) ;
c1->SetLineWidth(2) ;
c1->SetLineColor(kBlue) ;
c2->SetLineStyle(2) ;
c2->SetLineWidth(2) ;
c2->SetLineColor(kBlue) ;
// c1->Draw("A");
h->addObject(dpoint);
h->addObject(c1,"L");
h->addObject(c2,"L");
/*
for (int ix=0; ix<=contour->GetNbinsX(); ix++) {
for (int iy=0; iy<=contour->GetNbinsY(); iy++) {
double content=contour->GetBinContent(ix,iy);
double y1=contour->GetXaxis()->GetBinCenter(ix);
double y2=contour->GetYaxis()->GetBinCenter(iy);
double yprime=(1-y1)*y2;
int iyprime=contour->GetYaxis()->FindBin(yprime);
h->SetBinContent(ix,iyprime);
}
}
*/
// h->Draw();
return h;
}
void forData(string channel, string catcut, bool removeMinor=true){
// Suppress all the INFO message
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING);
// Input files and sum all backgrounds
TChain* treeData = new TChain("tree");
TChain* treeZjets = new TChain("tree");
if( channel == "ele" ){
treeData->Add(Form("%s/data/SingleElectron-Run2015D-05Oct2015-v1_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/data/SingleElectron-Run2015D-PromptReco-V4_toyMCnew.root", channel.data()));
}
else if( channel == "mu" ){
treeData->Add(Form("%s/data/SingleMuon-Run2015D-05Oct2015-v1_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/data/SingleMuon-Run2015D-PromptReco-V4_toyMCnew.root", channel.data()));
}
else return;
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-100to200_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-200to400_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-400to600_13TeV_toyMCnew.root", channel.data()));
treeZjets->Add(Form("%s/Zjets/DYJetsToLL_M-50_HT-600toInf_13TeV_toyMCnew.root", channel.data()));
// To remove minor background contribution in data set (weight is -1)
if( removeMinor ){
treeData->Add(Form("%s/VV/WW_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/VV/WZ_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/VV/ZZ_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
treeData->Add(Form("%s/TT/TT_TuneCUETP8M1_13TeV_toyMCnew.root", channel.data()));
}
// Define all the variables from the trees
RooRealVar cat ("cat", "", 0, 2);
RooRealVar mJet("prmass", "M_{jet}", 30., 300., "GeV");
RooRealVar mZH ("mllbb", "M_{ZH}", 900., 3000., "GeV");
RooRealVar evWeight("evweight", "", -1.e3, 1.e3);
// Set the range in jet mass
mJet.setRange("allRange", 30., 300.);
mJet.setRange("lowSB", 30., 65.);
mJet.setRange("highSB", 135., 300.);
mJet.setRange("signal", 105., 135.);
RooBinning binsmJet(54, 30, 300);
RooArgSet variables(cat, mJet, mZH, evWeight);
TCut catCut = Form("cat==%s", catcut.c_str());
TCut sbCut = "prmass>30 && !(prmass>65 && prmass<135) && prmass<300";
TCut sigCut = "prmass>105 && prmass<135";
// Create a dataset from a tree -> to process an unbinned likelihood fitting
RooDataSet dataSetData ("dataSetData", "dataSetData", variables, Cut(catCut), WeightVar(evWeight), Import(*treeData));
RooDataSet dataSetDataSB ("dataSetDataSB", "dataSetDataSB", variables, Cut(catCut && sbCut), WeightVar(evWeight), Import(*treeData));
RooDataSet dataSetZjets ("dataSetZjets", "dataSetZjets", variables, Cut(catCut), WeightVar(evWeight), Import(*treeZjets));
RooDataSet dataSetZjetsSB("dataSetZjetsSB", "dataSetZjetsSB", variables, Cut(catCut && sbCut), WeightVar(evWeight), Import(*treeZjets));
RooDataSet dataSetZjetsSG("dataSetZjetsSG", "dataSetZjetsSG", variables, Cut(catCut && sigCut), WeightVar(evWeight), Import(*treeZjets));
// Total events number
float totalMcEv = dataSetZjetsSB.sumEntries() + dataSetZjetsSG.sumEntries();
float totalDataEv = dataSetData.sumEntries();
RooRealVar nMcEvents("nMcEvents", "nMcEvents", 0., 99999.);
RooRealVar nDataEvents("nDataEvents", "nDataEvents", 0., 99999.);
nMcEvents.setVal(totalMcEv);
nMcEvents.setConstant(true);
nDataEvents.setVal(totalDataEv);
nDataEvents.setConstant(true);
// Signal region jet mass
RooRealVar constant("constant", "constant", -0.02, -1., 0.);
RooRealVar offset ("offset", "offset", 30., -50., 200.);
RooRealVar width ("width", "width", 100., 0., 200.);
if( catcut == "1" ) offset.setConstant(true);
RooErfExpPdf model_mJet("model_mJet", "model_mJet", mJet, constant, offset, width);
RooExtendPdf ext_model_mJet("ext_model_mJet", "ext_model_mJet", model_mJet, nMcEvents);
RooFitResult* mJet_result = ext_model_mJet.fitTo(dataSetZjets, SumW2Error(true), Extended(true), Range("allRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
// Side band jet mass
RooRealVar constantSB("constantSB", "constantSB", constant.getVal(), -1., 0.);
RooRealVar offsetSB ("offsetSB", "offsetSB", offset.getVal(), -50., 200.);
RooRealVar widthSB ("widthSB", "widthSB", width.getVal(), 0., 200.);
offsetSB.setConstant(true);
RooErfExpPdf model_mJetSB("model_mJetSB", "model_mJetSB", mJet, constantSB, offsetSB, widthSB);
RooExtendPdf ext_model_mJetSB("ext_model_mJetSB", "ext_model_mJetSB", model_mJetSB, nMcEvents);
RooFitResult* mJetSB_result = ext_model_mJetSB.fitTo(dataSetZjetsSB, SumW2Error(true), Extended(true), Range("lowSB,highSB"), Strategy(2), Minimizer("Minuit2"), Save(1));
RooAbsReal* nSIGFit = ext_model_mJetSB.createIntegral(RooArgSet(mJet), NormSet(mJet), Range("signal"));
float normFactor = nSIGFit->getVal() * totalMcEv;
// Plot the results on a frame
RooPlot* mJetFrame = mJet.frame();
dataSetZjetsSB. plotOn(mJetFrame, Binning(binsmJet));
ext_model_mJetSB.plotOn(mJetFrame, Range("allRange"), VisualizeError(*mJetSB_result), FillColor(kYellow));
dataSetZjetsSB. plotOn(mJetFrame, Binning(binsmJet));
ext_model_mJetSB.plotOn(mJetFrame, Range("allRange"));
mJetFrame->SetTitle("M_{jet} distribution in Z+jets MC");
// Alpha ratio part
mZH.setRange("fullRange", 900., 3000.);
RooBinning binsmZH(21, 900, 3000);
RooRealVar a("a", "a", 0., -1., 1.);
RooRealVar b("b", "b", 1000, 0., 4000.);
RooGenericPdf model_ZHSB("model_ZHSB", "model_ZHSB", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooGenericPdf model_ZHSG("model_ZHSG", "model_ZHSG", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooGenericPdf model_ZH ("model_ZH", "model_ZH", "TMath::Exp(@1*@0+@2/@0)", RooArgSet(mZH,a,b));
RooExtendPdf ext_model_ZHSB("ext_model_ZHSB", "ext_model_ZHSB", model_ZHSB, nMcEvents);
RooExtendPdf ext_model_ZHSG("ext_model_ZHSG", "ext_model_ZHSG", model_ZHSG, nMcEvents);
RooExtendPdf ext_model_ZH ("ext_model_ZH", "ext_model_ZH", model_ZH, nDataEvents);
// Fit ZH mass in side band
RooFitResult* mZHSB_result = ext_model_ZHSB.fitTo(dataSetZjetsSB, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
float p0 = a.getVal();
float p1 = b.getVal();
// Fit ZH mass in signal region
RooFitResult* mZHSG_result = ext_model_ZHSG.fitTo(dataSetZjetsSG, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
float p2 = a.getVal();
float p3 = b.getVal();
// Fit ZH mass in side band region (data)
RooFitResult* mZH_result = ext_model_ZH.fitTo(dataSetDataSB, SumW2Error(true), Extended(true), Range("fullRange"), Strategy(2), Minimizer("Minuit2"), Save(1));
// Draw the model of alpha ratio
// Multiply the model of background in data side band with the model of alpha ratio to the a model of background in data signal region
RooGenericPdf model_alpha("model_alpha", "model_alpha", Form("TMath::Exp(%f*@0+%f/@0)/TMath::Exp(%f*@0+%f/@0)", p2,p3,p0,p1), RooArgSet(mZH));
RooProdPdf model_sigData("model_sigData", "ext_model_ZH*model_alpha", RooArgList(ext_model_ZH,model_alpha));
// Plot the results to a frame
RooPlot* mZHFrameMC = mZH.frame();
dataSetZjetsSB.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSB.plotOn(mZHFrameMC, VisualizeError(*mZHSB_result), FillColor(kYellow));
dataSetZjetsSB.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSB.plotOn(mZHFrameMC, LineStyle(7), LineColor(kBlue));
dataSetZjetsSG.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSG.plotOn(mZHFrameMC, VisualizeError(*mZHSG_result), FillColor(kYellow));
dataSetZjetsSG.plotOn(mZHFrameMC, Binning(binsmZH));
ext_model_ZHSG.plotOn(mZHFrameMC, LineStyle(7), LineColor(kRed));
TLegend* leg = new TLegend(0.65,0.77,0.85,0.85);
leg->AddEntry(mZHFrameMC->findObject(mZHFrameMC->nameOf(3)), "side band", "l");
leg->AddEntry(mZHFrameMC->findObject(mZHFrameMC->nameOf(7)), "signal region", "l");
leg->Draw();
mZHFrameMC->addObject(leg);
mZHFrameMC->SetTitle("M_{ZH} distribution in MC");
RooPlot* mZHFrame = mZH.frame();
dataSetDataSB.plotOn(mZHFrame, Binning(binsmZH));
ext_model_ZH .plotOn(mZHFrame, VisualizeError(*mZH_result), FillColor(kYellow));
dataSetDataSB.plotOn(mZHFrame, Binning(binsmZH));
ext_model_ZH .plotOn(mZHFrame, LineStyle(7), LineColor(kBlue));
model_sigData.plotOn(mZHFrame, Normalization(normFactor, RooAbsReal::NumEvent), LineStyle(7), LineColor(kRed));
TLegend* leg1 = new TLegend(0.65,0.77,0.85,0.85);
leg1->AddEntry(mZHFrame->findObject(mZHFrame->nameOf(3)), "side band", "l");
leg1->AddEntry(mZHFrame->findObject(mZHFrame->nameOf(4)), "signal region", "l");
leg1->Draw();
mZHFrame->addObject(leg1);
mZHFrame->SetTitle("M_{ZH} distribution in Data");
TCanvas* c = new TCanvas("c","",0,0,1000,800);
c->cd();
mZHFrameMC->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf(", channel.data(), catcut.data()));
c->cd();
mZHFrame->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf", channel.data(), catcut.data()));
c->cd();
mJetFrame->Draw();
c->Print(Form("rooFit_forData_%s_cat%s.pdf)", channel.data(), catcut.data()));
}
void rf106_plotdecoration()
{
// S e t u p m o d e l
// ---------------------
// Create observables
RooRealVar x("x","x",-10,10) ;
// Create Gaussian
RooRealVar sigma("sigma","sigma",1,0.1,10) ;
RooRealVar mean("mean","mean",-3,-10,10) ;
RooGaussian gauss("gauss","gauss",x,mean,sigma) ;
// Generate a sample of 1000 events with sigma=3
RooDataSet* data = gauss.generate(x,1000) ;
// Fit pdf to data
gauss.fitTo(*data) ;
// P l o t p . d . f a n d d a t a
// -------------------------------------
// Overlay projection of gauss on data
RooPlot* frame = x.frame(Name("xframe"),Title("RooPlot with decorations"),Bins(40)) ;
data->plotOn(frame) ;
gauss.plotOn(frame) ;
// A d d b o x w i t h p d f p a r a m e t e r s
// -----------------------------------------------------
// Left edge of box starts at 55% of Xaxis)
gauss.paramOn(frame,Layout(0.55)) ;
// A d d b o x w i t h d a t a s t a t i s t i c s
// -------------------------------------------------------
// X size of box is from 55% to 99% of Xaxis range, top of box is at 80% of Yaxis range)
data->statOn(frame,Layout(0.55,0.99,0.8)) ;
// A d d t e x t a n d a r r o w
// -----------------------------------
// Add text to frame
TText* txt = new TText(2,100,"Signal") ;
txt->SetTextSize(0.04) ;
txt->SetTextColor(kRed) ;
frame->addObject(txt) ;
// Add arrow to frame
TArrow* arrow = new TArrow(2,100,-1,50,0.01,"|>") ;
arrow->SetLineColor(kRed) ;
arrow->SetFillColor(kRed) ;
arrow->SetLineWidth(3) ;
frame->addObject(arrow) ;
// P e r s i s t f r a m e w i t h a l l d e c o r a t i o n s i n R O O T f i l e
// ---------------------------------------------------------------------------------------------
TFile f("rf106_plotdecoration.root","RECREATE") ;
frame->Write() ;
f.Close() ;
// To read back and plot frame with all decorations in clean root session do
// root> TFile f("rf106_plotdecoration.root") ;
// root> xframe->Draw() ;
new TCanvas("rf106_plotdecoration","rf106_plotdecoration",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
}
