void Fitter::MakePlots(const string& name, const string& title, RooPlot*& pPlot1, RooPlot*& pPlot2, RooAbsPdf* pPdf, RooDataSet* pData)
{
bool plotbkg = false;
RooPlot* pFrame = pPlot1? pPlot1 : pFitVar->frame(RooFit::Bins(50), RooFit::Name(name.c_str()), RooFit::Title(title.c_str()));
RooPlot* pFramePull = pPlot2? pPlot2 : pFitVar->frame(RooFit::Bins(50), RooFit::Name((name+"_Pull").c_str()), RooFit::Title((title+" Pull").c_str()));
RooHist* pHisPull = NULL;
double pullMax = 0.;
if(!pPdf && !pData) plotbkg = true;
if(!pPdf) pPdf = pTotPdf;
if(!pData) pData = this->pData;
pData->plotOn(pFrame, RooFit::MarkerSize(0.9));
if(plotbkg)
{
RooArgList bkgComponent;
for(auto& pdf : bkgPdfs) bkgComponent.add(pdf.GetPdf());
pTotPdf->plotOn(pFrame, RooFit::Components(bkgComponent), RooFit::LineColor(kGreen) );
}
pPdf->plotOn(pFrame, RooFit::LineColor(kRed));
pPdf->paramOn(pFrame, RooFit::Format("NEU", RooFit::AutoPrecision(1)), RooFit::Layout(0.65, 0.99, 0.93));
pFrame->getAttText()->SetTextSize(0.75*pFrame->GetYaxis()->GetLabelSize());
pHisPull = pFrame->pullHist();
pFramePull->addPlotable(pHisPull, "P");
pullMax = max(fabs(pFramePull->GetMinimum()), pFramePull->GetMaximum());
pFramePull->GetYaxis()->SetRangeUser(-pullMax,pullMax);
pPlot1 = pFrame;
pPlot2 = pFramePull;
}
void ComputeUpperLimit(RooAbsData *data, RooStats::ModelConfig *model, float &UpperLimit, float &signif, RooRealVar *mu, RooArgSet *nullParams,RooWorkspace *ws,REGION region,const char* tag) {
bool StoreEverything=false; // activate if you want to store frames and all
RooStats::ProfileLikelihoodCalculator *plc = new RooStats::ProfileLikelihoodCalculator(*data, *model);
plc->SetParameters(*mu);
plc->SetNullParameters(*nullParams);
plc->SetTestSize(0.05);
RooStats::LikelihoodInterval *interval = plc->GetInterval();
bool ComputationSuccessful=false;
UpperLimit = interval->UpperLimit(*mu,ComputationSuccessful);
signif = 0.0; // plc->GetHypoTest()->Significance(); // deactivated significance (to make algorithm faster)
if(!ComputationSuccessful) {
cout << "There seems to have been a problem. Returned upper limit is " << UpperLimit << " but it will be set to -999" << endl;
UpperLimit=-999;
signif=-999;
}
if(StoreEverything) {
// Store it all
RooRealVar* minv = (RooRealVar*)model->GetObservables()->first();
minv->setBins(static_cast<int>((minv->getMax()-minv->getMin())/5.));
RooPlot* frameEE = minv->frame(RooFit::Title("ee sample"));
frameEE->GetXaxis()->CenterTitle(1);
frameEE->GetYaxis()->CenterTitle(1);
RooPlot* frameMM = minv->frame(RooFit::Title("mm sample"));
frameMM->GetXaxis()->CenterTitle(1);
frameMM->GetYaxis()->CenterTitle(1);
RooPlot* frameOF = minv->frame(RooFit::Title("OF sample"));
frameOF->GetXaxis()->CenterTitle(1);
frameOF->GetYaxis()->CenterTitle(1);
data->plotOn(frameMM,RooFit::Cut("catCentral==catCentral::MMCentral"));
model->GetPdf()->plotOn(frameMM,RooFit::Slice(*ws->cat("catCentral"), "MMCentral"),RooFit::ProjWData(*data));
data->plotOn(frameEE,RooFit::Cut("catCentral==catCentral::EECentral"));
model->GetPdf()->plotOn(frameEE,RooFit::Slice(*ws->cat("catCentral"), "EECentral"),RooFit::ProjWData(*data));
data->plotOn(frameOF,RooFit::Cut("catCentral==catCentral::OFOSCentral"));
model->GetPdf()->plotOn(frameOF,RooFit::Slice(*ws->cat("catCentral"), "OFOSCentral"),RooFit::ProjWData(*data));
TFile *fout = new TFile("fout.root","UPDATE");
frameMM->Write(Concatenate(Concatenate(data->GetName(),"_MM"),tag),TObject::kOverwrite);
frameEE->Write(Concatenate(Concatenate(data->GetName(),"_EE"),tag),TObject::kOverwrite);
frameOF->Write(Concatenate(Concatenate(data->GetName(),"_OF"),tag),TObject::kOverwrite);
fout->Close();
}
delete plc;
plc=0;
}
void rf304_uncorrprod()
{
// C r e a t e c o m p o n e n t p d f s i n x a n d y
// ----------------------------------------------------------------
// Create two p.d.f.s gaussx(x,meanx,sigmax) gaussy(y,meany,sigmay) and its variables
RooRealVar x("x","x",-5,5) ;
RooRealVar y("y","y",-5,5) ;
RooRealVar meanx("mean1","mean of gaussian x",2) ;
RooRealVar meany("mean2","mean of gaussian y",-2) ;
RooRealVar sigmax("sigmax","width of gaussian x",1) ;
RooRealVar sigmay("sigmay","width of gaussian y",5) ;
RooGaussian gaussx("gaussx","gaussian PDF",x,meanx,sigmax) ;
RooGaussian gaussy("gaussy","gaussian PDF",y,meany,sigmay) ;
// C o n s t r u c t u n c o r r e l a t e d p r o d u c t p d f
// -------------------------------------------------------------------
// Multiply gaussx and gaussy into a two-dimensional p.d.f. gaussxy
RooProdPdf gaussxy("gaussxy","gaussx*gaussy",RooArgList(gaussx,gaussy)) ;
// S a m p l e p d f , p l o t p r o j e c t i o n o n x a n d y
// ---------------------------------------------------------------------------
// Generate 10000 events in x and y from gaussxy
RooDataSet *data = gaussxy.generate(RooArgSet(x,y),10000) ;
// Plot x distribution of data and projection of gaussxy on x = Int(dy) gaussxy(x,y)
RooPlot* xframe = x.frame(Title("X projection of gauss(x)*gauss(y)")) ;
data->plotOn(xframe) ;
gaussxy.plotOn(xframe) ;
// Plot x distribution of data and projection of gaussxy on y = Int(dx) gaussxy(x,y)
RooPlot* yframe = y.frame(Title("Y projection of gauss(x)*gauss(y)")) ;
data->plotOn(yframe) ;
gaussxy.plotOn(yframe) ;
// Make canvas and draw RooPlots
TCanvas *c = new TCanvas("rf304_uncorrprod","rf304_uncorrprod",800, 400);
c->Divide(2);
c->cd(1) ; gPad->SetLeftMargin(0.15) ; xframe->GetYaxis()->SetTitleOffset(1.4) ; xframe->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; yframe->GetYaxis()->SetTitleOffset(1.4) ; yframe->Draw() ;
}
void rf301_composition()
{
// S e t u p c o m p o s e d m o d e l g a u s s ( x , m ( y ) , s )
// -----------------------------------------------------------------------
// Create observables
RooRealVar x("x","x",-5,5) ;
RooRealVar y("y","y",-5,5) ;
// Create function f(y) = a0 + a1*y
RooRealVar a0("a0","a0",-0.5,-5,5) ;
RooRealVar a1("a1","a1",-0.5,-1,1) ;
RooPolyVar fy("fy","fy",y,RooArgSet(a0,a1)) ;
// Creat gauss(x,f(y),s)
RooRealVar sigma("sigma","width of gaussian",0.5) ;
RooGaussian model("model","Gaussian with shifting mean",x,fy,sigma) ;
// S a m p l e d a t a , p l o t d a t a a n d p d f o n x a n d y
// ---------------------------------------------------------------------------------
// Generate 10000 events in x and y from model
RooDataSet *data = model.generate(RooArgSet(x,y),10000) ;
// Plot x distribution of data and projection of model on x = Int(dy) model(x,y)
RooPlot* xframe = x.frame() ;
data->plotOn(xframe) ;
model.plotOn(xframe) ;
// Plot x distribution of data and projection of model on y = Int(dx) model(x,y)
RooPlot* yframe = y.frame() ;
data->plotOn(yframe) ;
model.plotOn(yframe) ;
// Make two-dimensional plot in x vs y
TH1* hh_model = model.createHistogram("hh_model",x,Binning(50),YVar(y,Binning(50))) ;
hh_model->SetLineColor(kBlue) ;
// Make canvas and draw RooPlots
TCanvas *c = new TCanvas("rf301_composition","rf301_composition",1200, 400);
c->Divide(3);
c->cd(1) ; gPad->SetLeftMargin(0.15) ; xframe->GetYaxis()->SetTitleOffset(1.4) ; xframe->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; yframe->GetYaxis()->SetTitleOffset(1.4) ; yframe->Draw() ;
c->cd(3) ; gPad->SetLeftMargin(0.20) ; hh_model->GetZaxis()->SetTitleOffset(2.5) ; hh_model->Draw("surf") ;
}
void rf209_anaconv()
{
// B - p h y s i c s p d f w i t h t r u t h r e s o l u t i o n
// ---------------------------------------------------------------------
// Variables of decay p.d.f.
RooRealVar dt("dt","dt",-10,10) ;
RooRealVar tau("tau","tau",1.548) ;
// Build a truth resolution model (delta function)
RooTruthModel tm("tm","truth model",dt) ;
// Construct decay(t) (x) delta(t)
RooDecay decay_tm("decay_tm","decay",dt,tau,tm,RooDecay::DoubleSided) ;
// Plot p.d.f. (dashed)
RooPlot* frame = dt.frame(Title("Bdecay (x) resolution")) ;
decay_tm.plotOn(frame,LineStyle(kDashed)) ;
// B - p h y s i c s p d f w i t h G a u s s i a n r e s o l u t i o n
// ----------------------------------------------------------------------------
// Build a gaussian resolution model
RooRealVar bias1("bias1","bias1",0) ;
RooRealVar sigma1("sigma1","sigma1",1) ;
RooGaussModel gm1("gm1","gauss model 1",dt,bias1,sigma1) ;
// Construct decay(t) (x) gauss1(t)
RooDecay decay_gm1("decay_gm1","decay",dt,tau,gm1,RooDecay::DoubleSided) ;
// Plot p.d.f.
decay_gm1.plotOn(frame) ;
// B - p h y s i c s p d f w i t h d o u b l e G a u s s i a n r e s o l u t i o n
// ------------------------------------------------------------------------------------------
// Build another gaussian resolution model
RooRealVar bias2("bias2","bias2",0) ;
RooRealVar sigma2("sigma2","sigma2",5) ;
RooGaussModel gm2("gm2","gauss model 2",dt,bias2,sigma2) ;
// Build a composite resolution model f*gm1+(1-f)*gm2
RooRealVar gm1frac("gm1frac","fraction of gm1",0.5) ;
RooAddModel gmsum("gmsum","sum of gm1 and gm2",RooArgList(gm1,gm2),gm1frac) ;
// Construct decay(t) (x) (f*gm1 + (1-f)*gm2)
RooDecay decay_gmsum("decay_gmsum","decay",dt,tau,gmsum,RooDecay::DoubleSided) ;
// Plot p.d.f. (red)
decay_gmsum.plotOn(frame,LineColor(kRed)) ;
// Draw all frames on canvas
new TCanvas("rf209_anaconv","rf209_anaconv",600, 600);
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
}
void test01()
{
// S e t u p m o d e l
// ---------------------
TFile *openFile = new TFile("/tmp/kyolee/dimuonTree_upsiMiniTree_pA5tev_14nb_Run210498-210909_trigBit1_allTriggers0_pt4.root");
TTree* tree = (TTree*)openFile->Get("UpsilonTree");
// Declare variables with associated name, title, initial value and allowed range
RooRealVar mass("invariantMass","M_{#mu#mu} [GeV/c]",9.4,7,14) ;
RooRealVar muPlusPt("muPlusPt","muPlusPt",0,40) ;
RooRealVar muMinusPt("muMinusPt","muMinusPt",0,40) ;
RooRealVar mean("mean","mean of gaussian",9.4,8,11) ;
RooRealVar sigma("sigma","width of gaussian",1,0.1,10) ;
RooDataSet* data = new RooDataSet("data", "data", RooArgSet(mass,muPlusPt,muMinusPt), Import(*tree), Cut("muPlusPt>4 && muMinusPt>4"));
data->Print();
// Build gaussian p.d.f in terms of x,mean and sigma
RooGaussian gauss("gauss","gaussian PDF",mass,mean,sigma) ;
// Construct plot frame in 'x'
RooPlot* xframe = mass.frame(Title("Gaussian p.d.f.")) ;
data->plotOn(xframe);
/*
// P l o t m o d e l a n d c h a n g e p a r a m e t e r v a l u e s
// ---------------------------------------------------------------------------
// Plot gauss in frame (i.e. in x)
gauss.plotOn(xframe) ;
// Change the value of sigma to 3
sigma.setVal(3) ;
// Plot gauss in frame (i.e. in x) and draw frame on canvas
gauss.plotOn(xframe,LineColor(kRed)) ;
*/
// F i t m o d e l t o d a t a
// -----------------------------
// Fit pdf to data
gauss.fitTo(*data,Range(9,10)) ;
gauss.plotOn(xframe) ;
// Print values of mean and sigma (that now reflect fitted values and errors)
mean.Print() ;
sigma.Print() ;
// Draw all frames on a canvas
TCanvas* c = new TCanvas("rf101_basics","rf101_basics",800,400) ;
c->cd(1) ; gPad->SetLeftMargin(0.15) ; xframe->GetYaxis()->SetTitleOffset(1.6) ; xframe->Draw() ;
}
void rf314_paramfitrange()
{
// D e f i n e o b s e r v a b l e s a n d d e c a y p d f
// ---------------------------------------------------------------
// Declare observables
RooRealVar t("t","t",0,5) ;
RooRealVar tmin("tmin","tmin",0,0,5) ;
// Make parameterized range in t : [tmin,5]
t.setRange(tmin,RooConst(t.getMax())) ;
// Make pdf
RooRealVar tau("tau","tau",-1.54,-10,-0.1) ;
RooExponential model("model","model",t,tau) ;
// C r e a t e i n p u t d a t a
// ------------------------------------
// Generate complete dataset without acceptance cuts (for reference)
RooDataSet* dall = model.generate(t,10000) ;
// Generate a (fake) prototype dataset for acceptance limit values
RooDataSet* tmp = RooGaussian("gmin","gmin",tmin,RooConst(0),RooConst(0.5)).generate(tmin,5000) ;
// Generate dataset with t values that observe (t>tmin)
RooDataSet* dacc = model.generate(t,ProtoData(*tmp)) ;
// F i t p d f t o d a t a i n a c c e p t a n c e r e g i o n
// -----------------------------------------------------------------------
RooFitResult* r = model.fitTo(*dacc,Save()) ;
// P l o t f i t t e d p d f o n f u l l a n d a c c e p t e d d a t a
// ---------------------------------------------------------------------------------
// Make plot frame, add datasets and overlay model
RooPlot* frame = t.frame(Title("Fit to data with per-event acceptance")) ;
dall->plotOn(frame,MarkerColor(kRed),LineColor(kRed)) ;
model.plotOn(frame) ;
dacc->plotOn(frame) ;
// Print fit results to demonstrate absence of bias
r->Print("v") ;
new TCanvas("rf314_paramranges","rf314_paramranges",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
return ;
}
void DP_Fit() {
// C r e a t e m o d e l f o r p h y s i c s s a m p l e
// -------------------------------------------------------------
// Create observables
RooRealVar time("time","Time(ns)",-5,25) ;
// Construct QCD/signal pdf
RooRealVar mean("mean","mean",0,-5,25) ;
RooRealVar sigma("sigma","sigma",0.3,0.1,10) ;
RooGaussian gt("gt","gt",time,mean,sigma) ;
// Construct HALO/background pdf
RooRealVar a0("a0","a0",-0.1,-5,25) ;
RooRealVar a1("a1","a1",0.004,-1,1) ;
RooChebychev pt("pt","pt",time,RooArgSet(a0,a1)) ;
// Construct composite pdf
RooRealVar f("f","f",0.2,0.,1.) ;
RooAddPdf model("model","model",RooArgList(gt,pt),f) ;
// TFile* file = IFile();
// TH1D* ihist = get1Dhist(file);
TH1D* ihist = makeTH1(); // Random MC
// Create a binned dataset that imports contents of TH1 and associates its contents to observable 'x'
RooDataHist dhist("dhist","dhist",time,Import(*ihist));
// P l o t a n d f i t a R o o D a t a H i s t
// ---------------------------------------------------
// Make plot of binned dataset showing Poisson error bars (RooFit default)
RooPlot* frame = time.frame(Title("Imported Time Hist with Poisson error bars")) ;
dhist.plotOn(frame) ;
// Fit a Gaussian p.d.f to the data
gt.fitTo(dhist) ;
gt.plotOn(frame) ;
// If histogram has custom error (i.e. its contents is does not originate from a Poisson process
// but e.g. is a sum of weighted events) you can data with symmetric 'sum-of-weights' error instead
// (same error bars as shown by ROOT)
RooPlot* frame2 = time.frame(Title("Imported Time TH1 with internal errors")) ;
dhist.plotOn(frame2,DataError(RooAbsData::SumW2)) ;
gt.plotOn(frame2) ;
// Draw all frames on a canvas
TCanvas* c = new TCanvas("DP_Fit","DP_Fit",800,800) ;
c->Divide(2,0) ;
c->cd(1) ; gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; frame2->GetYaxis()->SetTitleOffset(1.4) ; frame2->Draw() ;
/* c->cd(3) ; gPad->SetLeftMargin(0.15) ; frame3->GetYaxis()->SetTitleOffset(1.4) ; frame3->Draw() ;
c->cd(4) ; gPad->SetLeftMargin(0.15) ; frame4->GetYaxis()->SetTitleOffset(1.4) ; frame4->Draw() ;
*/
}
void rf313_paramranges()
{
// C r e a t e 3 D p d f
// -------------------------
// Define observable (x,y,z)
RooRealVar x("x","x",0,10) ;
RooRealVar y("y","y",0,10) ;
RooRealVar z("z","z",0,10) ;
// Define 3 dimensional pdf
RooRealVar z0("z0","z0",-0.1,1) ;
RooPolynomial px("px","px",x,RooConst(0)) ;
RooPolynomial py("py","py",y,RooConst(0)) ;
RooPolynomial pz("pz","pz",z,z0) ;
RooProdPdf pxyz("pxyz","pxyz",RooArgSet(px,py,pz)) ;
// D e f i n e d n o n - r e c t a n g u l a r r e g i o n R i n ( x , y , z )
// -------------------------------------------------------------------------------------
//
// R = Z[0 - 0.1*Y^2] * Y[0.1*X - 0.9*X] * X[0 - 10]
//
// Construct range parameterized in "R" in y [ 0.1*x, 0.9*x ]
RooFormulaVar ylo("ylo","0.1*x",x) ;
RooFormulaVar yhi("yhi","0.9*x",x) ;
y.setRange("R",ylo,yhi) ;
// Construct parameterized ranged "R" in z [ 0, 0.1*y^2 ]
RooFormulaVar zlo("zlo","0.0*y",y) ;
RooFormulaVar zhi("zhi","0.1*y*y",y) ;
z.setRange("R",zlo,zhi) ;
// C a l c u l a t e i n t e g r a l o f n o r m a l i z e d p d f i n R
// ----------------------------------------------------------------------------------
// Create integral over normalized pdf model over x,y,z in "R" region
RooAbsReal* intPdf = pxyz.createIntegral(RooArgSet(x,y,z),RooArgSet(x,y,z),"R") ;
// Plot value of integral as function of pdf parameter z0
RooPlot* frame = z0.frame(Title("Integral of pxyz over x,y,z in region R")) ;
intPdf->plotOn(frame) ;
new TCanvas("rf313_paramranges","rf313_paramranges",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.6) ; frame->Draw() ;
return ;
}
void rf208_convolution()
{
// S e t u p c o m p o n e n t p d f s
// ---------------------------------------
// Construct observable
RooRealVar t("t","t",-10,30) ;
// Construct landau(t,ml,sl) ;
RooRealVar ml("ml","mean landau",5.,-20,20) ;
RooRealVar sl("sl","sigma landau",1,0.1,10) ;
RooLandau landau("lx","lx",t,ml,sl) ;
// Construct gauss(t,mg,sg)
RooRealVar mg("mg","mg",0) ;
RooRealVar sg("sg","sg",2,0.1,10) ;
RooGaussian gauss("gauss","gauss",t,mg,sg) ;
// C o n s t r u c t c o n v o l u t i o n p d f
// ---------------------------------------
// Set #bins to be used for FFT sampling to 10000
t.setBins(10000,"cache") ;
// Construct landau (x) gauss
RooFFTConvPdf lxg("lxg","landau (X) gauss",t,landau,gauss) ;
// S a m p l e , f i t a n d p l o t c o n v o l u t e d p d f
// ----------------------------------------------------------------------
// Sample 1000 events in x from gxlx
RooDataSet* data = lxg.generate(t,10000) ;
// Fit gxlx to data
lxg.fitTo(*data) ;
// Plot data, landau pdf, landau (X) gauss pdf
RooPlot* frame = t.frame(Title("landau (x) gauss convolution")) ;
data->plotOn(frame) ;
lxg.plotOn(frame) ;
landau.plotOn(frame,LineStyle(kDashed)) ;
// Draw frame on canvas
new TCanvas("rf208_convolution","rf208_convolution",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
}
void lifetimeFit()
{
// Import file.
TFile f("/afs/phas.gla.ac.uk/user/n/nwarrack/public_ppe/myLHCb/Gedcode/LHCb_CharmedHadrons/data/histoTAU_Lambda_cplus_SigOnly_cut04_20bins.root") ;
TH1F *h_signal = (TH1F*)f.Get("h_Signal"); // gets the histogram of signal yields from the .root file
// Read histogram into RooFit dataset
RooRealVar tau("tau", "tau (ns)", 0.00025, 0.002) ;
RooDataHist binnedData("binnedData", "binnedData", RooArgSet(tau), h_signal) ;
// Build exponential PDF.
//RooRealVar expoParam("expoParam", "expoParam", -5000., -5000., 0.) ; //for unblinded analysis
RooRealVar blindConst("blindConst", "blindConst", -5000., -5000., 0.) ; //for blinded analysis
RooUnblindOffset decayConstUnblind("decayConstUnblind", "Unblind decay rate", "someblindingstring", 500, blindConst) ; // to make comparisons with previous work.
//RooExponential lifetimePDF("lifetimePDF", "lifetimePDF", tau, expoParam) ; // non-blinded PDF
RooExponential lifetimePDF("lifetimePDF", "lifetimePDF", tau, decayConstUnblind) ; // blinded PDF
// Fit to data
lifetimePDF.fitTo(binnedData, RooFit::SumW2Error(false)) ;
// Print the blinded decay rate to screen
cout << "Decay rate: " << blindConst.getVal() << " +/- " << blindConst.getError() << endl ;
// Plot
TCanvas c1;
RooPlot* lifetimePlot = tau.frame() ;
binnedData.plotOn(lifetimePlot) ;
lifetimePDF.plotOn(lifetimePlot);
lifetimePlot->GetYaxis()->SetTitleOffset(1.4);
lifetimePlot->Draw();
// Save file as .pdf
c1.SaveAs("histo_Lambda_cplus_TAU_lifetime_SigOnly_cut04FITTED.pdf") ;
}
void rf510_wsnamedsets()
{
// C r e a t e m o d e l a n d d a t a s e t
// -----------------------------------------------
RooWorkspace* w = new RooWorkspace("w") ;
fillWorkspace(*w) ;
// Exploit convention encoded in named set "parameters" and "observables"
// to use workspace contents w/o need for introspected
RooAbsPdf* model = w->pdf("model") ;
// Generate data from p.d.f. in given observables
RooDataSet* data = model->generate(*w->set("observables"),1000) ;
// Fit model to data
model->fitTo(*data) ;
// Plot fitted model and data on frame of first (only) observable
RooPlot* frame = ((RooRealVar*)w->set("observables")->first())->frame() ;
data->plotOn(frame) ;
model->plotOn(frame) ;
// Overlay plot with model with reference parameters as stored in snapshots
w->loadSnapshot("reference_fit") ;
model->plotOn(frame,LineColor(kRed)) ;
w->loadSnapshot("reference_fit_bkgonly") ;
model->plotOn(frame,LineColor(kRed),LineStyle(kDashed)) ;
// Draw the frame on the canvas
new TCanvas("rf510_wsnamedsets","rf503_wsnamedsets",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
// Print workspace contents
w->Print() ;
// Workspace will remain in memory after macro finishes
gDirectory->Add(w) ;
}
void rf509_wsinteractive()
{
// C r e a t e a n d f i l l w o r k s p a c e
// ------------------------------------------------
// Create a workspace named 'w' that exports its contents to
// a same-name C++ namespace in CINT 'namespace w'.
RooWorkspace* w = new RooWorkspace("w",kTRUE) ;
// Fill workspace with p.d.f. and data in a separate function
fillWorkspace(*w) ;
// Print workspace contents
w->Print() ;
// U s e w o r k s p a c e c o n t e n t s t h r o u g h C I N T C + + n a m e s p a c e
// -------------------------------------------------------------------------------------------------
// Use the name space prefix operator to access the workspace contents
RooDataSet* d = w::model.generate(w::x,1000) ;
RooFitResult* r = w::model.fitTo(*d) ;
RooPlot* frame = w::x.frame() ;
d->plotOn(frame) ;
// NB: The 'w::' prefix can be omitted if namespace w is imported in local namespace
// in the usual C++ way
using namespace w;
model.plotOn(frame) ;
model.plotOn(frame,Components(bkg),LineStyle(kDashed)) ;
// Draw the frame on the canvas
new TCanvas("rf509_wsinteractive","rf509_wsinteractive",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
}
void fitWm(const TString outputDir, // output directory
const Double_t lumi, // integrated luminosity (/fb)
const Double_t nsigma=0 // vary MET corrections by n-sigmas (nsigma=0 means nominal correction)
) {
gBenchmark->Start("fitWm");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
// MET histogram binning and range
const Int_t NBINS = 50;
const Double_t METMAX = 100;
const Double_t PT_CUT = 25;
const Double_t ETA_CUT = 2.1;
// file format for output plots
const TString format("png");
// recoil correction
RecoilCorrector recoilCorr("../Recoil/ZmmData/fits.root");//, (!) uncomment to perform corrections to recoil from W-MC/Z-MC
//"../Recoil/WmpMC/fits.root",
//"../Recoil/WmmMC/fits.root",
//"../Recoil/ZmmMC/fits.root");
// NNLO boson pT k-factors
TFile nnloCorrFile("/data/blue/ksung/EWKAna/8TeV/Utils/Ratio.root");
TH1D *hNNLOCorr = (TH1D*)nnloCorrFile.Get("RpT_B");
//
// input ntuple file names
//
enum { eData, eWmunu, eEWK, eAntiData, eAntiWmunu, eAntiEWK }; // data type enum
vector<TString> fnamev;
vector<Int_t> typev;
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/Wmunu/ntuples/data_select.root"); typev.push_back(eData);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/Wmunu/ntuples/wm_select.root"); typev.push_back(eWmunu);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/Wmunu/ntuples/ewk_select.root"); typev.push_back(eEWK);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/Wmunu/ntuples/top_select.root"); typev.push_back(eEWK);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/AntiWmunu/ntuples/data_select.root"); typev.push_back(eAntiData);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/AntiWmunu/ntuples/wm_select.root"); typev.push_back(eAntiWmunu);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/AntiWmunu/ntuples/ewk_select.root"); typev.push_back(eAntiEWK);
fnamev.push_back("/data/blue/ksung/EWKAna/8TeV/Selection/AntiWmunu/ntuples/top_select.root"); typev.push_back(eAntiEWK);
//--------------------------------------------------------------------------------------------------------------
// Main analysis code
//==============================================================================================================
// Create output directory
gSystem->mkdir(outputDir,kTRUE);
CPlot::sOutDir = outputDir;
//
// Declare MET histograms
//
TH1D *hDataMet = new TH1D("hDataMet","", NBINS,0,METMAX); hDataMet->Sumw2();
TH1D *hDataMetm = new TH1D("hDataMetm","", NBINS,0,METMAX); hDataMetm->Sumw2();
TH1D *hDataMetp = new TH1D("hDataMetp","", NBINS,0,METMAX); hDataMetp->Sumw2();
TH1D *hWmunuMet = new TH1D("hWmunuMet","", NBINS,0,METMAX); hWmunuMet->Sumw2();
TH1D *hWmunuMetp = new TH1D("hWmunuMetp","",NBINS,0,METMAX); hWmunuMetp->Sumw2();
TH1D *hWmunuMetm = new TH1D("hWmunuMetm","",NBINS,0,METMAX); hWmunuMetm->Sumw2();
TH1D *hEWKMet = new TH1D("hEWKMet", "", NBINS,0,METMAX); hEWKMet->Sumw2();
TH1D *hEWKMetp = new TH1D("hEWKMetp", "", NBINS,0,METMAX); hEWKMetp->Sumw2();
TH1D *hEWKMetm = new TH1D("hEWKMetm", "", NBINS,0,METMAX); hEWKMetm->Sumw2();
TH1D *hAntiDataMet = new TH1D("hAntiDataMet","", NBINS,0,METMAX); hAntiDataMet->Sumw2();
TH1D *hAntiDataMetm = new TH1D("hAntiDataMetm","", NBINS,0,METMAX); hAntiDataMetm->Sumw2();
TH1D *hAntiDataMetp = new TH1D("hAntiDataMetp","", NBINS,0,METMAX); hAntiDataMetp->Sumw2();
TH1D *hAntiWmunuMet = new TH1D("hAntiWmunuMet","", NBINS,0,METMAX); hAntiWmunuMet->Sumw2();
TH1D *hAntiWmunuMetp = new TH1D("hAntiWmunuMetp","",NBINS,0,METMAX); hAntiWmunuMetp->Sumw2();
TH1D *hAntiWmunuMetm = new TH1D("hAntiWmunuMetm","",NBINS,0,METMAX); hAntiWmunuMetm->Sumw2();
TH1D *hAntiEWKMet = new TH1D("hAntiEWKMet", "", NBINS,0,METMAX); hAntiEWKMet->Sumw2();
TH1D *hAntiEWKMetp = new TH1D("hAntiEWKMetp", "", NBINS,0,METMAX); hAntiEWKMetp->Sumw2();
TH1D *hAntiEWKMetm = new TH1D("hAntiEWKMetm", "", NBINS,0,METMAX); hAntiEWKMetm->Sumw2();
//
// Declare variables to read in ntuple
//
UInt_t runNum, lumiSec, evtNum;
UInt_t npv, npu;
Float_t genVPt, genVPhi;
Float_t scale1fb;
Float_t met, metPhi, sumEt, mt, u1, u2;
Int_t q;
LorentzVector *lep=0;
Float_t pfChIso, pfGamIso, pfNeuIso;
TFile *infile=0;
TTree *intree=0;
//
// Loop over files
//
for(UInt_t ifile=0; ifile<fnamev.size(); ifile++) {
// Read input file and get the TTrees
cout << "Processing " << fnamev[ifile] << "..." << endl;
infile = new TFile(fnamev[ifile]); assert(infile);
intree = (TTree*)infile->Get("Events"); assert(intree);
intree->SetBranchAddress("runNum", &runNum); // event run number
intree->SetBranchAddress("lumiSec", &lumiSec); // event lumi section
intree->SetBranchAddress("evtNum", &evtNum); // event number
intree->SetBranchAddress("npv", &npv); // number of primary vertices
intree->SetBranchAddress("npu", &npu); // number of in-time PU events (MC)
intree->SetBranchAddress("genVPt", &genVPt); // GEN W boson pT (signal MC)
intree->SetBranchAddress("genVPhi", &genVPhi); // GEN W boson phi (signal MC)
intree->SetBranchAddress("scale1fb", &scale1fb); // event weight per 1/fb (MC)
intree->SetBranchAddress("met", &met); // MET
intree->SetBranchAddress("metPhi", &metPhi); // phi(MET)
intree->SetBranchAddress("sumEt", &sumEt); // Sum ET
intree->SetBranchAddress("mt", &mt); // transverse mass
intree->SetBranchAddress("u1", &u1); // parallel component of recoil
intree->SetBranchAddress("u2", &u2); // perpendicular component of recoil
intree->SetBranchAddress("q", &q); // lepton charge
intree->SetBranchAddress("lep", &lep); // lepton 4-vector
intree->SetBranchAddress("pfChIso", &pfChIso);
intree->SetBranchAddress("pfGamIso", &pfGamIso);
intree->SetBranchAddress("pfNeuIso", &pfNeuIso);
//
// loop over events
//
for(UInt_t ientry=0; ientry<intree->GetEntries(); ientry++) {
intree->GetEntry(ientry);
if(lep->Pt() < PT_CUT) continue;
if(fabs(lep->Eta()) > ETA_CUT) continue;
if( (typev[ifile]==eAntiData || typev[ifile]==eAntiWmunu || typev[ifile]==eAntiEWK) &&
(pfChIso+pfGamIso+pfNeuIso)>0.5*(lep->Pt()) )
continue;
if(typev[ifile]==eData) {
hDataMet->Fill(met);
if(q>0) { hDataMetp->Fill(met); }
else { hDataMetm->Fill(met); }
} else if(typev[ifile]==eAntiData) {
hAntiDataMet->Fill(met);
if(q>0) { hAntiDataMetp->Fill(met); }
else { hAntiDataMetm->Fill(met); }
} else {
Double_t weight = 1;
weight *= scale1fb*lumi;
if(typev[ifile]==eWmunu) {
Double_t corrMet=met, corrMetPhi=metPhi;
// apply recoil corrections to W MC
Double_t lepPt = lep->Pt();
//Double_t lepPt = gRandom->Gaus(lep->Pt(),0.5); // (!) uncomment to apply scale/res corrections to MC
recoilCorr.Correct(corrMet,corrMetPhi,genVPt,genVPhi,lepPt,lep->Phi(),nsigma,q);
Double_t nnlocorr=1;
for(Int_t ibin=1; ibin<=hNNLOCorr->GetNbinsX(); ibin++) {
if(genVPt >= hNNLOCorr->GetBinLowEdge(ibin) &&
genVPt < (hNNLOCorr->GetBinLowEdge(ibin)+hNNLOCorr->GetBinWidth(ibin)))
nnlocorr = hNNLOCorr->GetBinContent(ibin);
}
//weight *= nnlocorr; // (!) uncomment to apply NNLO corrections
hWmunuMet->Fill(corrMet,weight);
if(q>0) { hWmunuMetp->Fill(corrMet,weight); }
else { hWmunuMetm->Fill(corrMet,weight); }
}
if(typev[ifile]==eAntiWmunu) {
Double_t corrMet=met, corrMetPhi=metPhi;
// apply recoil corrections to W MC
Double_t lepPt = lep->Pt();//gRandom->Gaus(lep->Pt(),0.5);
//Double_t lepPt = gRandom->Gaus(lep->Pt(),0.5); // (!) uncomment to apply scale/res corrections to MC
recoilCorr.Correct(corrMet,corrMetPhi,genVPt,genVPhi,lepPt,lep->Phi(),nsigma,q);
Double_t nnlocorr=1;
for(Int_t ibin=1; ibin<=hNNLOCorr->GetNbinsX(); ibin++) {
if(genVPt >= hNNLOCorr->GetBinLowEdge(ibin) &&
genVPt < (hNNLOCorr->GetBinLowEdge(ibin)+hNNLOCorr->GetBinWidth(ibin)))
nnlocorr = hNNLOCorr->GetBinContent(ibin);
}
//weight *= nnlocorr; // (!) uncomment to apply NNLO corrections
hAntiWmunuMet->Fill(corrMet,weight);
if(q>0) { hAntiWmunuMetp->Fill(corrMet,weight); }
else { hAntiWmunuMetm->Fill(corrMet,weight); }
}
if(typev[ifile]==eEWK) {
hEWKMet->Fill(met,weight);
if(q>0) { hEWKMetp->Fill(met,weight); }
else { hEWKMetm->Fill(met,weight); }
}
if(typev[ifile]==eAntiEWK) {
hAntiEWKMet->Fill(met,weight);
if(q>0) { hAntiEWKMetp->Fill(met,weight); }
else { hAntiEWKMetm->Fill(met,weight); }
}
}
}
}
delete infile;
infile=0, intree=0;
//
// 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","nSig",0.7*(hDataMet->Integral()),0,hDataMet->Integral());
RooRealVar nQCD("nQCD","nQCD",0.3*(hDataMet->Integral()),0,hDataMet->Integral());
RooRealVar cewk("cewk","cewk",0.1,0,5) ;
cewk.setVal(hEWKMet->Integral()/hWmunuMet->Integral());
cewk.setConstant(kTRUE);
RooFormulaVar nEWK("nEWK","nEWK","cewk*nSig",RooArgList(nSig,cewk));
RooRealVar nAntiSig("nAntiSig","nAntiSig",0.05*(hAntiDataMet->Integral()),0,hAntiDataMet->Integral());
RooRealVar nAntiQCD("nAntiQCD","nAntiQCD",0.9*(hDataMet->Integral()),0,hDataMet->Integral());
RooRealVar dewk("dewk","dewk",0.1,0,5) ;
dewk.setVal(hAntiEWKMet->Integral()/hAntiWmunuMet->Integral());
dewk.setConstant(kTRUE);
RooFormulaVar nAntiEWK("nAntiEWK","nAntiEWK","dewk*nAntiSig",RooArgList(nAntiSig,dewk));
RooRealVar nSigp("nSigp","nSigp",0.7*(hDataMetp->Integral()),0,hDataMetp->Integral());
RooRealVar nQCDp("nQCDp","nQCDp",0.3*(hDataMetp->Integral()),0,hDataMetp->Integral());
RooRealVar cewkp("cewkp","cewkp",0.1,0,5) ;
cewkp.setVal(hEWKMetp->Integral()/hWmunuMetp->Integral());
cewkp.setConstant(kTRUE);
RooFormulaVar nEWKp("nEWKp","nEWKp","cewkp*nSigp",RooArgList(nSigp,cewkp));
RooRealVar nAntiSigp("nAntiSigp","nAntiSigp",0.05*(hAntiDataMetp->Integral()),0,hAntiDataMetp->Integral());
RooRealVar nAntiQCDp("nAntiQCDp","nAntiQCDp",0.9*(hAntiDataMetp->Integral()),0,hAntiDataMetp->Integral());
RooRealVar dewkp("dewkp","dewkp",0.1,0,5) ;
dewkp.setVal(hAntiEWKMetp->Integral()/hAntiWmunuMetp->Integral());
dewkp.setConstant(kTRUE);
RooFormulaVar nAntiEWKp("nAntiEWKp","nAntiEWKp","dewkp*nAntiSigp",RooArgList(nAntiSigp,dewkp));
RooRealVar nSigm("nSigm","nSigm",0.7*(hDataMetm->Integral()),0,hDataMetm->Integral());
RooRealVar nQCDm("nQCDm","nQCDm",0.3*(hDataMetm->Integral()),0,hDataMetm->Integral());
RooRealVar cewkm("cewkm","cewkm",0.1,0,5) ;
cewkm.setVal(hEWKMetm->Integral()/hWmunuMetm->Integral());
cewkm.setConstant(kTRUE);
RooFormulaVar nEWKm("nEWKm","nEWKm","cewkm*nSigm",RooArgList(nSigm,cewkm));
RooRealVar nAntiSigm("nAntiSigm","nAntiSigm",0.05*(hAntiDataMetm->Integral()),0,hAntiDataMetm->Integral());
RooRealVar nAntiQCDm("nAntiQCDm","nAntiQCDm",0.9*(hAntiDataMetm->Integral()),0,hAntiDataMetm->Integral());
RooRealVar dewkm("dewkm","dewkm",0.1,0,5) ;
dewkm.setVal(hAntiEWKMetm->Integral()/hAntiWmunuMetm->Integral());
dewkm.setConstant(kTRUE);
RooFormulaVar nAntiEWKm("nAntiEWKm","nAntiEWKm","dewkm*nAntiSigm",RooArgList(nAntiSigm,dewkm));
//
// Construct PDFs for fitting
//
RooRealVar pfmet("pfmet","pfmet",0,METMAX);
pfmet.setBins(NBINS);
// Signal PDFs
RooDataHist wmunuMet ("wmunuMET", "wmunuMET", RooArgSet(pfmet),hWmunuMet); RooHistPdf pdfWm ("wm", "wm", pfmet,wmunuMet, 1);
RooDataHist wmunuMetp("wmunuMETp","wmunuMETp",RooArgSet(pfmet),hWmunuMetp); RooHistPdf pdfWmp("wmp","wmp",pfmet,wmunuMetp,1);
RooDataHist wmunuMetm("wmunuMETm","wmunuMETm",RooArgSet(pfmet),hWmunuMetm); RooHistPdf pdfWmm("wmm","wmm",pfmet,wmunuMetm,1);
// EWK+top PDFs
RooDataHist ewkMet ("ewkMET", "ewkMET", RooArgSet(pfmet),hEWKMet); RooHistPdf pdfEWK ("ewk", "ewk", pfmet,ewkMet, 1);
RooDataHist ewkMetp("ewkMETp","ewkMETp",RooArgSet(pfmet),hEWKMetp); RooHistPdf pdfEWKp("ewkp","ewkp",pfmet,ewkMetp,1);
RooDataHist ewkMetm("ewkMETm","ewkMETm",RooArgSet(pfmet),hEWKMetm); RooHistPdf pdfEWKm("ewkm","ewkm",pfmet,ewkMetm,1);
// QCD Pdfs
CPepeModel1 qcd("qcd",pfmet);
CPepeModel1 qcdp("qcdp",pfmet);
CPepeModel1 qcdm("qcdm",pfmet);
// Signal + Background PDFs
RooAddPdf pdfMet ("pdfMet", "pdfMet", RooArgList(pdfWm,pdfEWK,*(qcd.model)), RooArgList(nSig,nEWK,nQCD));
RooAddPdf pdfMetp("pdfMetp","pdfMetp",RooArgList(pdfWmp,pdfEWKp,*(qcdp.model)),RooArgList(nSigp,nEWKp,nQCDp));
RooAddPdf pdfMetm("pdfMetm","pdfMetm",RooArgList(pdfWmm,pdfEWKm,*(qcdm.model)),RooArgList(nSigm,nEWKm,nQCDm));
// Anti-Signal PDFs
RooDataHist awmunuMet ("awmunuMET", "awmunuMET", RooArgSet(pfmet),hAntiWmunuMet); RooHistPdf apdfWm ("awm", "awm", pfmet,awmunuMet, 1);
RooDataHist awmunuMetp("awmunuMETp","awmunuMETp",RooArgSet(pfmet),hAntiWmunuMetp); RooHistPdf apdfWmp("awmp","awmp",pfmet,awmunuMetp,1);
RooDataHist awmunuMetm("awmunuMETm","awmunuMETm",RooArgSet(pfmet),hAntiWmunuMetm); RooHistPdf apdfWmm("awmm","awmm",pfmet,awmunuMetm,1);
// Anti-EWK+top PDFs
RooDataHist aewkMet ("aewkMET", "aewkMET", RooArgSet(pfmet),hAntiEWKMet); RooHistPdf apdfEWK ("aewk", "aewk", pfmet,aewkMet, 1);
RooDataHist aewkMetp("aewkMETp","aewkMETp",RooArgSet(pfmet),hAntiEWKMetp); RooHistPdf apdfEWKp("aewkp","aewkp",pfmet,aewkMetp,1);
RooDataHist aewkMetm("aewkMETm","aewkMETm",RooArgSet(pfmet),hAntiEWKMetm); RooHistPdf apdfEWKm("aewkm","aewkm",pfmet,aewkMetm,1);
// Anti-QCD Pdfs
CPepeModel1 aqcd("aqcd",pfmet,qcd.a1);
CPepeModel1 aqcdp("aqcdp",pfmet,qcdp.a1);
CPepeModel1 aqcdm("aqcdm",pfmet,qcdm.a1);
// Anti-selection PDFs
RooAddPdf apdfMet ("apdfMet", "apdfMet", RooArgList(apdfWm,apdfEWK,*(aqcd.model)), RooArgList(nAntiSig,nAntiEWK,nAntiQCD));
RooAddPdf apdfMetp("apdfMetp","apdfMetp",RooArgList(apdfWmp,apdfEWKp,*(aqcdp.model)),RooArgList(nAntiSigp,nAntiEWKp,nAntiQCDp));
RooAddPdf apdfMetm("apdfMetm","apdfMetm",RooArgList(apdfWmm,apdfEWKm,*(aqcdm.model)),RooArgList(nAntiSigm,nAntiEWKm,nAntiQCDm));
// PDF for simultaneous fit
RooCategory rooCat("rooCat","rooCat");
rooCat.defineType("Select");
rooCat.defineType("Anti");
RooSimultaneous pdfTotal("pdfTotal","pdfTotal",rooCat);
pdfTotal.addPdf(pdfMet, "Select");
pdfTotal.addPdf(apdfMet,"Anti");
RooSimultaneous pdfTotalp("pdfTotalp","pdfTotalp",rooCat);
pdfTotalp.addPdf(pdfMetp, "Select");
pdfTotalp.addPdf(apdfMetp,"Anti");
RooSimultaneous pdfTotalm("pdfTotalm","pdfTotalm",rooCat);
pdfTotalm.addPdf(pdfMetm, "Select");
pdfTotalm.addPdf(apdfMetm,"Anti");
//
// Perform fits
//
RooDataHist dataMet("dataMet", "dataMet", RooArgSet(pfmet), hDataMet);
RooDataHist antiMet("antiMet", "antiMet", RooArgSet(pfmet), hAntiDataMet);
RooDataHist dataTotal("dataTotal","dataTotal", RooArgList(pfmet), Index(rooCat),
Import("Select", dataMet),
Import("Anti", antiMet));
RooFitResult *fitRes = pdfTotal.fitTo(dataTotal,Extended(),Minos(kTRUE),Save(kTRUE));
RooDataHist dataMetp("dataMetp", "dataMetp", RooArgSet(pfmet), hDataMetp);
RooDataHist antiMetp("antiMetp", "antiMetp", RooArgSet(pfmet), hAntiDataMetp);
RooDataHist dataTotalp("dataTotalp","dataTotalp", RooArgList(pfmet), Index(rooCat),
Import("Select", dataMetp),
Import("Anti", antiMetp));
RooFitResult *fitResp = pdfTotalp.fitTo(dataTotalp,Extended(),Minos(kTRUE),Save(kTRUE));
RooDataHist dataMetm("dataMetm", "dataMetm", RooArgSet(pfmet), hDataMetm);
RooDataHist antiMetm("antiMetm", "antiMetm", RooArgSet(pfmet), hAntiDataMetm);
RooDataHist dataTotalm("dataTotalm","dataTotalm", RooArgList(pfmet), Index(rooCat),
Import("Select", dataMetm),
Import("Anti", antiMetm));
RooFitResult *fitResm = pdfTotalm.fitTo(dataTotalm,Extended(),Minos(kTRUE),Save(kTRUE));
//
// 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", pfmet));
hPdfMet->Scale((nSig.getVal()+nEWK.getVal()+nQCD.getVal())/hPdfMet->Integral());
TH1D *hMetDiff = makeDiffHist(hDataMet,hPdfMet,"hMetDiff");
hMetDiff->SetMarkerStyle(kFullCircle);
hMetDiff->SetMarkerSize(0.9);
TH1D *hPdfMetp = (TH1D*)(pdfMetp.createHistogram("hPdfMetp", pfmet));
hPdfMetp->Scale((nSigp.getVal()+nEWKp.getVal()+nQCDp.getVal())/hPdfMetp->Integral());
TH1D *hMetpDiff = makeDiffHist(hDataMetp,hPdfMetp,"hMetpDiff");
hMetpDiff->SetMarkerStyle(kFullCircle);
hMetpDiff->SetMarkerSize(0.9);
TH1D *hPdfMetm = (TH1D*)(pdfMetm.createHistogram("hPdfMetm", pfmet));
hPdfMetm->Scale((nSigm.getVal()+nEWKm.getVal()+nQCDm.getVal())/hPdfMetm->Integral());
TH1D *hMetmDiff = makeDiffHist(hDataMetm,hPdfMetm,"hMetmDiff");
hMetmDiff->SetMarkerStyle(kFullCircle);
hMetmDiff->SetMarkerSize(0.9);
TH1D *hPdfAntiMet = (TH1D*)(apdfMet.createHistogram("hPdfAntiMet", pfmet));
hPdfAntiMet->Scale((nAntiSig.getVal()+nAntiEWK.getVal()+nAntiQCD.getVal())/hPdfAntiMet->Integral());
TH1D *hAntiMetDiff = makeDiffHist(hAntiDataMet,hPdfAntiMet,"hAntiMetDiff");
hAntiMetDiff->SetMarkerStyle(kFullCircle);
hAntiMetDiff->SetMarkerSize(0.9);
TH1D *hPdfAntiMetp = (TH1D*)(apdfMetp.createHistogram("hPdfAntiMetp", pfmet));
hPdfAntiMetp->Scale((nAntiSigp.getVal()+nAntiEWKp.getVal()+nAntiQCDp.getVal())/hPdfAntiMetp->Integral());
TH1D *hAntiMetpDiff = makeDiffHist(hAntiDataMetp,hPdfAntiMetp,"hAntiMetpDiff");
hAntiMetpDiff->SetMarkerStyle(kFullCircle);
hAntiMetpDiff->SetMarkerSize(0.9);
TH1D *hPdfAntiMetm = (TH1D*)(apdfMetm.createHistogram("hPdfAntiMetm", pfmet));
hPdfAntiMetm->Scale((nAntiSigm.getVal()+nAntiEWKm.getVal()+nAntiQCDm.getVal())/hPdfAntiMetm->Integral());
TH1D *hAntiMetmDiff = makeDiffHist(hAntiDataMetm,hPdfAntiMetm,"hAntiMetmDiff");
hAntiMetmDiff->SetMarkerStyle(kFullCircle);
hAntiMetmDiff->SetMarkerSize(0.9);
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
TCanvas *c = MakeCanvas("c","c",800,800);
c->Divide(1,2,0,0);
c->cd(1)->SetPad(0,0.3,1.0,1.0);
c->cd(1)->SetTopMargin(0.1);
c->cd(1)->SetBottomMargin(0.01);
c->cd(1)->SetLeftMargin(0.15);
c->cd(1)->SetRightMargin(0.07);
c->cd(1)->SetTickx(1);
c->cd(1)->SetTicky(1);
c->cd(2)->SetPad(0,0,1.0,0.3);
c->cd(2)->SetTopMargin(0.05);
c->cd(2)->SetBottomMargin(0.45);
c->cd(2)->SetLeftMargin(0.15);
c->cd(2)->SetRightMargin(0.07);
c->cd(2)->SetTickx(1);
c->cd(2)->SetTicky(1);
gStyle->SetTitleOffset(1.100,"Y");
TGaxis::SetMaxDigits(3);
char ylabel[100]; // string buffer for y-axis label
// label for lumi
char lumitext[100];
if(lumi<0.1) sprintf(lumitext,"%.1f pb^{-1} at #sqrt{s} = 8 TeV",lumi*1000.);
else sprintf(lumitext,"%.2f fb^{-1} at #sqrt{s} = 8 TeV",lumi);
// 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
// (I can't 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));
wmframe->GetYaxis()->SetNdivisions(505);
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,*(qcd.model))),FillColor(fillcolorEWK),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfEWK,*(qcd.model))),LineColor(linecolorEWK));
pdfMet.plotOn(wmframe,Components(RooArgSet(*(qcd.model))),FillColor(fillcolorQCD),DrawOption("F"));
pdfMet.plotOn(wmframe,Components(RooArgSet(*(qcd.model))),LineColor(linecolorQCD));
pdfMet.plotOn(wmframe,Components(RooArgSet(pdfWm)),LineColor(linecolorW),LineStyle(2));
dataMet.plotOn(wmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hDataMet->GetBinWidth(1));
CPlot plotMet("fitmet",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*(hDataMet->GetMaximum()));
plotMet.Draw(c,kFALSE,format,1);
CPlot plotMetDiff("fitmet","","#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(c,kTRUE,format,2);
plotMet.SetName("fitmetlog");
plotMet.SetLogy();
plotMet.SetYRange(1e-3*(hDataMet->GetMaximum()),10*(hDataMet->GetMaximum()));
plotMet.Draw(c,kTRUE,format,1);
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,*(aqcd.model))),FillColor(fillcolorEWK),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfEWK,*(aqcd.model))),LineColor(linecolorEWK));
apdfMet.plotOn(awmframe,Components(RooArgSet(*(aqcd.model))),FillColor(fillcolorQCD),DrawOption("F"));
apdfMet.plotOn(awmframe,Components(RooArgSet(*(aqcd.model))),LineColor(linecolorQCD));
apdfMet.plotOn(awmframe,Components(RooArgSet(apdfWm)),LineColor(linecolorW),LineStyle(2));
antiMet.plotOn(awmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hAntiDataMet->GetBinWidth(1));
CPlot plotAntiMet("fitantimet",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*(hAntiDataMet->GetMaximum()));
plotAntiMet.Draw(c,kFALSE,format,1);
CPlot plotAntiMetDiff("fitantimet","","#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(c,kTRUE,format,2);
plotAntiMet.SetName("fitantimetlog");
plotAntiMet.SetLogy();
plotAntiMet.SetYRange(1e-3*(hAntiDataMet->GetMaximum()),10*(hAntiDataMet->GetMaximum()));
plotAntiMet.Draw(c,kTRUE,format,1);
//
// W+ MET plot
//
RooPlot *wmpframe = pfmet.frame(Bins(NBINS));
wmpframe->GetYaxis()->SetNdivisions(505);
dataMetp.plotOn(wmpframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
pdfMetp.plotOn(wmpframe,FillColor(fillcolorW),DrawOption("F"));
pdfMetp.plotOn(wmpframe,LineColor(linecolorW));
pdfMetp.plotOn(wmpframe,Components(RooArgSet(pdfEWKp,*(qcdp.model))),FillColor(fillcolorEWK),DrawOption("F"));
pdfMetp.plotOn(wmpframe,Components(RooArgSet(pdfEWKp,*(qcdp.model))),LineColor(linecolorEWK));
pdfMetp.plotOn(wmpframe,Components(RooArgSet(*(qcdp.model))),FillColor(fillcolorQCD),DrawOption("F"));
pdfMetp.plotOn(wmpframe,Components(RooArgSet(*(qcdp.model))),LineColor(linecolorQCD));
pdfMetp.plotOn(wmpframe,Components(RooArgSet(pdfWmp)),LineColor(linecolorW),LineStyle(2));
dataMetp.plotOn(wmpframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hDataMetp->GetBinWidth(1));
CPlot plotMetp("fitmetp",wmpframe,"","",ylabel);
plotMetp.SetLegend(0.68,0.57,0.93,0.77);
plotMetp.GetLegend()->AddEntry(hDummyData,"data","PL");
plotMetp.GetLegend()->AddEntry(hDummyW,"W^{+}#rightarrow#mu^{+}#nu","F");
plotMetp.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotMetp.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotMetp.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotMetp.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
// plotMetp.SetYRange(0.1,1.1*(hDataMetp->GetMaximum()));
plotMetp.SetYRange(0.1,4100);
plotMetp.Draw(c,kFALSE,format,1);
CPlot plotMetpDiff("fitmetp","","#slash{E}_{T} [GeV]","#chi");
plotMetpDiff.AddHist1D(hMetpDiff,"EX0",ratioColor);
plotMetpDiff.SetYRange(-8,8);
plotMetpDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotMetpDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotMetpDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotMetpDiff.Draw(c,kTRUE,format,2);
plotMetp.SetName("fitmetplog");
plotMetp.SetLogy();
plotMetp.SetYRange(1e-3*(hDataMetp->GetMaximum()),10*(hDataMetp->GetMaximum()));
plotMetp.Draw(c,kTRUE,format,1);
RooPlot *awmpframe = pfmet.frame(Bins(NBINS));
antiMetp.plotOn(awmpframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
apdfMetp.plotOn(awmpframe,FillColor(fillcolorW),DrawOption("F"));
apdfMetp.plotOn(awmpframe,LineColor(linecolorW));
apdfMetp.plotOn(awmpframe,Components(RooArgSet(apdfEWKp,*(aqcdp.model))),FillColor(fillcolorEWK),DrawOption("F"));
apdfMetp.plotOn(awmpframe,Components(RooArgSet(apdfEWKp,*(aqcdp.model))),LineColor(linecolorEWK));
apdfMetp.plotOn(awmpframe,Components(RooArgSet(*(aqcdp.model))),FillColor(fillcolorQCD),DrawOption("F"));
apdfMetp.plotOn(awmpframe,Components(RooArgSet(*(aqcdp.model))),LineColor(linecolorQCD));
apdfMetp.plotOn(awmpframe,Components(RooArgSet(apdfWmp)),LineColor(linecolorW),LineStyle(2));
antiMetp.plotOn(awmpframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hAntiDataMetp->GetBinWidth(1));
CPlot plotAntiMetp("fitantimetp",awmpframe,"","",ylabel);
plotAntiMetp.SetLegend(0.68,0.57,0.93,0.77);
plotAntiMetp.GetLegend()->AddEntry(hDummyData,"data","PL");
plotAntiMetp.GetLegend()->AddEntry(hDummyW,"W^{+}#rightarrow#mu^{+}#nu","F");
plotAntiMetp.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotAntiMetp.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotAntiMetp.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotAntiMetp.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
// plotAntiMetp.SetYRange(0.1,1.1*(hAntiDataMetp->GetMaximum()));
plotAntiMetp.SetYRange(0.1,1500);
plotAntiMetp.Draw(c,kFALSE,format,1);
CPlot plotAntiMetpDiff("fitantimetp","","#slash{E}_{T} [GeV]","#chi");
plotAntiMetpDiff.AddHist1D(hAntiMetpDiff,"EX0",ratioColor);
plotAntiMetpDiff.SetYRange(-8,8);
plotAntiMetpDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotAntiMetpDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotAntiMetpDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotAntiMetpDiff.Draw(c,kTRUE,format,2);
plotAntiMetp.SetName("fitantimetplog");
plotAntiMetp.SetLogy();
plotAntiMetp.SetYRange(1e-3*(hAntiDataMetp->GetMaximum()),10*(hAntiDataMetp->GetMaximum()));
plotAntiMetp.Draw(c,kTRUE,format,1);
//
// W- MET plot
//
RooPlot *wmmframe = pfmet.frame(Bins(NBINS));
wmmframe->GetYaxis()->SetNdivisions(505);
dataMetm.plotOn(wmmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
pdfMetm.plotOn(wmmframe,FillColor(fillcolorW),DrawOption("F"));
pdfMetm.plotOn(wmmframe,LineColor(linecolorW));
pdfMetm.plotOn(wmmframe,Components(RooArgSet(pdfEWKm,*(qcdm.model))),FillColor(fillcolorEWK),DrawOption("F"));
pdfMetm.plotOn(wmmframe,Components(RooArgSet(pdfEWKm,*(qcdm.model))),LineColor(linecolorEWK));
pdfMetm.plotOn(wmmframe,Components(RooArgSet(*(qcdm.model))),FillColor(fillcolorQCD),DrawOption("F"));
pdfMetm.plotOn(wmmframe,Components(RooArgSet(*(qcdm.model))),LineColor(linecolorQCD));
pdfMetm.plotOn(wmmframe,Components(RooArgSet(pdfWmm)),LineColor(linecolorW),LineStyle(2));
dataMetm.plotOn(wmmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hDataMetm->GetBinWidth(1));
CPlot plotMetm("fitmetm",wmmframe,"","",ylabel);
plotMetm.SetLegend(0.68,0.57,0.93,0.77);
plotMetm.GetLegend()->AddEntry(hDummyData,"data","PL");
plotMetm.GetLegend()->AddEntry(hDummyW,"W^{-}#rightarrow#mu^{-}#bar{#nu}","F");
plotMetm.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotMetm.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotMetm.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotMetm.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
// plotMetm.SetYRange(0.1,1.1*(hDataMetm->GetMaximum()));
plotMetm.SetYRange(0.1,4100);
plotMetm.Draw(c,kFALSE,format,1);
CPlot plotMetmDiff("fitmetm","","#slash{E}_{T} [GeV]","#chi");
plotMetmDiff.AddHist1D(hMetmDiff,"EX0",ratioColor);
plotMetmDiff.SetYRange(-8,8);
plotMetmDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotMetmDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotMetmDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotMetmDiff.Draw(c,kTRUE,format,2);
plotMetm.SetName("fitmetmlog");
plotMetm.SetLogy();
plotMetm.SetYRange(1e-3*(hDataMetm->GetMaximum()),10*(hDataMetm->GetMaximum()));
plotMetm.Draw(c,kTRUE,format,1);
RooPlot *awmmframe = pfmet.frame(Bins(NBINS));
antiMetm.plotOn(awmmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
apdfMetm.plotOn(awmmframe,FillColor(fillcolorW),DrawOption("F"));
apdfMetm.plotOn(awmmframe,LineColor(linecolorW));
apdfMetm.plotOn(awmmframe,Components(RooArgSet(apdfEWKm,*(aqcdm.model))),FillColor(fillcolorEWK),DrawOption("F"));
apdfMetm.plotOn(awmmframe,Components(RooArgSet(apdfEWKm,*(aqcdm.model))),LineColor(linecolorEWK));
apdfMetm.plotOn(awmmframe,Components(RooArgSet(*(aqcdm.model))),FillColor(fillcolorQCD),DrawOption("F"));
apdfMetm.plotOn(awmmframe,Components(RooArgSet(*(aqcdm.model))),LineColor(linecolorQCD));
apdfMetm.plotOn(awmmframe,Components(RooArgSet(apdfWmm)),LineColor(linecolorW),LineStyle(2));
antiMetm.plotOn(awmmframe,MarkerStyle(kFullCircle),MarkerSize(0.9),DrawOption("ZP"));
sprintf(ylabel,"Events / %.1f GeV",hDataMetm->GetBinWidth(1));
CPlot plotAntiMetm("fitantimetm",awmmframe,"","",ylabel);
plotAntiMetm.SetLegend(0.68,0.57,0.93,0.77);
plotAntiMetm.GetLegend()->AddEntry(hDummyData,"data","PL");
plotAntiMetm.GetLegend()->AddEntry(hDummyW,"W^{-}#rightarrow#mu^{-}#bar{#nu}","F");
plotAntiMetm.GetLegend()->AddEntry(hDummyEWK,"EWK+t#bar{t}","F");
plotAntiMetm.GetLegend()->AddEntry(hDummyQCD,"QCD","F");
plotAntiMetm.AddTextBox(lumitext,0.55,0.80,0.90,0.86,0);
plotAntiMetm.AddTextBox("CMS Preliminary",0.63,0.92,0.95,0.99,0);
// plotAntiMetm.SetYRange(0.1,1.1*(hAntiDataMetm->GetMaximum()));
plotAntiMetm.SetYRange(0.1,1500);
plotAntiMetm.Draw(c,kFALSE,format,1);
CPlot plotAntiMetmDiff("fitantimetm","","#slash{E}_{T} [GeV]","#chi");
plotAntiMetmDiff.AddHist1D(hAntiMetmDiff,"EX0",ratioColor);
plotAntiMetmDiff.SetYRange(-8,8);
plotAntiMetmDiff.AddLine(0, 0,METMAX, 0,kBlack,1);
plotAntiMetmDiff.AddLine(0, 5,METMAX, 5,kBlack,3);
plotAntiMetmDiff.AddLine(0,-5,METMAX,-5,kBlack,3);
plotAntiMetmDiff.Draw(c,kTRUE,format,2);
plotAntiMetm.SetName("fitantimetmlog");
plotAntiMetm.SetLogy();
plotAntiMetm.SetYRange(1e-3*(hAntiDataMetm->GetMaximum()),10*(hAntiDataMetm->GetMaximum()));
plotAntiMetm.Draw(c,kTRUE,format,1);
//--------------------------------------------------------------------------------------------------------------
// Output
//==============================================================================================================
cout << "*" << endl;
cout << "* SUMMARY" << endl;
cout << "*--------------------------------------------------" << endl;
//
// Write fit results
//
ofstream txtfile;
char txtfname[100];
ios_base::fmtflags flags;
Double_t chi2prob, chi2ndf;
Double_t ksprob, ksprobpe;
chi2prob = hDataMet->Chi2Test(hPdfMet,"PUW");
chi2ndf = hDataMet->Chi2Test(hPdfMet,"CHI2/NDFUW");
ksprob = hDataMet->KolmogorovTest(hPdfMet);
ksprobpe = hDataMet->KolmogorovTest(hPdfMet,"DX");
sprintf(txtfname,"%s/fitresWm.txt",CPlot::sOutDir.Data());
txtfile.open(txtfname);
assert(txtfile.is_open());
flags = txtfile.flags();
txtfile << setprecision(10);
txtfile << " *** Yields *** " << endl;
txtfile << "Selected: " << hDataMet->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();
chi2prob = hDataMetp->Chi2Test(hPdfMetp,"PUW");
chi2ndf = hDataMetp->Chi2Test(hPdfMetp,"CHI2/NDFUW");
ksprob = hDataMetp->KolmogorovTest(hPdfMetp);
ksprobpe = hDataMetp->KolmogorovTest(hPdfMetp,"DX");
sprintf(txtfname,"%s/fitresWmp.txt",CPlot::sOutDir.Data());
txtfile.open(txtfname);
assert(txtfile.is_open());
flags = txtfile.flags();
txtfile << setprecision(10);
txtfile << " *** Yields *** " << endl;
txtfile << "Selected: " << hDataMetp->Integral() << endl;
txtfile << " Signal: " << nSigp.getVal() << " +/- " << nSigp.getPropagatedError(*fitResp) << endl;
txtfile << " QCD: " << nQCDp.getVal() << " +/- " << nQCDp.getPropagatedError(*fitResp) << endl;
txtfile << " Other: " << nEWKp.getVal() << " +/- " << nEWKp.getPropagatedError(*fitResp) << endl;
txtfile << endl;
txtfile.flags(flags);
fitResp->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose);
txtfile << endl;
printCorrelations(txtfile, fitResp);
txtfile << endl;
printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe);
txtfile.close();
chi2prob = hDataMetm->Chi2Test(hPdfMetm,"PUW");
chi2ndf = hDataMetm->Chi2Test(hPdfMetm,"CHI2/NDFUW");
ksprob = hDataMetm->KolmogorovTest(hPdfMetm);
ksprobpe = hDataMetm->KolmogorovTest(hPdfMetm,"DX");
sprintf(txtfname,"%s/fitresWmm.txt",CPlot::sOutDir.Data());
txtfile.open(txtfname);
assert(txtfile.is_open());
flags = txtfile.flags();
txtfile << setprecision(10);
txtfile << " *** Yields *** " << endl;
txtfile << "Selected: " << hDataMetm->Integral() << endl;
txtfile << " Signal: " << nSigm.getVal() << " +/- " << nSigm.getPropagatedError(*fitResm) << endl;
txtfile << " QCD: " << nQCDm.getVal() << " +/- " << nQCDm.getPropagatedError(*fitResm) << endl;
txtfile << " Other: " << nEWKm.getVal() << " +/- " << nEWKm.getPropagatedError(*fitResm) << endl;
txtfile << endl;
txtfile.flags(flags);
fitResm->printStream(txtfile,RooPrintable::kValue,RooPrintable::kVerbose);
txtfile << endl;
printCorrelations(txtfile, fitResm);
txtfile << endl;
printChi2AndKSResults(txtfile, chi2prob, chi2ndf, ksprob, ksprobpe);
txtfile.close();
makeHTML(outputDir);
cout << endl;
cout << " <> Output saved in " << outputDir << "/" << endl;
cout << endl;
gBenchmark->Show("fitWm");
}
void Purity_1d_fit(int type = 0){
TChain* tree = new TChain("TEvent");
if(!type) tree->Add("/home/vitaly/B0toDh0/TMVA/FIL_b2dh_gen_0-1_full.root");
else tree->Add("/home/vitaly/B0toDh0/TMVA/FIL_b2dh_data.root");
RooCategory b0f("b0f","b0f");
b0f.defineType("signal",1);
b0f.defineType("fsr",10);
b0f.defineType("bad_pi0",5);
b0f.defineType("rho",3);
b0f.defineType("comb",-1);
RooArgSet argset;
const double deMin = -0.15;
const double deMax = 0.3;
RooRealVar mbc("mbc","M_{bc}",mbc_min,mbc_max,"GeV"); argset.add(mbc);
RooRealVar de("de","#DeltaE",deMin,deMax,"GeV"); argset.add(de);
de.setRange("Signal",de_min,de_max);
RooRealVar md("md","md",DMass-md_cut,DMass+md_cut,"GeV"); argset.add(md);
RooRealVar mk("mk","mk",KMass-mk_cut,KMass+mk_cut,"GeV"); argset.add(mk);
RooRealVar mpi0("mpi0","mpi0",Pi0Mass-mpi0_cut,Pi0Mass+mpi0_cut,"GeV"); argset.add(mpi0);
RooRealVar bdtgs("bdtgs","bdtgs",bdtgs_cut,1.); argset.add(bdtgs);
RooRealVar atckpi_max("atckpi_max","atckpi_max",0.,atckpi_cut); argset.add(atckpi_max);
if(!type) argset.add(b0f);
RooDataSet ds("ds","ds",tree,argset,"mbc>0||mbc<=0");
// RooDataSet* ds0 = ds.reduce(RooArgSet(de));
stringstream out;
if(!type){
out.str("");
out << "de<" << de_max << " && de>" << de_min;
Roo1DTable* sigtable = ds.table(b0f,out.str().c_str());
sigtable->Print();
sigtable->Print("v");
Roo1DTable* fulltable = ds.table(b0f);
fulltable->Print();
fulltable->Print("v");
}
// RooDataHist* dh = ds0->binnedClone();
// ds0->Print();
////////////////
// Signal PDF //
////////////////
////////////
// de pdf //
////////////
RooRealVar de0("de0","de0",m_de0,-0.1,0.1); if(cSig) de0.setConstant(kTRUE);
RooRealVar s1("s1","s1",m_s1,0.,0.5); if(cSig) s1.setConstant(kTRUE);
RooGaussian g1("g1","g1",de,de0,s1);
RooRealVar deCBl("deCBl","deCBl",m_deCBl,-0.1,0.1); if(cSig) deCBl.setConstant(kTRUE);
RooRealVar sCBl("sCBl","sCBl",m_sCBl,0.,0.5); if(cSig) sCBl.setConstant(kTRUE);
RooRealVar nl("nl","nl",m_nl,0.,100.); if(cSig) nl.setConstant(kTRUE);
RooRealVar alphal("alphal","alphal",m_alphal,-10.,10.); if(cSig) alphal.setConstant(kTRUE);
RooRealVar deCBr("deCBr","deCBr",m_deCBr,-0.1,0.1); if(cSig) deCBr.setConstant(kTRUE);
RooRealVar sCBr("sCBr","sCBr",m_sCBr,0.,0.5); if(cSig) sCBr.setConstant(kTRUE);
RooRealVar nr("nr","nr",m_nr,0.,100.); if(cSig) nr.setConstant(kTRUE);
RooRealVar alphar("alphar","alphar",m_alphar,-10.,10.); if(cSig) alphar.setConstant(kTRUE);
RooCBShape CBl("CBl","CBl",de,deCBl,sCBl,alphal,nl);
RooCBShape CBr("CBr","CBr",de,deCBr,sCBr,alphar,nr);
RooRealVar fCBl("fCBl","fCBl",m_fCBl,0.,1.); if(cSig) fCBl.setConstant(kTRUE);
RooRealVar fCBr("fCBr","fCBr",m_fCBr,0.,1.); if(cSig) fCBr.setConstant(kTRUE);
RooAddPdf pdf_sig("pdf_sig","pdf_sig",RooArgList(CBl,CBr,g1),RooArgSet(fCBl,fCBr));
//////////////
// Comb PDF //
//////////////
////////////
// de pdf //
////////////
RooRealVar c1("c1","c1",mc_c1_1d,-10.,10.); if(cComb) c1.setConstant(kTRUE);
RooRealVar c2("c2","c2",mc_c2_1d,-10.,10.); if(cComb) c2.setConstant(kTRUE);
RooChebychev pdf_comb("pdf_comb","pdf_comb",de,RooArgSet(c1,c2));
/////////////
// Rho PDF //
/////////////
////////////
// de pdf //
////////////
if(de_rho_param == 0){
RooRealVar exppar("exppar","exppar",mr_exppar,-40.,-25.);// if(cRho) exppar.setConstant(kTRUE);
RooExponential pdf_rho("pdf_rho","pdf_rho",de,exppar);
}
RooRealVar de0r("de0r","de0r",mr_de0r,-0.2,0.12); if(cRho) de0r.setConstant(kTRUE);
if(de_rho_param == 1){
RooRealVar slopel("slopel","slopel",mr_slopel,-1000,-500.); if(cRho) slopel.setConstant(kTRUE);
RooRealVar sloper("sloper","sloper",mr_sloper,-10000,0.); if(cRho) sloper.setConstant(kTRUE);
RooRealVar steep("steep","steep",mr_steep,7.,9.); if(cRho) steep.setConstant(kTRUE);
RooRealVar p5("p5","p5",mr_p5,0.01,1000.); if(cRho) p5.setConstant(kTRUE);
RooRhoDeltaEPdf pdf_rho("pdf_rho","pdf_rho",de,de0r,slopel,sloper,steep,p5);
}
if(de_rho_param == -1){
RooRealVar x0("x0","x0",mr_x0_1d,-0.2,0.12); if(cRho) x0.setConstant(kTRUE);
RooRealVar p1("p1","p1",mr_p1_1d,-1000.,100.); if(cRho) p1.setConstant(kTRUE);
RooRealVar p2("p2","p2",mr_p2_1d,0.,100.); if(cRho) p2.setConstant(kTRUE);
RooGenericPdf pdf_rho("pdf_rho","1+@0*@1-@2*TMath::Log(1+TMath::Exp(@2*(@0-@1)/@3))",RooArgSet(de,x0,p1,p2));
}
//////////////////
// Complete PDF //
//////////////////
RooRealVar Nsig("Nsig","Nsig",700,100.,1500.);// fsig.setConstant(kTRUE);
RooRealVar Nrho("Nrho","Nrho",400,100,1500.);// frho.setConstant(kTRUE);
RooRealVar Ncmb("Ncmb","Ncmb",1000,100,100000);// frho.setConstant(kTRUE);
RooAddPdf pdf("pdf","pdf",RooArgList(pdf_sig,pdf_rho,pdf_comb),RooArgList(Nsig,Nrho,Ncmb));
pdf.fitTo(ds,Verbose(),Timer(true));
RooAbsReal* intSig = pdf_sig.createIntegral(RooArgSet(de),NormSet(RooArgSet(de)),Range("Signal"));
RooAbsReal* intRho = pdf_rho.createIntegral(RooArgSet(de),NormSet(RooArgSet(de)),Range("Signal"));
RooAbsReal* intCmb = pdf_comb.createIntegral(RooArgSet(de),NormSet(RooArgSet(de)),Range("Signal"));
const double nsig = intSig->getVal()*Nsig.getVal();
const double nsig_err = intSig->getVal()*Nsig.getError();
const double nsig_err_npq = TMath::Sqrt(nsig*(Nsig.getVal()-nsig)/Nsig.getVal());
const double nsig_err_total = TMath::Sqrt(nsig_err*nsig_err+nsig_err_npq*nsig_err_npq);
const double nrho = intRho->getVal()*Nrho.getVal();
const double nrho_err = intRho->getVal()*Nrho.getError();
const double nrho_err_npq = TMath::Sqrt(nrho*(Nrho.getVal()-nrho)/Nrho.getVal());
const double nrho_err_total = TMath::Sqrt(nrho_err*nrho_err+nrho_err_npq*nrho_err_npq);
const double ncmb = intCmb->getVal()*Ncmb.getVal();
const double ncmb_err = intCmb->getVal()*Ncmb.getError();
const double ncmb_err_npq = TMath::Sqrt(ncmb*(Ncmb.getVal()-ncmb)/Ncmb.getVal());
const double ncmb_err_total = TMath::Sqrt(ncmb_err*ncmb_err+ncmb_err_npq*ncmb_err_npq);
const double purity = nsig/(nsig+nrho+ncmb);
const double purity_err = nsig_err_total/(nsig+nrho+ncmb);
cout << "Nsig = " << nsig <<" +- " << nsig_err << endl;
cout << "Nrho = " << nrho <<" +- " << nrho_err << endl;
cout << "Ncmb = " << ncmb <<" +- " << ncmb_err << endl;
/////////////
// Plots //
/////////////
// de //
RooPlot* deFrame = de.frame();
ds.plotOn(deFrame,DataError(RooAbsData::SumW2),MarkerSize(1));
pdf.plotOn(deFrame,Components(pdf_sig),LineStyle(kDashed));
pdf.plotOn(deFrame,Components(pdf_rho),LineStyle(kDashed));
pdf.plotOn(deFrame,Components(pdf_comb),LineStyle(kDashed));
pdf.plotOn(deFrame,LineWidth(2));
RooHist* hdepull = deFrame->pullHist();
RooPlot* dePull = de.frame(Title("#Delta E pull distribution"));
dePull->addPlotable(hdepull,"P");
dePull->GetYaxis()->SetRangeUser(-5,5);
TCanvas* cm = new TCanvas("Delta E","Delta E",600,700);
cm->cd();
TPad *pad3 = new TPad("pad3","pad3",0.01,0.20,0.99,0.99);
TPad *pad4 = new TPad("pad4","pad4",0.01,0.01,0.99,0.20);
pad3->Draw();
pad4->Draw();
pad3->cd();
pad3->SetLeftMargin(0.15);
pad3->SetFillColor(0);
deFrame->GetXaxis()->SetTitleSize(0.05);
deFrame->GetXaxis()->SetTitleOffset(0.85);
deFrame->GetXaxis()->SetLabelSize(0.04);
deFrame->GetYaxis()->SetTitleOffset(1.6);
deFrame->Draw();
stringstream out1;
TPaveText *pt = new TPaveText(0.6,0.75,0.98,0.9,"brNDC");
pt->SetFillColor(0);
pt->SetTextAlign(12);
out1.str("");
out1 << "#chi^{2}/n.d.f = " << deFrame->chiSquare();
pt->AddText(out1.str().c_str());
out1.str("");
out1 << "S: " << (int)(nsig+0.5) << " #pm " << (int)(nsig_err_total+0.5);
pt->AddText(out1.str().c_str());
out1.str("");
out1 << "Purity: " << std::fixed << std::setprecision(2) << purity*100. << " #pm " << purity_err*100;
pt->AddText(out1.str().c_str());
pt->Draw();
TLine *de_line_RIGHT = new TLine(de_max,0,de_max,50);
de_line_RIGHT->SetLineColor(kRed);
de_line_RIGHT->SetLineStyle(1);
de_line_RIGHT->SetLineWidth((Width_t)2.);
de_line_RIGHT->Draw();
TLine *de_line_LEFT = new TLine(de_min,0,de_min,50);
de_line_LEFT->SetLineColor(kRed);
de_line_LEFT->SetLineStyle(1);
de_line_LEFT->SetLineWidth((Width_t)2.);
de_line_LEFT->Draw();
pad4->cd(); pad4->SetLeftMargin(0.15); pad4->SetFillColor(0);
dePull->SetMarkerSize(0.05); dePull->Draw();
TLine *de_lineUP = new TLine(deMin,3,deMax,3);
de_lineUP->SetLineColor(kBlue);
de_lineUP->SetLineStyle(2);
de_lineUP->Draw();
TLine *de_line = new TLine(deMin,0,deMax,0);
de_line->SetLineColor(kBlue);
de_line->SetLineStyle(1);
de_line->SetLineWidth((Width_t)2.);
de_line->Draw();
TLine *de_lineDOWN = new TLine(deMin,-3,deMax,-3);
de_lineDOWN->SetLineColor(kBlue);
de_lineDOWN->SetLineStyle(2);
de_lineDOWN->Draw();
cm->Update();
if(!type){
out.str("");
out << "de<" << de_max << " && de>" << de_min;
Roo1DTable* sigtable = ds.table(b0f,out.str().c_str());
sigtable->Print();
sigtable->Print("v");
Roo1DTable* fulltable = ds.table(b0f);
fulltable->Print();
fulltable->Print("v");
}
cout << "Nsig = " << nsig <<" +- " << nsig_err << " +- " << nsig_err_npq << " (" << nsig_err_total << ")" << endl;
cout << "Nrho = " << nrho <<" +- " << nrho_err << " +- " << nrho_err_npq << " (" << nrho_err_total << ")" << endl;
cout << "Ncmb = " << ncmb <<" +- " << ncmb_err << " +- " << ncmb_err_npq << " (" << ncmb_err_total << ")" << endl;
cout << "Pury = " << purity << " +- " << purity_err << endl;
}
void rf103_interprfuncs()
{
/////////////////////////////////////////////////////////
// G e n e r i c i n t e r p r e t e d p . d . f . //
/////////////////////////////////////////////////////////
// Declare observable x
RooRealVar x("x","x",-20,20) ;
// C o n s t r u c t g e n e r i c p d f f r o m i n t e r p r e t e d e x p r e s s i o n
// -------------------------------------------------------------------------------------------------
// To construct a proper p.d.f, the formula expression is explicitly normalized internally by dividing
// it by a numeric integral of the expresssion over x in the range [-20,20]
//
RooRealVar alpha("alpha","alpha",5,0.1,10) ;
RooGenericPdf genpdf("genpdf","genpdf","(1+0.1*abs(x)+sin(sqrt(abs(x*alpha+0.1))))",RooArgSet(x,alpha)) ;
// S a m p l e , f i t a n d p l o t g e n e r i c p d f
// ---------------------------------------------------------------
// Generate a toy dataset from the interpreted p.d.f
RooDataSet* data = genpdf.generate(x,10000) ;
// Fit the interpreted p.d.f to the generated data
genpdf.fitTo(*data) ;
// Make a plot of the data and the p.d.f overlaid
RooPlot* xframe = x.frame(Title("Interpreted expression pdf")) ;
data->plotOn(xframe) ;
genpdf.plotOn(xframe) ;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// S t a n d a r d p . d . f a d j u s t w i t h i n t e r p r e t e d h e l p e r f u n c t i o n //
// //
// Make a gauss(x,sqrt(mean2),sigma) from a standard RooGaussian //
// //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// C o n s t r u c t s t a n d a r d p d f w i t h f o r m u l a r e p l a c i n g p a r a m e t e r
// ------------------------------------------------------------------------------------------------------------
// Construct parameter mean2 and sigma
RooRealVar mean2("mean2","mean^2",10,0,200) ;
RooRealVar sigma("sigma","sigma",3,0.1,10) ;
// Construct interpreted function mean = sqrt(mean^2)
RooFormulaVar mean("mean","mean","sqrt(mean2)",mean2) ;
// Construct a gaussian g2(x,sqrt(mean2),sigma) ;
RooGaussian g2("g2","h2",x,mean,sigma) ;
// G e n e r a t e t o y d a t a
// ---------------------------------
// Construct a separate gaussian g1(x,10,3) to generate a toy Gaussian dataset with mean 10 and width 3
RooGaussian g1("g1","g1",x,RooConst(10),RooConst(3)) ;
RooDataSet* data2 = g1.generate(x,1000) ;
// F i t a n d p l o t t a i l o r e d s t a n d a r d p d f
// -------------------------------------------------------------------
// Fit g2 to data from g1
RooFitResult* r = g2.fitTo(*data2,Save()) ;
r->Print() ;
// Plot data on frame and overlay projection of g2
RooPlot* xframe2 = x.frame(Title("Tailored Gaussian pdf")) ;
data2->plotOn(xframe2) ;
g2.plotOn(xframe2) ;
// Draw all frames on a canvas
TCanvas* c = new TCanvas("rf103_interprfuncs","rf103_interprfuncs",800,400) ;
c->Divide(2) ;
c->cd(1) ; gPad->SetLeftMargin(0.15) ; xframe->GetYaxis()->SetTitleOffset(1.4) ; xframe->Draw() ;
c->cd(2) ; gPad->SetLeftMargin(0.15) ; xframe2->GetYaxis()->SetTitleOffset(1.4) ; xframe2->Draw() ;
}
void rf316_llratioplot()
{
// C r e a t e 3 D p d f a n d d a t a
// -------------------------------------------
// Create observables
RooRealVar x("x","x",-5,5) ;
RooRealVar y("y","y",-5,5) ;
RooRealVar z("z","z",-5,5) ;
// Create signal pdf gauss(x)*gauss(y)*gauss(z)
RooGaussian gx("gx","gx",x,RooConst(0),RooConst(1)) ;
RooGaussian gy("gy","gy",y,RooConst(0),RooConst(1)) ;
RooGaussian gz("gz","gz",z,RooConst(0),RooConst(1)) ;
RooProdPdf sig("sig","sig",RooArgSet(gx,gy,gz)) ;
// Create background pdf poly(x)*poly(y)*poly(z)
RooPolynomial px("px","px",x,RooArgSet(RooConst(-0.1),RooConst(0.004))) ;
RooPolynomial py("py","py",y,RooArgSet(RooConst(0.1),RooConst(-0.004))) ;
RooPolynomial pz("pz","pz",z) ;
RooProdPdf bkg("bkg","bkg",RooArgSet(px,py,pz)) ;
// Create composite pdf sig+bkg
RooRealVar fsig("fsig","signal fraction",0.1,0.,1.) ;
RooAddPdf model("model","model",RooArgList(sig,bkg),fsig) ;
RooDataSet* data = model.generate(RooArgSet(x,y,z),20000) ;
// P r o j e c t p d f a n d d a t a o n x
// -------------------------------------------------
// Make plain projection of data and pdf on x observable
RooPlot* frame = x.frame(Title("Projection of 3D data and pdf on X"),Bins(40)) ;
data->plotOn(frame) ;
model.plotOn(frame) ;
// D e f i n e p r o j e c t e d s i g n a l l i k e l i h o o d r a t i o
// ----------------------------------------------------------------------------------
// Calculate projection of signal and total likelihood on (y,z) observables
// i.e. integrate signal and composite model over x
RooAbsPdf* sigyz = sig.createProjection(x) ;
RooAbsPdf* totyz = model.createProjection(x) ;
// Construct the log of the signal / signal+background probability
RooFormulaVar llratio_func("llratio","log10(@0)-log10(@1)",RooArgList(*sigyz,*totyz)) ;
// P l o t d a t a w i t h a L L r a t i o c u t
// -------------------------------------------------------
// Calculate the llratio value for each event in the dataset
data->addColumn(llratio_func) ;
// Extract the subset of data with large signal likelihood
RooDataSet* dataSel = (RooDataSet*) data->reduce(Cut("llratio>0.7")) ;
// Make plot frame
RooPlot* frame2 = x.frame(Title("Same projection on X with LLratio(y,z)>0.7"),Bins(40)) ;
// Plot select data on frame
dataSel->plotOn(frame2) ;
// M a k e M C p r o j e c t i o n o f p d f w i t h s a m e L L r a t i o c u t
// ---------------------------------------------------------------------------------------------
// Generate large number of events for MC integration of pdf projection
RooDataSet* mcprojData = model.generate(RooArgSet(x,y,z),10000) ;
// Calculate LL ratio for each generated event and select MC events with llratio)0.7
mcprojData->addColumn(llratio_func) ;
RooDataSet* mcprojDataSel = (RooDataSet*) mcprojData->reduce(Cut("llratio>0.7")) ;
// Project model on x, integrating projected observables (y,z) with Monte Carlo technique
// on set of events with the same llratio cut as was applied to data
model.plotOn(frame2,ProjWData(*mcprojDataSel)) ;
TCanvas* c = new TCanvas("rf316_llratioplot","rf316_llratioplot",800,400) ;
c->Divide(2) ;
c->cd(1) ;
gPad->SetLeftMargin(0.15) ;
frame->GetYaxis()->SetTitleOffset(1.4) ;
frame->Draw() ;
c->cd(2) ;
gPad->SetLeftMargin(0.15) ;
frame2->GetYaxis()->SetTitleOffset(1.4) ;
frame2->Draw() ;
}
void RooKeysEx()
{
cout << "--------------------------"<< endl;
cout << "Start the RooKeys Example "<< endl;
cout << "--------------------------"<< endl;
// This is the variable that we will use ex: it could be the invariant mass Lb- >pK gamma
RooRealVar x("K#pi#mu#mu","K#pi#mu#mu",1800,1940, "MeV/c2") ;
// This is some constant number that we use to generate the toy data
RooPolynomial p("p","p",x,RooArgList(RooConst(0.01),RooConst(-0.01),RooConst(0.0004))) ;
// These are some PDF that we use to generate the toy day
RooExponential exp("exp", "exp", x, RooConst(-0.01));
RooGaussian signal("signal", "signal", x, RooConst(1866), RooConst(8));
RooGaussian G1("G1", "G1",x,RooConst(1850),RooConst(10) );
RooGaussian G2("G2", "G2",x,RooConst(1840),RooConst(15) );
RooAddPdf SumG1andG2("SumG1andG2", "SumG1andG2",RooArgList(G1,G2), RooArgList(RooConst(0.6) ) );
//RooAddPdf TotalPDF ("TotalPDF", "TotalPDF", RooArgList(signal, SumG1andG2),RooArgList(RooConst(0.6)));
RooAddPdf TotalPDF("TotalPDF", "TotalPDF", RooArgList(signal, SumG1andG2, exp),RooArgList(RooConst(0.4), RooConst(0.2) ));
// Prepare the today data
//RooDataSet* data1 = p.generate(x,10000) ;
//RooDataSet* data1 = G.generate(x,5000) ;
//RooDataSet* data1 = SumG1andG2.generate(x,500) ;
// Here we generate some events in the x variable using the PDFs that we defined before
RooDataSet* data1= SumG1andG2.generate(x,1000);
RooDataSet* data2 = TotalPDF.generate(x,10000) ; // generate signal and background
cout << "--------------------------"<< endl;
cout << " Done generating the data " << endl;
cout << "--------------------------"<< endl;
// is mirrored over the boundaries to minimize edge effects in distribution
// that do not fall to zero towards the edges
RooKeysPdf kest1("kest1","kest1",x,*data1,RooKeysPdf::MirrorBoth) ;
// An adaptive kernel estimation pdf on the same data without mirroring option
// for comparison
RooKeysPdf kest2("kest2","kest2",x,*data1,RooKeysPdf::NoMirror) ;
// Adaptive kernel estimation pdf with increased bandwidth scale factor
// (promotes smoothness over detail preservation)
RooKeysPdf kest3("kest3","kest3",x,*data1,RooKeysPdf::MirrorBoth,2) ;
//===========================================================================
// Here are the PDF and variable that we will use in the fit :
//===========================================================================
RooRealVar signal_mean("signal_mean","signal_mean", 1850, 1840, 1900);
RooRealVar signal_width("signal_width", "signal_width", 10, 0, 20);
//----
RooRealVar comb_slope ("comb_slope", "comb_slope", 0, -1., 1);
//----
RooRealVar Nsig("Nsig", "Nsig", 100, 0, 10000);
RooRealVar Nbkg_comb("Nbkg_comb", "Nbkg_comb", 100, 0, 10000);
RooRealVar Nbkg_misID("Nbkg_misID", "Nbkg_misID", 100, 0, 10000);
//----
RooGaussian signal_fitted ("signal_fitted", "signal_fitted", x, signal_mean, signal_width);
// RooKeysPdf background_fitted ("background_fitted", "background_fitted", x, *data1, RooKeysPdf::MirrorBoth );
//----
RooExponential comb_PDF ("comb_PDF", "comb_PDF", x, comb_slope);
//---
//RooAddPdf TotalPDF_fitted ("TotalPDF_fitted", "TotalPDF_fitted", RooArgList(signal_fitted, background_fitted), RooArgList(Nsig,Nbkg));
RooAddPdf TotalPDF_fitted ("TotalPDF_fitted", "TotalPDF_fitted", RooArgList(signal_fitted, kest1, comb_PDF ), RooArgList(Nsig,Nbkg_misID, Nbkg_comb));
TotalPDF_fitted -> fitTo(*data2);
cout << "----------------------------"<< endl;
cout << " Done doing the fit to data " << endl;
cout << "----------------------------"<< endl;
// Here we are going to plot stuff
RooPlot* frame0 = x.frame(Title("Adaptive kernel estimation pdf with and w/o mirroring"),Bins(20)) ;
// G1.plotOn(frame0, LineColor(1)) ;
//G2.plotOn(frame0, LineColor(2)) ;
SumG1andG2.plotOn(frame0) ;
// Plot kernel estimation pdfs with and without mirroring over data
RooPlot* frame = x.frame(Title("Adaptive kernel estimation pdf with and w/o mirroring"),Bins(20)) ;
data1->plotOn(frame) ;
kest1.plotOn(frame, LineColor(875)) ;
//kest2.plotOn(frame, LineColor(429)) ;
//kest3.plotOn(frame, LineColor(625)) ;
// Plot kernel estimation pdfs with regular and increased bandwidth
RooPlot* frame2 = x.frame(Title("Adaptive kernel estimation pdf with regular, increased bandwidth")) ;
kest1.plotOn(frame2, LineColor(875)) ;
kest3.plotOn(frame2, LineColor(807)) ;
RooPlot* frame3 = x.frame(Title(""));
data2->plotOn(frame3);
TotalPDF_fitted.plotOn(frame3, Components(kest1), LineColor(875));
TotalPDF_fitted.plotOn(frame3, Components(signal_fitted), LineColor(429));
TotalPDF_fitted.plotOn(frame3, Components(comb_PDF), LineColor(801));
TotalPDF_fitted.plotOn(frame3);
TCanvas* c = new TCanvas("c","c",600,600) ;
c->Divide(2,2) ;
c->cd(1) ;
frame0->GetYaxis()->SetTitleOffset(1.4) ; frame0->Draw() ;
c->cd(2) ;
frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
c->cd(3) ;
frame2->GetYaxis()->SetTitleOffset(1.8) ; frame2->Draw() ;
c->cd(4) ;
frame3->GetYaxis()->SetTitleOffset(1.8) ; frame3->Draw() ;
c->SaveAs("Keys.pdf");
TCanvas * c1 = new TCanvas("c1","c1", 400,400);
//c1->cd();
frame3->GetYaxis()->SetTitleOffset(1.8) ; frame3->Draw() ;
frame3->SetTitle("");
c1->SaveAs("KeysResult.pdf");
cout<< "Fin"<< endl;
}
void plotPdf_7D_XWW(double mH = 125, bool draw=true) {
gROOT->ProcessLine(".L tdrstyle.C");
setTDRStyle();
TGaxis::SetMaxDigits(3);
gROOT->ForceStyle();
// Declaration of the PDFs to use
gROOT->ProcessLine(".L PDFs/RooSpinTwo_7D.cxx+");
// W/Z mass and decay width constants
double mV = 80.399;
double gamV = 2.085;
bool offshell = false;
if ( mH < 2 * mV ) offshell = true;
// for the pole mass and decay width of W
RooRealVar* mX = new RooRealVar("mX","mX", mH);
RooRealVar* mW = new RooRealVar("mW","mW", mV);
RooRealVar* gamW = new RooRealVar("gamW","gamW",gamV);
//
// Observables (7D)
//
RooRealVar* wplusmass = new RooRealVar("wplusmass","m(W+)",mV,1e-09,120);
wplusmass->setBins(50);
RooRealVar* wminusmass = new RooRealVar("wminusmass","m(W-)",mV,1e-09,120);
wminusmass->setBins(50);
RooRealVar* hs = new RooRealVar("costhetastar","cos#theta*",-1,1);
hs->setBins(20);
RooRealVar* Phi1 = new RooRealVar("phistar1","#Phi_{1}",-TMath::Pi(),TMath::Pi());
Phi1->setBins(20);
RooRealVar* h1 = new RooRealVar("costheta1","cos#theta_{1}",-1,1);
h1->setBins(20);
RooRealVar* h2 = new RooRealVar("costheta2","cos#theta_{2}",-1,1);
h2->setBins(20);
RooRealVar* Phi = new RooRealVar("phi","#Phi",-TMath::Pi(),TMath::Pi());
Phi->setBins(20);
//
// coupling constants for 2m+
// See equation 5,6,7 in PRD 91, 075022
//
double s = (mH*mH-2*mV*mV)/2.;
double c1 = 2*(1+mV*mV/s);
c1 = c1 * 2.0; // scale up to be consistent with the generator
// std::cout << "c1 = " << c1 << "\n";
RooRealVar* c1Val = new RooRealVar("c1Val", "c1Val", c1);
RooRealVar* c2Val = new RooRealVar("c2Val", "c2Val", -0.5);
RooRealVar* c3Val = new RooRealVar("c3Val", "c3Val", 0.);
RooRealVar* c4Val = new RooRealVar("c4Val", "c4Val", -1.);
RooRealVar* c5Val = new RooRealVar("c5Val", "c5Val", 0.);
RooRealVar* c6Val = new RooRealVar("c6Val", "c6Val", 0.);
RooRealVar* c7Val = new RooRealVar("c7Val", "c7Val", 0.);
//
// Alternative definition in terms of g1->g10
//
RooRealVar* useGTerm = new RooRealVar("useGTerm", "useGTerm",1.); // set to 1 if using g couplings
RooRealVar* g1Val = new RooRealVar("g1Val", "g1Val", 1);
RooRealVar* g2Val = new RooRealVar("g2Val", "g2Val", 0.);
RooRealVar* g3Val = new RooRealVar("g3Val", "g3Val", 0.);
RooRealVar* g4Val = new RooRealVar("g4Val", "g4Val", 0.);
RooRealVar* g5Val = new RooRealVar("g5Val", "g5Val", 1.);
RooRealVar* g6Val = new RooRealVar("g6Val", "g6Val", 0.);
RooRealVar* g7Val = new RooRealVar("g7Val", "g7Val", 0.);
RooRealVar* g8Val = new RooRealVar("g8Val", "g8Val", 0.);
RooRealVar* g9Val = new RooRealVar("g9Val", "g9Val", 0.);
RooRealVar* g10Val = new RooRealVar("g10Val", "g10Val", 0.);
// related to the gg/qq productions
RooRealVar* fz1Val = new RooRealVar("fz1Val", "fz1Val", 0);
RooRealVar* fz2Val = new RooRealVar("fz2Val", "fz2Val", 1.0);
// Even more parameters, do not have to touch, based on Z couplings
RooRealVar* R1Val = new RooRealVar("R1Val","R1Val",1);
RooRealVar* R2Val = new RooRealVar("R2Val","R2Val",1);
// PDF definition SM Higgs (JP = 2+)
RooSpinTwo_7D *myPDF;
if ( offshell )
myPDF = new RooSpinTwo_7D("myPDF","myPDF", *mX, *wplusmass, *wminusmass, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1Val, *g2Val, *g3Val, *g4Val, *g5Val, *g6Val, *g7Val, *g8Val, *g9Val, *g10Val,
*fz1Val, *fz2Val, *R1Val, *R2Val, *mW, *gamW);
else
myPDF = new RooSpinTwo_7D("myPDF","myPDF", *mX, *mW, *mW, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1Val, *g2Val, *g3Val, *g4Val, *g5Val, *g6Val, *g7Val, *g8Val, *g9Val, *g10Val,
*fz1Val, *fz2Val, *R1Val, *R2Val, *mW, *gamW);
// dataset for (JP = 2+)
TString fileName;
if ( useGTerm->getVal() > 0.) {
fileName = Form("TWW_2mplus_%.0f_JHU.root", mH);
}
else {
fileName = Form("TWW_%.0f_JHU_GenFromC.root", mH);
}
std::cout << "Opening " << fileName << "\n";
TFile* fin = new TFile(fileName);
TTree* tin = (TTree*) fin->Get("angles");
if ( offshell)
RooDataSet data("data","data",tin,RooArgSet(*wplusmass, *wminusmass, *hs, *h1, *h2, *Phi, *Phi1));
else
RooDataSet data("data","data",tin,RooArgSet(*hs, *h1, *h2, *Phi, *Phi1));
//
// 2h-
//
RooRealVar* g1ValMinus = new RooRealVar("g1ValMinus", "g1ValMinus", 0);
RooRealVar* g2ValMinus = new RooRealVar("g2ValMinus", "g2ValMinus", 0.);
RooRealVar* g3ValMinus = new RooRealVar("g3ValMinus", "g3ValMinus", 0.);
RooRealVar* g4ValMinus = new RooRealVar("g4ValMinus", "g4ValMinus", 0.);
RooRealVar* g5ValMinus = new RooRealVar("g5ValMinus", "g5ValMinus", 0.);
RooRealVar* g6ValMinus = new RooRealVar("g6ValMinus", "g6ValMinus", 0.);
RooRealVar* g7ValMinus = new RooRealVar("g7ValMinus", "g7ValMinus", 0.);
RooRealVar* g8ValMinus = new RooRealVar("g8ValMinus", "g8ValMinus", 1.);
RooRealVar* g9ValMinus = new RooRealVar("g9ValMinus", "g9ValMinus", 0.);
RooRealVar* g10ValMinus = new RooRealVar("g10ValMinus", "g10ValMinus", 0.);
RooRealVar* fz1ValMinus = new RooRealVar("fz1ValMinus", "fz1ValMinus", 0.0);
RooRealVar* fz2ValMinus = new RooRealVar("fz2ValMinus", "fz2ValMinus", 0.0);
RooSpinTwo_7D *myPDFMinus;
if ( offshell )
myPDFMinus = new RooSpinTwo_7D("myPDFMinus","myPDFMinus", *mX, *wplusmass, *wminusmass, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1ValMinus, *g2ValMinus, *g3ValMinus, *g4ValMinus,
*g5ValMinus, *g6ValMinus, *g7ValMinus, *g8ValMinus, *g9ValMinus, *g10ValMinus,
*fz1ValMinus, *fz2ValMinus, *R1Val, *R2Val, *mW, *gamW);
else
myPDFMinus = new RooSpinTwo_7D("myPDFMinus","myPDFMinus", *mX, *mW, *mW, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1ValMinus, *g2ValMinus, *g3ValMinus, *g4ValMinus,
*g5ValMinus, *g6ValMinus, *g7ValMinus, *g8ValMinus, *g9ValMinus, *g10ValMinus,
*fz1ValMinus, *fz2ValMinus, *R1Val, *R2Val, *mW, *gamW);
// dataset for (JP = 2-)
TString fileNameMinus;
if ( useGTerm->getVal() > 0.) {
fileNameMinus = Form("TWW_2hminus_%.0f_JHU.root", mH);
}
std::cout << "Opening " << fileNameMinus << "\n";
TFile* finMinus = new TFile(fileNameMinus);
TTree* tinMinus = (TTree*) finMinus->Get("angles");
if ( offshell)
RooDataSet dataMinus("dataMinus","dataMinus",tinMinus,RooArgSet(*wplusmass, *wminusmass, *hs, *h1, *h2, *Phi, *Phi1));
else
RooDataSet dataMinus("dataMinus","dataMinus",tinMinus,RooArgSet(*hs, *h1, *h2, *Phi, *Phi1));
//
// 2h+
//
RooRealVar* g1ValHPlus = new RooRealVar("g1ValHPlus", "g1ValHPlus", 0);
RooRealVar* g2ValHPlus = new RooRealVar("g2ValHPlus", "g2ValHPlus", 0.);
RooRealVar* g3ValHPlus = new RooRealVar("g3ValHPlus", "g3ValHPlus", 0.);
RooRealVar* g4ValHPlus = new RooRealVar("g4ValHPlus", "g4ValHPlus", 1.);
RooRealVar* g5ValHPlus = new RooRealVar("g5ValHPlus", "g5ValHPlus", 0.);
RooRealVar* g6ValHPlus = new RooRealVar("g6ValHPlus", "g6ValHPlus", 0.);
RooRealVar* g7ValHPlus = new RooRealVar("g7ValHPlus", "g7ValHPlus", 0.);
RooRealVar* g8ValHPlus = new RooRealVar("g8ValHPlus", "g8ValHPlus", 0.);
RooRealVar* g9ValHPlus = new RooRealVar("g9ValHPlus", "g9ValHPlus", 0.);
RooRealVar* g10ValHPlus = new RooRealVar("g10ValHPlus", "g10ValHPlus", 0.);
RooRealVar* fz1ValHPlus = new RooRealVar("fz1ValHPlus", "fz1ValHPlus", 0.0);
RooRealVar* fz2ValHPlus = new RooRealVar("fz2ValHPlus", "fz2ValHPlus", 0.0);
RooSpinTwo_7D *myPDFHPlus;
if ( offshell )
myPDFHPlus = new RooSpinTwo_7D("myPDFHPlus","myPDFHPlus", *mX, *wplusmass, *wminusmass, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1ValHPlus, *g2ValHPlus, *g3ValHPlus, *g4ValHPlus,
*g5ValHPlus, *g6ValHPlus, *g7ValHPlus, *g8ValHPlus, *g9ValHPlus, *g10ValHPlus,
*fz1ValHPlus, *fz2ValHPlus, *R1Val, *R2Val, *mW, *gamW);
else
myPDFHPlus = new RooSpinTwo_7D("myPDFHPlus","myPDFHPlus", *mX, *mW, *mW, *hs, *h1,*h2, *Phi, *Phi1,
*c1Val, *c2Val, *c3Val, *c4Val, *c5Val, *c6Val, *c7Val,
*useGTerm, *g1ValHPlus, *g2ValHPlus, *g3ValHPlus, *g4ValHPlus,
*g5ValHPlus, *g6ValHPlus, *g7ValHPlus, *g8ValHPlus, *g9ValHPlus, *g10ValHPlus,
*fz1ValHPlus, *fz2ValHPlus, *R1Val, *R2Val, *mW, *gamW);
TString fileNameHPlus;
if ( useGTerm->getVal() > 0.) {
fileNameHPlus = Form("TWW_2hplus_%.0f_JHU.root", mH);
}
std::cout << "Opening " << fileNameHPlus << "\n";
TFile* finHPlus = new TFile(fileNameHPlus);
TTree* tinHPlus = (TTree*) finHPlus->Get("angles");
if ( offshell)
RooDataSet dataHPlus("dataHPlus","dataHPlus",tinHPlus,RooArgSet(*wplusmass, *wminusmass, *hs, *h1, *h2, *Phi, *Phi1));
else
RooDataSet dataHPlus("dataHPlus","dataHPlus",tinHPlus,RooArgSet(*hs, *h1, *h2, *Phi, *Phi1));
// P L O T . . .
// (All parameters fixed, no fitting, just looking at the shape of the PDFs w.r.t. the data)
if ( draw ) {
bool drawmplus = true;
bool drawhminus = true;
bool drawhplus = true;
bool drawpaper = true;
double rescale = 1.0;
if ( drawpaper )
rescale = .001;
TH1F* dum0 = new TH1F("dum0","dum0",1,0,1); dum0->SetLineColor(kRed); dum0->SetMarkerColor(kBlack); dum0->SetLineWidth(3);
TH1F* dum1 = new TH1F("dum1","dum1",1,0,1); dum1->SetLineColor(kBlue); dum1->SetMarkerColor(kBlack); dum1->SetMarkerStyle(24), dum1->SetLineWidth(3);
TH1F* dum2 = new TH1F("dum2","dum2",1,0,1); dum2->SetLineColor(kGreen); dum2->SetMarkerColor(kBlack); dum2->SetMarkerStyle(21), dum2->SetLineWidth(3); // 2L+
TLegend * box3 = new TLegend(0.1,0.1,0.9,0.92);
box3->SetFillColor(0);
box3->SetBorderSize(0);
if ( drawmplus )
box3->AddEntry(dum0,Form("X(%.0f)#rightarrow WW JP = 2m+", mH),"lp");
if ( drawhminus )
box3->AddEntry(dum1,Form("X(%.0f)#rightarrow WW JP = 2h-", mH),"lp");
if ( drawhplus )
box3->AddEntry(dum2,Form("X(%.0f)#rightarrow WW JP = 2h+,", mH),"lp");
//
// h1
//
RooPlot* h1frame = h1->frame(20);
h1frame->GetXaxis()->CenterTitle();
h1frame->GetYaxis()->CenterTitle();
h1frame->GetYaxis()->SetTitle(" ");
double ymax_h1;
TH1F *h1_mplus = new TH1F("h1_mplus", "h1_mplus", 20, -1, 1);
tin->Project("h1_mplus", "costheta1");
ymax_h1 = h1_mplus->GetMaximum();
TH1F *h1_hminus = new TH1F("h1_hminus", "h1_hminus", 20, -1, 1);
tinMinus->Project("h1_hminus", "costheta1");
ymax_h1 = h1_hminus->GetMaximum() > ymax_h1 ? h1_hminus->GetMaximum() : ymax_h1;
TH1F *h1_hplus = new TH1F("h1_hplus", "h1_hplus", 20, -1, 1);
tinHPlus->Project("h1_hplus", "costheta1");
ymax_h1 = h1_hplus->GetMaximum() > ymax_h1 ? h1_hplus->GetMaximum() : ymax_h1;
if ( drawmplus ) {
data.plotOn(h1frame, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(h1frame, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(h1frame, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(h1frame, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(h1frame, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(h1frame, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
h1frame->GetYaxis()->SetRangeUser(0, ymax_h1 * rescale * 1.3);
//
// h2
//
RooPlot* h2frame = h2->frame(20);
h2frame->GetXaxis()->CenterTitle();
h2frame->GetYaxis()->CenterTitle();
h2frame->GetYaxis()->SetTitle(" ");
double ymax_h2;
TH1F *h2_mplus = new TH1F("h2_mplus", "h2_mplus", 20, -1, 1);
tin->Project("h2_mplus", "costheta2");
ymax_h2 = h2_mplus->GetMaximum();
TH1F *h2_hminus = new TH1F("h2_hminus", "h2_hminus", 20, -1, 1);
tinMinus->Project("h2_hminus", "costheta2");
ymax_h2 = h2_hminus->GetMaximum() > ymax_h2 ? h2_hminus->GetMaximum() : ymax_h2;
TH1F *h2_hplus = new TH1F("h2_hplus", "h2_hplus", 20, -1, 1);
tinHPlus->Project("h2_hplus", "costheta2");
ymax_h2 = h2_hplus->GetMaximum() > ymax_h2 ? h2_hplus->GetMaximum() : ymax_h2;
if ( drawmplus ) {
data.plotOn(h2frame, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(h2frame, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(h2frame, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(h2frame, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(h2frame, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(h1frame, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
h2frame->GetYaxis()->SetRangeUser(0, ymax_h2 * rescale * 1.3);
//
// Phi
//
RooPlot* Phiframe = Phi->frame(20);
Phiframe->GetXaxis()->CenterTitle();
Phiframe->GetYaxis()->CenterTitle();
Phiframe->GetYaxis()->SetTitle(" ");
double ymax_Phi;
TH1F *Phi_mplus = new TH1F("Phi_mplus", "Phi_mplus", 20, -TMath::Pi(), TMath::Pi());
tin->Project("Phi_mplus", "phi");
ymax_Phi = Phi_mplus->GetMaximum();
TH1F *Phi_hminus = new TH1F("Phi_hminus", "Phi_hminus", 20, -TMath::Pi(), TMath::Pi());
tinMinus->Project("Phi_hminus", "phi");
ymax_Phi = Phi_hminus->GetMaximum() > ymax_Phi ? Phi_hminus->GetMaximum() : ymax_Phi;
TH1F *Phi_hplus = new TH1F("Phi_hplus", "Phi_hplus", 20, -TMath::Pi(), TMath::Pi());
tinHPlus->Project("Phi_hplus", "phi");
ymax_Phi = Phi_hplus->GetMaximum() > ymax_Phi ? Phi_hplus->GetMaximum() : ymax_Phi;
if ( drawmplus ) {
data.plotOn(Phiframe, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(Phiframe, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(Phiframe, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(Phiframe, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(Phiframe, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(Phiframe, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
Phiframe->GetYaxis()->SetRangeUser(0, ymax_Phi * rescale * 1.3);
//
// hs
//
RooPlot* hsframe = hs->frame(20);
hsframe->GetXaxis()->CenterTitle();
hsframe->GetYaxis()->CenterTitle();
hsframe->GetYaxis()->SetTitle(" ");
double ymax_hs;
TH1F *hs_mplus = new TH1F("hs_mplus", "hs_mplus", 20, -1, 1);
tin->Project("hs_mplus", "costhetastar");
ymax_hs = hs_mplus->GetMaximum();
TH1F *hs_hminus = new TH1F("hs_hminus", "hs_hminus", 20, -1, 1);
tinMinus->Project("hs_hminus", "costhetastar");
ymax_hs = hs_hminus->GetMaximum() > ymax_hs ? hs_hminus->GetMaximum() : ymax_hs;
TH1F *hs_hplus = new TH1F("hs_hplus", "hs_hplus", 20, -1, 1);
tinHPlus->Project("hs_hplus", "costhetastar");
ymax_hs = hs_hplus->GetMaximum() > ymax_hs ? hs_hplus->GetMaximum() : ymax_hs;
if ( drawmplus ) {
data.plotOn(hsframe, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(hsframe, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(hsframe, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(hsframe, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(hsframe, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(hsframe, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
hsframe->GetYaxis()->SetRangeUser(0, ymax_hs * rescale * 1.3);
//
// Phi1
//
RooPlot* Phi1frame = Phi1->frame(20);
Phi1frame->GetXaxis()->CenterTitle();
Phi1frame->GetYaxis()->CenterTitle();
Phi1frame->GetYaxis()->SetTitle(" ");
double ymax_Phi1;
TH1F *Phi1_mplus = new TH1F("Phi1_mplus", "Phi1_mplus", 20, -TMath::Pi(), TMath::Pi());
tin->Project("Phi1_mplus", "phistar1");
ymax_Phi1 = Phi1_mplus->GetMaximum();
TH1F *Phi1_hminus = new TH1F("Phi1_hminus", "Phi1_hminus", 20, -TMath::Pi(), TMath::Pi());
tinMinus->Project("Phi1_hminus", "phistar1");
ymax_Phi1 = Phi1_hminus->GetMaximum() > ymax_Phi1 ? Phi1_hminus->GetMaximum() : ymax_Phi1;
TH1F *Phi1_hplus = new TH1F("Phi1_hplus", "Phi1_hplus", 20, -TMath::Pi(), TMath::Pi());
tinHPlus->Project("Phi1_hplus", "phistar1");
ymax_Phi1 = Phi1_hplus->GetMaximum() > ymax_Phi1 ? Phi1_hplus->GetMaximum() : ymax_Phi1;
if ( drawmplus ) {
data.plotOn(Phi1frame, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(Phi1frame, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(Phi1frame, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(Phi1frame, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(Phi1frame, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(Phi1frame, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
Phi1frame->GetYaxis()->SetRangeUser(0, ymax_Phi1 * rescale * 1.3);
if ( offshell ) {
RooPlot* w1frame = wplusmass->frame(50);
w1frame->GetXaxis()->CenterTitle();
w1frame->GetYaxis()->CenterTitle();
w1frame->GetYaxis()->SetTitle(" ");
double ymax_w1;
TH1F *w1_mplus = new TH1F("w1_mplus", "w1_mplus", 50, 1e-09, 120);
tin->Project("w1_mplus", "wplusmass");
ymax_w1 = w1_mplus->GetMaximum();
TH1F *w1_hminus = new TH1F("w1_hminus", "w1_hminus", 50, 1e-09, 120);
tinMinus->Project("w1_hminus", "wplusmass");
ymax_w1 = w1_hminus->GetMaximum() > ymax_w1 ? w1_hminus->GetMaximum() : ymax_w1;
TH1F *w1_hplus = new TH1F("w1_hplus", "w1_hplus", 50, 1e-09, 120);
tinHPlus->Project("w1_hplus", "wplusmass");
ymax_w1 = w1_hplus->GetMaximum() > ymax_w1 ? w1_hplus->GetMaximum() : ymax_w1;
if ( drawmplus ) {
data.plotOn(w1frame, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(w1frame, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(w1frame, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(w1frame, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(w1frame, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(w1frame, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
w1frame->GetYaxis()->SetRangeUser(0, ymax_w1 * rescale * 1.5);
//
// wminus
//
RooPlot* w2frame = wminusmass->frame(50);
w2frame->GetXaxis()->CenterTitle();
w2frame->GetYaxis()->CenterTitle();
w2frame->GetYaxis()->SetTitle(" ");
double ymax_w2;
TH1F *w2_mplus = new TH1F("w2_mplus", "w2_mplus", 50, 1e-09, 120);
tin->Project("w2_mplus", "wminusmass");
ymax_w2 = w2_mplus->GetMaximum();
TH1F *w2_hminus = new TH1F("w2_hminus", "w2_hminus", 50, 1e-09, 120);
tinMinus->Project("w2_hminus", "wminusmass");
ymax_w2 = w2_hminus->GetMaximum() > ymax_w2 ? w2_hminus->GetMaximum() : ymax_w2;
TH1F *w2_hplus = new TH1F("w2_hplus", "w2_hplus", 50, 1e-09, 120);
tinHPlus->Project("w2_hplus", "wminusmass");
ymax_w2 = w2_hplus->GetMaximum() > ymax_w2 ? w2_hplus->GetMaximum() : ymax_w2;
if ( drawmplus ) {
data.plotOn(w2frame, MarkerColor(kRed),MarkerStyle(4),MarkerSize(1.5),LineWidth(0),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDF->plotOn(w2frame, LineColor(kRed),LineWidth(2), Normalization(rescale));
}
if ( drawhminus ) {
dataMinus.plotOn(w2frame, MarkerColor(kBlue),MarkerStyle(27),MarkerSize(1.9),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFMinus->plotOn(w2frame, LineColor(kBlue),LineWidth(2), Normalization(rescale));
}
if ( drawhplus ) {
dataHPlus.plotOn(w2frame, MarkerColor(kGreen+3),MarkerStyle(25),MarkerSize(1.5),XErrorSize(0), Rescale(rescale), DataError(RooAbsData::None));
myPDFHPlus->plotOn(w2frame, LineColor(kGreen+3),LineWidth(2), Normalization(rescale));
}
if ( rescale != 1. )
w2frame->GetYaxis()->SetRangeUser(0, ymax_w2 * rescale * 1.5);
}
}
if ( drawpaper ) {
TCanvas* can =new TCanvas("can","can",600,600);
if ( offshell ) {
w1frame->GetXaxis()->SetTitle("m_{l#nu} [GeV]");
w1frame->Draw();
can->Print(Form("paperplots/wplusmass_%.0fGeV_spin2_3in1_ww.eps", mH));
can->SaveAs(Form("paperplots/wplusmass_%.0fGeV_spin2_3in1_ww.C", mH));
}
can->Clear();
hsframe->Draw();
can->Print(Form("paperplots/costhetastar_%.0fGeV_spin2_3in1_ww.eps", mH));
can->SaveAs(Form("paperplots/costhetastar_%.0fGeV_spin2_3in1_ww.C", mH));
can->Clear();
Phi1frame->Draw();
can->Print(Form("paperplots/phistar1_%.0fGeV_spin2_3in1_ww.eps", mH));
can->SaveAs(Form("paperplots/phistar1_%.0fGeV_spin2_3in1_ww.C", mH));
can->Clear();
h1frame->GetXaxis()->SetTitle("cos#theta_{1} or cos#theta_{2}");
h1frame->Draw();
can->Print(Form("paperplots/costheta1_%.0fGeV_spin2_3in1_ww.eps", mH));
can->SaveAs(Form("paperplots/costheta1_%.0fGeV_spin2_3in1_ww.C", mH));
can->Clear();
Phiframe->Draw();
can->Print(Form("paperplots/phi_%.0fGeV_spin2_3in1_ww.eps", mH));
can->SaveAs(Form("paperplots/phi_%.0fGeV_spin2_3in1_ww.C", mH));
} else {
TCanvas* czz = new TCanvas( "czz", "czz", 1000, 600 );
czz->Divide(4,2);
if ( offshell ) {
czz->cd(1);
w1frame->Draw();
czz->cd(2);
w2frame->Draw();
}
czz->cd(3);
hsframe->Draw();
czz->cd(4);
box3->Draw();
czz->cd(5);
Phi1frame->Draw();
czz->cd(6);
h1frame->Draw();
czz->cd(7);
h2frame->Draw();
czz->cd(8);
Phiframe->Draw();
if ( useGTerm->getVal() > 0.) {
czz->SaveAs(Form("epsfiles/angles_TWW%.0f_JHU_7D.eps", mH));
czz->SaveAs(Form("pngfiles/angles_TWW%.0f_JHU_7D.png", mH));
} else {
czz->SaveAs(Form("epsfiles/angles_TWW%.0f_JHU_7D_GenFromC.eps", mH));
czz->SaveAs(Form("pngfiles/angles_TWW%.0f_JHU_7D_GenFromC.png", mH));
}
}
}
void RooToyMCFit(){
stringstream out;
out.str("");
out << "toyMC_" << _sigma_over_tau << "_" << _purity << "_" << mistag_rate << ".root";
TFile* file = TFile::Open(out.str().c_str());
TTree* tree = (TTree*)file->Get("ToyTree");
tree->Print();
// TFile* file = TFile::Open("ToyData/toyMC_453_0.912888_0.3_0.8_0.root");
// TFile* file = TFile::Open("ToyData/toyMC_10000_0.9_0.3_0.8_0.root");
// TTree* tree = (TTree*)file->Get("ToyTree1");
RooRealVar tau("tau","tau",_tau,"ps"); tau.setConstant(kTRUE);
RooRealVar dm("dm","dm",_dm,"ps^{-1}"); dm.setConstant(kTRUE);
RooAbsReal* sin2beta;
RooAbsReal* cos2beta;
if(softlimit){
RooRealVar x("x","x",_cos2beta,-3.,30000.); if(constBeta) x.setConstant(kTRUE);
RooRealVar y("y","y",_sin2beta,-3.,30000.); if(constBeta) y.setConstant(kTRUE);
cos2beta = new RooFormulaVar("cos2beta","cos2beta","@0/sqrt(@0*@0+@1*@1)",RooArgSet(x,y));
sin2beta = new RooFormulaVar("sin2beta","sin2beta","@0/sqrt(@0*@0+@1*@1)",RooArgSet(y,x));
// sin2beta = new RooFormulaVar("sin2beta","sin2beta","2/TMath::Pi()*TMath::ATan(@0)",RooArgSet(y));
// cos2beta = new RooFormulaVar("cos2beta","cos2beta","2/TMath::Pi()*TMath::ATan(@0)",RooArgSet(x));
}
else{
sin2beta = new RooRealVar("sin2beta","sin2beta",_sin2beta,-3.,3.); if(constBeta) ((RooRealVar*)sin2beta)->setConstant(kTRUE);
cos2beta = new RooRealVar("cos2beta","cos2beta",_cos2beta,-3.,3.); if(constBeta) ((RooRealVar*)cos2beta)->setConstant(kTRUE);
}
RooRealVar dt("dt","#Deltat",-5.,5.,"ps");
RooRealVar avgMisgat("avgMisgat","avgMisgat",mistag_rate,0.0,0.5); if(constMistag) avgMisgat.setConstant(kTRUE);
RooRealVar delMisgat("delMisgat","delMisgat",0); delMisgat.setConstant(kTRUE);
RooRealVar mu("mu","mu",0); mu.setConstant(kTRUE);
tau.Print();
dm.Print();
sin2beta->Print();
cos2beta->Print();
avgMisgat.Print();
RooRealVar moment("moment","moment",0.); moment.setConstant(kTRUE);
RooRealVar parity("parity","parity",-1.); parity.setConstant(kTRUE);
RooRealVar* K[8];
RooAbsReal* Kb[8];
RooArgList Kset;
RooRealVar* C[8];
RooRealVar* S[8];
RooFormulaVar* a1[2][8];
RooFormulaVar* b1[2][8];
RooFormulaVar* a2[2][8];
RooFormulaVar* b2[2][8];
for(int i=0; i<8; i++){
out.str("");
out << "K" << i+1;
K[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_K[i],0.,1.); Kset.add(*K[i]); if(constK) K[i]->setConstant(kTRUE);
K[i]->Print();
if(i!=7){
out.str("");
out << "Kb" << i+1;
Kb[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_Kb[i],0.,1.); Kset.add(*Kb[i]); if(constK) ((RooRealVar*)Kb[i])->setConstant(kTRUE);
Kb[i]->Print();
}
out.str("");
out << "C" << i+1;
C[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_C[i]); C[i]->setConstant(kTRUE);
C[i]->Print();
out.str("");
out << "S" << i+1;
S[i] = new RooRealVar(out.str().c_str(),out.str().c_str(),_S[i]); S[i]->setConstant(kTRUE);
S[i]->Print();
}
Kb[7] = new RooFormulaVar("K8b","K8b","1-@0-@1-@2-@3-@4-@5-@6-@7-@8-@9-@10-@11-@12-@13-@14",Kset);
for(int i=0; i<8; i++){
out.str("");
out << "a10_" << i+1;
a1[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a1[0][i]->Print();
out.str("");
out << "a11_" << i+1;
a1[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a1[1][i]->Print();
out.str("");
out << "a20_" << i+1;
a2[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a2[0][i]->Print();
out.str("");
out << "a21_" << i+1;
a2[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-(@0-@1)/(@0+@1)",RooArgList(*K[i],*Kb[i]));
a2[1][i]->Print();
out.str("");
out << "b10_" << i+1;
b1[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b1[0][i]->Print();
out.str("");
out << "b11_" << i+1;
b1[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b1[1][i]->Print();
out.str("");
out << "b20_" << i+1;
b2[0][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b2[0][i]->Print();
out.str("");
out << "b21_" << i+1;
b2[1][i] = new RooFormulaVar(out.str().c_str(),out.str().c_str(),"-2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1)",RooArgList(*K[i],*Kb[i],*C[i],*S[i],*sin2beta,*cos2beta));
b2[1][i]->Print();
cout << "bin = " << i+1 << endl;
cout << " a11 = " << a1[0][i]->getVal() << " b11 = " << b1[0][i]->getVal() << endl;
cout << " a12 = " << a1[1][i]->getVal() << " b12 = " << b1[1][i]->getVal() << endl;
cout << " a21 = " << a2[0][i]->getVal() << " b21 = " << b2[0][i]->getVal() << endl;
cout << " a22 = " << a2[1][i]->getVal() << " b22 = " << b2[1][i]->getVal() << endl;
}
RooRealVar* dgamma = new RooRealVar("dgamma","dgamma",0.); dgamma->setConstant(kTRUE);
RooRealVar* f0 = new RooRealVar("f0","f0",1.); f0->setConstant(kTRUE);
RooRealVar* f1 = new RooRealVar("f1","f1",0.); f1->setConstant(kTRUE);
RooCategory tag("tag","tag");
tag.defineType("B0",1);
tag.defineType("anti-B0",-1);
RooCategory bin("bin","bin");
bin.defineType("1",1);
bin.defineType("2",2);
bin.defineType("3",3);
bin.defineType("4",4);
bin.defineType("5",5);
bin.defineType("6",6);
bin.defineType("7",7);
bin.defineType("8",8);
bin.defineType("-1",-1);
bin.defineType("-2",-2);
bin.defineType("-3",-3);
bin.defineType("-4",-4);
bin.defineType("-5",-5);
bin.defineType("-6",-6);
bin.defineType("-7",-7);
bin.defineType("-8",-8);
RooSuperCategory bintag("bintag","bintag",RooArgSet(bin,tag));
tree->Print();
RooDataSet d("data","data",tree,RooArgSet(dt,bin,tag));
cout << "DataSet is ready." << endl;
d.Print();
RooRealVar mean("mean","mean",0.,"ps"); mean.setConstant(kTRUE);
RooRealVar sigma("sigma","sigma",_sigma_over_tau*_tau,0.,1.5*_tau,"ps"); if(constSigma) sigma.setConstant(kTRUE);
RooGaussModel rf("rf","rf",dt,mean,sigma);
// RooTruthModel rf("rf","rf",dt);
RooGaussian rfpdf("rfpdf","rfpdf",dt,mean,sigma);
cout << "Preparing PDFs..." << endl;
// RooRealVar* fsigs1[8];
// RooRealVar* fsigs1b[8];
// RooRealVar* fsigs2[8];
// RooRealVar* fsigs2b[8];
RooBDecay* sigpdfs1[8];
RooBDecay* sigpdfs1b[8];
RooBDecay* sigpdfs2[8];
RooBDecay* sigpdfs2b[8];
RooAddPdf* PDFs1[8];
RooAddPdf* PDFs1b[8];
RooAddPdf* PDFs2[8];
RooAddPdf* PDFs2b[8];
RooAddPdf* pdfs1[8];
RooAddPdf* pdfs1b[8];
RooAddPdf* pdfs2[8];
RooAddPdf* pdfs2b[8];
RooSimultaneous pdf("pdf","pdf",bintag);
RooRealVar fsig("fsig","fsig",_purity,0.,1.); if(constFSig) fsig.setConstant(kTRUE);
fsig.Print();
for(int j=0; j<8; j++){
// out.str("");
// out << "fsig1" << j+1;
// fsigs1[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs1[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig1b" << j+1;
// fsigs1b[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs1b[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig2" << j+1;
// fsigs2[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs2[j]->setConstant(kTRUE);
// out.str("");
// out << "fsig2b" << j+1;
// fsigs2b[j] = new RooRealVar(out.str().c_str(),out.str().c_str(),_purity,0.,1.); if(constFSig) fsigs2b[j]->setConstant(kTRUE);
out.str("");
out << "sigpdf1" << j+1;
sigpdfs1[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a1[0][j],*b1[0][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf1b" << j+1;
sigpdfs1b[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a1[1][j],*b1[1][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf2" << j+1;
sigpdfs2[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a2[0][j],*b2[0][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "sigpdf2b" << j+1;
sigpdfs2b[j] = new RooBDecay(out.str().c_str(),out.str().c_str(),dt,tau,*dgamma,*f0,*f1,*a2[1][j],*b2[1][j],dm,rf,RooBDecay::DoubleSided);
out.str("");
out << "PDF1" << j+1;
PDFs1[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs1[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF1b" << j+1;
PDFs1b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs1b[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF2" << j+1;
PDFs2[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs2[j],rfpdf),RooArgList(fsig));
out.str("");
out << "PDF2b" << j+1;
PDFs2b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*sigpdfs2b[j],rfpdf),RooArgList(fsig));
//Adding mistaging
out.str("");
out << "pdf1" << j+1;
pdfs1[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs2[j],*PDFs1[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf1b" << j+1;
pdfs1b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs2b[j],*PDFs1b[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf2" << j+1;
pdfs2[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs1[j],*PDFs2[j]),RooArgList(avgMisgat));
out.str("");
out << "pdf2b" << j+1;
pdfs2b[j] = new RooAddPdf(out.str().c_str(),out.str().c_str(),RooArgList(*PDFs1b[j],*PDFs2b[j]),RooArgList(avgMisgat));
out.str("");
out << "{" << j+1 << ";B0}";
pdf.addPdf(*pdfs1[j],out.str().c_str());
out.str("");
out << "{" << -(j+1) << ";B0}";
pdf.addPdf(*pdfs1b[j],out.str().c_str());
out.str("");
out << "{" << j+1 << ";anti-B0}";
pdf.addPdf(*pdfs2[j],out.str().c_str());
out.str("");
out << "{" << -(j+1) << ";anti-B0}";
pdf.addPdf(*pdfs2b[j],out.str().c_str());
}
cout << "Fitting..." << endl;
pdf.fitTo(d,Verbose(),Timer());
dt.setBins(50);
cout << "Drawing plots." << endl;
for(int i=0; i<8; i++){
RooPlot* dtFrame = dt.frame();
out.str("");
out << "tag == 1 && bin == " << i+1;
RooDataSet* ds = d.reduce(out.str().c_str());
ds->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kBlue));
out.str("");
out << "{" << j+1 << ";B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
out.str("");
out << "tag == -1 && bin == " << i+1;
RooDataSet* dsb = d.reduce(out.str().c_str());
dsb->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kRed));
out.str("");
out << "{" << j+1 << ";anti-B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*dsb),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
out.str("");
out << "#Delta t, toy MC, bin == " << i+1;
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << (i+1);
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << _sigma_over_tau;
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrame->Draw();
ptB->Draw();
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << (i+1) << ".root";
cm->Print(out.str().c_str());
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << (i+1) << ".png";
cm->Print(out.str().c_str());
}
for(int i=0; i<8; i++){
RooPlot* dtFrame = dt.frame();
out.str("");
out << "tag == 1 && bin == " << -(i+1);
RooDataSet* ds2 = (RooDataSet*)d.reduce(out.str().c_str());
ds2->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kBlue));
out.str("");
out << "{" << -(j+1) << ";B0}";
bintag = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds2),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
out.str("");
out << "tag == -1 && bin == " << -(i+1);
RooDataSet* ds2b = (RooDataSet*)d.reduce(out.str().c_str());
ds2b->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),Cut(out.str().c_str()),MarkerColor(kRed));
out.str("");
out << "{" << -(j+1) << ";anti-B0}";
bin = out.str().c_str();
pdf.plotOn(dtFrame,ProjWData(*ds2b),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
out.str("");
out << "#Delta t, toy MC, bin == " << -(i+1);
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << -(i+1);
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << _sigma_over_tau;
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrame->Draw();
ptB->Draw();
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << -(i+1) << ".root";
cm->Print(out.str().c_str());
out.str("");
out << "../Reports/cpfitfigs/dt_bin" << -(i+1) << ".png";
cm->Print(out.str().c_str());
}
return;
}
void rf403_weightedevts()
{
// C r e a t e o b s e r v a b l e a n d u n w e i g h t e d d a t a s e t
// -------------------------------------------------------------------------------
// Declare observable
RooRealVar x("x","x",-10,10) ;
x.setBins(40) ;
// Construction a uniform pdf
RooPolynomial p0("px","px",x) ;
// Sample 1000 events from pdf
RooDataSet* data = p0.generate(x,1000) ;
// C a l c u l a t e w e i g h t a n d m a k e d a t a s e t w e i g h t e d
// -----------------------------------------------------------------------------------
// Construct formula to calculate (fake) weight for events
RooFormulaVar wFunc("w","event weight","(x*x+10)",x) ;
// Add column with variable w to previously generated dataset
RooRealVar* w = (RooRealVar*) data->addColumn(wFunc) ;
// Dataset d is now a dataset with two observable (x,w) with 1000 entries
data->Print() ;
// Instruct dataset wdata in interpret w as event weight rather than as observable
RooDataSet wdata(data->GetName(),data->GetTitle(),data,*data->get(),0,w->GetName()) ;
// Dataset d is now a dataset with one observable (x) with 1000 entries and a sum of weights of ~430K
wdata.Print() ;
// U n b i n n e d M L f i t t o w e i g h t e d d a t a
// ---------------------------------------------------------------
// Construction quadratic polynomial pdf for fitting
RooRealVar a0("a0","a0",1) ;
RooRealVar a1("a1","a1",0,-1,1) ;
RooRealVar a2("a2","a2",1,0,10) ;
RooPolynomial p2("p2","p2",x,RooArgList(a0,a1,a2),0) ;
// Fit quadratic polynomial to weighted data
// NOTE: A plain Maximum likelihood fit to weighted data does in general
// NOT result in correct error estimates, unless individual
// event weights represent Poisson statistics themselves.
//
// Fit with 'wrong' errors
RooFitResult* r_ml_wgt = p2.fitTo(wdata,Save()) ;
// A first order correction to estimated parameter errors in an
// (unbinned) ML fit can be obtained by calculating the
// covariance matrix as
//
// V' = V C-1 V
//
// where V is the covariance matrix calculated from a fit
// to -logL = - sum [ w_i log f(x_i) ] and C is the covariance
// matrix calculated from -logL' = -sum [ w_i^2 log f(x_i) ]
// (i.e. the weights are applied squared)
//
// A fit in this mode can be performed as follows:
RooFitResult* r_ml_wgt_corr = p2.fitTo(wdata,Save(),SumW2Error(kTRUE)) ;
// P l o t w e i g h e d d a t a a n d f i t r e s u l t
// ---------------------------------------------------------------
// Construct plot frame
RooPlot* frame = x.frame(Title("Unbinned ML fit, binned chi^2 fit to weighted data")) ;
// Plot data using sum-of-weights-squared error rather than Poisson errors
wdata.plotOn(frame,DataError(RooAbsData::SumW2)) ;
// Overlay result of 2nd order polynomial fit to weighted data
p2.plotOn(frame) ;
// M L F i t o f p d f t o e q u i v a l e n t u n w e i g h t e d d a t a s e t
// -----------------------------------------------------------------------------------------
// Construct a pdf with the same shape as p0 after weighting
RooGenericPdf genPdf("genPdf","x*x+10",x) ;
// Sample a dataset with the same number of events as data
RooDataSet* data2 = genPdf.generate(x,1000) ;
// Sample a dataset with the same number of weights as data
RooDataSet* data3 = genPdf.generate(x,43000) ;
// Fit the 2nd order polynomial to both unweighted datasets and save the results for comparison
RooFitResult* r_ml_unw10 = p2.fitTo(*data2,Save()) ;
RooFitResult* r_ml_unw43 = p2.fitTo(*data3,Save()) ;
// C h i 2 f i t o f p d f t o b i n n e d w e i g h t e d d a t a s e t
// ------------------------------------------------------------------------------------
// Construct binned clone of unbinned weighted dataset
RooDataHist* binnedData = wdata.binnedClone() ;
binnedData->Print("v") ;
// Perform chi2 fit to binned weighted dataset using sum-of-weights errors
//
// NB: Within the usual approximations of a chi2 fit, a chi2 fit to weighted
// data using sum-of-weights-squared errors does give correct error
// estimates
RooChi2Var chi2("chi2","chi2",p2,*binnedData,DataError(RooAbsData::SumW2)) ;
RooMinuit m(chi2) ;
m.migrad() ;
m.hesse() ;
// Plot chi^2 fit result on frame as well
RooFitResult* r_chi2_wgt = m.save() ;
p2.plotOn(frame,LineStyle(kDashed),LineColor(kRed)) ;
// C o m p a r e f i t r e s u l t s o f c h i 2 , M L f i t s t o ( u n ) w e i g h t e d d a t a
// ---------------------------------------------------------------------------------------------------------------
// Note that ML fit on 1Kevt of weighted data is closer to result of ML fit on 43Kevt of unweighted data
// than to 1Kevt of unweighted data, whereas the reference chi^2 fit with SumW2 error gives a result closer to
// that of an unbinned ML fit to 1Kevt of unweighted data.
cout << "==> ML Fit results on 1K unweighted events" << endl ;
r_ml_unw10->Print() ;
cout << "==> ML Fit results on 43K unweighted events" << endl ;
r_ml_unw43->Print() ;
cout << "==> ML Fit results on 1K weighted events with a summed weight of 43K" << endl ;
r_ml_wgt->Print() ;
cout << "==> Corrected ML Fit results on 1K weighted events with a summed weight of 43K" << endl ;
r_ml_wgt_corr->Print() ;
cout << "==> Chi2 Fit results on 1K weighted events with a summed weight of 43K" << endl ;
r_chi2_wgt->Print() ;
new TCanvas("rf403_weightedevts","rf403_weightedevts",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.8) ; frame->Draw() ;
}
void fastEfficiencyNadir(unsigned int iEG, int iECAL1, int iColl1, int iECAL2, int iColl2,
TString dirIn="/home/llr/cms/ndaci/SKWork/macro/skEfficiency/tagAndProbe/EfficiencyStudy/SingEle-May10ReReco/UPDATE2/Tag80Probe95/",
TString lumi="200 pb", int nCPU=4,
int color1=kBlack, int style1=kFullCircle, int color2=kRed, int style2=kOpenSquare,
TString probe="WP80", TString tag="WP80", TString fileIn="tree_effi_TagProbe.root")
{
// STYLE //
gROOT->Reset();
loadPresentationStyle();
gROOT->ForceStyle();
// EG THRESHOLDS //
const int nEG = 71;
double thres[nEG];
for(int i=0 ; i<nEG ; i++) thres[i]=i;
TString names[nEG];
ostringstream ossi;
for(int i=0;i<(int)nEG;i++) {
ossi.str("");
ossi << thres[i] ;
names[i] = ossi.str();
}
// NAMES //
const int nECAL=2;
const int nColl=2;
TString name_leg_ecal[nECAL] = {"Barrel","Endcaps"};
TString name_leg_coll[nColl] = {"Online","Emulation"};
TString name_ecal[nECAL] = {"_EB","_EE"};
TString name_coll[nColl] = {"_N","_M"};
TString dirResults = dirIn + "/turnons/EG"+names[iEG]+"/" ;
TString name_image =
dirResults + "eff_EG"+names[iEG]+"_tag"+tag+"_probe"+probe+name_ecal[iECAL1]+name_coll[iColl1]+"_vs"+name_ecal[iECAL2]+name_coll[iColl2] ;
// Output log //
ofstream fichier(name_image+".txt", ios::out);
// BINNING //
const int nbins[nEG] = {29,29,29,29,21,21,21,22,22,21,22,21,22,18,19,18,18,18,18,20,20,20,20,19,20,20,20,20,21,21,
21,21,21,21,21,21,21,21,21,21, //EG30
22,22,22,22,22,22,22,22,22,22, //EG40
29,29,29,29,29,29,29,29,29,29, //EG50
29,29,29,29,29,29,29,29,29,29};//EG60
Double_t bins_0[29] = {1,1.5,1.8,2,2.2,2.4,2.6,2.8, 3, 3.5, 4,4.2,4.5,4.7,5,5.5,6,6.5,7,7.5,8,8.5,9,10,12,15,20,50,150};// EG0
Double_t bins_1[29] = {1,1.5,1.8,2,2.2,2.4,2.6,2.8, 3, 3.5, 4,4.2,4.5,4.7,5,5.5,6,6.5,7,7.5,8,8.5,9,10,12,15,20,50,150};// EG1
Double_t bins_2[29] = {1,1.5,1.8,2,2.2,2.4,2.6,2.8, 3, 3.5, 4,4.2,4.5,4.7,5,5.5,6,6.5,7,7.5,8,8.5,9,10,12,15,20,50,150};// EG2
Double_t bins_3[29] = {1,1.5,1.8,2,2.2,2.4,2.6,2.8, 3, 3.5, 4,4.2,4.5,4.7,5,5.5,6,6.5,7,7.5,8,8.5,9,10,12,15,20,50,150};// EG3
Double_t bins_4[21] = {1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 15, 17, 19, 21, 27, 32, 41, 50, 60, 70, 150}; // EG4
Double_t bins_5[21] = {2, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 22, 24, 31, 40, 50, 60, 70, 150}; // EG5
Double_t bins_6[21] = {3, 4, 5, 6, 7, 8, 9, 11, 13, 15, 17, 19, 21, 23, 27, 32, 41, 50, 60, 70, 150}; // EG6
Double_t bins_7[22] = {2, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20, 22, 24, 26, 31, 40, 50, 60, 70, 150}; // EG7
Double_t bins_8[22] = {3, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 21, 23, 25, 27, 32, 41, 50, 60, 70, 150}; // EG8
Double_t bins_9[21] = {4, 6, 7, 8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 31, 40, 50, 60, 70, 150}; // EG9
Double_t bins_10[22] = {5, 7, 8, 9, 10, 11, 12, 13, 15, 17, 19, 21, 23, 25, 27, 29, 32, 41, 50, 60, 70, 150}; // EG10
Double_t bins_11[21] = {6, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 24, 26, 28, 31, 40, 50, 60, 70, 150}; // EG11
Double_t bins_12[22] = {5, 7, 9, 10, 11, 12, 13, 14, 15, 17, 19, 21, 23, 25, 27, 29, 32, 41, 50, 60, 70, 150}; // EG12
Double_t bins_13[18] = {5, 7, 9, 11, 12, 13, 14, 15, 17, 19, 22, 25, 29, 37, 50, 60, 70, 150}; // EG13
Double_t bins_14[19] = {6, 8, 10, 12, 13, 14, 15, 16, 18, 20, 22, 25, 30, 35, 40, 50, 60, 70, 150}; // EG14
Double_t bins_15[18] = {5, 7, 9, 11, 13, 14, 15, 16, 17, 19, 22, 25, 29, 37, 50, 60, 70, 150}; // EG15
Double_t bins_16[18] = {8, 10, 12, 14, 16, 17, 18, 19, 20, 22, 25, 30, 35, 40, 50, 60, 70, 150}; // EG16
Double_t bins_17[18] = {9, 11, 13, 15, 16, 17, 18, 19, 21, 23, 25, 30, 35, 40, 50, 60, 70, 150}; // EG17
Double_t bins_18[18] = {8, 10, 12, 14, 16, 17, 18, 19, 20, 22, 25, 30, 35, 40, 50, 60, 70, 150}; // EG18
Double_t bins_19[20] = {9, 11, 13, 15, 17, 18, 19, 20, 21, 23, 25, 27, 30, 35, 40, 45, 50, 60, 70, 150}; // EG19
Double_t bins_20[20] = {8, 10, 12, 14, 16, 18, 19, 20, 21, 22, 24, 26, 30, 35, 40, 45, 50, 60, 70, 100}; // EG20
Double_t bins_21[20] = {9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 27, 30, 35, 40, 45, 50, 60, 70, 150}; // EG21
Double_t bins_22[20] = {10, 12, 14, 16, 18, 20, 21, 22, 23, 24, 26, 28, 30, 35, 40, 45, 50, 60, 70, 150}; // EG22
Double_t bins_23[19] = {11, 13, 15, 17, 19, 21, 22, 23, 24, 25, 27, 30, 35, 40, 45, 50, 60, 70, 150}; // EG23
Double_t bins_24[20] = {10, 12, 14, 16, 18, 20, 22, 23, 24, 25, 26, 28, 30, 35, 40, 45, 50, 60, 70, 150}; // EG24
Double_t bins_25[20] = {11, 13, 15, 17, 19, 21, 23, 24, 25, 26, 27, 29, 30, 35, 40, 45, 50, 60, 70, 150}; // EG25
Double_t bins_26[20] = {10, 12, 14, 16, 18, 20, 22, 24, 25, 26, 27, 28, 30, 35, 40, 45, 50, 60, 70, 150}; // EG26
Double_t bins_27[20] = {11, 13, 15, 17, 19, 21, 23, 25, 26, 27, 28, 29, 33, 35, 40, 45, 50, 60, 70, 150}; // EG27
Double_t bins_28[21] = {10, 12, 14, 16, 18, 20, 22, 24, 26, 27, 28, 29, 30, 32, 35, 40, 45, 50, 60, 70, 150}; // EG28
Double_t bins_29[21] = {11, 13, 15, 17, 19, 21, 23, 25, 27, 28, 29, 30, 31, 33, 35, 40, 45, 50, 60, 70, 150}; // EG29
Double_t bins_30[21] = {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 29, 30, 31, 32, 35, 40, 45, 50, 60, 70, 150}; // EG30
Double_t bins_40[22] = {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 38, 39, 40, 42, 45, 50, 60, 70, 150}; // EG40
Double_t bins_50[29] = {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 48, 50, 55, 60, 70, 90, 110, 130, 150, 170, 190}; // EG50
Double_t bins_60[29] = {10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 48, 50, 55, 60, 70, 90, 110, 130, 150, 170, 190}; // EG60
vector< Double_t* > bins;
bins.push_back( bins_0 ); bins.push_back( bins_1 ); bins.push_back( bins_2 ); bins.push_back( bins_3 ); bins.push_back( bins_4 );
bins.push_back( bins_5 ); bins.push_back( bins_6 ); bins.push_back( bins_7 ); bins.push_back( bins_8 ); bins.push_back( bins_9 );
bins.push_back( bins_10 ); bins.push_back( bins_11 ); bins.push_back( bins_12 ); bins.push_back( bins_13 ); bins.push_back( bins_14 );
bins.push_back( bins_15 ); bins.push_back( bins_16 ); bins.push_back( bins_17 ); bins.push_back( bins_18 ); bins.push_back( bins_19 );
bins.push_back( bins_20 ); bins.push_back( bins_21 ); bins.push_back( bins_22 ); bins.push_back( bins_23 ); bins.push_back( bins_24 );
bins.push_back( bins_25 ); bins.push_back( bins_26 ); bins.push_back( bins_27 ); bins.push_back( bins_28 ); bins.push_back( bins_29 );
for(int iV=0 ; iV<10 ; iV++) bins.push_back( bins_30 );
for(int iV=0 ; iV<10 ; iV++) bins.push_back( bins_40 );
for(int iV=0 ; iV<10 ; iV++) bins.push_back( bins_50 );
for(int iV=0 ; iV<10 ; iV++) bins.push_back( bins_60 );
RooBinning binning = RooBinning(nbins[iEG]-1, bins[iEG], "binning");
// INPUT DATA //
TFile* f1 = TFile::Open(dirIn+"/"+fileIn);
TTree* treenew;
TTree* treenew_2;
treenew = (TTree*) gDirectory->Get( "treenew"+name_ecal[iECAL1]+name_coll[iColl1] ) ;
treenew_2 = (TTree*) gDirectory->Get( "treenew"+name_ecal[iECAL2]+name_coll[iColl2] ) ;
TString name_scet[2], name_scdr[2], name_l1bin[2];
name_scet[0] = "sc_et"+name_ecal[iECAL1]+name_coll[iColl1];
name_scet[1] = "sc_et"+name_ecal[iECAL2]+name_coll[iColl2];
name_scdr[0] = "sc_dr"+name_ecal[iECAL1]+name_coll[iColl1];
name_scdr[1] = "sc_dr"+name_ecal[iECAL2]+name_coll[iColl2];
name_l1bin[0] = "l1_"+names[iEG]+name_ecal[iECAL1]+name_coll[iColl1];
name_l1bin[1] = "l1_"+names[iEG]+name_ecal[iECAL2]+name_coll[iColl2];
RooRealVar et_plot(name_scet[0],name_scet[0],0,150) ;
RooRealVar dr(name_scdr[0],name_scdr[0],0.5,1.5) ;
RooRealVar et_plot2(name_scet[1],name_scet[1],0,150) ;
RooRealVar dr2(name_scdr[1],name_scdr[1],0.5,1.5) ;
// Acceptance state cut (1 or 0)
RooCategory cut(name_l1bin[0],name_l1bin[0]) ;
cut.defineType("accept",1) ;
cut.defineType("reject",0) ;
RooCategory cut2(name_l1bin[1],name_l1bin[1]) ;
cut2.defineType("accept",1) ;
cut2.defineType("reject",0) ;
// PARAMETRES ROOFIT CRYSTAL BALL
RooRealVar norm("norm","N",1,0.6,1);
RooRealVar alpha("alpha","#alpha",0.671034,0.01,8);
RooRealVar n("n","n",4.07846,1.1,35);
RooRealVar mean("mean","mean",20.8,0,100);
//mean.setVal(thres[iEG]);
RooRealVar sigma("sigma","#sigma",0.972825,0.01,5);
//RooRealVar pedestal("pedestal","pedestal",0.01,0,0.4);
RooRealVar norm2("norm2","N",0.999069,0.6,1);
RooRealVar alpha2("alpha2","#alpha",0.492303,0.01,8);
RooRealVar n2("n2","n",11.6694,1.1,35);
RooRealVar mean2("mean2","mean",21.4582,0,100);
//mean2.setVal(thres[iEG]);
RooRealVar sigma2("sigma2","#sigma",1.19,0.01,5);
//RooRealVar pedestal2("pedestal2","pedestal",0.01,0,0.4);
FuncCB cb("cb","Crystal Ball Integree",et_plot,mean,sigma,alpha,n,norm) ;
FuncCB cb2("cb2","Crystal Ball Integree",et_plot2,mean2,sigma2,alpha2,n2,norm2) ;
// EFFICIENCY //
RooEfficiency eff("eff","efficiency",cb,cut,"accept");
RooEfficiency eff2("eff2","efficiency",cb2,cut2,"accept");
// DATASETS //
RooDataSet dataSet("data","data",RooArgSet(et_plot, cut,dr),Import(*treenew));
RooDataSet dataSet2("data2","data2",RooArgSet(et_plot2, cut2,dr2),Import(*treenew_2));
dataSet.Print();
dataSet2.Print();
// PLOT //
RooPlot* frame = et_plot.frame(Bins(18000),Title("Fitted efficiency")) ;
RooPlot* frame2 = et_plot2.frame(Bins(18000),Title("Fitted efficiency")) ;
dataSet.plotOn(frame, Binning(binning), Efficiency(cut), MarkerColor(color1), LineColor(color1), MarkerStyle(style1) );
dataSet2.plotOn(frame2, Binning(binning), Efficiency(cut2), MarkerColor(color2), LineColor(color2), MarkerStyle(style2) );
/////////////////////// FITTING /////////////////////////////
double fit_cuts_min = thres[iEG]-1.5 ;
double fit_cuts_max = 150;
et_plot.setRange("interesting",fit_cuts_min,fit_cuts_max);
et_plot2.setRange("interesting",fit_cuts_min,fit_cuts_max);
RooFitResult* roofitres1 = new RooFitResult("roofitres1","roofitres1");
RooFitResult* roofitres2 = new RooFitResult("roofitres2","roofitres2");
fichier << "Fit characteristics :" << endl ;
fichier << "EG " << names[iEG] << endl ;
fichier << "Fit Range , EB Coll : [" << fit_cuts_min << "," << fit_cuts_max << "]" << endl ;
fichier << "Fit Range , EE Coll : [" << fit_cuts_min << "," << fit_cuts_max << "]" << endl ;
fichier << "----------------------" << endl ;
// Fit #1 //
roofitres1 = eff.fitTo(dataSet,ConditionalObservables(et_plot),Range("interesting"),Minos(kTRUE),Warnings(kFALSE),NumCPU(nCPU),Save(kTRUE));
cb.plotOn(frame,LineColor(color1),LineWidth(2));
double res_norm1 = norm.getVal();
double err_norm1 = norm.getErrorLo();
double res_mean1 = mean.getVal();
double err_mean1 = mean.getError();
double res_sigma1 = sigma.getVal();
double err_sigma1 = sigma.getError();
double res_n1 = n.getVal();
double err_n1 = n.getError();
double res_alpha1 = alpha.getVal();
double err_alpha1 = alpha.getError();
fichier << "<----------------- EB ----------------->" << endl
<< "double res_mean=" << res_mean1 << "; "
<< "double res_sigma=" << res_sigma1 << "; "
<< "double res_alpha=" << res_alpha1 << "; "
<< "double res_n=" << res_n1 << "; "
<< "double res_norm=" << res_norm1 << "; "
<< endl
<< "double err_mean=" << err_mean1 << "; "
<< "double err_sigma=" << err_sigma1 << "; "
<< "double err_alpha=" << err_alpha1 << "; "
<< "double err_n=" << err_n1 << "; "
<< "double err_norm=" << err_norm1 << "; "
<< endl;
// Fit #2 //
roofitres2 = eff2.fitTo(dataSet2,ConditionalObservables(et_plot2),Range("interesting"),Minos(kTRUE),Warnings(kFALSE),NumCPU(nCPU),Save(kTRUE));
cb2.plotOn(frame2,LineColor(color2),LineWidth(2));
double res_norm2 = norm2.getVal();
double err_norm2 = norm2.getErrorLo();
double res_mean2 = mean2.getVal();
double err_mean2 = mean2.getError();
double res_sigma2 = sigma2.getVal();
double err_sigma2 = sigma2.getError();
double res_n2 = n2.getVal();
double err_n2 = n2.getError();
double res_alpha2 = alpha2.getVal();
double err_alpha2 = alpha2.getError();
fichier << "<----------------- EE ----------------->" << endl
<< "double res_mean=" << res_mean2 << "; "
<< "double res_sigma=" << res_sigma2 << "; "
<< "double res_alpha=" << res_alpha2 << "; "
<< "double res_n=" << res_n2 << "; "
<< "double res_norm=" << res_norm2 << "; "
<< endl
<< "double err_mean=" << err_mean2 << "; "
<< "double err_sigma=" << err_sigma2 << "; "
<< "double err_alpha=" << err_alpha2 << "; "
<< "double err_n=" << err_n2 << "; "
<< "double err_norm=" << err_norm2 << "; "
<< endl;
//////////////////////////// DRAWING PLOTS AND LEGENDS /////////////////////////////////
TCanvas* ca = new TCanvas("ca","Trigger Efficiency") ;
ca->SetGridx();
ca->SetGridy();
ca->cd();
gPad->SetLogx();
gPad->SetObjectStat(1);
frame->GetYaxis()->SetRangeUser(0,1.05);
frame->GetXaxis()->SetRangeUser(1,100.);
frame->GetYaxis()->SetTitle("Efficiency");
frame->GetXaxis()->SetTitle("E_{T} [GeV]");
frame->Draw() ;
frame2->GetYaxis()->SetRangeUser(0,1.05);
frame2->GetXaxis()->SetRangeUser(1,100.);
frame2->GetYaxis()->SetTitle("Efficiency");
frame2->GetXaxis()->SetTitle("E_{T} [GeV]");
frame2->Draw("same") ;
TH1F *SCeta1 = new TH1F("SCeta1","SCeta1",50,-2.5,2.5);
TH1F *SCeta2 = new TH1F("SCeta2","SCeta2",50,-2.5,2.5);
SCeta1->SetLineColor(color1) ;
SCeta1->SetMarkerColor(color1);
SCeta1->SetMarkerStyle(style1);
SCeta2->SetLineColor(color2) ;
SCeta2->SetMarkerColor(color2);
SCeta2->SetMarkerStyle(style2);
TLegend *leg = new TLegend(0.246,0.435,0.461,0.560,NULL,"brNDC"); // mid : x=353.5
leg->SetLineColor(1);
leg->SetTextColor(1);
leg->SetTextFont(42);
leg->SetTextSize(0.03);
leg->SetShadowColor(kWhite);
leg->SetFillColor(kWhite);
leg->SetMargin(0.25);
TLegendEntry *entry=leg->AddEntry("NULL","L1_SingleEG"+names[iEG],"h");
// leg->AddEntry(SCeta1,name_leg_ecal[iECAL1]+" "+name_leg_coll[iColl1],"p");
// leg->AddEntry(SCeta2,name_leg_ecal[iECAL2]+" "+name_leg_coll[iColl2],"p");
leg->AddEntry(SCeta1,name_leg_ecal[iECAL1],"p");
leg->AddEntry(SCeta2,name_leg_ecal[iECAL2],"p");
leg->Draw();
leg = new TLegend(0.16,0.725,0.58,0.905,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextFont(62);
leg->SetTextSize(0.03);
leg->SetLineColor(0);
leg->SetLineStyle(1);
leg->SetLineWidth(1);
leg->SetFillColor(0);
leg->SetFillStyle(0);
leg->AddEntry("NULL","CMS Preliminary 2012 pp #sqrt{s}=8 TeV","h");
leg->AddEntry("NULL","#int L dt = "+lumi+"^{-1}","h");
leg->AddEntry("NULL","Threshold : "+names[iEG]+" GeV","h");
leg->Draw();
TPaveText *pt2 = new TPaveText(0.220,0.605,0.487,0.685,"brNDC"); // mid : x=353.5
pt2->SetLineColor(1);
pt2->SetTextColor(1);
pt2->SetTextFont(42);
pt2->SetTextSize(0.03);
pt2->SetFillColor(kWhite);
pt2->SetShadowColor(kWhite);
pt2->AddText("L1 E/Gamma Trigger");
pt2->AddText("Electrons from Z");
pt2->Draw();
//TString name_image="eff_EG20_2012_12fb";
ca->Print(name_image+".cxx","cxx");
ca->Print(name_image+".png","png");
ca->Print(name_image+".gif","gif");
ca->Print(name_image+".pdf","pdf");
ca->Print(name_image+".ps","ps");
ca->Print(name_image+".eps","eps");
/////////////////////////////
// SAVE THE ROO FIT RESULT //
/////////////////////////////
RooWorkspace *w = new RooWorkspace("workspace","workspace") ;
w->import(dataSet);
w->import(dataSet2);
w->import(*roofitres1,"roofitres1");
w->import(*roofitres2,"roofitres2");
cout << "CREATES WORKSPACE : " << endl;
w->Print();
w->writeToFile(name_image+"_fitres.root") ;
//gDirectory->Add(w) ;
//f1->Close();
}
void rf208_convolution()
{
// S e t u p c o m p o n e n t p d f s
// ---------------------------------------
// Construct observable
RooRealVar t("t","t",-10,30) ;
// Construct landau(t,ml,sl) ;
RooRealVar ml("ml","mean bw",5.,-20,20) ;
RooRealVar sl("sl","sigma bw",1,0.1,10) ;
RooBreitWigner bw("bw","bw",t,ml,sl) ;
// Construct gauss(t,mg,sg)
RooRealVar mg("mg","mg",0) ;
RooRealVar sg("sg","sg",2,0.1,10) ;
RooGaussian gauss("gauss","gauss",t,mg,sg) ;
// C o n s t r u c t c o n v o l u t i o n p d f
// ---------------------------------------
// Set #bins to be used for FFT sampling to 10000
t.setBins(10000,"cache") ;
// Construct landau (x) gauss
RooFFTConvPdf lxg("lxg","bw (X) gauss",t,bw,gauss) ;
// S a m p l e , f i t a n d p l o t c o n v o l u t e d p d f
// ----------------------------------------------------------------------
// Sample 1000 events in x from gxlx
RooDataSet* data = lxg.generate(t,10000) ;
// Fit gxlx to data
lxg.fitTo(*data) ;
// Plot data, landau pdf, landau (X) gauss pdf
RooPlot* frame = t.frame(Title("landau (x) gauss convolution")) ;
data->plotOn(frame) ;
lxg.plotOn(frame) ;
bw.plotOn(frame,LineStyle(kDashed)) ;
// Draw frame on canvas
new TCanvas("rf208_convolution","rf208_convolution",600,600) ;
gPad->SetLeftMargin(0.15) ; frame->GetYaxis()->SetTitleOffset(1.4) ; frame->Draw() ;
//add a variable to the dataset
RooFormulaVar *r_formula = new RooFormulaVar("r_formula","","@0",t);
RooRealVar* r = (RooRealVar*) data->addColumn(*r_formula);
r->SetName("r");
r->SetTitle("r");
RooDataSet* data_r =(RooDataSet*) data->reduce(*r, "");
r->setRange("sigrange",-10.,30.);
RooPlot* r_frame = r->frame(Range("sigRange"),Title(" r (x) gauss convolution")) ;
data_r->plotOn(r_frame, MarkerColor(kRed));
r_frame->GetXaxis()->SetRangeUser(-10., 30.);
r_frame->Draw() ;
}
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();
}
void drawMassFrom2DPlot(RooWorkspace& myws, // Local workspace
string outputDir, // Output directory
struct InputOpt opt, // Variable with run information (kept for legacy purpose)
struct KinCuts cut, // Variable with current kinematic cuts
map<string, string> parIni, // Variable containing all initial parameters
string plotLabel, // The label used to define the output file name
// Select the type of datasets to fit
string DSTAG, // Specifies the type of datasets: i.e, DATA, MCJPSINP, ...
bool isPbPb, // Define if it is PbPb (True) or PP (False)
// Select the type of object to fit
bool incJpsi, // Includes Jpsi model
bool incPsi2S, // Includes Psi(2S) model
bool incBkg, // Includes Background model
// Select the fitting options
// Select the drawing options
bool setLogScale, // Draw plot with log scale
bool incSS, // Include Same Sign data
double binWidth, // Bin width
bool paperStyle=false // if true, print less info
)
{
RooMsgService::instance().getStream(0).removeTopic(Caching);
RooMsgService::instance().getStream(1).removeTopic(Caching);
RooMsgService::instance().getStream(0).removeTopic(Plotting);
RooMsgService::instance().getStream(1).removeTopic(Plotting);
RooMsgService::instance().getStream(0).removeTopic(Integration);
RooMsgService::instance().getStream(1).removeTopic(Integration);
RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING) ;
if (DSTAG.find("_")!=std::string::npos) DSTAG.erase(DSTAG.find("_"));
int nBins = min(int( round((cut.dMuon.M.Max - cut.dMuon.M.Min)/binWidth) ), 1000);
string pdfTotName = Form("pdfCTAUMASS_Tot_%s", (isPbPb?"PbPb":"PP"));
string pdfJpsiPRName = Form("pdfCTAUMASS_JpsiPR_%s", (isPbPb?"PbPb":"PP"));
string pdfJpsiNoPRName = Form("pdfCTAUMASS_JpsiNoPR_%s", (isPbPb?"PbPb":"PP"));
string pdfPsi2SPRName = Form("pdfCTAUMASS_Psi2SPR_%s", (isPbPb?"PbPb":"PP"));
string pdfPsi2SNoPRName = Form("pdfCTAUMASS_Psi2SNoPR_%s", (isPbPb?"PbPb":"PP"));
string dsOSName = Form("dOS_%s_%s", DSTAG.c_str(), (isPbPb?"PbPb":"PP"));
string dsOSNameCut = dsOSName+"_CTAUCUT";
string dsSSName = Form("dSS_%s_%s", DSTAG.c_str(), (isPbPb?"PbPb":"PP"));
bool isWeighted = myws.data(dsOSName.c_str())->isWeighted();
bool isMC = (DSTAG.find("MC")!=std::string::npos);
double normDSTot = 1.0; if (myws.data(dsOSNameCut.c_str())) { normDSTot = myws.data(dsOSName.c_str())->sumEntries()/myws.data(dsOSNameCut.c_str())->sumEntries(); }
// Create the main plot of the fit
RooPlot* frame = myws.var("invMass")->frame(Bins(nBins), Range(cut.dMuon.M.Min, cut.dMuon.M.Max));
myws.data(dsOSName.c_str())->plotOn(frame, Name("dOS"), DataError(RooAbsData::SumW2), XErrorSize(0), MarkerColor(kBlack), LineColor(kBlack), MarkerSize(1.2));
if (paperStyle) TGaxis::SetMaxDigits(3); // to display powers of 10
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("BKG"),Components(RooArgSet(*myws.pdf(Form("pdfMASS_Bkg_%s", (isPbPb?"PbPb":"PP"))))),
FillStyle(paperStyle ? 0 : 1001), FillColor(kAzure-9), VLines(), DrawOption("LCF"), LineColor(kBlue), LineStyle(kDashed)
);
if (!paperStyle) {
if (incJpsi) {
if ( myws.pdf(Form("pdfCTAUMASS_JpsiPR_%s", (isPbPb?"PbPb":"PP"))) ) {
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("JPSIPR"),Components(RooArgSet(*myws.pdf(Form("pdfCTAUMASS_JpsiPR_%s", (isPbPb?"PbPb":"PP"))), *myws.pdf(Form("pdfCTAUMASS_Bkg_%s", (isPbPb?"PbPb":"PP"))))),
ProjWData(RooArgSet(*myws.var("ctauErr")), *myws.data(dsOSName.c_str()), kTRUE),
Normalization(normDSTot, RooAbsReal::NumEvent),
LineColor(kRed+3), LineStyle(1), Precision(1e-4), NumCPU(32)
);
}
if ( myws.pdf(Form("pdfCTAUMASS_JpsiNoPR_%s", (isPbPb?"PbPb":"PP"))) ) {
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("JPSINOPR"),Components(RooArgSet(*myws.pdf(Form("pdfCTAUMASS_JpsiNoPR_%s", (isPbPb?"PbPb":"PP"))), *myws.pdf(Form("pdfCTAUMASS_Bkg_%s", (isPbPb?"PbPb":"PP"))))),
ProjWData(RooArgSet(*myws.var("ctauErr")), *myws.data(dsOSName.c_str()), kTRUE),
Normalization(normDSTot, RooAbsReal::NumEvent),
LineColor(kGreen+3), LineStyle(1), Precision(1e-4), NumCPU(32)
);
}
}
if (incPsi2S) {
if ( myws.pdf(Form("pdfCTAUMASS_Psi2SPR_%s", (isPbPb?"PbPb":"PP"))) ) {
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("PSI2SPR"),Components(RooArgSet(*myws.pdf(Form("pdfCTAUMASS_Psi2SPR_%s", (isPbPb?"PbPb":"PP"))))),
ProjWData(RooArgSet(*myws.var("ctauErr")), *myws.data(dsOSName.c_str()), kTRUE),
Normalization(normDSTot, RooAbsReal::NumEvent),
LineColor(kRed+3), LineStyle(1), Precision(1e-4), NumCPU(32)
);
}
if ( myws.pdf(Form("pdfCTAUMASS_Psi2SNoPR_%s", (isPbPb?"PbPb":"PP"))) ) {
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("PSI2SNOPR"),Components(RooArgSet(*myws.pdf(Form("pdfCTAUMASS_Psi2SNoPR_%s", (isPbPb?"PbPb":"PP"))))),
ProjWData(RooArgSet(*myws.var("ctauErr")), *myws.data(dsOSName.c_str()), kTRUE),
Normalization(normDSTot, RooAbsReal::NumEvent),
LineColor(kGreen+3), LineStyle(1), Precision(1e-4), NumCPU(32)
);
}
}
}
if (incSS) {
myws.data(dsSSName.c_str())->plotOn(frame, Name("dSS"), MarkerColor(kRed), LineColor(kRed), MarkerSize(1.2));
}
myws.data(dsOSName.c_str())->plotOn(frame, Name("dOS"), DataError(RooAbsData::SumW2), XErrorSize(0), MarkerColor(kBlack), LineColor(kBlack), MarkerSize(1.2));
myws.pdf(pdfTotName.c_str())->plotOn(frame,Name("PDF"),
ProjWData(RooArgSet(*myws.var("ctauErr")), *myws.data(dsOSName.c_str()), kTRUE),
Normalization(normDSTot, RooAbsReal::NumEvent),
LineColor(kBlack), NumCPU(32)
);
// Create the pull distribution of the fit
RooPlot* frameTMP = (RooPlot*)frame->Clone("TMP");
int nBinsTMP = nBins;
RooHist *hpull = frameTMP->pullHist(0, 0, true);
hpull->SetName("hpull");
RooPlot* frame2 = myws.var("invMass")->frame(Title("Pull Distribution"), Bins(nBins), Range(cut.dMuon.M.Min, cut.dMuon.M.Max));
frame2->addPlotable(hpull, "PX");
// set the CMS style
setTDRStyle();
// Create the main canvas
TCanvas *cFig = new TCanvas(Form("cMassFig_%s", (isPbPb?"PbPb":"PP")), "cMassFig",800,800);
TPad *pad1 = new TPad(Form("pad1_%s", (isPbPb?"PbPb":"PP")),"",0,paperStyle ? 0 : 0.23,1,1);
TPad *pad2 = new TPad(Form("pad2_%s", (isPbPb?"PbPb":"PP")),"",0,0,1,.228);
TLine *pline = new TLine(cut.dMuon.M.Min, 0.0, cut.dMuon.M.Max, 0.0);
// TPad *pad4 = new TPad("pad4","This is pad4",0.55,0.46,0.97,0.87);
TPad *pad4 = new TPad("pad4","This is pad4",0.55,paperStyle ? 0.29 : 0.36,0.97,paperStyle ? 0.70 : 0.77);
pad4->SetFillStyle(0);
pad4->SetLeftMargin(0.28);
pad4->SetRightMargin(0.10);
pad4->SetBottomMargin(0.21);
pad4->SetTopMargin(0.072);
frame->SetTitle("");
frame->GetXaxis()->CenterTitle(kTRUE);
if (!paperStyle) {
frame->GetXaxis()->SetTitle("");
frame->GetXaxis()->SetTitleSize(0.045);
frame->GetXaxis()->SetTitleFont(42);
frame->GetXaxis()->SetTitleOffset(3);
frame->GetXaxis()->SetLabelOffset(3);
frame->GetYaxis()->SetLabelSize(0.04);
frame->GetYaxis()->SetTitleSize(0.04);
frame->GetYaxis()->SetTitleOffset(1.7);
frame->GetYaxis()->SetTitleFont(42);
} else {
frame->GetXaxis()->SetTitle("m_{#mu^{+}#mu^{-}} (GeV/c^{2})");
frame->GetXaxis()->SetTitleOffset(1.1);
frame->GetYaxis()->SetTitleOffset(1.45);
frame->GetXaxis()->SetTitleSize(0.05);
frame->GetYaxis()->SetTitleSize(0.05);
}
setMassFrom2DRange(myws, frame, dsOSName, setLogScale);
if (paperStyle) {
double Ydown = 0.;//frame->GetMinimum();
double Yup = 0.9*frame->GetMaximum();
frame->GetYaxis()->SetRangeUser(Ydown,Yup);
}
cFig->cd();
pad2->SetTopMargin(0.02);
pad2->SetBottomMargin(0.4);
pad2->SetFillStyle(4000);
pad2->SetFrameFillStyle(4000);
if (!paperStyle) pad1->SetBottomMargin(0.015);
//plot fit
pad1->Draw();
pad1->cd();
frame->Draw();
printMassFrom2DParameters(myws, pad1, isPbPb, pdfTotName, isWeighted);
pad1->SetLogy(setLogScale);
// Drawing the text in the plot
TLatex *t = new TLatex(); t->SetNDC(); t->SetTextSize(0.032);
float dy = 0;
t->SetTextSize(0.03);
if (!paperStyle) { // do not print selection details for paper style
t->DrawLatex(0.20, 0.86-dy, "2015 HI Soft Muon ID"); dy+=0.045;
if (isPbPb) {
t->DrawLatex(0.20, 0.86-dy, "HLT_HIL1DoubleMu0_v1"); dy+=2.0*0.045;
} else {
t->DrawLatex(0.20, 0.86-dy, "HLT_HIL1DoubleMu0_v1"); dy+=2.0*0.045;
}
}
if (cut.dMuon.AbsRap.Min>0.1) {t->DrawLatex(0.5175, 0.86-dy, Form("%.1f < |y^{#mu#mu}| < %.1f",cut.dMuon.AbsRap.Min,cut.dMuon.AbsRap.Max)); dy+=0.045;}
else {t->DrawLatex(0.5175, 0.86-dy, Form("|y^{#mu#mu}| < %.1f",cut.dMuon.AbsRap.Max)); dy+=0.045;}
t->DrawLatex(0.5175, 0.86-dy, Form("%g < p_{T}^{#mu#mu} < %g GeV/c",cut.dMuon.Pt.Min,cut.dMuon.Pt.Max)); dy+=0.045;
if (isPbPb) {t->DrawLatex(0.5175, 0.86-dy, Form("Cent. %d-%d%%", (int)(cut.Centrality.Start/2), (int)(cut.Centrality.End/2))); dy+=0.045;}
// Drawing the Legend
double ymin = 0.7602;
if (incPsi2S && incJpsi && incSS) { ymin = 0.7202; }
if (incPsi2S && incJpsi && !incSS) { ymin = 0.7452; }
if (paperStyle) { ymin = 0.72; }
TLegend* leg = new TLegend(0.5175, ymin, 0.7180, 0.8809); leg->SetTextSize(0.03);
if (frame->findObject("dOS")) { leg->AddEntry(frame->findObject("dOS"), (incSS?"Opposite Charge":"Data"),"pe"); }
if (incSS) { leg->AddEntry(frame->findObject("dSS"),"Same Charge","pe"); }
if (frame->findObject("PDF")) { leg->AddEntry(frame->findObject("PDF"),"Total fit","l"); }
if (frame->findObject("JPSIPR")) { leg->AddEntry(frame->findObject("JPSIPR"),"Prompt J/#psi","l"); }
if (frame->findObject("JPSINOPR")) { leg->AddEntry(frame->findObject("JPSINOPR"),"Non-Prompt J/#psi","l"); }
if (incBkg && frame->findObject("BKG")) { leg->AddEntry(frame->findObject("BKG"),"Background",paperStyle ? "l" : "fl"); }
leg->Draw("same");
//Drawing the title
TString label;
if (isPbPb) {
if (opt.PbPb.RunNb.Start==opt.PbPb.RunNb.End){
label = Form("PbPb Run %d", opt.PbPb.RunNb.Start);
} else {
label = Form("%s [%s %d-%d]", "PbPb", "HIOniaL1DoubleMu0", opt.PbPb.RunNb.Start, opt.PbPb.RunNb.End);
}
} else {
if (opt.pp.RunNb.Start==opt.pp.RunNb.End){
label = Form("PP Run %d", opt.pp.RunNb.Start);
} else {
label = Form("%s [%s %d-%d]", "PP", "DoubleMu0", opt.pp.RunNb.Start, opt.pp.RunNb.End);
}
}
// CMS_lumi(pad1, isPbPb ? 105 : 104, 33, label);
CMS_lumi(pad1, isPbPb ? 108 : 107, 33, "");
if (!paperStyle) gStyle->SetTitleFontSize(0.05);
pad1->Update();
cFig->cd();
if (!paperStyle) {
//---plot pull
pad2->Draw();
pad2->cd();
frame2->SetTitle("");
frame2->GetYaxis()->CenterTitle(kTRUE);
frame2->GetYaxis()->SetTitleOffset(0.4);
frame2->GetYaxis()->SetTitleSize(0.1);
frame2->GetYaxis()->SetLabelSize(0.1);
frame2->GetYaxis()->SetTitle("Pull");
frame2->GetXaxis()->CenterTitle(kTRUE);
frame2->GetXaxis()->SetTitleOffset(1);
frame2->GetXaxis()->SetTitleSize(0.12);
frame2->GetXaxis()->SetLabelSize(0.1);
frame2->GetXaxis()->SetTitle("m_{#mu^{+}#mu^{-}} (GeV/c^{2})");
frame2->GetYaxis()->SetRangeUser(-7.0, 7.0);
frame2->Draw();
// *** Print chi2/ndof
printChi2(myws, pad2, frameTMP, "invMass", dsOSName.c_str(), pdfTotName.c_str(), nBinsTMP, false);
pline->Draw("same");
pad2->Update();
}
// Save the plot in different formats
gSystem->mkdir(Form("%sctauMass/%s/plot/root/", outputDir.c_str(), DSTAG.c_str()), kTRUE);
cFig->SaveAs(Form("%sctauMass/%s/plot/root/PLOT_%s_%s_%s%s_pt%.0f%.0f_rap%.0f%.0f_cent%d%d.root", outputDir.c_str(), DSTAG.c_str(), "MASS", DSTAG.c_str(), (isPbPb?"PbPb":"PP"), plotLabel.c_str(), (cut.dMuon.Pt.Min*10.0), (cut.dMuon.Pt.Max*10.0), (cut.dMuon.AbsRap.Min*10.0), (cut.dMuon.AbsRap.Max*10.0), cut.Centrality.Start, cut.Centrality.End));
gSystem->mkdir(Form("%sctauMass/%s/plot/png/", outputDir.c_str(), DSTAG.c_str()), kTRUE);
cFig->SaveAs(Form("%sctauMass/%s/plot/png/PLOT_%s_%s_%s%s_pt%.0f%.0f_rap%.0f%.0f_cent%d%d.png", outputDir.c_str(), DSTAG.c_str(), "MASS", DSTAG.c_str(), (isPbPb?"PbPb":"PP"), plotLabel.c_str(), (cut.dMuon.Pt.Min*10.0), (cut.dMuon.Pt.Max*10.0), (cut.dMuon.AbsRap.Min*10.0), (cut.dMuon.AbsRap.Max*10.0), cut.Centrality.Start, cut.Centrality.End));
gSystem->mkdir(Form("%sctauMass/%s/plot/pdf/", outputDir.c_str(), DSTAG.c_str()), kTRUE);
cFig->SaveAs(Form("%sctauMass/%s/plot/pdf/PLOT_%s_%s_%s%s_pt%.0f%.0f_rap%.0f%.0f_cent%d%d.pdf", outputDir.c_str(), DSTAG.c_str(), "MASS", DSTAG.c_str(), (isPbPb?"PbPb":"PP"), plotLabel.c_str(), (cut.dMuon.Pt.Min*10.0), (cut.dMuon.Pt.Max*10.0), (cut.dMuon.AbsRap.Min*10.0), (cut.dMuon.AbsRap.Max*10.0), cut.Centrality.Start, cut.Centrality.End));
cFig->Clear();
cFig->Close();
};
void RooToyMCFit1Bin(const int _bin){
if(_bin<1 || _bin>8){
cout << "Bin number should be between 1 and 8" << endl;
return;
}
stringstream out;
out.str("");
out << "toyMC_" << _sigma_over_tau << "_" << _purity << "_" << mistag_rate << ".root";
TFile* file = TFile::Open(out.str().c_str());
TTree* tree = (TTree*)file->Get("ToyTree");
cout << "The tree has been readed from the file " << out.str().c_str() << endl;
RooRealVar tau("tau","tau",_tau,"ps"); tau.setConstant(kTRUE);
RooRealVar dm("dm","dm",_dm,"ps^{-1}"); dm.setConstant(kTRUE);
RooRealVar sin2beta("sin2beta","sin2beta",_sin2beta,-5.,5.); if(constBeta) sin2beta.setConstant(kTRUE);
RooRealVar cos2beta("cos2beta","cos2beta",_cos2beta,-5.,5.); if(constBeta) cos2beta.setConstant(kTRUE);
RooRealVar dt("dt","#Deltat",-5.,5.,"ps");
RooRealVar avgMisgat("avgMisgat","avgMisgat",mistag_rate,0.0,0.5); if(constMistag) avgMisgat.setConstant(kTRUE);
RooRealVar delMisgat("delMisgat","delMisgat",0); delMisgat.setConstant(kTRUE);
RooRealVar mu("mu","mu",0); mu.setConstant(kTRUE);
RooRealVar moment("moment","moment",0.); moment.setConstant(kTRUE);
RooRealVar parity("parity","parity",-1.); parity.setConstant(kTRUE);
cout << "Preparing coefficients..." << endl;
RooRealVar* K = new RooRealVar("K","K",K8[_bin-1],0.,1.); if(constK) K->setConstant(kTRUE);
RooFormulaVar* Kb = new RooFormulaVar("Kb","Kb","1-@0",RooArgList(*K));
RooRealVar* C = new RooRealVar("C","C",_C[_bin-1]); C->setConstant(kTRUE);
RooRealVar* S = new RooRealVar("S","S",_S[_bin-1]); S->setConstant(kTRUE);
RooFormulaVar* a1 = new RooFormulaVar("a1","a1","-(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a1b = new RooFormulaVar("a1b","a1b","(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a2 = new RooFormulaVar("a2","a2","(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* a2b = new RooFormulaVar("a2b","a2b","-(@0-@1)/(@0+@1)",RooArgList(*K,*Kb));
RooFormulaVar* b1 = new RooFormulaVar("b1","b1","2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b1b = new RooFormulaVar("b1b","b1b","2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b2 = new RooFormulaVar("b2","b2","-2.*(@2*@4+@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooFormulaVar* b2b = new RooFormulaVar("b2b","b2b","-2.*(@2*@4-@3*@5)*TMath::Sqrt(@0*@1)/(@0+@1);",RooArgList(*K,*Kb,*C,*S,sin2beta,cos2beta));
RooRealVar* dgamma = new RooRealVar("dgamma","dgamma",0.); dgamma->setConstant(kTRUE);
RooRealVar* f0 = new RooRealVar("f0","f0",1.); f0->setConstant(kTRUE);
RooRealVar* f1 = new RooRealVar("f1","f1",0.); f1->setConstant(kTRUE);
RooCategory tag("tag","tag");
tag.defineType("B0",1);
tag.defineType("anti-B0",-1);
RooCategory bin("bin","bin");
bin.defineType("bin",_bin);
bin.defineType("binb",-_bin);
RooSuperCategory bintag("bintag","bintag",RooArgSet(bin,tag));
RooDataSet d("data","data",tree,RooArgSet(dt,bin,tag));
cout << "DataSet is ready." << endl;
d.Print();
RooRealVar mean("mean","mean",0.,"ps"); mean.setConstant(kTRUE);
RooRealVar sigma("sigma","sigma",_sigma_over_tau*_tau,0.,_tau,"ps"); if(constSigma) sigma.setConstant(kTRUE);
RooGaussModel rf("rf","rf",dt,mean,sigma);
// RooTruthModel rf("rf","rf",dt);
RooGaussian rfpdf("rfpdf","rfpdf",dt,mean,sigma);
cout << "Preparing PDFs..." << endl;
RooBDecay* sigpdf1 = new RooBDecay("sigpdf1","sigpdf1",dt,tau,*dgamma,*f0,*f1,*a1,*b1,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf2 = new RooBDecay("sigpdf2","sigpdf2",dt,tau,*dgamma,*f0,*f1,*a2,*b2,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf1b = new RooBDecay("sigpdf1b","sigpdf1b",dt,tau,*dgamma,*f0,*f1,*a1b,*b1b,dm,rf,RooBDecay::DoubleSided);
RooBDecay* sigpdf2b = new RooBDecay("sigpdf2b","sigpdf2b",dt,tau,*dgamma,*f0,*f1,*a2b,*b2b,dm,rf,RooBDecay::DoubleSided);
RooRealVar fsig("fsig","fsigs",_purity,0.,1.); if(constFSig) fsig.setConstant(kTRUE);
RooAddPdf* PDF1 = new RooAddPdf("PDF1","PDF1",RooArgList(*sigpdf1,rfpdf),RooArgList(fsig));
RooAddPdf* PDF2 = new RooAddPdf("PDF2","PDF2",RooArgList(*sigpdf2,rfpdf),RooArgList(fsig));
RooAddPdf* PDF1b= new RooAddPdf("PDF1b","PDF1b",RooArgList(*sigpdf1b,rfpdf),RooArgList(fsig));
RooAddPdf* PDF2b= new RooAddPdf("PDF2b","PDF2b",RooArgList(*sigpdf2b,rfpdf),RooArgList(fsig));
//Adding mistaging
RooAddPdf* pdf1 = new RooAddPdf("pdf1","pdf1",RooArgList(*PDF2,*PDF1),RooArgList(avgMisgat));
RooAddPdf* pdf2 = new RooAddPdf("pdf2","pdf2",RooArgList(*PDF1,*PDF2),RooArgList(avgMisgat));
RooAddPdf* pdf1b= new RooAddPdf("pdf1b","pdf1b",RooArgList(*PDF2b,*PDF1b),RooArgList(avgMisgat));
RooAddPdf* pdf2b= new RooAddPdf("pdf2b","pdf2b",RooArgList(*PDF1b,*PDF2b),RooArgList(avgMisgat));
RooSimultaneous pdf("pdf","pdf",bintag);
pdf.addPdf(*pdf1,"{bin;B0}");
pdf.addPdf(*pdf2,"{bin;anti-B0}");
pdf.addPdf(*pdf1b,"{binb;B0}");
pdf.addPdf(*pdf2b,"{binb;anti-B0}");
cout << "Fitting..." << endl;
pdf.fitTo(d,Verbose(),Timer());
cout << "Drawing plots." << endl;
// Plus bin
RooPlot* dtFrame = dt.frame();
// B0
out.str("");
out << "tag == 1 && bin == " << _bin;
cout << out.str() << endl;
RooDataSet* ds = d.reduce(out.str().c_str());
ds->Print();
ds->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kBlue));
bintag = "{bin;B0}";
pdf.plotOn(dtFrame,ProjWData(RooArgSet(),*ds),Slice(bintag),LineColor(kBlue));
double chi2 = dtFrame->chiSquare();
// anti-B0
out.str("");
out << "tag == -1 && bin == " << _bin;
cout << out.str() << endl;
RooDataSet* dsb = d.reduce(out.str().c_str());
dsb->Print();
dsb->plotOn(dtFrame,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kRed));
bintag = "{bin;anti-B0}";
pdf.plotOn(dtFrame,ProjWData(RooArgSet(),*dsb),Slice(bintag),LineColor(kRed));
double chi2b = dtFrame->chiSquare();
// Canvas
out.str("");
out << "#Delta t, toy MC, bin == " << _bin;
TCanvas* cm = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm->cd();
dtFrame->GetXaxis()->SetTitleSize(0.05);
dtFrame->GetXaxis()->SetTitleOffset(0.85);
dtFrame->GetXaxis()->SetLabelSize(0.05);
dtFrame->GetYaxis()->SetTitleOffset(1.6);
TPaveText *pt = new TPaveText(0.7,0.6,0.98,0.99,"brNDC");
pt->SetFillColor(0);
pt->SetTextAlign(12);
out.str("");
out << "bin = " << _bin;
pt->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
pt->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
pt->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << sigma.getVal()/tau.getVal();
pt->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
pt->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
pt->AddText(out.str().c_str());
dtFrame->Draw();
pt->Draw();
// Minus bin
RooPlot* dtFrameB = dt.frame();
// B0
out.str("");
out << "tag == 1 && bin == " << -_bin;
cout << out.str() << endl;
RooDataSet* ds2 = d.reduce(out.str().c_str());
ds2->Print();
ds2->plotOn(dtFrameB,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kBlue));
bintag = "{binb;B0}";
pdf.plotOn(dtFrameB,ProjWData(RooArgSet(),*ds2),Slice(bintag),LineColor(kBlue));
chi2 = dtFrameB->chiSquare();
//anti-B0
out.str("");
out << "tag == -1 && bin == " << -_bin;
cout << out.str() << endl;
RooDataSet* dsb2 = d.reduce(out.str().c_str());
dsb2->Print();
dsb2->plotOn(dtFrameB,DataError(RooAbsData::SumW2),MarkerSize(1),MarkerColor(kRed));
bintag = "{binb;anti-B0}";
pdf.plotOn(dtFrameB,ProjWData(RooArgSet(),*dsb2),Slice(bintag),LineColor(kRed));
chi2b = dtFrameB->chiSquare();
//Canvas
out.str("");
out << "#Delta t, toy MC, bin == " << -_bin;
TCanvas* cm2 = new TCanvas(out.str().c_str(),out.str().c_str(),600,400);
cm2->cd();
dtFrameB->GetXaxis()->SetTitleSize(0.05);
dtFrameB->GetXaxis()->SetTitleOffset(0.85);
dtFrameB->GetXaxis()->SetLabelSize(0.05);
dtFrameB->GetYaxis()->SetTitleOffset(1.6);
TPaveText *ptB = new TPaveText(0.7,0.65,0.98,0.99,"brNDC");
ptB->SetFillColor(0);
ptB->SetTextAlign(12);
out.str("");
out << "bin = " << -_bin;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(B^{0}) = " << chi2;
ptB->AddText(out.str().c_str());
out.str("");
out << "#chi^{2}(#barB^{0}) = " << chi2b;
ptB->AddText(out.str().c_str());
out.str("");
out << "#sigma/#tau = " << sigma.getVal()/tau.getVal();
ptB->AddText(out.str().c_str());
out.str("");
out << "purity = " << _purity;
ptB->AddText(out.str().c_str());
out.str("");
out << "mistag = " << mistag_rate;
ptB->AddText(out.str().c_str());
dtFrameB->Draw();
ptB->Draw();
return;
}
void fitSignalShapeW(int massBin,int id, int channels,int categ, int sample,
/* float lumi, bool doSfLepton, */double rangeLow, double rangeHigh,
double bwSigma,
double fitValues[9], double fitErrors[9], double covQual[1]){
// ------ root settings ---------
gROOT->Reset();
gROOT->SetStyle("Plain");
gStyle->SetPadGridX(kFALSE);
gStyle->SetPadGridY(kFALSE);
//gStyle->SetOptStat("kKsSiourRmMen");
gStyle->SetOptStat("iourme");
//gStyle->SetOptStat("rme");
//gStyle->SetOptStat("");
gStyle->SetOptFit(11);
gStyle->SetPadLeftMargin(0.14);
gStyle->SetPadRightMargin(0.06);
// ------------------------------
ROOT::Math::MinimizerOptions::SetDefaultTolerance( 1.E-7);
stringstream FileName;
//Insert the file here
if(sample==1) FileName <<"root://lxcms03//data3/Higgs/150915/ZH125/ZZ4lAnalysis.root" ;
else if(sample==2) FileName << "root://lxcms03//data3/Higgs/150915/WplusH125/ZZ4lAnalysis.root";
else if(sample==3) FileName << "root://lxcms03//data3/Higgs/150915/WminusH125/ZZ4lAnalysis.root";
else if(sample==4) FileName << "root://lxcms03//data3/Higgs/150915/ttH125/ZZ4lAnalysis.root";
else {
cout << "Wrong sample." << endl;
return;
}
cout << "Using " << FileName.str() << endl;
TFile* ggFile = TFile::Open(FileName.str().c_str());
TTree* ggTree = (TTree*) ggFile->Get("ZZTree/candTree");
float m4l;
Short_t z1flav, z2flav;
float weight;
Short_t nExtraLeptons;
float ZZPt;
Short_t nJets;
Short_t nBTaggedJets;
std::vector<float> * jetpt = 0;
std::vector<float> * jeteta = 0;
std::vector<float> * jetphi = 0;
std::vector<float> * jetmass = 0;
float jet30pt[10];
float jet30eta[10];
float jet30phi[10];
float jet30mass[10];
float Fisher;
int nentries = ggTree->GetEntries();
//--- ggTree part
ggTree->SetBranchAddress("ZZMass",&m4l);
ggTree->SetBranchAddress("Z1Flav",&z1flav);
ggTree->SetBranchAddress("Z2Flav",&z2flav);
ggTree->SetBranchAddress("genHEPMCweight",&weight);
ggTree->SetBranchAddress("nExtraLep",&nExtraLeptons);
ggTree->SetBranchAddress("nCleanedJets",&nJets);
ggTree->SetBranchAddress("nCleanedJetsPt30BTagged",&nBTaggedJets);
ggTree->SetBranchAddress("DiJetFisher",&Fisher);
ggTree->SetBranchAddress("JetPt",&jetpt);
ggTree->SetBranchAddress("JetEta",&jeteta);
ggTree->SetBranchAddress("JetPhi",&jetphi);
ggTree->SetBranchAddress("JetMass",&jetmass);
ggTree->SetBranchAddress("ZZPt",&ZZPt);
//--- rooFit part
double xMin,xMax,xInit;
xInit = (double) massBin;
xMin = rangeLow;
xMax = rangeHigh ;
cout << "Fit range: [" << xMin << " , " << xMax << "]. Init value = " << xInit << endl;
TH1F *hmass = new TH1F("hmass","hmass",200,xMin,xMax);
//---------
RooRealVar x("mass","m_{4l}",xInit,xMin,xMax,"GeV");
RooRealVar w("myW","myW",1.0,0.,1000.);
RooArgSet ntupleVarSet(x,w);
RooDataSet dataset("mass4l","mass4l",ntupleVarSet,WeightVar("myW"));
for(int k=0; k<nentries; k++){
ggTree->GetEvent(k);
int njet30 = 0;
for (unsigned int ijet = 0; ijet < jetpt->size(); ijet++) {
if ( (*jetpt)[ijet] > 30. ) {
jet30pt[njet30] = (*jetpt)[ijet];
jet30eta[njet30] = (*jeteta)[ijet];
jet30phi[njet30] = (*jetphi)[ijet];
jet30mass[njet30] = (*jetmass)[ijet];
njet30++;
}
}
int Cat = category(nExtraLeptons, ZZPt, m4l, njet30, nBTaggedJets, jet30pt, jet30eta, jet30phi,jet30mass, Fisher);
if (categ >= 0 && categ != Cat ) continue;
if(channels==0 && z1flav*z2flav != 28561) continue;
if(channels==1 && z1flav*z2flav != 14641) continue;
if (weight <= 0 ) cout << "Warning! Negative weight events" << endl;
if(channels==2 && z1flav*z2flav != 20449) continue;
ntupleVarSet.setRealValue("mass",m4l);
ntupleVarSet.setRealValue("myW",weight);
if(x.getVal()>xMin && x.getVal()<xMax)
dataset.add(ntupleVarSet, weight);
hmass->Fill(m4l);
}
//---------
cout << "dataset n entries: " << dataset.sumEntries() << endl;
TCanvas *c1 = new TCanvas("c1","c1",725,725);
c1->cd();
TPad *pad1 = new TPad("pad1","This is pad1",0.05,0.35,0.95,0.97);
pad1->Draw();
TPad *pad2 = new TPad("pad2","This is pad2",0.05,0.02,0.95,0.35);
pad2->Draw();
//--- double CrystalBall
RooRealVar mean("bias","mean of gaussian",0,-5.,5.) ;
RooRealVar sigma("sigma","width of gaussian",1.5,0.,30.);
RooRealVar a1("a1","a1",1.46,0.5,5.);
RooRealVar n1("n1","n1",1.92,0.,10.);
RooRealVar a2("a2","a2",1.46,1.,10.);
RooRealVar n2("n2","n2",20,1.,50.);
RooDoubleCB DCBall("DCBall","Double Crystal ball",x,mean,sigma,a1,n1,a2,n2);
if (channels== 1) mean.setVal(-1.);
//--- Breit-Wigner
float bwSigmaMax,bwSigmaMin;
if(massBin<400) bwSigmaMin=bwSigmaMax=bwSigma;
else {
bwSigmaMin=bwSigma-20.;
bwSigmaMax=bwSigma+20.;
}
RooRealVar mean3("mean3","mean3",xInit) ;
RooRealVar sigma3("sigma3","width3",bwSigma,bwSigmaMin,bwSigmaMax);
RooRealVar scale3("scale3","scale3 ",1.);
RooRelBWUFParam bw("bw","bw",x,mean3,scale3);
//Chebyshev-Polynomial
RooRealVar A1("A1","A1",-1,-3,3.);
RooRealVar A2("A2","A2",0.5,-3.,3.);
RooChebychev BkgPDF("BkgPDF","BkgPDF",x ,RooArgList(A1,A2));
//Fraction
RooRealVar frac("frac","Fraction for PDF",0.5,0.,1.);
x.setBins(10000,"fft");
RooFFTConvPdf model("model","model",x,bw,DCBall);
RooAddPdf totPDF("totPDF","Total PDF ",RooArgList(model,BkgPDF),RooArgList(frac));
RooArgSet* params = totPDF.getParameters(x);
if(sample!=1 && categ!=0 && id!=125){
if(channels==0 ){params->readFromFile("Ch0_Cat0_paraT.txt");}// Read the Parameter for the Resonance + Bkg(ChebyChev)
if(channels==1 ){params->readFromFile("Ch1_Cat0_paraT.txt");}// Read the Parameter for the Resonance + Bkg(ChebyChev)
if(channels==2 ){params->readFromFile("Ch2_Cat0_paraT.txt");}// Read the Parameter for the Resonance + Bkg(ChebyChev)
}
RooFitResult *fitres = (RooFitResult*)totPDF.fitTo(dataset,SumW2Error(1),Range(xMin,xMax),Strategy(2),NumCPU(8),Save(true));
if (sample==1 && categ==0 && id==125){
mean.setConstant(kTRUE);
sigma.setConstant(kTRUE);
a1.setConstant(kTRUE);
n1.setConstant(kTRUE);
a2.setConstant(kTRUE);
n2.setConstant(kTRUE);
mean3.setConstant(kTRUE);
sigma3.setConstant(kTRUE);
scale3.setConstant(kTRUE);
A1.setConstant(kTRUE);
A2.setConstant(kTRUE);
frac.setConstant(kTRUE);
if(channels==0 ){
params->readFromFile("Ch0_Cat0_para.txt"); // Read the Parameter for the Resonance as ggH sample
params->writeToFile("Ch0_Cat0_paraT.txt");} // Writing the Parameter for Full PDF including the Chebyshev-Polynomial
if(channels==1 )
{params->readFromFile("Ch1_Cat0_para.txt"); // Read the Parameter for the Resonance as in ggH sample
params->writeToFile("Ch1_Cat0_paraT.txt");}// Writing the Parameter for Full PDF including the Chebyshev-Polynomial
if(channels==2 ){
params->readFromFile("Ch2_Cat0_para.txt"); // Read the Parameter for the Resonance as ggH sample
params->writeToFile("Ch2_Cat0_paraT.txt");}// Writing the Parameter for Full PDF including the Chebyshev-Polynomial
}
stringstream frameTitle;
if(channels==0){frameTitle << "4#mu, m_{H} = "; }
if(channels==1){frameTitle << "4e, m_{H} = ";}
if(channels==2){frameTitle << "2e2#mu, m_{H} = ";}
frameTitle << massBin << " GeV";
stringstream nameFileRoot;
nameFileRoot << "fitM" << massBin << ".root";
TFile *fileplot = TFile::Open(nameFileRoot.str().c_str(), "recreate");
RooPlot* xframe = x.frame() ;
xframe->SetTitle("");
xframe->SetName("m4lplot");
dataset.plotOn(xframe,DataError(RooAbsData::SumW2), MarkerStyle(kOpenCircle), MarkerSize(1.1) );
int col;
if(channels==0) col=kOrange+7;
if(channels==1) col=kAzure+2;
if(channels==2) col=kGreen+3;
totPDF.plotOn(xframe,LineColor(col));
RooHist* hpull = xframe->pullHist();
RooPlot* frame3 = x.frame(Title("Pull Distribution")) ;
frame3->addPlotable(hpull,"P");
// cosmetics
TLegend *legend = new TLegend(0.20,0.45,0.45,0.60,NULL,"brNDC");
legend->SetBorderSize(0);
legend->SetFillColor(0);
legend->SetTextAlign(12);
legend->SetTextFont (42);
legend->SetTextSize (0.03);
TH1F *dummyPoints = new TH1F("dummyP","dummyP",1,0,1);
TH1F *dummyLine = new TH1F("dummyL","dummyL",1,0,1);
dummyPoints->SetMarkerStyle(kOpenCircle);
dummyPoints->SetMarkerSize(1.1);
dummyLine->SetLineColor(col);
legend->AddEntry(dummyPoints, "Simulation", "pe");
legend->AddEntry(dummyLine, "Parametric Model", "l");
TPaveText *text = new TPaveText(0.15,0.90,0.77,0.98,"brNDC");
text->AddText("CMS Simulation");
text->SetBorderSize(0);
text->SetFillStyle(0);
text->SetTextAlign(12);
text->SetTextFont(42);
text->SetTextSize(0.03);
TPaveText *titlet = new TPaveText(0.15,0.80,0.60,0.85,"brNDC");
titlet->AddText(frameTitle.str().c_str());
titlet->SetBorderSize(0);
titlet->SetFillStyle(0);
titlet->SetTextAlign(12);
titlet->SetTextFont(132);
titlet->SetTextSize(0.045);
TPaveText *sigmat = new TPaveText(0.15,0.65,0.77,0.78,"brNDC");
stringstream sigmaval0, sigmaval1, sigmaval2;
sigmaval0 << fixed;
sigmaval0 << setprecision(1);
sigmaval0 << "m_{dCB} = " << mean.getVal() + massBin << " GeV";
sigmaval1 << fixed;
sigmaval1 << setprecision(1);
sigmaval1 << "#sigma_{dCB} = " << sigma.getVal() << " GeV";
sigmaval2 << fixed;
sigmaval2 << setprecision(1);
sigmaval2 << "RMS_{eff} = " << effSigma(hmass) << " GeV";
sigmat->AddText(sigmaval1.str().c_str());
sigmat->AddText(sigmaval2.str().c_str());
sigmat->SetBorderSize(0);
sigmat->SetFillStyle(0);
sigmat->SetTextAlign(12);
sigmat->SetTextFont(132);
sigmat->SetTextSize(0.04);
xframe->GetYaxis()->SetTitleOffset(1.5);
cout << "EFF RMS = " << effSigma(hmass) << " RMS = " << hmass->GetRMS() << endl;
pad1->cd();
stringstream nameFile, nameFileC, nameFilePng;
nameFile << "fitM" << massBin << "_channel" << channels<< "_category"<< categ << ".pdf";
nameFileC << "fitM" << massBin << "_channel" << channels << "_category"<< categ << ".C";
nameFilePng << "fitM" << massBin << "_channel" << channels << "_category"<< categ << ".png";
xframe->Draw();
gPad->Update(); legend->Draw(); text->Draw(); sigmat->Draw(); titlet->Draw();
pad2->cd() ;
frame3->Draw() ;
frame3->SetMinimum(-3);
frame3->SetMaximum(3);
TLine *line1 = new TLine(105,0,140,0);
line1->SetLineColor(kRed);
line1->Draw();
c1->Print(nameFile.str().c_str());
c1->SaveAs(nameFileC.str().c_str());
c1->SaveAs(nameFilePng.str().c_str());
fileplot->cd();
xframe->Write();
sigmat->Write();
hmass->Write();
fileplot->Close();
if(fitValues!=0){
fitValues[0] = a1.getVal();
fitValues[1] = a2.getVal();
fitValues[2] = mean.getVal();
fitValues[3] = mean3.getVal();
fitValues[4] = n1.getVal();
fitValues[5] = n2.getVal();
fitValues[6] = sigma.getVal();
fitValues[7] = A1.getVal();
fitValues[8] = A2.getVal();
}
if(fitErrors!=0){
fitErrors[0] = a1.getError();
fitErrors[1] = a2.getError();
fitErrors[2] = mean.getError();
fitErrors[3] = mean3.getError();
fitErrors[4] = n1.getError();
fitErrors[5] = n2.getError();
fitErrors[6] = sigma.getError();
fitErrors[7] = A1.getError();
fitErrors[8] = A2.getError();
}
covQual[0] = fitres->covQual();
}
void BackgroundPrediction(std::string pname,int rebin_factor,int model_number = 0,int imass=750, bool plotBands = false)
{
rebin = rebin_factor;
std::string fname = std::string("../fitFilesMETPT34/") + pname + std::string("/histos_bkg.root");
stringstream iimass ;
iimass << imass;
std::string dirName = "info_"+iimass.str()+"_"+pname;
gStyle->SetOptStat(000000000);
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
setTDRStyle();
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
gStyle->SetOptStat(0000);
writeExtraText = true; // if extra text
extraText = "Preliminary"; // default extra text is "Preliminary"
lumi_13TeV = "2.7 fb^{-1}"; // default is "19.7 fb^{-1}"
lumi_7TeV = "4.9 fb^{-1}"; // default is "5.1 fb^{-1}"
double ratio_tau=-1;
TFile *f=new TFile(fname.c_str());
TH1F *h_mX_CR_tau=(TH1F*)f->Get("distribs_18_10_1")->Clone("CR_tau");
TH1F *h_mX_SR=(TH1F*)f->Get("distribs_18_10_0")->Clone("The_SR");
double maxdata = h_mX_SR->GetMaximum();
double nEventsSR = h_mX_SR->Integral(600,4000);
ratio_tau=(h_mX_SR->GetSumOfWeights()/(h_mX_CR_tau->GetSumOfWeights()));
//double nEventsSR = h_mX_SR->Integral(600,4000);
std::cout<<"ratio tau "<<ratio_tau<<std::endl;
TH1F *h_SR_Prediction;
TH1F *h_SR_Prediction2;
if(blind) {
h_SR_Prediction2 = (TH1F*)h_mX_CR_tau->Clone("h_SR_Prediction2");
h_mX_CR_tau->Rebin(rebin);
h_mX_CR_tau->SetLineColor(kBlack);
h_SR_Prediction=(TH1F*)h_mX_CR_tau->Clone("h_SR_Prediction");
} else {
h_SR_Prediction2=(TH1F*)h_mX_SR->Clone("h_SR_Prediction2");
h_mX_SR->Rebin(rebin);
h_mX_SR->SetLineColor(kBlack);
h_SR_Prediction=(TH1F*)h_mX_SR->Clone("h_SR_Prediction");
}
h_SR_Prediction->SetMarkerSize(0.7);
h_SR_Prediction->GetYaxis()->SetTitleOffset(1.2);
h_SR_Prediction->Sumw2();
/*TFile *f_sig = new TFile((dirName+"/w_signal_"+iimass.str()+".root").c_str());
RooWorkspace* xf_sig = (RooWorkspace*)f_sig->Get("Vg");
RooAbsPdf *xf_sig_pdf = (RooAbsPdf *)xf_sig->pdf((std::string("signal_fixed_")+pname).c_str());
RooWorkspace w_sig("w");
w_sig.import(*xf_sig_pdf,RooFit::RenameVariable((std::string("signal_fixed_")+pname).c_str(),(std::string("signal_fixed_")+pname+std::string("low")).c_str()),RooFit::RenameAllVariablesExcept("low","x"));
xf_sig_pdf = w_sig.pdf((std::string("signal_fixed_")+pname+std::string("low")).c_str());
RooArgSet* biasVars = xf_sig_pdf->getVariables();
TIterator *it = biasVars->createIterator();
RooRealVar* var = (RooRealVar*)it->Next();
while (var) {
var->setConstant(kTRUE);
var = (RooRealVar*)it->Next();
}
*/
RooRealVar x("x", "m_{X} (GeV)", SR_lo, SR_hi);
RooRealVar nBackground((std::string("bg_")+pname+std::string("_norm")).c_str(),"nbkg",h_mX_SR->GetSumOfWeights());
RooRealVar nBackground2((std::string("alt_bg_")+pname+std::string("_norm")).c_str(),"nbkg",h_mX_SR->GetSumOfWeights());
std::string blah = pname;
//pname=""; //Antibtag=tag to constrain b-tag to the anti-btag shape
/* RooRealVar bg_p0((std::string("bg_p0_")+pname).c_str(), "bg_p0", 4.2, 0, 200.);
RooRealVar bg_p1((std::string("bg_p1_")+pname).c_str(), "bg_p1", 4.5, 0, 300.);
RooRealVar bg_p2((std::string("bg_p2_")+pname).c_str(), "bg_p2", 0.000047, 0, 10.1);
RooGenericPdf bg_pure = RooGenericPdf((std::string("bg_pure_")+blah).c_str(),"(pow(1-@0/13000,@1)/pow(@0/13000,@2+@3*log(@0/13000)))",RooArgList(x,bg_p0,bg_p1,bg_p2));
*/
RooRealVar bg_p0((std::string("bg_p0_")+pname).c_str(), "bg_p0", 0., -1000, 200.);
RooRealVar bg_p1((std::string("bg_p1_")+pname).c_str(), "bg_p1", -13, -1000, 1000.);
RooRealVar bg_p2((std::string("bg_p2_")+pname).c_str(), "bg_p2", -1.4, -1000, 1000.);
bg_p0.setConstant(kTRUE);
//RooGenericPdf bg_pure = RooGenericPdf((std::string("bg_pure_")+blah).c_str(),"(pow(@0/13000,@1+@2*log(@0/13000)))",RooArgList(x,bg_p1,bg_p2));
RooGenericPdf bg = RooGenericPdf((std::string("bg_")+blah).c_str(),"(pow(@0/13000,@1+@2*log(@0/13000)))",RooArgList(x,bg_p1,bg_p2));
/*TF1* biasFunc = new TF1("biasFunc","(0.63*x/1000-1.45)",1350,3600);
TF1* biasFunc2 = new TF1("biasFunc2","TMath::Min(2.,2.3*x/1000-3.8)",1350,3600);
double bias_term_s = 0;
if ((imass > 2450 && blah == "antibtag") || (imass > 1640 && blah == "btag")) {
if (blah == "antibtag") {
bias_term_s = 2.7*biasFunc->Eval(imass);
} else {
bias_term_s = 2.7*biasFunc2->Eval(imass);
}
bias_term_s/=nEventsSR;
}
RooRealVar bias_term((std::string("bias_term_")+blah).c_str(), "bias_term", 0., -bias_term_s, bias_term_s);
//bias_term.setConstant(kTRUE);
RooAddPdf bg((std::string("bg_")+blah).c_str(), "bg_all", RooArgList(*xf_sig_pdf, bg_pure), bias_term);
*/
string name_output = "CR_RooFit_Exp";
std::cout<<"Nevents "<<nEventsSR<<std::endl;
RooDataHist pred("pred", "Prediction from SB", RooArgList(x), h_SR_Prediction);
RooFitResult *r_bg=bg.fitTo(pred, RooFit::Minimizer("Minuit2"), RooFit::Range(SR_lo, SR_hi), RooFit::SumW2Error(kTRUE), RooFit::Save());
//RooFitResult *r_bg=bg.fitTo(pred, RooFit::Range(SR_lo, SR_hi), RooFit::Save());
//RooFitResult *r_bg=bg.fitTo(pred, RooFit::Range(SR_lo, SR_hi), RooFit::Save(),RooFit::SumW2Error(kTRUE));
std::cout<<" --------------------- Building Envelope --------------------- "<<std::endl;
//std::cout<< "bg_p0_"<< pname << " param "<<bg_p0.getVal() << " "<<bg_p0.getError()<<std::endl;
std::cout<< "bg_p1_"<< pname << " param "<<bg_p1.getVal() << " "<<100*bg_p1.getError()<<std::endl;
std::cout<< "bg_p2_"<< pname << " param "<<bg_p2.getVal() << " "<<100*bg_p2.getError()<<std::endl;
//std::cout<< "bias_term_"<< blah << " param 0 "<<bias_term_s<<std::endl;
RooPlot *aC_plot=x.frame();
pred.plotOn(aC_plot, RooFit::MarkerColor(kPink+2));
if (!plotBands) {
bg.plotOn(aC_plot, RooFit::VisualizeError(*r_bg, 2), RooFit::FillColor(kYellow));
bg.plotOn(aC_plot, RooFit::VisualizeError(*r_bg, 1), RooFit::FillColor(kGreen));
}
bg.plotOn(aC_plot, RooFit::LineColor(kBlue));
//pred.plotOn(aC_plot, RooFit::LineColor(kBlack), RooFit::MarkerColor(kBlack));
TGraph* error_curve[5]; //correct error bands
TGraphAsymmErrors* dataGr = new TGraphAsymmErrors(h_SR_Prediction->GetNbinsX()); //data w/o 0 entries
for (int i=2; i!=5; ++i) {
error_curve[i] = new TGraph();
}
error_curve[2] = (TGraph*)aC_plot->getObject(1)->Clone("errs");
int nPoints = error_curve[2]->GetN();
error_curve[0] = new TGraph(2*nPoints);
error_curve[1] = new TGraph(2*nPoints);
error_curve[0]->SetFillStyle(1001);
error_curve[1]->SetFillStyle(1001);
error_curve[0]->SetFillColor(kGreen);
error_curve[1]->SetFillColor(kYellow);
error_curve[0]->SetLineColor(kGreen);
error_curve[1]->SetLineColor(kYellow);
if (plotBands) {
RooDataHist pred2("pred2", "Prediction from SB", RooArgList(x), h_SR_Prediction2);
error_curve[3]->SetFillStyle(1001);
error_curve[4]->SetFillStyle(1001);
error_curve[3]->SetFillColor(kGreen);
error_curve[4]->SetFillColor(kYellow);
error_curve[3]->SetLineColor(kGreen);
error_curve[4]->SetLineColor(kYellow);
error_curve[2]->SetLineColor(kBlue);
error_curve[2]->SetLineWidth(3);
double binSize = rebin;
for (int i=0; i!=nPoints; ++i) {
double x0,y0, x1,y1;
error_curve[2]->GetPoint(i,x0,y0);
RooAbsReal* nlim = new RooRealVar("nlim","y0",y0,-100000,100000);
//double lowedge = x0 - (SR_hi - SR_lo)/double(2*nPoints);
//double upedge = x0 + (SR_hi - SR_lo)/double(2*nPoints);
double lowedge = x0 - binSize/2.;
double upedge = x0 + binSize/2.;
x.setRange("errRange",lowedge,upedge);
RooExtendPdf* epdf = new RooExtendPdf("epdf","extpdf",bg, *nlim,"errRange");
// Construct unbinned likelihood
RooAbsReal* nll = epdf->createNLL(pred2,NumCPU(2));
// Minimize likelihood w.r.t all parameters before making plots
RooMinimizer* minim = new RooMinimizer(*nll);
minim->setMinimizerType("Minuit2");
minim->setStrategy(2);
minim->setPrintLevel(-1);
minim->migrad();
minim->hesse();
RooFitResult* result = minim->lastMinuitFit();
double errm = nlim->getPropagatedError(*result);
//std::cout<<x0<<" "<<lowedge<<" "<<upedge<<" "<<y0<<" "<<nlim->getVal()<<" "<<errm<<std::endl;
error_curve[0]->SetPoint(i,x0,(y0-errm));
error_curve[0]->SetPoint(2*nPoints-i-1,x0,y0+errm);
error_curve[1]->SetPoint(i,x0,(y0-2*errm));
error_curve[1]->SetPoint(2*nPoints-i-1,x0,(y0+2*errm));
error_curve[3]->SetPoint(i,x0,-errm/sqrt(y0));
error_curve[3]->SetPoint(2*nPoints-i-1,x0,errm/sqrt(y0));
error_curve[4]->SetPoint(i,x0,-2*errm/sqrt(y0));
error_curve[4]->SetPoint(2*nPoints-i-1,x0,2*errm/sqrt(y0));
}
int npois = 0;
dataGr->SetMarkerSize(1.0);
dataGr->SetMarkerStyle (20);
const double alpha = 1 - 0.6827;
for (int i=0; i!=h_SR_Prediction->GetNbinsX(); ++i){
if (h_SR_Prediction->GetBinContent(i+1) > 0) {
int N = h_SR_Prediction->GetBinContent(i+1);
double L = (N==0) ? 0 : (ROOT::Math::gamma_quantile(alpha/2,N,1.));
double U = ROOT::Math::gamma_quantile_c(alpha/2,N+1,1) ;
dataGr->SetPoint(npois,h_SR_Prediction->GetBinCenter(i+1),h_SR_Prediction->GetBinContent(i+1));
dataGr->SetPointEYlow(npois, N-L);
dataGr->SetPointEYhigh(npois, U-N);
npois++;
}
}
}
double xG[2] = {-10,4000};
double yG[2] = {0.0,0.0};
TGraph* unityG = new TGraph(2, xG, yG);
unityG->SetLineColor(kBlue);
unityG->SetLineWidth(1);
double xPad = 0.3;
TCanvas *c_rooFit=new TCanvas("c_rooFit", "c_rooFit", 800*(1.-xPad), 600);
c_rooFit->SetFillStyle(4000);
c_rooFit->SetFrameFillColor(0);
TPad *p_1=new TPad("p_1", "p_1", 0, xPad, 1, 1);
p_1->SetFillStyle(4000);
p_1->SetFrameFillColor(0);
p_1->SetBottomMargin(0.02);
TPad* p_2 = new TPad("p_2", "p_2",0,0,1,xPad);
p_2->SetBottomMargin((1.-xPad)/xPad*0.13);
p_2->SetTopMargin(0.03);
p_2->SetFillColor(0);
p_2->SetBorderMode(0);
p_2->SetBorderSize(2);
p_2->SetFrameBorderMode(0);
p_2->SetFrameBorderMode(0);
p_1->Draw();
p_2->Draw();
p_1->cd();
int nbins = (int) (SR_hi- SR_lo)/rebin;
x.setBins(nbins);
std::cout << "chi2(data) " << aC_plot->chiSquare()<<std::endl;
//std::cout << "p-value: data under hypothesis H0: " << TMath::Prob(chi2_data->getVal(), nbins - 1) << std::endl;
aC_plot->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
aC_plot->GetXaxis()->SetLabelOffset(0.02);
aC_plot->GetYaxis()->SetRangeUser(0.1, 1000.);
h_SR_Prediction->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
string rebin_ = itoa(rebin);
aC_plot->GetXaxis()->SetTitle("M_{Z#gamma} [GeV] ");
aC_plot->GetYaxis()->SetTitle(("Events / "+rebin_+" GeV ").c_str());
aC_plot->SetMarkerSize(0.7);
aC_plot->GetYaxis()->SetTitleOffset(1.2);
aC_plot->Draw();
if (plotBands) {
error_curve[1]->Draw("Fsame");
error_curve[0]->Draw("Fsame");
error_curve[2]->Draw("Lsame");
dataGr->Draw("p e1 same");
}
aC_plot->SetTitle("");
TPaveText *pave = new TPaveText(0.85,0.4,0.67,0.5,"NDC");
pave->SetBorderSize(0);
pave->SetTextSize(0.05);
pave->SetTextFont(42);
pave->SetLineColor(1);
pave->SetLineStyle(1);
pave->SetLineWidth(2);
pave->SetFillColor(0);
pave->SetFillStyle(0);
char name[1000];
sprintf(name,"#chi^{2}/n = %.2f",aC_plot->chiSquare());
pave->AddText(name);
//pave->Draw();
TLegend *leg = new TLegend(0.88,0.65,0.55,0.90,NULL,"brNDC");
leg->SetBorderSize(0);
leg->SetTextSize(0.05);
leg->SetTextFont(42);
leg->SetLineColor(1);
leg->SetLineStyle(1);
leg->SetLineWidth(2);
leg->SetFillColor(0);
leg->SetFillStyle(0);
h_SR_Prediction->SetMarkerColor(kBlack);
h_SR_Prediction->SetLineColor(kBlack);
h_SR_Prediction->SetMarkerStyle(20);
h_SR_Prediction->SetMarkerSize(1.0);
//h_mMMMMa_3Tag_SR->GetXaxis()->SetTitleSize(0.09);
if (blind)
leg->AddEntry(h_SR_Prediction, "Data: sideband", "ep");
else {
if (blah == "antibtag" )
leg->AddEntry(h_SR_Prediction, "Data: anti-b-tag SR", "ep");
else
leg->AddEntry(h_SR_Prediction, "Data: b-tag SR", "ep");
}
leg->AddEntry(error_curve[2], "Fit model", "l");
leg->AddEntry(error_curve[0], "Fit #pm1#sigma", "f");
leg->AddEntry(error_curve[1], "Fit #pm2#sigma", "f");
leg->Draw();
aC_plot->Draw("axis same");
CMS_lumi( p_1, iPeriod, iPos );
p_2->cd();
RooHist* hpull;
hpull = aC_plot->pullHist();
RooPlot* frameP = x.frame() ;
frameP->SetTitle("");
frameP->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
frameP->addPlotable(hpull,"P");
frameP->GetYaxis()->SetRangeUser(-7,7);
frameP->GetYaxis()->SetNdivisions(505);
frameP->GetYaxis()->SetTitle("#frac{(data-fit)}{#sigma_{stat}}");
frameP->GetYaxis()->SetTitleSize((1.-xPad)/xPad*0.06);
frameP->GetYaxis()->SetTitleOffset(1.0/((1.-xPad)/xPad));
frameP->GetXaxis()->SetTitleSize((1.-xPad)/xPad*0.06);
//frameP->GetXaxis()->SetTitleOffset(1.0);
frameP->GetXaxis()->SetLabelSize((1.-xPad)/xPad*0.05);
frameP->GetYaxis()->SetLabelSize((1.-xPad)/xPad*0.05);
frameP->Draw();
if (plotBands) {
error_curve[4]->Draw("Fsame");
error_curve[3]->Draw("Fsame");
unityG->Draw("same");
hpull->Draw("psame");
frameP->Draw("axis same");
}
c_rooFit->SaveAs((dirName+"/"+name_output+".pdf").c_str());
const int nModels = 9;
TString models[nModels] = {
"env_pdf_0_13TeV_dijet2", //0
"env_pdf_0_13TeV_exp1", //1
"env_pdf_0_13TeV_expow1", //2
"env_pdf_0_13TeV_expow2", //3 => skip
"env_pdf_0_13TeV_pow1", //4
"env_pdf_0_13TeV_lau1", //5
"env_pdf_0_13TeV_atlas1", //6
"env_pdf_0_13TeV_atlas2", //7 => skip
"env_pdf_0_13TeV_vvdijet1" //8
};
int nPars[nModels] = {
2, 1, 2, 3, 1, 1, 2, 3, 2
};
TString parNames[nModels][3] = {
"env_pdf_0_13TeV_dijet2_log1","env_pdf_0_13TeV_dijet2_log2","",
"env_pdf_0_13TeV_exp1_p1","","",
"env_pdf_0_13TeV_expow1_exp1","env_pdf_0_13TeV_expow1_pow1","",
"env_pdf_0_13TeV_expow2_exp1","env_pdf_0_13TeV_expow2_pow1","env_pdf_0_13TeV_expow2_exp2",
"env_pdf_0_13TeV_pow1_p1","","",
"env_pdf_0_13TeV_lau1_l1","","",
"env_pdf_0_13TeV_atlas1_coeff1","env_pdf_0_13TeV_atlas1_log1","",
"env_pdf_0_13TeV_atlas2_coeff1","env_pdf_0_13TeV_atlas2_log1","env_pdf_0_13TeV_atlas2_log2",
"env_pdf_0_13TeV_vvdijet1_coeff1","env_pdf_0_13TeV_vvdijet1_log1",""
}
if(bias){
//alternative model
gSystem->Load("libHiggsAnalysisCombinedLimit");
gSystem->Load("libdiphotonsUtils");
TFile *f = new TFile("antibtag_multipdf.root");
RooWorkspace* xf = (RooWorkspace*)f->Get("wtemplates");
RooWorkspace *w_alt=new RooWorkspace("Vg");
for(int i=model_number; i<=model_number; i++){
RooMultiPdf *alternative = (RooMultiPdf *)xf->pdf("model_bkg_AntiBtag");
std::cout<<"Number of pdfs "<<alternative->getNumPdfs()<<std::endl;
for (int j=0; j!=alternative->getNumPdfs(); ++j){
std::cout<<alternative->getPdf(j)->GetName()<<std::endl;
}
RooAbsPdf *alt_bg = alternative->getPdf(alternative->getCurrentIndex()+i);//->clone();
w_alt->import(*alt_bg, RooFit::RenameVariable(alt_bg->GetName(),("alt_bg_"+blah).c_str()));
w_alt->Print("V");
std::cerr<<w_alt->var("x")<<std::endl;
RooRealVar * range_ = w_alt->var("x");
range_->setRange(SR_lo,SR_hi);
char* asd = ("alt_bg_"+blah).c_str() ;
w_alt->import(nBackground2);
std::cout<<alt_bg->getVal() <<std::endl;
w_alt->pdf(asd)->fitTo(pred, RooFit::Minimizer("Minuit2"), RooFit::Range(SR_lo, SR_hi), RooFit::SumW2Error(kTRUE), RooFit::Save());
RooArgSet* altVars = w_alt->pdf(asd)->getVariables();
TIterator *it2 = altVars->createIterator();
RooRealVar* varAlt = (RooRealVar*)it2->Next();
while (varAlt) {
varAlt->setConstant(kTRUE);
varAlt = (RooRealVar*)it2->Next();
}
alt_bg->plotOn(aC_plot, RooFit::LineColor(i+1), RooFit::LineStyle(i+2));
p_1->cd();
aC_plot->GetYaxis()->SetRangeUser(0.01, maxdata*50.);
aC_plot->Draw("same");
TH1F *h=new TH1F();
h->SetLineColor(1+i);
h->SetLineStyle(i+2);
leg->AddEntry(h, alt_bg->GetName(), "l");
w_alt->SaveAs((dirName+"/w_background_alternative.root").c_str());
}
leg->Draw();
p_1->SetLogy();
c_rooFit->Update();
c_rooFit->SaveAs((dirName+"/"+name_output+blah+"_multipdf.pdf").c_str());
for (int i=0; i!=nPars[model_number]; ++i) {
std::cout<<parNames[model_number][i]<<" param "<< w_alt->var(parNames[model_number][i])->getVal()<<" "<<w_alt->var(parNames[model_number][i])->getError()<<std::endl;
}
} else {
p_1->SetLogy();
c_rooFit->Update();
c_rooFit->SaveAs((dirName+"/"+name_output+"_log.pdf").c_str());
}
RooWorkspace *w=new RooWorkspace("Vg");
w->import(bg);
w->import(nBackground);
w->SaveAs((dirName+"/w_background_GaussExp.root").c_str());
TH1F *h_mX_SR_fakeData=(TH1F*)h_mX_SR->Clone("h_mX_SR_fakeData");
h_mX_SR_fakeData->Scale(nEventsSR/h_mX_SR_fakeData->GetSumOfWeights());
RooDataHist data_obs("data_obs", "Data", RooArgList(x), h_mX_SR_fakeData);
std::cout<<" Background number of events = "<<nEventsSR<<std::endl;
RooWorkspace *w_data=new RooWorkspace("Vg");
w_data->import(data_obs);
w_data->SaveAs((dirName+"/w_data.root").c_str());
}
//---------------------------------------------------------------
void doTheFit()
//---------------------------------------------------------------
{
gROOT->SetStyle("Plain");
TFile *_file0 = TFile::Open("analyzeDmeson.root");
gDirectory->cd("demo");
TH1D* histo = (TH1D*)gDirectory->Get("HMASS4");
RooRealVar x("x","D0 mass (GeV)",1.75,1.95);
RooDataHist dh("dh","dh",x,histo);
RooRealVar mean("mean","mean",1.86,1.8,2.0);
RooRealVar sigma("sigma","sigma",0.005,0.001,0.200);
RooRealVar lambda("lambda", "slope", -0.1, -5., 0.);
RooGaussian sig("sig","sig",x,mean,sigma);
RooExponential bck("bck", "exponential PDF", x, lambda);
RooRealVar fsig("fsig","signal fraction 1",0.10,0.,1.);
// fsig.setConstant(kTRUE);
// Signal+Background pdf
RooAddPdf model("model","model",RooArgList(sig,bck),RooArgList(fsig)) ;
// Fit and Plot
RooPlot* frame = x.frame();
model.fitTo(dh);
dh.plotOn(frame);
model.plotOn(frame);
mass = mean.getVal();
masserr = mean.getError();
width = sigma.getVal();
widtherr = sigma.getError();
mean.Print();
sigma.Print();
// Overlay the background component of model with a dashed line
// model.plotOn(frame,Components(bck),LineStyle(kDashed)) ;
model.plotOn(frame,Components(bck),LineColor(kRed)) ;
// Overlay the background+sig2 components of model with a dotted line
// model.plotOn(frame,Components(RooArgSet(sig)),LineStyle(kDotted)) ;
model.plotOn(frame,Components(RooArgSet(sig)),LineColor(kGreen)) ;
// Overlay the background+sig2 components of model with a dotted line
// model.plotOn(frame,Components(RooArgSet(sig2)),LineStyle(kDotted)) ;
TCanvas* c = new TCanvas("D0 meson candidate","D0 meson candidate");
gPad->SetLeftMargin(0.15);
frame->GetYaxis()->SetTitleOffset(1.4);
frame->GetXaxis()->SetLabelSize(0.04);
frame->Draw();
c->Update();
}
TCanvas* comparePlots2(RooPlot *plot_bC, RooPlot *plot_bS, TH1F *data, TH1F *qcd, std::string title)
{
RooRealVar x("x", "m_{X} (GeV)", SR_lo, SR_hi);
TCanvas *c=new TCanvas(("c_RooFit_"+title).c_str(), "c", 700, 700);
TPad *p_1=new TPad("p_1", "p_1", 0, 0.35, 1, 1);
gStyle->SetPadGridX(0);
gStyle->SetPadGridY(0);
gROOT->SetStyle("Plain");
p_1->SetFrameFillColor(0);
TPad *p_2 = new TPad("p_2", "p_2",0,0.003740648,0.9975278,0.3391022);
p_2->Range(160.1237,-0.8717948,1008.284,2.051282);
p_2->SetFillColor(0);
p_2->SetBorderMode(0);
p_2->SetBorderSize(2);
p_2->SetTopMargin(0.02);
p_2->SetBottomMargin(0.3);
p_2->SetFrameBorderMode(0);
p_2->SetFrameBorderMode(0);
p_1->Draw();
p_2->Draw();
p_1->cd();
double maxdata=data->GetMaximum();
double maxqcd=qcd->GetMaximum();
double maxy=(maxdata>maxqcd) ? maxdata : maxqcd;
title=";m_{X} (GeV); Events / "+itoa(data->GetBinWidth(1))+" GeV";
p_1->DrawFrame(SR_lo, 0, SR_hi, maxy*1., title.c_str());
plot_bS->SetMarkerStyle(20);
plot_bS->Draw("same");
// plot_bS->Draw("same");
CMS_lumi( p_1, iPeriod, iPos );
p_2->cd();
/* TH1F *h_ratio=(TH1F*)data->Clone("h_ratio");
h_ratio->GetYaxis()->SetTitle("VR/VSB Ratio");
h_ratio->GetXaxis()->SetTitle("m_{X} (GeV)");
h_ratio->SetTitle("");//("VR/VR-SB Ratio "+title+" ; VR/VR-SB Ratio").c_str());
h_ratio->GetYaxis()->SetTitleSize(0.07);
h_ratio->GetYaxis()->SetTitleOffset(0.5);
h_ratio->GetXaxis()->SetTitleSize(0.09);
h_ratio->GetXaxis()->SetTitleOffset(1.0);
h_ratio->GetXaxis()->SetLabelSize(0.07);
h_ratio->GetYaxis()->SetLabelSize(0.06);
h_ratio->Divide(qcd);
h_ratio->SetLineColor(1);
h_ratio->SetMarkerStyle(20);
h_ratio->GetXaxis()->SetRangeUser(SR_lo, SR_hi-10);
h_ratio->GetYaxis()->SetRangeUser(0.,2.);
*/
RooHist* hpull;
hpull = plot_bS->pullHist();
hpull->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
RooPlot* frameP = x.frame() ;
frameP->SetTitle("");
frameP->GetYaxis()->SetTitle("Pull");
frameP->GetXaxis()->SetRangeUser(SR_lo, SR_hi);
frameP->addPlotable(hpull,"P");
frameP->GetYaxis()->SetTitle("Pull");
frameP->GetYaxis()->SetTitleSize(0.07);
frameP->GetYaxis()->SetTitleOffset(0.5);
frameP->GetXaxis()->SetTitleSize(0.09);
frameP->GetXaxis()->SetTitleOffset(1.0);
frameP->GetXaxis()->SetLabelSize(0.07);
frameP->GetYaxis()->SetLabelSize(0.06);
frameP->Draw();
// TLine *m_one_line = new TLine(SR_lo,1,SR_hi,1);
// h_ratio->Draw("");
// m_one_line->Draw("same");
p_1->cd();
return c;
}
