void getGLWADScor()
{
TFile *f = TFile::Open("winter2012ADSGLWResult.root");
RooFitResult *r = (RooFitResult*)f->Get("fitresult_model_reducedData_binned");
TString vars[] = {
"A_CPP_b2dk_d2kk",
"A_CPP_b2dpi_d2kk",
"A_CPP_b2dk_d2pipi",
"A_CPP_b2dpi_d2pipi",
"A_FAV_b2dk_d2kpi",
"A_FAV_b2dpi_d2kpi",
"R_dk_vs_dpi_d2pipi",
"R_dk_vs_dpi_d2kk",
"R_dk_vs_dpi_d2kpi",
"R_minus_b2dk_d2pik",
"R_minus_b2dpi_d2pik",
"R_plus_b2dk_d2pik",
"R_plus_b2dpi_d2pik"
};
// for ( int i=0; i<13; i++ )
// {
// printf("%20s", vars[i].Data());
// for ( int j=0; j<13; j++ )
// {
// float c = r->correlation(vars[i], vars[j]);
// // if ( fabs(c)<0.01 ) continue;
// // printf("%20s : %20s = %6.3f\n", vars[i].Data(), vars[j].Data(), c);
// if ( fabs(c)<0.00049 )
// printf("%7s", "");
// else
// printf("%7.3f", c);
// }
// cout << endl;
// }
//
// LATEX PRINTOUT
//
for ( int i=0; i<13; i++ )
{
printf(" & %20s ", varToTex(vars[i]).Data());
}
cout << "\\\\" << endl;
cout << "\\hline" << endl;
for ( int i=0; i<13; i++ )
{
printf("%20s & ", varToTex(vars[i]).Data());
for ( int j=0; j<13; j++ )
{
float c = r->correlation(vars[i], vars[j]);
if ( j>=i )
if ( fabs(c)<0.001 ) printf("%7.0f ", 0);
else if ( c==1 ) printf("%7.0f ", 1);
else printf("%7.3f ", c);
else
printf("%7s ", " ");
if ( j<12 ) cout << "&";
}
cout << "\\\\" << endl;
}
}
void TwoCategorySimZFitter( TH1& h_TT, TH1& h_TF,
double intLumi, int removeEE )
{
// The fit variable - lepton invariant mass
rooMass_ = new RooRealVar("Mass","m_{ee}",60.0, 120.0, "GeV/c^{2}");
rooMass_->setBins(20.0);
RooRealVar Mass = *rooMass_;
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("TT", 1) ;
sample.defineType("TF", 2) ;
gROOT->cd();
///////// convert Histograms into RooDataHists
RooDataHist* data_TT = new RooDataHist("data_TT","data_TT",
RooArgList(Mass), &h_TT);
RooDataHist* data_TF = new RooDataHist("data_TF","data_TF",
RooArgList(Mass), &h_TF);
RooDataHist* data = new RooDataHist( "fitData","fitData",
RooArgList(Mass),Index(sample),
Import("TT",*data_TT), Import("TF",*data_TF) );
data->get()->Print();
cout << "Made datahist" << endl;
// ********** Construct signal & bkg shape PDF ********** //
makeSignalPdf();
cout << "Made signal pdf" << endl;
makeBkgPdf();
cout << "Made bkg pdf" << endl;
// Now supply integrated luminosity in inverse picobarn
// --> we get this number from the CMS lumi group
// https://twiki.cern.ch/twiki/bin/view/CMS/LumiWiki2010Data
RooRealVar lumi("lumi","lumi", intLumi);
// Now define Z production cross section variable (in pb)
RooRealVar xsec("xsec","xsec", 1300., 400.0, 2000.0);
// Define efficiency variables
RooRealVar eff("eff","eff", 0.9, 0.5, 1.0);
// Now define acceptance variables --> we get these numbers from MC
// RooRealVar acc_BB("acc_BB","acc_BB", 0.2253);
// RooRealVar acc_EB("acc_EB","acc_EB", 0.1625);
// RooRealVar acc_EE("acc_EE","acc_EE", 0.0479);
double ACCEPTANCE=0.4357;
if(removeEE==1) ACCEPTANCE= 0.3878;
if(removeEE==2) ACCEPTANCE= 0.2253;
RooRealVar acc("acc","acc", ACCEPTANCE);
// Define background yield variables: they are not related to each other
RooRealVar nBkgTF("nBkgTF","nBkgTF",10.,-10.,100000.);
////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
// Define signal yield variables.
// They are linked together by the total cross section: e.g.
// Nbb = sigma*L*Abb*effB
char* formula;
RooArgList* args;
formula = "lumi*xsec*acc*eff*eff";
args = new RooArgList(lumi,xsec,acc,eff);
RooFormulaVar nSigTT("nSigTT", formula, *args);
delete args;
formula = "lumi*xsec*acc*eff*(1.0-eff)";
args = new RooArgList(lumi,xsec,acc,eff);
RooFormulaVar nSigTF("nSigTF",formula, *args);
delete args;
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
RooArgList componentsTF(*signalShapePdfTF_,*bkgShapePdfTF_);
RooArgList yieldsTF(nSigTF, nBkgTF );
RooExtendPdf pdfTT("pdfTT","extended sum pdf", *signalShapePdfTT_, nSigTT);
RooAddPdf pdfTF("pdfTF","extended sum pdf",componentsTF, yieldsTF);
// The total simultaneous fit ...
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfTT,"TT");
totalPdf.Print();
totalPdf.addPdf(pdfTF,"TF");
totalPdf.Print();
// ********* Do the Actual Fit ********** //
RooFitResult *fitResult = totalPdf.fitTo(*data, Save(true),
Extended(), Minos(),
PrintEvalErrors(-1),Warnings(false) );
fitResult->Print("v");
// ********** Make and save Canvas for the plots ********** //
gROOT->ProcessLine(".L ~/tdrstyle.C");
setTDRStyle();
tdrStyle->SetErrorX(0.5);
tdrStyle->SetPadLeftMargin(0.19);
tdrStyle->SetPadRightMargin(0.10);
tdrStyle->SetPadBottomMargin(0.15);
tdrStyle->SetLegendBorderSize(0);
tdrStyle->SetTitleYOffset(1.5);
RooAbsData::ErrorType errorType = RooAbsData::SumW2;
TString cname = Form("Zmass_TT_%dnb", (int)(1000*intLumi) );
c = new TCanvas(cname,cname,500,500);
RooPlot* frame1 = Mass.frame();
data_TT->plotOn(frame1,RooFit::DataError(errorType));
pdfTT.plotOn(frame1,ProjWData(*data_TT));
frame1->SetMinimum(0);
frame1->Draw("e0");
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.1f", intLumi);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = eff.getVal()*xsec.getVal()*acc.getVal()*lumi.getVal();
double xsecFrErr = xsec.getError()/xsec.getVal();
double effFrErr = eff.getError()/eff.getVal();
double effxsecCorr = fitResult->correlation(eff, xsec);
double nsigerr = sqrt(effFrErr**2 +xsecFrErr**2 +
2.0*effxsecCorr*xsecFrErr*effFrErr)*nsig;
sprintf(temp, "Signal = %.2f #pm %.2f", nsig, nsigerr);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "#epsilon = %.4f #pm %.4f", eff.getVal(), eff.getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
sprintf(temp, "#sigma = %.1f #pm %.1f pb", xsec.getVal(), xsec.getError());
plotlabel6->AddText(temp);
plotlabel->Draw();
plotlabel2->Draw();
plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
c->SaveAs( cname + TString(".root"));
c->SaveAs( cname + TString(".png"));
c->SaveAs( cname + TString(".C"));
TString cname = Form("Zmass_TF_%dnb", (int)(1000*intLumi) );
c = new TCanvas(cname,cname,500,500);
RooPlot* frame2 = Mass.frame();
data_TF->plotOn(frame2,RooFit::DataError(errorType));
pdfTF.plotOn(frame2,ProjWData(*data_TF),
Components(*bkgShapePdfTF_),LineColor(kRed));
pdfTF.plotOn(frame2,ProjWData(*data_TF));
frame2->SetMinimum(0);
frame2->Draw("e0");
frame2->GetYaxis()->SetNdivisions(505);
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.1f", intLumi);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = (1.0-eff.getVal())*xsec.getVal()*acc.getVal()*lumi.getVal();
double xsecFrErr = xsec.getError()/xsec.getVal();
double effFrErr = eff.getError()/(1.0-eff.getVal());
double effxsecCorr = fitResult->correlation(eff, xsec);
double nsigerr = sqrt(effFrErr**2 +xsecFrErr**2 +
2.0*effxsecCorr*xsecFrErr*effFrErr)*nsig;
sprintf(temp, "Signal = %.2f #pm %.2f", nsig, nsigerr);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", nBkgTF.getVal(), nBkgTF.getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
sprintf(temp, "#epsilon = %.4f #pm %.4f", eff.getVal(), eff.getError());
plotlabel6->AddText(temp);
plotlabel->Draw();
plotlabel2->Draw();
plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
c->SaveAs( cname + TString(".root"));
c->SaveAs( cname + TString(".png"));
c->SaveAs( cname + TString(".C"));
/*
RooMCStudy toymc( totalPdf, RooArgSet(Mass, sample), Binned(kTRUE),
FitModel(totalPdf), Extended(),FitOptions(Extended(), Minos()));
int numEventsToGenerate = (int)(h_TT.Integral()+h_TF.Integral());
toymc.generateAndFit(1000,numEventsToGenerate);
RooPlot* plot1 = toymc.plotPull( xsec, -4., 4., 24);
plot1->SetTitle("");
plot1->GetXaxis()->SetTitle("cross section pull");
TString cname = Form("pull_crosssection_%dnb", (int)(1000*intLumi));
TCanvas *c2 = new TCanvas(cname,"Pull distribution of cross section",500,500);
plot1->Draw();
c2->SaveAs( cname + TString(".eps"));
c2->SaveAs( cname + TString(".gif"));
c2->SaveAs( cname + TString(".root"));
RooPlot* plot2 = toymc.plotError( eff, 0., 0.2, 20);
plot2->SetTitle("");
plot2->GetXaxis()->SetTitle("Uncertainty in efficiency");
TString cname = Form("error_efficiency_%dnb", (int)(1000*intLumi));
TCanvas *c3 = new TCanvas(cname,"Uncertainty in efficiency",500,500);
plot2->Draw();
c3->SaveAs( cname + TString(".eps"));
c3->SaveAs( cname + TString(".gif"));
c3->SaveAs( cname + TString(".root"));
RooPlot* plot3 = toymc.plotError( xsec, 0., 650., 65);
plot3->SetTitle("");
plot3->GetXaxis()->SetTitle("Uncertainty in cross section (pb)");
TString cname = Form("error_crosssection_%dnb", (int)(1000*intLumi));
TCanvas *c4 = new TCanvas(cname,"Uncertainty in cross section",500,500);
plot3->Draw();
c4->SaveAs( cname + TString(".eps"));
c4->SaveAs( cname + TString(".gif"));
c4->SaveAs( cname + TString(".root"));
*/
// if(data) delete data;
// if(c) delete c;
}
///v1 using unbinnned fit
//input data text file
void FitTagAndProbev1(char *datafile_pass, char *datafile_fail, char *mcRootFile, char *mcPassHist, char *mcFailHist, float xminFit, float xmaxFit, bool SetPassBkgZero,bool SetFailBkgZero){
gROOT->cd();
gROOT->Reset();
gSystem->Load("libRooFit") ;
gSystem->Load("libRooFitCore") ;
RooRealVar* rooMass_ = new RooRealVar("Mass","m_{#mu#mu}",xminFit, xmaxFit, "GeV/c^{2}");
RooRealVar Mass = *rooMass_;
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("Pass", 1) ;
sample.defineType("Fail", 2) ;
///////// convert Histograms into RooDataHists
//RooDataHist* data_pass = new RooDataHist("data_pass","data_pass",
//RooArgList(Mass), hist_pass);
RooDataSet *data_pass = RooDataSet::read(datafile_pass,RooArgSet(Mass));
//RooDataHist* data_fail = new RooDataHist("data_fail","data_fail",
//RooArgList(Mass), hist_fail);
RooDataSet *data_fail = RooDataSet::read(datafile_fail,RooArgSet(Mass));
cout<<data_pass->sumEntries()<<" " <<data_fail->sumEntries()<<endl;
// RooDataHist* data = new RooDataHist( "fitData","fitData",
// RooArgList(Mass),RooFit::Index(sample),
// RooFit::Import("Pass",*hist_pass), RooFit::Import("Fail",*hist_fail) );
RooDataSet* data = new RooDataSet( "fitData","fitData",RooArgList(Mass),RooFit::Index(sample),RooFit::Import("Pass",*data_pass),RooFit::Import("Fail",*data_fail) );
// Signal pdf
//TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag2.mT1.root","read");
// TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag2.mT1.cha1.mt30.root","read");
//res/testTagProbe.dm2.dflag2.mT1.cha1.mt30.root
//TFile *Zeelineshape_file = new TFile("res/testTagProbe.dm2.dflag3.mT1.cha0.mt-1.pu1.root","read");
TFile *Zeelineshape_file = new TFile(mcRootFile,"read");
TH1F *th1 = (TH1F*)Zeelineshape_file->Get(mcPassHist);
// ///int nbins = th1->GetNbinsX();
// int nbins = int( (xmaxFit - xminFit+0.1) / th1->GetBinWidth(1));
// int rebin = 2;
// nbins = nbins/ rebin;
// cout<<"nbins: "<< nbins <<endl;
// th1->Rebin(rebin);
int nbins = 60;
RooDataHist* rdh = new RooDataHist("rdh","", Mass, th1);
TH1 *th1f = (TH1F*)Zeelineshape_file->Get(mcFailHist);
RooDataHist* rdhf = new RooDataHist("rdh","", Mass, th1f);
const char *passHistName = th1->GetName();
const char *failHistName = th1f->GetName();
const char *passHistTitle = th1->GetTitle();
const char *failHistTitle = th1->GetTitle();
float xlowMC = th1->GetXaxis()->GetXmin();
float xmaxMC = th1->GetXaxis()->GetXmax();
if( xminFit < xlowMC || xmaxFit > xmaxMC ){
cout<<"FitRangeNotMC "<< xlowMC <<"to"<< xmaxMC <<" MC "<<endl;
return;
}
int startbin = int((xminFit-xlowMC+0.001)/th1->GetBinWidth(1)) + 1;
int endbin = int((xmaxFit-xlowMC+0.001)/th1->GetBinWidth(1));
float passMC = th1->Integral(startbin,endbin);
float allMC = th1->Integral(startbin,endbin) + th1f->Integral(startbin,endbin);
float effTP_MC = passMC / allMC;
float effTP_MCerr = sqrt( effTP_MC * (1- effTP_MC)/ allMC);
// float effTP_MC = th1->Integral() / ( th1->Integral() + th1f->Integral());
//RooRealVar* rooMass1_ = new RooRealVar("Mass","m_{#mu#mu}",xminFit, xmaxFit, "GeV/c^{2}");
//RooRealVar Mass1 = *rooMass1_;
// RooRealVar* massShift = new RooRealVar("massShift","massShift",0.,-2,2);
//RooFormulaVar* rooMass1_ = new RooFormulaVar("Mass1", "(1-massShift)*Mass", RooArgList(*massShift,Mass));
//RooFormulaVar Mass1 = *rooMass1_;
RooHistPdf* signalShapePdfPass = new RooHistPdf("signalShapePdf", "",
RooArgSet(Mass), *rdh,1);
RooHistPdf* signalShapePdfFail = new RooHistPdf("signalShapePdf", "",
RooArgSet(Mass), *rdhf,1);
RooRealVar cbBias ("#Deltam_{CB}", "CB Bias", 0.05, -2, 2,"GeV/c^{2}");
RooRealVar cbSigma("#sigma_{CB}","CB Width", 1.38, 0.01, 10.0,"GeV/c^{2}");
RooRealVar cbCut ("a_{CB}","CB Cut", 1.5, 0.1, 2.0);
RooRealVar cbPower("n_{CB}","CB Power", 1.3, 0.1, 20.0);
RooRealVar bwMean("m_{Z}","BW Mean", 91.1876, "GeV/c^{2}");
RooRealVar bwWidth("#Gamma_{Z}", "BW Width", 2.4952, "GeV/c^{2}");
RooBreitWigner bw("bw", "bw", Mass, bwMean, bwWidth);
RooCBShape cball("cball", "A Crystal Ball Lineshape", Mass, cbBias, cbSigma, cbCut, cbPower);
RooFFTConvPdf BWxCB("BWxCB","bw (X) crystall ball", Mass, bw, cball);
// Background pass PDF
RooRealVar* bkgShape = new RooRealVar("bkgShape","bkgShape",-0.2,-10.,0.);
if(SetPassBkgZero){
bkgShape = new RooRealVar("bkgShape","bkgShape",0.,0.,0.);
}
RooExponential* bkgShapePdf = new RooExponential("bkgShapePdf","bkgShapePdf",Mass, *bkgShape);
// Background fail PDF
RooRealVar* bkgShapef = new RooRealVar("bkgShapef","bkgShape",-0.2,-10.,0.);
if(SetFailBkgZero){
bkgShapef = new RooRealVar("bkgShapef","bkgShape",0.,0.,0.);
}
RooExponential* bkgShapePdff = new RooExponential("bkgShapePdff","bkgShapePdff",Mass, *bkgShapef);
//RooGenericPdf* bkgShapePdff = new RooGenericPdf("bkgShapePdff","bkgShapePdff","pow(Mass,bkgShapef)",RooArgSet(Mass, *bkgShapef));
// Now define some efficiency/yield variables
RooRealVar* numSignal = new RooRealVar("numSignal","numSignal", 100, 0.0, 1000000.0);
RooRealVar* eff = new RooRealVar("eff","eff", 0.9, 0.2, 1.0);
RooFormulaVar* nSigPass = new RooFormulaVar("nSigPass", "eff*numSignal", RooArgList(*eff,*numSignal));
RooFormulaVar* nSigFail = new RooFormulaVar("nSigFail", "(1.0-eff)*numSignal", RooArgList(*eff,*numSignal));
RooRealVar* nBkgPass = new RooRealVar("nBkgPass","nBkgPass", 100, 0.0, 10000000);
if(SetPassBkgZero){
nBkgPass = new RooRealVar("nBkgPass","nBkgPass", 0., 0., 0.);
}
RooRealVar* nBkgFail = new RooRealVar("nBkgFail","nBkgFail", 100, 0.0, 10000000);
if(SetFailBkgZero){
nBkgFail = new RooRealVar("nBkgFail","nBkgFail", 0.,0.,0.);
}
RooArgList componentsPass(*signalShapePdfPass,*bkgShapePdf);
RooArgList yieldsPass(*nSigPass, *nBkgPass);
RooArgList componentsFail(*signalShapePdfFail,*bkgShapePdff);
// RooArgList componentsFail(BWxCB,*bkgShapePdff);
RooArgList yieldsFail(*nSigFail, *nBkgFail);
RooAddPdf pdfPass("pdfPass","extended sum pdf", componentsPass, yieldsPass);
RooAddPdf pdfFail("pdfFail","extended sum pdf", componentsFail, yieldsFail);
// The total simultaneous fit ...
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfPass,"Pass");
totalPdf.Print();
totalPdf.addPdf(pdfFail,"Fail");
totalPdf.Print();
ifstream readinfail(datafile_fail,ios::in);
float mm;
int ndataFailPeak = 0;
while(readinfail.good()){
if( readinfail.eof()) break;
readinfail>>mm;
if( mm> 80 && mm <100){
ndataFailPeak ++;
}
}
// ********* Do the Actual Fit ********** //
RooFitResult *fitResult = totalPdf.fitTo(*data,RooFit::Save(true),
RooFit::Extended(true), RooFit::PrintLevel(-1));
fitResult->Print("v");
double numerator = nSigPass->getVal();
double nfails = nSigFail->getVal();
double denominator = numerator + nfails;
cout<<"num/den: "<< numerator <<" "<< denominator <<endl;
RooAbsData::ErrorType errorType = RooAbsData::Poisson;
TCanvas *can0 = new TCanvas("can0","c000",200,10,550,500);
setTCanvasNicev1(can0);
//RooPlot* frame1 = Mass.frame();
RooPlot* frame1 = Mass.frame(Range(xminFit,xmaxFit),Bins(nbins));
frame1->SetMinimum(0);
data_pass->plotOn(frame1,RooFit::DataError(errorType));
pdfPass.plotOn(frame1,RooFit::ProjWData(*data_pass),
RooFit::Components(*bkgShapePdf),RooFit::LineColor(kRed));
pdfPass.plotOn(frame1,RooFit::ProjWData(*data_pass));
frame1->Draw("e0");
char *filename = new char[1000];
sprintf(filename,"Probe Pass %s",passHistTitle);
TLatex l;
l.SetNDC();
l.SetTextSize(0.04);
l.SetTextColor(1);
l.DrawLatex(0.2,0.9,filename);
double nsig = numSignal->getVal();
double nErr = numSignal->getError();
double e = eff->getVal();
double eErr = eff->getError();
double corr = fitResult->correlation(*eff, *numSignal);
double err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(filename, "N_{s} = %.2f #pm %.2f", nSigPass->getVal(), err);
l.DrawLatex(0.62,0.8,filename);
sprintf(filename, "N_{b} = %.2f #pm %.2f", nBkgPass->getVal(), nBkgPass->getError());
l.DrawLatex(0.62,0.75,filename);
sprintf(filename, "#epsilon^{Data}_{s} = %4.3f #pm %4.3f", eff->getVal(), eff->getError());
l.DrawLatex(0.62,0.7,filename);
sprintf(filename, "#epsilon^{MC}_{s} = %4.3f", effTP_MC);
l.DrawLatex(0.62,0.65,filename);
sprintf(filename,"resTP/hhu_probepass_%s.gif",passHistName);
can0->Print(filename);
sprintf(filename,"resTP/hhu_probepass_%s.pdf",passHistName);
can0->Print(filename);
//probel fail
TCanvas *can1 = new TCanvas("can1","c001",200,10,550,500);
setTCanvasNicev1(can1);
//RooPlot* frame1f = Mass.frame();
//RooPlot* frame1f = Mass.frame(Range(xminFit,xmaxFit),Bins(nbins));
RooPlot* frame1f = Mass.frame(Range(xminFit,xmaxFit),Bins(30));
frame1f->SetMinimum(0);
data_fail->plotOn(frame1f,RooFit::DataError(errorType));
pdfFail.plotOn(frame1f,RooFit::ProjWData(*data_fail),
RooFit::Components(*bkgShapePdff),RooFit::LineColor(kRed));
pdfFail.plotOn(frame1f,RooFit::ProjWData(*data_fail));
frame1f->Draw("e0");
sprintf(filename,"Probe Fail %s", failHistTitle);
l.DrawLatex(0.2,0.9,filename);
nsig = numSignal->getVal();
nErr = numSignal->getError();
e = 1-eff->getVal();
eErr = eff->getError();
corr = fitResult->correlation(*eff, *numSignal);
err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(filename, "N_{s} = %.2f #pm %.2f", nSigFail->getVal(), err);
l.DrawLatex(0.6,0.8,filename);
sprintf(filename, "N_{b} = %.2f #pm %.2f", nBkgFail->getVal(), nBkgFail->getError());
l.DrawLatex(0.6,0.75,filename);
sprintf(filename, "#epsilon^{Data}_{s} = %3.3f #pm %3.3f", eff->getVal(), eff->getError());
//l.DrawLatex(0.65,0.6,filename);
sprintf(filename, "#epsilon^{MC}_{s} = %3.3f", effTP_MC);
//l.DrawLatex(0.6,0.5,filename);
sprintf(filename,"resTP/hhu_probefail_%s.pdf",failHistName);
can1->Print(filename);
sprintf(filename,"resTP/hhu_probefail_%s.gif",failHistName);
can1->Print(filename);
cout<<"effMC: "<< effTP_MC <<" +/- " <<effTP_MCerr <<endl;
cout<<"eff: "<< eff->getVal() <<" +/- " << eff->getError() <<endl;
cout<<"ndataPeakFail " << ndataFailPeak <<endl;
}
void PDF_GLWADS_DKDpi_K3pi::setCorrelations(config c)
{
resetCorrelations();
switch(c)
{
case lumi1fb:{
corSource = "1fb-1, ExpNll/sept2012K3PIResult.root";
TString File = this->dir+"/ExpNll/sept2012K3PIResult.root";
if ( !FileExists(File) ){cout << "PDF_GLWADS_DKDpi_K3pi::setCorrelations : ERROR : File not found : " << File << endl; exit(1);}
TFile *fr = TFile::Open(File);
RooFitResult *r = (RooFitResult*)fr->Get("fitresult_model_reducedData_binned");
assert(r);
for ( int i=0; i<nObs; i++ )
for ( int j=0; j<nObs; j++ )
{
RooRealVar* pObs1 = (RooRealVar*)((RooArgList*)observables)->at(i);
RooRealVar* pObs2 = (RooRealVar*)((RooArgList*)observables)->at(j);
corStatMatrix[i][j] = r->correlation(obsTmkToMalcolm(pObs1->GetName()),obsTmkToMalcolm(pObs2->GetName()));
}
// no systematics correlation
fr->Close();
delete r;
delete fr;
break;
}
case lumi1fbSystCor:{
corSource = "1fb-1, ExpNll/sept2012K3PIResult.root, Malcolm's toys";
TString File = this->dir+"/ExpNll/sept2012K3PIResult.root";
if ( !FileExists(File) ){cout << "PDF_GLWADS_DKDpi_K3pi::setCorrelations : ERROR : File not found : " << File << endl; exit(1);}
TFile *fr = TFile::Open(File);
RooFitResult *r = (RooFitResult*)fr->Get("fitresult_model_reducedData_binned");
assert(r);
for ( int i=0; i<nObs; i++ )
for ( int j=0; j<nObs; j++ ){
RooRealVar* pObs1 = (RooRealVar*)((RooArgList*)observables)->at(i);
RooRealVar* pObs2 = (RooRealVar*)((RooArgList*)observables)->at(j);
corStatMatrix[i][j] = r->correlation(obsTmkToMalcolm(pObs1->GetName()),obsTmkToMalcolm(pObs2->GetName()));
}
// systematics correlations
SystCor_K3pi mySystCor;
for ( int i=0; i<nObs; i++ )
for ( int j=0; j<nObs; j++ ){
RooRealVar* tmkObs1 = (RooRealVar*)((RooArgList*)observables)->at(i);
RooRealVar* tmkObs2 = (RooRealVar*)((RooArgList*)observables)->at(j);
corSystMatrix[i][j] = mySystCor.getCor(obsTmkToMalcolm(tmkObs1->GetName()), obsTmkToMalcolm(tmkObs2->GetName()));
}
fr->Close();
delete r;
delete fr;
break;
}
case zero:{
corSource = "zero";
break;
}
default:{
cout << "PDF_GLWADS_DKDpi_K3pi::setCorrelations() : ERROR : config "+ConfigToTString(c)+" not found." << endl;
exit(1);
}
}
}
void performFit(string inputDir, string inputParameterFile, string label,
string PassInputDataFilename, string FailInputDataFilename,
string PassSignalTemplateHistName, string FailSignalTemplateHistName)
{
gBenchmark->Start("fitZCat");
//--------------------------------------------------------------------------------------------------------------
// Settings
//==============================================================================================================
const Double_t mlow = 60;
const Double_t mhigh = 120;
const Int_t nbins = 24;
TString effType = inputDir;
// The fit variable - lepton invariant mass
RooRealVar* rooMass_ = new RooRealVar("Mass","m_{ee}",mlow, mhigh, "GeV/c^{2}");
RooRealVar Mass = *rooMass_;
Mass.setBins(nbins);
// Make the category variable that defines the two fits,
// namely whether the probe passes or fails the eff criteria.
RooCategory sample("sample","") ;
sample.defineType("Pass", 1) ;
sample.defineType("Fail", 2) ;
RooDataSet *dataPass = RooDataSet::read((inputDir+PassInputDataFilename).c_str(),RooArgList(Mass));
RooDataSet *dataFail = RooDataSet::read((inputDir+FailInputDataFilename).c_str(),RooArgList(Mass));
RooDataSet *dataCombined = new RooDataSet("dataCombined","dataCombined", RooArgList(Mass), RooFit::Index(sample),
RooFit::Import("Pass",*dataPass),
RooFit::Import("Fail",*dataFail));
//*********************************************************************************************
//Define Free Parameters
//*********************************************************************************************
RooRealVar* ParNumSignal = LoadParameters(inputParameterFile, label,"ParNumSignal");
RooRealVar* ParNumBkgPass = LoadParameters(inputParameterFile, label,"ParNumBkgPass");
RooRealVar* ParNumBkgFail = LoadParameters(inputParameterFile, label, "ParNumBkgFail");
RooRealVar* ParEfficiency = LoadParameters(inputParameterFile, label, "ParEfficiency");
RooRealVar* ParPassBackgroundExpCoefficient = LoadParameters(inputParameterFile, label, "ParPassBackgroundExpCoefficient");
RooRealVar* ParFailBackgroundExpCoefficient = LoadParameters(inputParameterFile, label, "ParFailBackgroundExpCoefficient");
RooRealVar* ParPassSignalMassShift = LoadParameters(inputParameterFile, label, "ParPassSignalMassShift");
RooRealVar* ParFailSignalMassShift = LoadParameters(inputParameterFile, label, "ParFailSignalMassShift");
RooRealVar* ParPassSignalResolution = LoadParameters(inputParameterFile, label, "ParPassSignalResolution");
RooRealVar* ParFailSignalResolution = LoadParameters(inputParameterFile, label, "ParFailSignalResolution");
// new RooRealVar ("ParPassSignalMassShift","ParPassSignalMassShift",-2.6079e-02,-10.0, 10.0); //ParPassSignalMassShift->setConstant(kTRUE);
// RooRealVar* ParFailSignalMassShift = new RooRealVar ("ParFailSignalMassShift","ParFailSignalMassShift",7.2230e-01,-10.0, 10.0); //ParFailSignalMassShift->setConstant(kTRUE);
// RooRealVar* ParPassSignalResolution = new RooRealVar ("ParPassSignalResolution","ParPassSignalResolution",6.9723e-01,0.0, 10.0); ParPassSignalResolution->setConstant(kTRUE);
// RooRealVar* ParFailSignalResolution = new RooRealVar ("ParFailSignalResolution","ParFailSignalResolution",1.6412e+00,0.0, 10.0); ParFailSignalResolution->setConstant(kTRUE);
//*********************************************************************************************
//
//Load Signal PDFs
//
//*********************************************************************************************
TFile *Zeelineshape_file = new TFile("res/photonEfffromZee.dflag1.eT1.2.gT40.mt15.root", "READ");
TH1* histTemplatePass = (TH1D*) Zeelineshape_file->Get(PassSignalTemplateHistName.c_str());
TH1* histTemplateFail = (TH1D*) Zeelineshape_file->Get(FailSignalTemplateHistName.c_str());
//Introduce mass shift coordinate transformation
// RooFormulaVar PassShiftedMass("PassShiftedMass","@0-@1",RooArgList(Mass,*ParPassSignalMassShift));
// RooFormulaVar FailShiftedMass("FailShiftedMass","@0-@1",RooArgList(Mass,*ParFailSignalMassShift));
RooGaussian *PassSignalResolutionFunction = new RooGaussian("PassSignalResolutionFunction","PassSignalResolutionFunction",Mass,*ParPassSignalMassShift,*ParPassSignalResolution);
RooGaussian *FailSignalResolutionFunction = new RooGaussian("FailSignalResolutionFunction","FailSignalResolutionFunction",Mass,*ParFailSignalMassShift,*ParFailSignalResolution);
RooDataHist* dataHistPass = new RooDataHist("dataHistPass","dataHistPass", RooArgSet(Mass), histTemplatePass);
RooDataHist* dataHistFail = new RooDataHist("dataHistFail","dataHistFail", RooArgSet(Mass), histTemplateFail);
RooHistPdf* signalShapePassTemplatePdf = new RooHistPdf("signalShapePassTemplatePdf", "signalShapePassTemplatePdf", Mass, *dataHistPass, 1);
RooHistPdf* signalShapeFailTemplatePdf = new RooHistPdf("signalShapeFailTemplatePdf", "signalShapeFailTemplatePdf", Mass, *dataHistFail, 1);
RooFFTConvPdf* signalShapePassPdf = new RooFFTConvPdf("signalShapePassPdf","signalShapePassPdf" , Mass, *signalShapePassTemplatePdf,*PassSignalResolutionFunction,2);
RooFFTConvPdf* signalShapeFailPdf = new RooFFTConvPdf("signalShapeFailPdf","signalShapeFailPdf" , Mass, *signalShapeFailTemplatePdf,*FailSignalResolutionFunction,2);
// Now define some efficiency/yield variables
RooFormulaVar* NumSignalPass = new RooFormulaVar("NumSignalPass", "ParEfficiency*ParNumSignal", RooArgList(*ParEfficiency,*ParNumSignal));
RooFormulaVar* NumSignalFail = new RooFormulaVar("NumSignalFail", "(1.0-ParEfficiency)*ParNumSignal", RooArgList(*ParEfficiency,*ParNumSignal));
//*********************************************************************************************
//
// Create Background PDFs
//
//*********************************************************************************************
RooExponential* bkgPassPdf = new RooExponential("bkgPassPdf","bkgPassPdf",Mass, *ParPassBackgroundExpCoefficient);
RooExponential* bkgFailPdf = new RooExponential("bkgFailPdf","bkgFailPdf",Mass, *ParFailBackgroundExpCoefficient);
//*********************************************************************************************
//
// Create Total PDFs
//
//*********************************************************************************************
RooAddPdf pdfPass("pdfPass","pdfPass",RooArgList(*signalShapePassPdf,*bkgPassPdf), RooArgList(*NumSignalPass,*ParNumBkgPass));
RooAddPdf pdfFail("pdfFail","pdfFail",RooArgList(*signalShapeFailPdf,*bkgFailPdf), RooArgList(*NumSignalFail,*ParNumBkgFail));
// PDF for simultaneous fit
RooSimultaneous totalPdf("totalPdf","totalPdf", sample);
totalPdf.addPdf(pdfPass,"Pass");
// totalPdf.Print();
totalPdf.addPdf(pdfFail,"Fail");
totalPdf.Print();
//*********************************************************************************************
//
// Perform Fit
//
//*********************************************************************************************
RooFitResult *fitResult = 0;
// ********* Fix with Migrad first ********** //
fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
RooFit::Extended(true), RooFit::PrintLevel(-1));
fitResult->Print("v");
// // ********* Fit With Minos ********** //
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1), RooFit::Minos());
// fitResult->Print("v");
// // ********* Fix Mass Shift and Fit For Resolution ********** //
// ParPassSignalMassShift->setConstant(kTRUE);
// ParFailSignalMassShift->setConstant(kTRUE);
// ParPassSignalResolution->setConstant(kFALSE);
// ParFailSignalResolution->setConstant(kFALSE);
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1));
// fitResult->Print("v");
// // ********* Do Final Fit ********** //
// ParPassSignalMassShift->setConstant(kFALSE);
// ParFailSignalMassShift->setConstant(kFALSE);
// ParPassSignalResolution->setConstant(kTRUE);
// ParFailSignalResolution->setConstant(kTRUE);
// fitResult = totalPdf.fitTo(*dataCombined, RooFit::Save(true),
// RooFit::Extended(true), RooFit::PrintLevel(-1));
// fitResult->Print("v");
double nSignalPass = NumSignalPass->getVal();
double nSignalFail = NumSignalFail->getVal();
double denominator = nSignalPass + nSignalFail;
printf("\nFit results:\n");
if( fitResult->status() != 0 ){
std::cout<<"ERROR: BAD FIT STATUS"<<std::endl;
}
printf(" Efficiency = %.4f +- %.4f\n",
ParEfficiency->getVal(), ParEfficiency->getPropagatedError(*fitResult));
cout << "Signal Pass: "******"Signal Fail: " << nSignalFail << endl;
cout << "*********************************************************************\n";
cout << "Final Parameters\n";
cout << "*********************************************************************\n";
PrintParameter(ParNumSignal, label,"ParNumSignal");
PrintParameter(ParNumBkgPass, label,"ParNumBkgPass");
PrintParameter(ParNumBkgFail, label, "ParNumBkgFail");
PrintParameter(ParEfficiency , label, "ParEfficiency");
PrintParameter(ParPassBackgroundExpCoefficient , label, "ParPassBackgroundExpCoefficient");
PrintParameter(ParFailBackgroundExpCoefficient , label, "ParFailBackgroundExpCoefficient");
PrintParameter(ParPassSignalMassShift , label, "ParPassSignalMassShift");
PrintParameter(ParFailSignalMassShift , label, "ParFailSignalMassShift");
PrintParameter(ParPassSignalResolution , label, "ParPassSignalResolution");
PrintParameter(ParFailSignalResolution , label, "ParFailSignalResolution");
cout << endl << endl;
//--------------------------------------------------------------------------------------------------------------
// Make plots
//==============================================================================================================
TFile *canvasFile = new TFile("Efficiency_FitResults.root", "UPDATE");
RooAbsData::ErrorType errorType = RooAbsData::Poisson;
Mass.setBins(NBINSPASS);
TString cname = TString((label+"_Pass").c_str());
TCanvas *c = new TCanvas(cname,cname,800,600);
RooPlot* frame1 = Mass.frame();
frame1->SetMinimum(0);
dataPass->plotOn(frame1,RooFit::DataError(errorType));
pdfPass.plotOn(frame1,RooFit::ProjWData(*dataPass),
RooFit::Components(*bkgPassPdf),RooFit::LineColor(kRed));
pdfPass.plotOn(frame1,RooFit::ProjWData(*dataPass));
frame1->Draw("e0");
TPaveText *plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
TPaveText *plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
TPaveText *plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
char temp[100];
sprintf(temp, "%.4f", LUMINOSITY);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
TPaveText *plotlabel4 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
double nsig = ParNumSignal->getVal();
double nErr = ParNumSignal->getError();
double e = ParEfficiency->getVal();
double eErr = ParEfficiency->getError();
double corr = fitResult->correlation(*ParEfficiency, *ParNumSignal);
double err = ErrorInProduct(nsig, nErr, e, eErr, corr);
sprintf(temp, "Signal = %.2f #pm %.2f", NumSignalPass->getVal(), err);
plotlabel4->AddText(temp);
TPaveText *plotlabel5 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", ParNumBkgPass->getVal(), ParNumBkgPass->getError());
plotlabel5->AddText(temp);
TPaveText *plotlabel6 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
plotlabel6->AddText("Passing probes");
TPaveText *plotlabel7 = new TPaveText(0.6,0.72,0.8,0.77,"NDC");
plotlabel7->SetTextColor(kBlack);
plotlabel7->SetFillColor(kWhite);
plotlabel7->SetBorderSize(0);
plotlabel7->SetTextAlign(12);
plotlabel7->SetTextSize(0.03);
sprintf(temp, "Eff = %.3f #pm %.3f", ParEfficiency->getVal(), ParEfficiency->getErrorHi());
plotlabel7->AddText(temp);
TPaveText *plotlabel8 = new TPaveText(0.6,0.72,0.8,0.66,"NDC");
plotlabel8->SetTextColor(kBlack);
plotlabel8->SetFillColor(kWhite);
plotlabel8->SetBorderSize(0);
plotlabel8->SetTextAlign(12);
plotlabel8->SetTextSize(0.03);
sprintf(temp, "#chi^{2}/DOF = %.3f", frame1->chiSquare());
plotlabel8->AddText(temp);
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
plotlabel7->Draw();
plotlabel8->Draw();
// c->SaveAs( cname + TString(".eps"));
c->SaveAs( cname + TString(".gif"));
canvasFile->WriteTObject(c, c->GetName(), "WriteDelete");
Mass.setBins(NBINSFAIL);
cname = TString((label+"_Fail").c_str());
TCanvas* c2 = new TCanvas(cname,cname,800,600);
RooPlot* frame2 = Mass.frame();
frame2->SetMinimum(0);
dataFail->plotOn(frame2,RooFit::DataError(errorType));
pdfFail.plotOn(frame2,RooFit::ProjWData(*dataFail),
RooFit::Components(*bkgFailPdf),RooFit::LineColor(kRed));
pdfFail.plotOn(frame2,RooFit::ProjWData(*dataFail));
frame2->Draw("e0");
plotlabel = new TPaveText(0.23,0.87,0.43,0.92,"NDC");
plotlabel->SetTextColor(kBlack);
plotlabel->SetFillColor(kWhite);
plotlabel->SetBorderSize(0);
plotlabel->SetTextAlign(12);
plotlabel->SetTextSize(0.03);
plotlabel->AddText("CMS Preliminary 2010");
plotlabel2 = new TPaveText(0.23,0.82,0.43,0.87,"NDC");
plotlabel2->SetTextColor(kBlack);
plotlabel2->SetFillColor(kWhite);
plotlabel2->SetBorderSize(0);
plotlabel2->SetTextAlign(12);
plotlabel2->SetTextSize(0.03);
plotlabel2->AddText("#sqrt{s} = 7 TeV");
plotlabel3 = new TPaveText(0.23,0.75,0.43,0.80,"NDC");
plotlabel3->SetTextColor(kBlack);
plotlabel3->SetFillColor(kWhite);
plotlabel3->SetBorderSize(0);
plotlabel3->SetTextAlign(12);
plotlabel3->SetTextSize(0.03);
sprintf(temp, "%.4f", LUMINOSITY);
plotlabel3->AddText((string("#int#font[12]{L}dt = ") +
temp + string(" pb^{ -1}")).c_str());
plotlabel4 = new TPaveText(0.6,0.82,0.8,0.87,"NDC");
plotlabel4->SetTextColor(kBlack);
plotlabel4->SetFillColor(kWhite);
plotlabel4->SetBorderSize(0);
plotlabel4->SetTextAlign(12);
plotlabel4->SetTextSize(0.03);
err = ErrorInProduct(nsig, nErr, 1.0-e, eErr, corr);
sprintf(temp, "Signal = %.2f #pm %.2f", NumSignalFail->getVal(), err);
plotlabel4->AddText(temp);
plotlabel5 = new TPaveText(0.6,0.77,0.8,0.82,"NDC");
plotlabel5->SetTextColor(kBlack);
plotlabel5->SetFillColor(kWhite);
plotlabel5->SetBorderSize(0);
plotlabel5->SetTextAlign(12);
plotlabel5->SetTextSize(0.03);
sprintf(temp, "Bkg = %.2f #pm %.2f", ParNumBkgFail->getVal(), ParNumBkgFail->getError());
plotlabel5->AddText(temp);
plotlabel6 = new TPaveText(0.6,0.87,0.8,0.92,"NDC");
plotlabel6->SetTextColor(kBlack);
plotlabel6->SetFillColor(kWhite);
plotlabel6->SetBorderSize(0);
plotlabel6->SetTextAlign(12);
plotlabel6->SetTextSize(0.03);
plotlabel6->AddText("Failing probes");
plotlabel7 = new TPaveText(0.6,0.72,0.8,0.77,"NDC");
plotlabel7->SetTextColor(kBlack);
plotlabel7->SetFillColor(kWhite);
plotlabel7->SetBorderSize(0);
plotlabel7->SetTextAlign(12);
plotlabel7->SetTextSize(0.03);
sprintf(temp, "Eff = %.3f #pm %.3f", ParEfficiency->getVal(), ParEfficiency->getErrorHi(), ParEfficiency->getErrorLo());
plotlabel7->AddText(temp);
plotlabel8 = new TPaveText(0.6,0.72,0.8,0.66,"NDC");
plotlabel8->SetTextColor(kBlack);
plotlabel8->SetFillColor(kWhite);
plotlabel8->SetBorderSize(0);
plotlabel8->SetTextAlign(12);
plotlabel8->SetTextSize(0.03);
sprintf(temp, "#chi^{2}/DOF = %.3f", frame2->chiSquare());
plotlabel8->AddText(temp);
// plotlabel->Draw();
// plotlabel2->Draw();
// plotlabel3->Draw();
plotlabel4->Draw();
plotlabel5->Draw();
plotlabel6->Draw();
plotlabel7->Draw();
plotlabel8->Draw();
c2->SaveAs( cname + TString(".gif"));
// c2->SaveAs( cname + TString(".eps"));
// c2->SaveAs( cname + TString(".root"));
canvasFile->WriteTObject(c2, c2->GetName(), "WriteDelete");
canvasFile->Close();
effTextFile.width(40);
effTextFile << label;
effTextFile.width(20);
effTextFile << setiosflags(ios::fixed) << setprecision(4) << left << ParEfficiency->getVal() ;
effTextFile.width(20);
effTextFile << left << ParEfficiency->getErrorHi();
effTextFile.width(20);
effTextFile << left << ParEfficiency->getErrorLo();
effTextFile.width(14);
effTextFile << setiosflags(ios::fixed) << setprecision(2) << left << nSignalPass ;
effTextFile.width(14);
effTextFile << left << nSignalFail << endl;
}
